[linux-next] LinuxNextTracking branch, master, updated. next-20191031

31 Oct 2019

The following commit has been merged in the master branch:
commit 33c55730cec5d4676660819729b0a151aa9fca37
Merge: 27a12342bb6c408f425ec2af679e019ffb64ab65 ec2f877856e0af3889940e00b160f7f20f8d774f
Author: Stephen Rothwell sfr@canb.auug.org.au
Date:   Thu Oct 31 15:20:29 2019 +1100
Merge remote-tracking branch 'kspp/for-next/kspp'
diff --combined Documentation/process/coding-style.rst
index ada573b7d703,146b3a2c661c..e7c60f5339b2

--- a/Documentation/process/coding-style.rst
+++ b/Documentation/process/coding-style.rst
@@@ -56,7 -56,7 +56,7 @@@ instead of ``double-indenting`` the ``c
    case 'K':
    case 'k':
    	mem <<= 10;
 -		/* fall through */
 +		fallthrough;
    default:
    	break;
    }
@@@ -988,7 -988,7 +988,7 @@@ Similarly, if you need to calculate th
.. code-block:: c
- 	#define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))
+ 	#define sizeof_member(t, f) (sizeof(((t*)0)->f))
There are also min() and max() macros that do strict type checking if you
  need them.  Feel free to peruse that header file to see what else is already
diff --combined arch/arm64/include/asm/processor.h
index 8899d26f73ff,2d61a909984d..b5000e7cd59f
--- a/arch/arm64/include/asm/processor.h
+++ b/arch/arm64/include/asm/processor.h
@@@ -26,12 -26,10 +26,12 @@@
  #include <linux/init.h>
  #include <linux/stddef.h>
  #include <linux/string.h>
 +#include <linux/thread_info.h>
#include <asm/alternative.h>
  #include <asm/cpufeature.h>
  #include <asm/hw_breakpoint.h>
 +#include <asm/kasan.h>
  #include <asm/lse.h>
  #include <asm/pgtable-hwdef.h>
  #include <asm/pointer_auth.h>
@@@ -154,13 -152,13 +154,13 @@@ static inline void arch_thread_struct_w
    					unsigned long *size)
  {
    /* Verify that there is no padding among the whitelisted fields: */
- 	BUILD_BUG_ON(sizeof_field(struct thread_struct, uw) !=
- 		     sizeof_field(struct thread_struct, uw.tp_value) +
- 		     sizeof_field(struct thread_struct, uw.tp2_value) +
- 		     sizeof_field(struct thread_struct, uw.fpsimd_state));
+ 	BUILD_BUG_ON(sizeof_member(struct thread_struct, uw) !=
+ 		     sizeof_member(struct thread_struct, uw.tp_value) +
+ 		     sizeof_member(struct thread_struct, uw.tp2_value) +
+ 		     sizeof_member(struct thread_struct, uw.fpsimd_state));
*offset = offsetof(struct thread_struct, uw);
- 	*size = sizeof_field(struct thread_struct, uw);
+ 	*size = sizeof_member(struct thread_struct, uw);
  }
#ifdef CONFIG_COMPAT
@@@ -216,18 -214,6 +216,18 @@@ static inline void start_thread(struct 
    regs->sp = sp;
  }
+static inline bool is_ttbr0_addr(unsigned long addr)
 +{
 +	/* entry assembly clears tags for TTBR0 addrs */
 +	return addr < TASK_SIZE;
 +}
 +
 +static inline bool is_ttbr1_addr(unsigned long addr)
 +{
 +	/* TTBR1 addresses may have a tag if KASAN_SW_TAGS is in use */
 +	return arch_kasan_reset_tag(addr) >= PAGE_OFFSET;
 +}
 +
  #ifdef CONFIG_COMPAT
  static inline void compat_start_thread(struct pt_regs *regs, unsigned long pc,
    			       unsigned long sp)
diff --combined block/blk-core.c
index 1d3880e1c436,fd6b31d400e7..f2d845aea77f
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@@ -184,22 -184,6 +184,22 @@@ static const struct 
    [BLK_STS_IOERR]		= { -EIO,	"I/O" },
  };
+#ifdef CONFIG_BLK_NOTIFICATIONS
 +static const
 +enum block_notification_type blk_notifications[ARRAY_SIZE(blk_errors)] = {
 +	[BLK_STS_TIMEOUT]	= NOTIFY_BLOCK_ERROR_TIMEOUT,
 +	[BLK_STS_NOSPC]		= NOTIFY_BLOCK_ERROR_NO_SPACE,
 +	[BLK_STS_TRANSPORT]	= NOTIFY_BLOCK_ERROR_RECOVERABLE_TRANSPORT,
 +	[BLK_STS_TARGET]	= NOTIFY_BLOCK_ERROR_CRITICAL_TARGET,
 +	[BLK_STS_NEXUS]		= NOTIFY_BLOCK_ERROR_CRITICAL_NEXUS,
 +	[BLK_STS_MEDIUM]	= NOTIFY_BLOCK_ERROR_CRITICAL_MEDIUM,
 +	[BLK_STS_PROTECTION]	= NOTIFY_BLOCK_ERROR_PROTECTION,
 +	[BLK_STS_RESOURCE]	= NOTIFY_BLOCK_ERROR_KERNEL_RESOURCE,
 +	[BLK_STS_DEV_RESOURCE]	= NOTIFY_BLOCK_ERROR_DEVICE_RESOURCE,
 +	[BLK_STS_IOERR]		= NOTIFY_BLOCK_ERROR_IO,
 +};
 +#endif
 +
  blk_status_t errno_to_blk_status(int errno)
  {
    int i;
@@@ -240,19 -224,6 +240,19 @@@ static void print_req_error(struct requ
    	req->cmd_flags & ~REQ_OP_MASK,
    	req->nr_phys_segments,
    	IOPRIO_PRIO_CLASS(req->ioprio));
 +
 +#ifdef CONFIG_BLK_NOTIFICATIONS
 +	if (blk_notifications[idx]) {
 +		struct block_notification n = {
 +			.watch.type	= WATCH_TYPE_BLOCK_NOTIFY,
 +			.watch.subtype	= blk_notifications[idx],
 +			.watch.info	= watch_sizeof(n),
 +			.dev		= req->rq_disk ? disk_devt(req->rq_disk) : 0,
 +			.sector		= blk_rq_pos(req),
 +		};
 +		post_block_notification(&n);
 +	}
 +#endif
  }
static void req_bio_endio(struct request *rq, struct bio *bio,
@@@ -365,14 -336,14 +365,14 @@@ EXPORT_SYMBOL_GPL(blk_set_queue_dying)
   */
  void blk_cleanup_queue(struct request_queue *q)
  {
 +	WARN_ON_ONCE(blk_queue_registered(q));
 +
    /* mark @q DYING, no new request or merges will be allowed afterwards */
 -	mutex_lock(&q->sysfs_lock);
    blk_set_queue_dying(q);
blk_queue_flag_set(QUEUE_FLAG_NOMERGES, q);
    blk_queue_flag_set(QUEUE_FLAG_NOXMERGES, q);
    blk_queue_flag_set(QUEUE_FLAG_DYING, q);
 -	mutex_unlock(&q->sysfs_lock);
/*
     * Drain all requests queued before DYING marking. Set DEAD flag to
@@@ -1819,9 -1790,9 +1819,9 @@@ int __init blk_dev_init(void
  {
    BUILD_BUG_ON(REQ_OP_LAST >= (1 << REQ_OP_BITS));
    BUILD_BUG_ON(REQ_OP_BITS + REQ_FLAG_BITS > 8 *
- 			FIELD_SIZEOF(struct request, cmd_flags));
+ 			sizeof_member(struct request, cmd_flags));
    BUILD_BUG_ON(REQ_OP_BITS + REQ_FLAG_BITS > 8 *
- 			FIELD_SIZEOF(struct bio, bi_opf));
+ 			sizeof_member(struct bio, bi_opf));
/* used for unplugging and affects IO latency/throughput - HIGHPRI */
    kblockd_workqueue = alloc_workqueue("kblockd",
diff --combined drivers/firmware/efi/efi.c
index 69f00f7453a3,17d32fb72c9a..e3c8b51e7000
--- a/drivers/firmware/efi/efi.c
+++ b/drivers/firmware/efi/efi.c
@@@ -267,9 -267,6 +267,9 @@@ static __init int efivar_ssdt_load(void
    void *data;
    int ret;
+	if (!efivar_ssdt[0])
 +		return 0;
 +
    ret = efivar_init(efivar_ssdt_iter, &entries, true, &entries);
list_for_each_entry_safe(entry, aux, &entries, list) {
@@@ -673,7 -670,7 +673,7 @@@ device_initcall(efi_load_efivars)
    	{ name },				   \
    	{ prop },				   \
    	offsetof(struct efi_fdt_params, field),    \
- 		FIELD_SIZEOF(struct efi_fdt_params, field) \
+ 		sizeof_member(struct efi_fdt_params, field) \
    }
struct params {
diff --combined drivers/gpu/drm/i915/gvt/scheduler.c
index 36bb7639e82f,76c2db58adcd..508a90bee72a
--- a/drivers/gpu/drm/i915/gvt/scheduler.c
+++ b/drivers/gpu/drm/i915/gvt/scheduler.c
@@@ -365,8 -365,7 +365,8 @@@ static void set_context_ppgtt_from_shad
    				  struct i915_gem_context *ctx)
  {
    struct intel_vgpu_mm *mm = workload->shadow_mm;
 -	struct i915_ppgtt *ppgtt = i915_vm_to_ppgtt(ctx->vm);
 +	struct i915_ppgtt *ppgtt =
 +		i915_vm_to_ppgtt(i915_gem_context_get_vm_rcu(ctx));
    int i = 0;
if (mm->ppgtt_mm.root_entry_type == GTT_TYPE_PPGTT_ROOT_L4_ENTRY) {
@@@ -379,8 -378,6 +379,8 @@@
    		px_dma(pd) = mm->ppgtt_mm.shadow_pdps[i];
    	}
    }
 +
 +	i915_vm_put(&ppgtt->vm);
  }
static int
@@@ -388,8 -385,11 +388,8 @@@ intel_gvt_workload_req_alloc(struct int
  {
    struct intel_vgpu *vgpu = workload->vgpu;
    struct intel_vgpu_submission *s = &vgpu->submission;
 -	struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
    struct i915_request *rq;
-	lockdep_assert_held(&dev_priv->drm.struct_mutex);
 -
    if (workload->req)
    	return 0;
@@@ -415,9 -415,10 +415,9 @@@ int intel_gvt_scan_and_shadow_workload(
  {
    struct intel_vgpu *vgpu = workload->vgpu;
    struct intel_vgpu_submission *s = &vgpu->submission;
 -	struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
    int ret;
-	lockdep_assert_held(&dev_priv->drm.struct_mutex);
 +	lockdep_assert_held(&vgpu->vgpu_lock);
if (workload->shadow)
    	return 0;
@@@ -579,6 -580,8 +579,6 @@@ static void update_vreg_in_ctx(struct i
static void release_shadow_batch_buffer(struct intel_vgpu_workload *workload)
  {
 -	struct intel_vgpu *vgpu = workload->vgpu;
 -	struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
    struct intel_vgpu_shadow_bb *bb, *pos;
if (list_empty(&workload->shadow_bb))
@@@ -587,6 -590,8 +587,6 @@@
    bb = list_first_entry(&workload->shadow_bb,
    		struct intel_vgpu_shadow_bb, list);
-	mutex_lock(&dev_priv->drm.struct_mutex);
 -
    list_for_each_entry_safe(bb, pos, &workload->shadow_bb, list) {
    	if (bb->obj) {
    		if (bb->accessing)
@@@ -604,6 -609,8 +604,6 @@@
    	list_del(&bb->list);
    	kfree(bb);
    }
 -
 -	mutex_unlock(&dev_priv->drm.struct_mutex);
  }
static int prepare_workload(struct intel_vgpu_workload *workload)
@@@ -678,6 -685,7 +678,6 @@@ err_unpin_mm
  static int dispatch_workload(struct intel_vgpu_workload *workload)
  {
    struct intel_vgpu *vgpu = workload->vgpu;
 -	struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
    struct i915_request *rq;
    int ring_id = workload->ring_id;
    int ret;
@@@ -686,6 -694,7 +686,6 @@@
    	ring_id, workload);
mutex_lock(&vgpu->vgpu_lock);
 -	mutex_lock(&dev_priv->drm.struct_mutex);
ret = intel_gvt_workload_req_alloc(workload);
    if (ret)
@@@ -720,6 -729,7 +720,6 @@@ out
  err_req:
    if (ret)
    	workload->status = ret;
 -	mutex_unlock(&dev_priv->drm.struct_mutex);
    mutex_unlock(&vgpu->vgpu_lock);
    return ret;
  }
@@@ -877,7 -887,7 +877,7 @@@ void intel_vgpu_clean_workloads(struct 
    intel_engine_mask_t tmp;
/* free the unsubmited workloads in the queues. */
 -	for_each_engine_masked(engine, dev_priv, engine_mask, tmp) {
 +	for_each_engine_masked(engine, &dev_priv->gt, engine_mask, tmp) {
    	list_for_each_entry_safe(pos, n,
    		&s->workload_q_head[engine->id], list) {
    		list_del_init(&pos->list);
@@@ -1223,18 -1233,20 +1223,18 @@@ int intel_vgpu_setup_submission(struct 
    struct intel_vgpu_submission *s = &vgpu->submission;
    struct intel_engine_cs *engine;
    struct i915_gem_context *ctx;
 +	struct i915_ppgtt *ppgtt;
    enum intel_engine_id i;
    int ret;
-	mutex_lock(&i915->drm.struct_mutex);
 -
    ctx = i915_gem_context_create_kernel(i915, I915_PRIORITY_MAX);
 -	if (IS_ERR(ctx)) {
 -		ret = PTR_ERR(ctx);
 -		goto out_unlock;
 -	}
 +	if (IS_ERR(ctx))
 +		return PTR_ERR(ctx);
i915_gem_context_set_force_single_submission(ctx);
-	i915_context_ppgtt_root_save(s, i915_vm_to_ppgtt(ctx->vm));
 +	ppgtt = i915_vm_to_ppgtt(i915_gem_context_get_vm_rcu(ctx));
 +	i915_context_ppgtt_root_save(s, ppgtt);
for_each_engine(engine, i915, i) {
    	struct intel_context *ce;
@@@ -1268,7 -1280,7 +1268,7 @@@
    					  sizeof(struct intel_vgpu_workload), 0,
    					  SLAB_HWCACHE_ALIGN,
    					  offsetof(struct intel_vgpu_workload, rb_tail),
- 						  sizeof_field(struct intel_vgpu_workload, rb_tail),
+ 						  sizeof_member(struct intel_vgpu_workload, rb_tail),
    					  NULL);
if (!s->workloads) {
@@@ -1279,12 -1291,12 +1279,12 @@@
    atomic_set(&s->running_workload_num, 0);
    bitmap_zero(s->tlb_handle_pending, I915_NUM_ENGINES);
+	i915_vm_put(&ppgtt->vm);
    i915_gem_context_put(ctx);
 -	mutex_unlock(&i915->drm.struct_mutex);
    return 0;
out_shadow_ctx:
 -	i915_context_ppgtt_root_restore(s, i915_vm_to_ppgtt(ctx->vm));
 +	i915_context_ppgtt_root_restore(s, ppgtt);
    for_each_engine(engine, i915, i) {
    	if (IS_ERR(s->shadow[i]))
    		break;
@@@ -1292,8 -1304,9 +1292,8 @@@
    	intel_context_unpin(s->shadow[i]);
    	intel_context_put(s->shadow[i]);
    }
 +	i915_vm_put(&ppgtt->vm);
    i915_gem_context_put(ctx);
 -out_unlock:
 -	mutex_unlock(&i915->drm.struct_mutex);
    return ret;
  }
@@@ -1584,9 -1597,9 +1584,9 @@@ intel_vgpu_create_workload(struct intel
     */
    if (list_empty(workload_q_head(vgpu, ring_id))) {
    	intel_runtime_pm_get(&dev_priv->runtime_pm);
 -		mutex_lock(&dev_priv->drm.struct_mutex);
 +		mutex_lock(&vgpu->vgpu_lock);
    	ret = intel_gvt_scan_and_shadow_workload(workload);
 -		mutex_unlock(&dev_priv->drm.struct_mutex);
 +		mutex_unlock(&vgpu->vgpu_lock);
    	intel_runtime_pm_put_unchecked(&dev_priv->runtime_pm);
    }
diff --combined drivers/infiniband/hw/hfi1/sdma.c
index c61b6022575e,a772955bd2ad..f87acd4af819
--- a/drivers/infiniband/hw/hfi1/sdma.c
+++ b/drivers/infiniband/hw/hfi1/sdma.c
@@@ -65,7 -65,6 +65,7 @@@
  #define SDMA_DESCQ_CNT 2048
  #define SDMA_DESC_INTR 64
  #define INVALID_TAIL 0xffff
 +#define SDMA_PAD max_t(size_t, MAX_16B_PADDING, sizeof(u32))
static uint sdma_descq_cnt = SDMA_DESCQ_CNT;
  module_param(sdma_descq_cnt, uint, S_IRUGO);
@@@ -848,7 -847,7 +848,7 @@@ static const struct rhashtable_params s
    .nelem_hint = NR_CPUS_HINT,
    .head_offset = offsetof(struct sdma_rht_node, node),
    .key_offset = offsetof(struct sdma_rht_node, cpu_id),
- 	.key_len = FIELD_SIZEOF(struct sdma_rht_node, cpu_id),
+ 	.key_len = sizeof_member(struct sdma_rht_node, cpu_id),
    .max_size = NR_CPUS,
    .min_size = 8,
    .automatic_shrinking = true,
@@@ -1297,7 -1296,7 +1297,7 @@@ void sdma_clean(struct hfi1_devdata *dd
    struct sdma_engine *sde;
if (dd->sdma_pad_dma) {
 -		dma_free_coherent(&dd->pcidev->dev, 4,
 +		dma_free_coherent(&dd->pcidev->dev, SDMA_PAD,
    			  (void *)dd->sdma_pad_dma,
    			  dd->sdma_pad_phys);
    	dd->sdma_pad_dma = NULL;
@@@ -1492,7 -1491,7 +1492,7 @@@ int sdma_init(struct hfi1_devdata *dd, 
    }
/* Allocate memory for pad */
 -	dd->sdma_pad_dma = dma_alloc_coherent(&dd->pcidev->dev, sizeof(u32),
 +	dd->sdma_pad_dma = dma_alloc_coherent(&dd->pcidev->dev, SDMA_PAD,
    				      &dd->sdma_pad_phys, GFP_KERNEL);
    if (!dd->sdma_pad_dma) {
    	dd_dev_err(dd, "failed to allocate SendDMA pad memory\n");
@@@ -1527,11 -1526,8 +1527,11 @@@
    }
ret = rhashtable_init(tmp_sdma_rht, &sdma_rht_params);
 -	if (ret < 0)
 +	if (ret < 0) {
 +		kfree(tmp_sdma_rht);
    	goto bail;
 +	}
 +
    dd->sdma_rht = tmp_sdma_rht;
dd_dev_info(dd, "SDMA num_sdma: %u\n", dd->num_sdma);
diff --combined drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c
index bf6bca26c337,491acfe19e2a..a477fe75bc9c
--- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c
@@@ -55,8 -55,6 +55,8 @@@
#define HCLGE_LINK_STATUS_MS	10
+#define HCLGE_VF_VPORT_START_NUM	1
 +
  static int hclge_set_mac_mtu(struct hclge_dev *hdev, int new_mps);
  static int hclge_init_vlan_config(struct hclge_dev *hdev);
  static void hclge_sync_vlan_filter(struct hclge_dev *hdev);
@@@ -325,7 -323,8 +325,7 @@@ static const struct hclge_mac_mgr_tbl_e
    {
    	.flags = HCLGE_MAC_MGR_MASK_VLAN_B,
    	.ethter_type = cpu_to_le16(ETH_P_LLDP),
 -		.mac_addr_hi32 = cpu_to_le32(htonl(0x0180C200)),
 -		.mac_addr_lo16 = cpu_to_le16(htons(0x000E)),
 +		.mac_addr = {0x01, 0x80, 0xc2, 0x00, 0x00, 0x0e},
    	.i_port_bitmap = 0x1,
    },
  };
@@@ -907,9 -906,6 +907,9 @@@ static int hclge_query_pf_resource(stru
    	hnae3_get_field(__le16_to_cpu(req->pf_intr_vector_number),
    			HCLGE_PF_VEC_NUM_M, HCLGE_PF_VEC_NUM_S);
+		/* nic's msix numbers is always equals to the roce's. */
 +		hdev->num_nic_msi = hdev->num_roce_msi;
 +
    	/* PF should have NIC vectors and Roce vectors,
    	 * NIC vectors are queued before Roce vectors.
    	 */
@@@ -919,15 -915,6 +919,15 @@@
    	hdev->num_msi =
    	hnae3_get_field(__le16_to_cpu(req->pf_intr_vector_number),
    			HCLGE_PF_VEC_NUM_M, HCLGE_PF_VEC_NUM_S);
 +
 +		hdev->num_nic_msi = hdev->num_msi;
 +	}
 +
 +	if (hdev->num_nic_msi < HNAE3_MIN_VECTOR_NUM) {
 +		dev_err(&hdev->pdev->dev,
 +			"Just %u msi resources, not enough for pf(min:2).\n",
 +			hdev->num_nic_msi);
 +		return -EINVAL;
    }
return 0;
@@@ -1195,35 -1182,6 +1195,35 @@@ static void hclge_parse_link_mode(struc
    	hclge_parse_backplane_link_mode(hdev, speed_ability);
  }
+static u32 hclge_get_max_speed(u8 speed_ability)
 +{
 +	if (speed_ability & HCLGE_SUPPORT_100G_BIT)
 +		return HCLGE_MAC_SPEED_100G;
 +
 +	if (speed_ability & HCLGE_SUPPORT_50G_BIT)
 +		return HCLGE_MAC_SPEED_50G;
 +
 +	if (speed_ability & HCLGE_SUPPORT_40G_BIT)
 +		return HCLGE_MAC_SPEED_40G;
 +
 +	if (speed_ability & HCLGE_SUPPORT_25G_BIT)
 +		return HCLGE_MAC_SPEED_25G;
 +
 +	if (speed_ability & HCLGE_SUPPORT_10G_BIT)
 +		return HCLGE_MAC_SPEED_10G;
 +
 +	if (speed_ability & HCLGE_SUPPORT_1G_BIT)
 +		return HCLGE_MAC_SPEED_1G;
 +
 +	if (speed_ability & HCLGE_SUPPORT_100M_BIT)
 +		return HCLGE_MAC_SPEED_100M;
 +
 +	if (speed_ability & HCLGE_SUPPORT_10M_BIT)
 +		return HCLGE_MAC_SPEED_10M;
 +
 +	return HCLGE_MAC_SPEED_1G;
 +}
 +
  static void hclge_parse_cfg(struct hclge_cfg *cfg, struct hclge_desc *desc)
  {
    struct hclge_cfg_param_cmd *req;
@@@ -1394,8 -1352,6 +1394,8 @@@ static int hclge_configure(struct hclge
hclge_parse_link_mode(hdev, cfg.speed_ability);
+	hdev->hw.mac.max_speed = hclge_get_max_speed(cfg.speed_ability);
 +
    if ((hdev->tc_max > HNAE3_MAX_TC) ||
        (hdev->tc_max < 1)) {
    	dev_warn(&hdev->pdev->dev, "TC num = %d.\n",
@@@ -1551,10 -1507,6 +1551,10 @@@ static int  hclge_assign_tqp(struct hcl
    kinfo->rss_size = min_t(u16, hdev->rss_size_max,
    			vport->alloc_tqps / hdev->tm_info.num_tc);
+	/* ensure one to one mapping between irq and queue at default */
 +	kinfo->rss_size = min_t(u16, kinfo->rss_size,
 +				(hdev->num_nic_msi - 1) / hdev->tm_info.num_tc);
 +
    return 0;
  }
@@@ -1681,7 -1633,6 +1681,7 @@@ static int hclge_alloc_vport(struct hcl
    for (i = 0; i < num_vport; i++) {
    	vport->back = hdev;
    	vport->vport_id = i;
 +		vport->vf_info.link_state = IFLA_VF_LINK_STATE_AUTO;
    	vport->mps = HCLGE_MAC_DEFAULT_FRAME;
    	vport->port_base_vlan_cfg.state = HNAE3_PORT_BASE_VLAN_DISABLE;
    	vport->rxvlan_cfg.rx_vlan_offload_en = true;
@@@ -2334,8 -2285,7 +2334,8 @@@ static int hclge_init_msi(struct hclge_
    int vectors;
    int i;
-	vectors = pci_alloc_irq_vectors(pdev, 1, hdev->num_msi,
 +	vectors = pci_alloc_irq_vectors(pdev, HNAE3_MIN_VECTOR_NUM,
 +					hdev->num_msi,
    				PCI_IRQ_MSI | PCI_IRQ_MSIX);
    if (vectors < 0) {
    	dev_err(&pdev->dev,
@@@ -2350,7 -2300,6 +2350,7 @@@
hdev->num_msi = vectors;
    hdev->num_msi_left = vectors;
 +
    hdev->base_msi_vector = pdev->irq;
    hdev->roce_base_vector = hdev->base_msi_vector +
    			hdev->roce_base_msix_offset;
@@@ -2904,62 -2853,6 +2904,62 @@@ static int hclge_get_status(struct hnae
    return hdev->hw.mac.link;
  }
+static struct hclge_vport *hclge_get_vf_vport(struct hclge_dev *hdev, int vf)
 +{
 +	if (pci_num_vf(hdev->pdev) == 0) {
 +		dev_err(&hdev->pdev->dev,
 +			"SRIOV is disabled, can not get vport(%d) info.\n", vf);
 +		return NULL;
 +	}
 +
 +	if (vf < 0 || vf >= pci_num_vf(hdev->pdev)) {
 +		dev_err(&hdev->pdev->dev,
 +			"vf id(%d) is out of range(0 <= vfid < %d)\n",
 +			vf, pci_num_vf(hdev->pdev));
 +		return NULL;
 +	}
 +
 +	/* VF start from 1 in vport */
 +	vf += HCLGE_VF_VPORT_START_NUM;
 +	return &hdev->vport[vf];
 +}
 +
 +static int hclge_get_vf_config(struct hnae3_handle *handle, int vf,
 +			       struct ifla_vf_info *ivf)
 +{
 +	struct hclge_vport *vport = hclge_get_vport(handle);
 +	struct hclge_dev *hdev = vport->back;
 +
 +	vport = hclge_get_vf_vport(hdev, vf);
 +	if (!vport)
 +		return -EINVAL;
 +
 +	ivf->vf = vf;
 +	ivf->linkstate = vport->vf_info.link_state;
 +	ivf->spoofchk = vport->vf_info.spoofchk;
 +	ivf->trusted = vport->vf_info.trusted;
 +	ivf->min_tx_rate = 0;
 +	ivf->max_tx_rate = vport->vf_info.max_tx_rate;
 +	ether_addr_copy(ivf->mac, vport->vf_info.mac);
 +
 +	return 0;
 +}
 +
 +static int hclge_set_vf_link_state(struct hnae3_handle *handle, int vf,
 +				   int link_state)
 +{
 +	struct hclge_vport *vport = hclge_get_vport(handle);
 +	struct hclge_dev *hdev = vport->back;
 +
 +	vport = hclge_get_vf_vport(hdev, vf);
 +	if (!vport)
 +		return -EINVAL;
 +
 +	vport->vf_info.link_state = link_state;
 +
 +	return 0;
 +}
 +
  static u32 hclge_check_event_cause(struct hclge_dev *hdev, u32 *clearval)
  {
    u32 rst_src_reg, cmdq_src_reg, msix_src_reg;
@@@ -4010,7 -3903,6 +4010,7 @@@ static int hclge_get_vector(struct hnae
    int alloc = 0;
    int i, j;
+	vector_num = min_t(u16, hdev->num_nic_msi - 1, vector_num);
    vector_num = min(hdev->num_msi_left, vector_num);
for (j = 0; j < vector_num; j++) {
@@@ -4666,8 -4558,8 +4666,8 @@@ static int hclge_unmap_ring_frm_vector(
    return ret;
  }
-int hclge_cmd_set_promisc_mode(struct hclge_dev *hdev,
 -			       struct hclge_promisc_param *param)
 +static int hclge_cmd_set_promisc_mode(struct hclge_dev *hdev,
 +				      struct hclge_promisc_param *param)
  {
    struct hclge_promisc_cfg_cmd *req;
    struct hclge_desc desc;
@@@ -4694,9 -4586,8 +4694,9 @@@
    return ret;
  }
-void hclge_promisc_param_init(struct hclge_promisc_param *param, bool en_uc,
 -			      bool en_mc, bool en_bc, int vport_id)
 +static void hclge_promisc_param_init(struct hclge_promisc_param *param,
 +				     bool en_uc, bool en_mc, bool en_bc,
 +				     int vport_id)
  {
    if (!param)
    	return;
@@@ -4711,21 -4602,12 +4711,21 @@@
    param->vf_id = vport_id;
  }
+int hclge_set_vport_promisc_mode(struct hclge_vport *vport, bool en_uc_pmc,
 +				 bool en_mc_pmc, bool en_bc_pmc)
 +{
 +	struct hclge_dev *hdev = vport->back;
 +	struct hclge_promisc_param param;
 +
 +	hclge_promisc_param_init(&param, en_uc_pmc, en_mc_pmc, en_bc_pmc,
 +				 vport->vport_id);
 +	return hclge_cmd_set_promisc_mode(hdev, &param);
 +}
 +
  static int hclge_set_promisc_mode(struct hnae3_handle *handle, bool en_uc_pmc,
    			  bool en_mc_pmc)
  {
    struct hclge_vport *vport = hclge_get_vport(handle);
 -	struct hclge_dev *hdev = vport->back;
 -	struct hclge_promisc_param param;
    bool en_bc_pmc = true;
/* For revision 0x20, if broadcast promisc enabled, vlan filter is
@@@ -4735,8 -4617,9 +4735,8 @@@
    if (handle->pdev->revision == 0x20)
    	en_bc_pmc = handle->netdev_flags & HNAE3_BPE ? true : false;
-	hclge_promisc_param_init(&param, en_uc_pmc, en_mc_pmc, en_bc_pmc,
 -				 vport->vport_id);
 -	return hclge_cmd_set_promisc_mode(hdev, &param);
 +	return hclge_set_vport_promisc_mode(vport, en_uc_pmc, en_mc_pmc,
 +					    en_bc_pmc);
  }
static int hclge_get_fd_mode(struct hclge_dev *hdev, u8 *fd_mode)
@@@ -7508,67 -7391,6 +7508,67 @@@ static int hclge_get_mac_ethertype_cmd_
    return return_status;
  }
+static bool hclge_check_vf_mac_exist(struct hclge_vport *vport, int vf_idx,
 +				     u8 *mac_addr)
 +{
 +	struct hclge_mac_vlan_tbl_entry_cmd req;
 +	struct hclge_dev *hdev = vport->back;
 +	struct hclge_desc desc;
 +	u16 egress_port = 0;
 +	int i;
 +
 +	if (is_zero_ether_addr(mac_addr))
 +		return false;
 +
 +	memset(&req, 0, sizeof(req));
 +	hnae3_set_field(egress_port, HCLGE_MAC_EPORT_VFID_M,
 +			HCLGE_MAC_EPORT_VFID_S, vport->vport_id);
 +	req.egress_port = cpu_to_le16(egress_port);
 +	hclge_prepare_mac_addr(&req, mac_addr, false);
 +
 +	if (hclge_lookup_mac_vlan_tbl(vport, &req, &desc, false) != -ENOENT)
 +		return true;
 +
 +	vf_idx += HCLGE_VF_VPORT_START_NUM;
 +	for (i = hdev->num_vmdq_vport + 1; i < hdev->num_alloc_vport; i++)
 +		if (i != vf_idx &&
 +		    ether_addr_equal(mac_addr, hdev->vport[i].vf_info.mac))
 +			return true;
 +
 +	return false;
 +}
 +
 +static int hclge_set_vf_mac(struct hnae3_handle *handle, int vf,
 +			    u8 *mac_addr)
 +{
 +	struct hclge_vport *vport = hclge_get_vport(handle);
 +	struct hclge_dev *hdev = vport->back;
 +
 +	vport = hclge_get_vf_vport(hdev, vf);
 +	if (!vport)
 +		return -EINVAL;
 +
 +	if (ether_addr_equal(mac_addr, vport->vf_info.mac)) {
 +		dev_info(&hdev->pdev->dev,
 +			 "Specified MAC(=%pM) is same as before, no change committed!\n",
 +			 mac_addr);
 +		return 0;
 +	}
 +
 +	if (hclge_check_vf_mac_exist(vport, vf, mac_addr)) {
 +		dev_err(&hdev->pdev->dev, "Specified MAC(=%pM) exists!\n",
 +			mac_addr);
 +		return -EEXIST;
 +	}
 +
 +	ether_addr_copy(vport->vf_info.mac, mac_addr);
 +	dev_info(&hdev->pdev->dev,
 +		 "MAC of VF %d has been set to %pM, and it will be reinitialized!\n",
 +		 vf, mac_addr);
 +
 +	return hclge_inform_reset_assert_to_vf(vport);
 +}
 +
  static int hclge_add_mgr_tbl(struct hclge_dev *hdev,
    		     const struct hclge_mac_mgr_tbl_entry_cmd *req)
  {
@@@ -7742,8 -7564,6 +7742,8 @@@ static int hclge_set_vf_vlan_common(str
    			    __be16 proto)
  {
  #define HCLGE_MAX_VF_BYTES  16
 +
 +	struct hclge_vport *vport = &hdev->vport[vfid];
    struct hclge_vlan_filter_vf_cfg_cmd *req0;
    struct hclge_vlan_filter_vf_cfg_cmd *req1;
    struct hclge_desc desc[2];
@@@ -7752,18 -7572,10 +7752,18 @@@
    int ret;
/* if vf vlan table is full, firmware will close vf vlan filter, it
 -	 * is unable and unnecessary to add new vlan id to vf vlan filter
 +	 * is unable and unnecessary to add new vlan id to vf vlan filter.
 +	 * If spoof check is enable, and vf vlan is full, it shouldn't add
 +	 * new vlan, because tx packets with these vlan id will be dropped.
     */
 -	if (test_bit(vfid, hdev->vf_vlan_full) && !is_kill)
 +	if (test_bit(vfid, hdev->vf_vlan_full) && !is_kill) {
 +		if (vport->vf_info.spoofchk && vlan) {
 +			dev_err(&hdev->pdev->dev,
 +				"Can't add vlan due to spoof check is on and vf vlan table is full\n");
 +			return -EPERM;
 +		}
    	return 0;
 +	}
hclge_cmd_setup_basic_desc(&desc[0],
    			   HCLGE_OPC_VLAN_FILTER_VF_CFG, false);
@@@ -8260,15 -8072,12 +8260,15 @@@ static void hclge_restore_vlan_table(st
    	}
list_for_each_entry_safe(vlan, tmp, &vport->vlan_list, node) {
 -			if (vlan->hd_tbl_status)
 -				hclge_set_vlan_filter_hw(hdev,
 -							 htons(ETH_P_8021Q),
 -							 vport->vport_id,
 -							 vlan->vlan_id,
 -							 false);
 +			int ret;
 +
 +			if (!vlan->hd_tbl_status)
 +				continue;
 +			ret = hclge_set_vlan_filter_hw(hdev, htons(ETH_P_8021Q),
 +						       vport->vport_id,
 +						       vlan->vlan_id, false);
 +			if (ret)
 +				break;
    	}
    }
@@@ -9510,219 -9319,6 +9510,219 @@@ static void hclge_stats_clear(struct hc
    memset(&hdev->hw_stats, 0, sizeof(hdev->hw_stats));
  }
+static int hclge_set_mac_spoofchk(struct hclge_dev *hdev, int vf, bool enable)
 +{
 +	return hclge_config_switch_param(hdev, vf, enable,
 +					 HCLGE_SWITCH_ANTI_SPOOF_MASK);
 +}
 +
 +static int hclge_set_vlan_spoofchk(struct hclge_dev *hdev, int vf, bool enable)
 +{
 +	return hclge_set_vlan_filter_ctrl(hdev, HCLGE_FILTER_TYPE_VF,
 +					  HCLGE_FILTER_FE_NIC_INGRESS_B,
 +					  enable, vf);
 +}
 +
 +static int hclge_set_vf_spoofchk_hw(struct hclge_dev *hdev, int vf, bool enable)
 +{
 +	int ret;
 +
 +	ret = hclge_set_mac_spoofchk(hdev, vf, enable);
 +	if (ret) {
 +		dev_err(&hdev->pdev->dev,
 +			"Set vf %d mac spoof check %s failed, ret=%d\n",
 +			vf, enable ? "on" : "off", ret);
 +		return ret;
 +	}
 +
 +	ret = hclge_set_vlan_spoofchk(hdev, vf, enable);
 +	if (ret)
 +		dev_err(&hdev->pdev->dev,
 +			"Set vf %d vlan spoof check %s failed, ret=%d\n",
 +			vf, enable ? "on" : "off", ret);
 +
 +	return ret;
 +}
 +
 +static int hclge_set_vf_spoofchk(struct hnae3_handle *handle, int vf,
 +				 bool enable)
 +{
 +	struct hclge_vport *vport = hclge_get_vport(handle);
 +	struct hclge_dev *hdev = vport->back;
 +	u32 new_spoofchk = enable ? 1 : 0;
 +	int ret;
 +
 +	if (hdev->pdev->revision == 0x20)
 +		return -EOPNOTSUPP;
 +
 +	vport = hclge_get_vf_vport(hdev, vf);
 +	if (!vport)
 +		return -EINVAL;
 +
 +	if (vport->vf_info.spoofchk == new_spoofchk)
 +		return 0;
 +
 +	if (enable && test_bit(vport->vport_id, hdev->vf_vlan_full))
 +		dev_warn(&hdev->pdev->dev,
 +			 "vf %d vlan table is full, enable spoof check may cause its packet send fail\n",
 +			 vf);
 +	else if (enable && hclge_is_umv_space_full(vport))
 +		dev_warn(&hdev->pdev->dev,
 +			 "vf %d mac table is full, enable spoof check may cause its packet send fail\n",
 +			 vf);
 +
 +	ret = hclge_set_vf_spoofchk_hw(hdev, vport->vport_id, enable);
 +	if (ret)
 +		return ret;
 +
 +	vport->vf_info.spoofchk = new_spoofchk;
 +	return 0;
 +}
 +
 +static int hclge_reset_vport_spoofchk(struct hclge_dev *hdev)
 +{
 +	struct hclge_vport *vport = hdev->vport;
 +	int ret;
 +	int i;
 +
 +	if (hdev->pdev->revision == 0x20)
 +		return 0;
 +
 +	/* resume the vf spoof check state after reset */
 +	for (i = 0; i < hdev->num_alloc_vport; i++) {
 +		ret = hclge_set_vf_spoofchk_hw(hdev, vport->vport_id,
 +					       vport->vf_info.spoofchk);
 +		if (ret)
 +			return ret;
 +
 +		vport++;
 +	}
 +
 +	return 0;
 +}
 +
 +static int hclge_set_vf_trust(struct hnae3_handle *handle, int vf, bool enable)
 +{
 +	struct hclge_vport *vport = hclge_get_vport(handle);
 +	struct hclge_dev *hdev = vport->back;
 +	u32 new_trusted = enable ? 1 : 0;
 +	bool en_bc_pmc;
 +	int ret;
 +
 +	vport = hclge_get_vf_vport(hdev, vf);
 +	if (!vport)
 +		return -EINVAL;
 +
 +	if (vport->vf_info.trusted == new_trusted)
 +		return 0;
 +
 +	/* Disable promisc mode for VF if it is not trusted any more. */
 +	if (!enable && vport->vf_info.promisc_enable) {
 +		en_bc_pmc = hdev->pdev->revision != 0x20;
 +		ret = hclge_set_vport_promisc_mode(vport, false, false,
 +						   en_bc_pmc);
 +		if (ret)
 +			return ret;
 +		vport->vf_info.promisc_enable = 0;
 +		hclge_inform_vf_promisc_info(vport);
 +	}
 +
 +	vport->vf_info.trusted = new_trusted;
 +
 +	return 0;
 +}
 +
 +static void hclge_reset_vf_rate(struct hclge_dev *hdev)
 +{
 +	int ret;
 +	int vf;
 +
 +	/* reset vf rate to default value */
 +	for (vf = HCLGE_VF_VPORT_START_NUM; vf < hdev->num_alloc_vport; vf++) {
 +		struct hclge_vport *vport = &hdev->vport[vf];
 +
 +		vport->vf_info.max_tx_rate = 0;
 +		ret = hclge_tm_qs_shaper_cfg(vport, vport->vf_info.max_tx_rate);
 +		if (ret)
 +			dev_err(&hdev->pdev->dev,
 +				"vf%d failed to reset to default, ret=%d\n",
 +				vf - HCLGE_VF_VPORT_START_NUM, ret);
 +	}
 +}
 +
 +static int hclge_vf_rate_param_check(struct hclge_dev *hdev, int vf,
 +				     int min_tx_rate, int max_tx_rate)
 +{
 +	if (min_tx_rate != 0 ||
 +	    max_tx_rate < 0 || max_tx_rate > hdev->hw.mac.max_speed) {
 +		dev_err(&hdev->pdev->dev,
 +			"min_tx_rate:%d [0], max_tx_rate:%d [0, %u]\n",
 +			min_tx_rate, max_tx_rate, hdev->hw.mac.max_speed);
 +		return -EINVAL;
 +	}
 +
 +	return 0;
 +}
 +
 +static int hclge_set_vf_rate(struct hnae3_handle *handle, int vf,
 +			     int min_tx_rate, int max_tx_rate, bool force)
 +{
 +	struct hclge_vport *vport = hclge_get_vport(handle);
 +	struct hclge_dev *hdev = vport->back;
 +	int ret;
 +
 +	ret = hclge_vf_rate_param_check(hdev, vf, min_tx_rate, max_tx_rate);
 +	if (ret)
 +		return ret;
 +
 +	vport = hclge_get_vf_vport(hdev, vf);
 +	if (!vport)
 +		return -EINVAL;
 +
 +	if (!force && max_tx_rate == vport->vf_info.max_tx_rate)
 +		return 0;
 +
 +	ret = hclge_tm_qs_shaper_cfg(vport, max_tx_rate);
 +	if (ret)
 +		return ret;
 +
 +	vport->vf_info.max_tx_rate = max_tx_rate;
 +
 +	return 0;
 +}
 +
 +static int hclge_resume_vf_rate(struct hclge_dev *hdev)
 +{
 +	struct hnae3_handle *handle = &hdev->vport->nic;
 +	struct hclge_vport *vport;
 +	int ret;
 +	int vf;
 +
 +	/* resume the vf max_tx_rate after reset */
 +	for (vf = 0; vf < pci_num_vf(hdev->pdev); vf++) {
 +		vport = hclge_get_vf_vport(hdev, vf);
 +		if (!vport)
 +			return -EINVAL;
 +
 +		/* zero means max rate, after reset, firmware already set it to
 +		 * max rate, so just continue.
 +		 */
 +		if (!vport->vf_info.max_tx_rate)
 +			continue;
 +
 +		ret = hclge_set_vf_rate(handle, vf, 0,
 +					vport->vf_info.max_tx_rate, true);
 +		if (ret) {
 +			dev_err(&hdev->pdev->dev,
 +				"vf%d failed to resume tx_rate:%u, ret=%d\n",
 +				vf, vport->vf_info.max_tx_rate, ret);
 +			return ret;
 +		}
 +	}
 +
 +	return 0;
 +}
 +
  static void hclge_reset_vport_state(struct hclge_dev *hdev)
  {
    struct hclge_vport *vport = hdev->vport;
@@@ -9800,9 -9396,6 +9800,9 @@@ static int hclge_reset_ae_dev(struct hn
    	return ret;
    }
+	/* Log and clear the hw errors those already occurred */
 +	hclge_handle_all_hns_hw_errors(ae_dev);
 +
    /* Re-enable the hw error interrupts because
     * the interrupts get disabled on global reset.
     */
@@@ -9825,13 -9418,6 +9825,13 @@@
    }
hclge_reset_vport_state(hdev);
 +	ret = hclge_reset_vport_spoofchk(hdev);
 +	if (ret)
 +		return ret;
 +
 +	ret = hclge_resume_vf_rate(hdev);
 +	if (ret)
 +		return ret;
dev_info(&pdev->dev, "Reset done, %s driver initialization finished.\n",
    	 HCLGE_DRIVER_NAME);
@@@ -9844,7 -9430,6 +9844,7 @@@ static void hclge_uninit_ae_dev(struct 
    struct hclge_dev *hdev = ae_dev->priv;
    struct hclge_mac *mac = &hdev->hw.mac;
+	hclge_reset_vf_rate(hdev);
    hclge_misc_affinity_teardown(hdev);
    hclge_state_uninit(hdev);
@@@ -10213,7 -9798,7 +10213,7 @@@ static int hclge_get_dfx_reg_len(struc
    	return ret;
    }
- 	data_len_per_desc = FIELD_SIZEOF(struct hclge_desc, data);
+ 	data_len_per_desc = sizeof_member(struct hclge_desc, data);
    *len = 0;
    for (i = 0; i < dfx_reg_type_num; i++) {
    	bd_num = bd_num_list[i];
@@@ -10567,12 -10152,6 +10567,12 @@@ static const struct hnae3_ae_ops hclge_
    .mac_connect_phy = hclge_mac_connect_phy,
    .mac_disconnect_phy = hclge_mac_disconnect_phy,
    .restore_vlan_table = hclge_restore_vlan_table,
 +	.get_vf_config = hclge_get_vf_config,
 +	.set_vf_link_state = hclge_set_vf_link_state,
 +	.set_vf_spoofchk = hclge_set_vf_spoofchk,
 +	.set_vf_trust = hclge_set_vf_trust,
 +	.set_vf_rate = hclge_set_vf_rate,
 +	.set_vf_mac = hclge_set_vf_mac,
  };
static struct hnae3_ae_algo ae_algo = {
diff --combined drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_tm.c
index b3c30e5f9aa5,a0f08f94b12b..c5e9d0604f09
--- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_tm.c
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_tm.c
@@@ -46,7 -46,7 +46,7 @@@ static int hclge_shaper_para_calc(u32 i
  #define DIVISOR_CLK		(1000 * 8)
  #define DIVISOR_IR_B_126	(126 * DIVISOR_CLK)
-	const u16 tick_array[HCLGE_SHAPER_LVL_CNT] = {
 +	static const u16 tick_array[HCLGE_SHAPER_LVL_CNT] = {
    	6 * 256,        /* Prioriy level */
    	6 * 32,         /* Prioriy group level */
    	6 * 8,          /* Port level */
@@@ -511,49 -511,6 +511,49 @@@ static int hclge_tm_qs_bp_cfg(struct hc
    return hclge_cmd_send(&hdev->hw, &desc, 1);
  }
+int hclge_tm_qs_shaper_cfg(struct hclge_vport *vport, int max_tx_rate)
 +{
 +	struct hnae3_knic_private_info *kinfo = &vport->nic.kinfo;
 +	struct hclge_qs_shapping_cmd *shap_cfg_cmd;
 +	struct hclge_dev *hdev = vport->back;
 +	struct hclge_desc desc;
 +	u8 ir_b, ir_u, ir_s;
 +	u32 shaper_para;
 +	int ret, i;
 +
 +	if (!max_tx_rate)
 +		max_tx_rate = HCLGE_ETHER_MAX_RATE;
 +
 +	ret = hclge_shaper_para_calc(max_tx_rate, HCLGE_SHAPER_LVL_QSET,
 +				     &ir_b, &ir_u, &ir_s);
 +	if (ret)
 +		return ret;
 +
 +	shaper_para = hclge_tm_get_shapping_para(ir_b, ir_u, ir_s,
 +						 HCLGE_SHAPER_BS_U_DEF,
 +						 HCLGE_SHAPER_BS_S_DEF);
 +
 +	for (i = 0; i < kinfo->num_tc; i++) {
 +		hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_QCN_SHAPPING_CFG,
 +					   false);
 +
 +		shap_cfg_cmd = (struct hclge_qs_shapping_cmd *)desc.data;
 +		shap_cfg_cmd->qs_id = cpu_to_le16(vport->qs_offset + i);
 +		shap_cfg_cmd->qs_shapping_para = cpu_to_le32(shaper_para);
 +
 +		ret = hclge_cmd_send(&hdev->hw, &desc, 1);
 +		if (ret) {
 +			dev_err(&hdev->pdev->dev,
 +				"vf%d, qs%u failed to set tx_rate:%d, ret=%d\n",
 +				vport->vport_id, shap_cfg_cmd->qs_id,
 +				max_tx_rate, ret);
 +			return ret;
 +		}
 +	}
 +
 +	return 0;
 +}
 +
  static void hclge_tm_vport_tc_info_update(struct hclge_vport *vport)
  {
    struct hnae3_knic_private_info *kinfo = &vport->nic.kinfo;
@@@ -580,16 -537,9 +580,16 @@@
    	kinfo->rss_size = kinfo->req_rss_size;
    } else if (kinfo->rss_size > max_rss_size ||
    	   (!kinfo->req_rss_size && kinfo->rss_size < max_rss_size)) {
 +		/* if user not set rss, the rss_size should compare with the
 +		 * valid msi numbers to ensure one to one map between tqp and
 +		 * irq as default.
 +		 */
 +		if (!kinfo->req_rss_size)
 +			max_rss_size = min_t(u16, max_rss_size,
 +					     (hdev->num_nic_msi - 1) /
 +					     kinfo->num_tc);
 +
    	/* Set to the maximum specification value (max_rss_size). */
 -		dev_info(&hdev->pdev->dev, "rss changes from %d to %d\n",
 -			 kinfo->rss_size, max_rss_size);
    	kinfo->rss_size = max_rss_size;
    }
@@@ -614,7 -564,7 +614,7 @@@
    }
memcpy(kinfo->prio_tc, hdev->tm_info.prio_tc,
- 	       FIELD_SIZEOF(struct hnae3_knic_private_info, prio_tc));
+ 	       sizeof_member(struct hnae3_knic_private_info, prio_tc));
  }
static void hclge_tm_vport_info_update(struct hclge_dev *hdev)
diff --combined drivers/net/ethernet/intel/i40e/i40e_ethtool.c
index d24d8731bef0,8b0c60d754e1..990e29ff7ac4
--- a/drivers/net/ethernet/intel/i40e/i40e_ethtool.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_ethtool.c
@@@ -43,7 -43,7 +43,7 @@@ struct i40e_stats 
   */
  #define I40E_STAT(_type, _name, _stat) { \
    .stat_string = _name, \
- 	.sizeof_stat = FIELD_SIZEOF(_type, _stat), \
+ 	.sizeof_stat = sizeof_member(_type, _stat), \
    .stat_offset = offsetof(_type, _stat) \
  }
@@@ -722,14 -722,7 +722,14 @@@ static void i40e_get_settings_link_up_f
    ethtool_link_ksettings_add_link_mode(ks, supported, FEC_RS);
    ethtool_link_ksettings_add_link_mode(ks, supported, FEC_BASER);
-	if (I40E_AQ_SET_FEC_REQUEST_RS & req_fec_info) {
 +	if ((I40E_AQ_SET_FEC_REQUEST_RS & req_fec_info) &&
 +	    (I40E_AQ_SET_FEC_REQUEST_KR & req_fec_info)) {
 +		ethtool_link_ksettings_add_link_mode(ks, advertising,
 +						     FEC_NONE);
 +		ethtool_link_ksettings_add_link_mode(ks, advertising,
 +						     FEC_BASER);
 +		ethtool_link_ksettings_add_link_mode(ks, advertising, FEC_RS);
 +	} else if (I40E_AQ_SET_FEC_REQUEST_RS & req_fec_info) {
    	ethtool_link_ksettings_add_link_mode(ks, advertising, FEC_RS);
    } else if (I40E_AQ_SET_FEC_REQUEST_KR & req_fec_info) {
    	ethtool_link_ksettings_add_link_mode(ks, advertising,
@@@ -737,6 -730,12 +737,6 @@@
    } else {
    	ethtool_link_ksettings_add_link_mode(ks, advertising,
    					     FEC_NONE);
 -		if (I40E_AQ_SET_FEC_AUTO & req_fec_info) {
 -			ethtool_link_ksettings_add_link_mode(ks, advertising,
 -							     FEC_RS);
 -			ethtool_link_ksettings_add_link_mode(ks, advertising,
 -							     FEC_BASER);
 -		}
    }
  }
@@@ -1438,7 -1437,6 +1438,7 @@@ static int i40e_get_fec_param(struct ne
    struct i40e_hw *hw = &pf->hw;
    i40e_status status = 0;
    int err = 0;
 +	u8 fec_cfg;
/* Get the current phy config */
    memset(&abilities, 0, sizeof(abilities));
@@@ -1450,16 -1448,18 +1450,16 @@@
    }
fecparam->fec = 0;
 -	if (abilities.fec_cfg_curr_mod_ext_info & I40E_AQ_SET_FEC_AUTO)
 +	fec_cfg = abilities.fec_cfg_curr_mod_ext_info;
 +	if (fec_cfg & I40E_AQ_SET_FEC_AUTO)
    	fecparam->fec |= ETHTOOL_FEC_AUTO;
 -	if ((abilities.fec_cfg_curr_mod_ext_info &
 -	     I40E_AQ_SET_FEC_REQUEST_RS) ||
 -	    (abilities.fec_cfg_curr_mod_ext_info &
 -	     I40E_AQ_SET_FEC_ABILITY_RS))
 +	else if (fec_cfg & (I40E_AQ_SET_FEC_REQUEST_RS |
 +		 I40E_AQ_SET_FEC_ABILITY_RS))
    	fecparam->fec |= ETHTOOL_FEC_RS;
 -	if ((abilities.fec_cfg_curr_mod_ext_info &
 -	     I40E_AQ_SET_FEC_REQUEST_KR) ||
 -	    (abilities.fec_cfg_curr_mod_ext_info & I40E_AQ_SET_FEC_ABILITY_KR))
 +	else if (fec_cfg & (I40E_AQ_SET_FEC_REQUEST_KR |
 +		 I40E_AQ_SET_FEC_ABILITY_KR))
    	fecparam->fec |= ETHTOOL_FEC_BASER;
 -	if (abilities.fec_cfg_curr_mod_ext_info == 0)
 +	if (fec_cfg == 0)
    	fecparam->fec |= ETHTOOL_FEC_OFF;
if (hw->phy.link_info.fec_info & I40E_AQ_CONFIG_FEC_KR_ENA)
@@@ -5112,7 -5112,7 +5112,7 @@@ static int i40e_get_module_info(struct 
    case I40E_MODULE_TYPE_SFP:
    	status = i40e_aq_get_phy_register(hw,
    			I40E_AQ_PHY_REG_ACCESS_EXTERNAL_MODULE,
 -				I40E_I2C_EEPROM_DEV_ADDR,
 +				I40E_I2C_EEPROM_DEV_ADDR, true,
    			I40E_MODULE_SFF_8472_COMP,
    			&sff8472_comp, NULL);
    	if (status)
@@@ -5120,7 -5120,7 +5120,7 @@@
status = i40e_aq_get_phy_register(hw,
    			I40E_AQ_PHY_REG_ACCESS_EXTERNAL_MODULE,
 -				I40E_I2C_EEPROM_DEV_ADDR,
 +				I40E_I2C_EEPROM_DEV_ADDR, true,
    			I40E_MODULE_SFF_8472_SWAP,
    			&sff8472_swap, NULL);
    	if (status)
@@@ -5152,7 -5152,7 +5152,7 @@@
    	/* Read from memory page 0. */
    	status = i40e_aq_get_phy_register(hw,
    			I40E_AQ_PHY_REG_ACCESS_EXTERNAL_MODULE,
 -				0,
 +				0, true,
    			I40E_MODULE_REVISION_ADDR,
    			&sff8636_rev, NULL);
    	if (status)
@@@ -5223,7 -5223,7 +5223,7 @@@ static int i40e_get_module_eeprom(struc
status = i40e_aq_get_phy_register(hw,
    			I40E_AQ_PHY_REG_ACCESS_EXTERNAL_MODULE,
 -				addr, offset, &value, NULL);
 +				true, addr, offset, &value, NULL);
    	if (status)
    		return -EIO;
    	data[i] = value;
@@@ -5242,7 -5242,6 +5242,7 @@@ static int i40e_set_eee(struct net_devi
  }
static const struct ethtool_ops i40e_ethtool_recovery_mode_ops = {
 +	.get_drvinfo		= i40e_get_drvinfo,
    .set_eeprom		= i40e_set_eeprom,
    .get_eeprom_len		= i40e_get_eeprom_len,
    .get_eeprom		= i40e_get_eeprom,
diff --combined drivers/net/ethernet/netronome/nfp/bpf/jit.c
index c80bb83c8ac9,276af07a2841..a2c02be6e34c
--- a/drivers/net/ethernet/netronome/nfp/bpf/jit.c
+++ b/drivers/net/ethernet/netronome/nfp/bpf/jit.c
@@@ -2652,17 -2652,17 +2652,17 @@@ static int mem_ldx_skb(struct nfp_prog
switch (meta->insn.off) {
    case offsetof(struct __sk_buff, len):
- 		if (size != FIELD_SIZEOF(struct __sk_buff, len))
+ 		if (size != sizeof_member(struct __sk_buff, len))
    		return -EOPNOTSUPP;
    	wrp_mov(nfp_prog, dst, plen_reg(nfp_prog));
    	break;
    case offsetof(struct __sk_buff, data):
- 		if (size != FIELD_SIZEOF(struct __sk_buff, data))
+ 		if (size != sizeof_member(struct __sk_buff, data))
    		return -EOPNOTSUPP;
    	wrp_mov(nfp_prog, dst, pptr_reg(nfp_prog));
    	break;
    case offsetof(struct __sk_buff, data_end):
- 		if (size != FIELD_SIZEOF(struct __sk_buff, data_end))
+ 		if (size != sizeof_member(struct __sk_buff, data_end))
    		return -EOPNOTSUPP;
    	emit_alu(nfp_prog, dst,
    		 plen_reg(nfp_prog), ALU_OP_ADD, pptr_reg(nfp_prog));
@@@ -2683,12 -2683,12 +2683,12 @@@ static int mem_ldx_xdp(struct nfp_prog
switch (meta->insn.off) {
    case offsetof(struct xdp_md, data):
- 		if (size != FIELD_SIZEOF(struct xdp_md, data))
+ 		if (size != sizeof_member(struct xdp_md, data))
    		return -EOPNOTSUPP;
    	wrp_mov(nfp_prog, dst, pptr_reg(nfp_prog));
    	break;
    case offsetof(struct xdp_md, data_end):
- 		if (size != FIELD_SIZEOF(struct xdp_md, data_end))
+ 		if (size != sizeof_member(struct xdp_md, data_end))
    		return -EOPNOTSUPP;
    	emit_alu(nfp_prog, dst,
    		 plen_reg(nfp_prog), ALU_OP_ADD, pptr_reg(nfp_prog));
@@@ -3952,7 -3952,7 +3952,7 @@@ static void nfp_bpf_opt_neg_add_sub(str
  static void nfp_bpf_opt_ld_mask(struct nfp_prog *nfp_prog)
  {
    struct nfp_insn_meta *meta1, *meta2;
 -	const s32 exp_mask[] = {
 +	static const s32 exp_mask[] = {
    	[BPF_B] = 0x000000ffU,
    	[BPF_H] = 0x0000ffffU,
    	[BPF_W] = 0xffffffffU,
diff --combined drivers/net/hyperv/netvsc_drv.c
index fd4fff57fd6e,6102264d9978..83c3c78e9f05
--- a/drivers/net/hyperv/netvsc_drv.c
+++ b/drivers/net/hyperv/netvsc_drv.c
@@@ -571,7 -571,7 +571,7 @@@ static int netvsc_start_xmit(struct sk_
/* Use the skb control buffer for building up the packet */
    BUILD_BUG_ON(sizeof(struct hv_netvsc_packet) >
- 			FIELD_SIZEOF(struct sk_buff, cb));
+ 			sizeof_member(struct sk_buff, cb));
    packet = (struct hv_netvsc_packet *)skb->cb;
packet->q_idx = skb_get_queue_mapping(skb);
@@@ -2335,6 -2335,8 +2335,6 @@@ static int netvsc_probe(struct hv_devic
    	NETIF_F_HW_VLAN_CTAG_RX;
    net->vlan_features = net->features;
-	netdev_lockdep_set_classes(net);
 -
    /* MTU range: 68 - 1500 or 65521 */
    net->min_mtu = NETVSC_MTU_MIN;
    if (nvdev->nvsp_version >= NVSP_PROTOCOL_VERSION_2)
diff --combined drivers/net/vxlan.c
index 8869154fad88,27bfde225a73..4700191d1adc
--- a/drivers/net/vxlan.c
+++ b/drivers/net/vxlan.c
@@@ -2487,11 -2487,9 +2487,11 @@@ static void vxlan_xmit_one(struct sk_bu
    	vni = tunnel_id_to_key32(info->key.tun_id);
    	ifindex = 0;
    	dst_cache = &info->dst_cache;
 -		if (info->options_len &&
 -		    info->key.tun_flags & TUNNEL_VXLAN_OPT)
 +		if (info->key.tun_flags & TUNNEL_VXLAN_OPT) {
 +			if (info->options_len < sizeof(*md))
 +				goto drop;
    		md = ip_tunnel_info_opts(info);
 +		}
    	ttl = info->key.ttl;
    	tos = info->key.tos;
    	label = info->key.label;
@@@ -3072,10 -3070,10 +3072,10 @@@ static void vxlan_raw_setup(struct net_
static const struct nla_policy vxlan_policy[IFLA_VXLAN_MAX + 1] = {
    [IFLA_VXLAN_ID]		= { .type = NLA_U32 },
- 	[IFLA_VXLAN_GROUP]	= { .len = FIELD_SIZEOF(struct iphdr, daddr) },
+ 	[IFLA_VXLAN_GROUP]	= { .len = sizeof_member(struct iphdr, daddr) },
    [IFLA_VXLAN_GROUP6]	= { .len = sizeof(struct in6_addr) },
    [IFLA_VXLAN_LINK]	= { .type = NLA_U32 },
- 	[IFLA_VXLAN_LOCAL]	= { .len = FIELD_SIZEOF(struct iphdr, saddr) },
+ 	[IFLA_VXLAN_LOCAL]	= { .len = sizeof_member(struct iphdr, saddr) },
    [IFLA_VXLAN_LOCAL6]	= { .len = sizeof(struct in6_addr) },
    [IFLA_VXLAN_TOS]	= { .type = NLA_U8 },
    [IFLA_VXLAN_TTL]	= { .type = NLA_U8 },
@@@ -3568,13 -3566,10 +3568,13 @@@ static int __vxlan_dev_create(struct ne
  {
    struct vxlan_net *vn = net_generic(net, vxlan_net_id);
    struct vxlan_dev *vxlan = netdev_priv(dev);
 +	struct net_device *remote_dev = NULL;
    struct vxlan_fdb *f = NULL;
    bool unregister = false;
 +	struct vxlan_rdst *dst;
    int err;
+	dst = &vxlan->default_dst;
    err = vxlan_dev_configure(net, dev, conf, false, extack);
    if (err)
    	return err;
@@@ -3582,14 -3577,14 +3582,14 @@@
    dev->ethtool_ops = &vxlan_ethtool_ops;
/* create an fdb entry for a valid default destination */
 -	if (!vxlan_addr_any(&vxlan->default_dst.remote_ip)) {
 +	if (!vxlan_addr_any(&dst->remote_ip)) {
    	err = vxlan_fdb_create(vxlan, all_zeros_mac,
 -				       &vxlan->default_dst.remote_ip,
 +				       &dst->remote_ip,
    			       NUD_REACHABLE | NUD_PERMANENT,
    			       vxlan->cfg.dst_port,
 -				       vxlan->default_dst.remote_vni,
 -				       vxlan->default_dst.remote_vni,
 -				       vxlan->default_dst.remote_ifindex,
 +				       dst->remote_vni,
 +				       dst->remote_vni,
 +				       dst->remote_ifindex,
    			       NTF_SELF, &f);
    	if (err)
    		return err;
@@@ -3600,41 -3595,26 +3600,41 @@@
    	goto errout;
    unregister = true;
+	if (dst->remote_ifindex) {
 +		remote_dev = __dev_get_by_index(net, dst->remote_ifindex);
 +		if (!remote_dev)
 +			goto errout;
 +
 +		err = netdev_upper_dev_link(remote_dev, dev, extack);
 +		if (err)
 +			goto errout;
 +	}
 +
    err = rtnl_configure_link(dev, NULL);
    if (err)
 -		goto errout;
 +		goto unlink;
if (f) {
 -		vxlan_fdb_insert(vxlan, all_zeros_mac,
 -				 vxlan->default_dst.remote_vni, f);
 +		vxlan_fdb_insert(vxlan, all_zeros_mac, dst->remote_vni, f);
/* notify default fdb entry */
    	err = vxlan_fdb_notify(vxlan, f, first_remote_rtnl(f),
    			       RTM_NEWNEIGH, true, extack);
    	if (err) {
    		vxlan_fdb_destroy(vxlan, f, false, false);
 +			if (remote_dev)
 +				netdev_upper_dev_unlink(remote_dev, dev);
    		goto unregister;
    	}
    }
list_add(&vxlan->next, &vn->vxlan_list);
 +	if (remote_dev)
 +		dst->remote_dev = remote_dev;
    return 0;
 -
 +unlink:
 +	if (remote_dev)
 +		netdev_upper_dev_unlink(remote_dev, dev);
  errout:
    /* unregister_netdevice() destroys the default FDB entry with deletion
     * notification. But the addition notification was not sent yet, so
@@@ -3952,12 -3932,11 +3952,12 @@@ static int vxlan_changelink(struct net_
    		    struct netlink_ext_ack *extack)
  {
    struct vxlan_dev *vxlan = netdev_priv(dev);
 -	struct vxlan_rdst *dst = &vxlan->default_dst;
    struct net_device *lowerdev;
    struct vxlan_config conf;
 +	struct vxlan_rdst *dst;
    int err;
+	dst = &vxlan->default_dst;
    err = vxlan_nl2conf(tb, data, dev, &conf, true, extack);
    if (err)
    	return err;
@@@ -3967,14 -3946,6 +3967,14 @@@
    if (err)
    	return err;
+	if (dst->remote_dev == lowerdev)
 +		lowerdev = NULL;
 +
 +	err = netdev_adjacent_change_prepare(dst->remote_dev, lowerdev, dev,
 +					     extack);
 +	if (err)
 +		return err;
 +
    /* handle default dst entry */
    if (!vxlan_addr_equal(&conf.remote_ip, &dst->remote_ip)) {
    	u32 hash_index = fdb_head_index(vxlan, all_zeros_mac, conf.vni);
@@@ -3991,8 -3962,6 +3991,8 @@@
    				       NTF_SELF, true, extack);
    		if (err) {
    			spin_unlock_bh(&vxlan->hash_lock[hash_index]);
 +				netdev_adjacent_change_abort(dst->remote_dev,
 +							     lowerdev, dev);
    			return err;
    		}
    	}
@@@ -4010,11 -3979,6 +4010,11 @@@
    if (conf.age_interval != vxlan->cfg.age_interval)
    	mod_timer(&vxlan->age_timer, jiffies);
+	netdev_adjacent_change_commit(dst->remote_dev, lowerdev, dev);
 +	if (lowerdev && lowerdev != dst->remote_dev) {
 +		dst->remote_dev = lowerdev;
 +		netdev_update_lockdep_key(lowerdev);
 +	}
    vxlan_config_apply(dev, &conf, lowerdev, vxlan->net, true);
    return 0;
  }
@@@ -4027,8 -3991,6 +4027,8 @@@ static void vxlan_dellink(struct net_de
list_del(&vxlan->next);
    unregister_netdevice_queue(dev, head);
 +	if (vxlan->default_dst.remote_dev)
 +		netdev_upper_dev_unlink(vxlan->default_dst.remote_dev, dev);
  }
static size_t vxlan_get_size(const struct net_device *dev)
diff --combined drivers/scsi/aacraid/aachba.c
index e36608ce937a,f30fe29b5701..3b232b6a3eff
--- a/drivers/scsi/aacraid/aachba.c
+++ b/drivers/scsi/aacraid/aachba.c
@@@ -535,7 -535,7 +535,7 @@@ static void get_container_name_callback
    if ((le32_to_cpu(get_name_reply->status) == CT_OK)
     && (get_name_reply->data[0] != '\0')) {
    	char *sp = get_name_reply->data;
- 		int data_size = FIELD_SIZEOF(struct aac_get_name_resp, data);
+ 		int data_size = sizeof_member(struct aac_get_name_resp, data);
sp[data_size - 1] = '\0';
    	while (*sp == ' ')
@@@ -574,7 -574,7 +574,7 @@@ static int aac_get_container_name(struc
dev = (struct aac_dev *)scsicmd->device->host->hostdata;
- 	data_size = FIELD_SIZEOF(struct aac_get_name_resp, data);
+ 	data_size = sizeof_member(struct aac_get_name_resp, data);
cmd_fibcontext = aac_fib_alloc_tag(dev, scsicmd);
@@@ -1477,7 -1477,6 +1477,7 @@@ static struct aac_srb * aac_scsi_common
    struct aac_srb * srbcmd;
    u32 flag;
    u32 timeout;
 +	struct aac_dev *dev = fib->dev;
aac_fib_init(fib);
    switch(cmd->sc_data_direction){
@@@ -1504,7 -1503,7 +1504,7 @@@
    srbcmd->flags    = cpu_to_le32(flag);
    timeout = cmd->request->timeout/HZ;
    if (timeout == 0)
 -		timeout = 1;
 +		timeout = (dev->sa_firmware ? AAC_SA_TIMEOUT : AAC_ARC_TIMEOUT);
    srbcmd->timeout  = cpu_to_le32(timeout);  // timeout in seconds
    srbcmd->retry_limit = 0; /* Obsolete parameter */
    srbcmd->cdb_size = cpu_to_le32(cmd->cmd_len);
@@@ -2468,13 -2467,13 +2468,13 @@@ static int aac_read(struct scsi_cmnd * 
    	scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 |
    		SAM_STAT_CHECK_CONDITION;
    	set_sense(&dev->fsa_dev[cid].sense_data,
 -			  HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE,
 +			  ILLEGAL_REQUEST, SENCODE_LBA_OUT_OF_RANGE,
    		  ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0);
    	memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data,
    	       min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data),
    		     SCSI_SENSE_BUFFERSIZE));
    	scsicmd->scsi_done(scsicmd);
 -		return 1;
 +		return 0;
    }
dprintk((KERN_DEBUG "aac_read[cpu %d]: lba = %llu, t = %ld.\n",
@@@ -2560,13 -2559,13 +2560,13 @@@ static int aac_write(struct scsi_cmnd 
    	scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 |
    		SAM_STAT_CHECK_CONDITION;
    	set_sense(&dev->fsa_dev[cid].sense_data,
 -			  HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE,
 +			  ILLEGAL_REQUEST, SENCODE_LBA_OUT_OF_RANGE,
    		  ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0);
    	memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data,
    	       min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data),
    		     SCSI_SENSE_BUFFERSIZE));
    	scsicmd->scsi_done(scsicmd);
 -		return 1;
 +		return 0;
    }
dprintk((KERN_DEBUG "aac_write[cpu %d]: lba = %llu, t = %ld.\n",
diff --combined drivers/scsi/cxgbi/libcxgbi.c
index 0d044c165960,cf261e1ae9d4..e7143b257117
--- a/drivers/scsi/cxgbi/libcxgbi.c
+++ b/drivers/scsi/cxgbi/libcxgbi.c
@@@ -2284,6 -2284,34 +2284,6 @@@ int cxgbi_set_conn_param(struct iscsi_c
  }
  EXPORT_SYMBOL_GPL(cxgbi_set_conn_param);
-static inline int csk_print_port(struct cxgbi_sock *csk, char *buf)
 -{
 -	int len;
 -
 -	cxgbi_sock_get(csk);
 -	len = sprintf(buf, "%hu\n", ntohs(csk->daddr.sin_port));
 -	cxgbi_sock_put(csk);
 -
 -	return len;
 -}
 -
 -static inline int csk_print_ip(struct cxgbi_sock *csk, char *buf)
 -{
 -	int len;
 -
 -	cxgbi_sock_get(csk);
 -	if (csk->csk_family == AF_INET)
 -		len = sprintf(buf, "%pI4",
 -			      &csk->daddr.sin_addr.s_addr);
 -	else
 -		len = sprintf(buf, "%pI6",
 -			      &csk->daddr6.sin6_addr);
 -
 -	cxgbi_sock_put(csk);
 -
 -	return len;
 -}
 -
  int cxgbi_get_ep_param(struct iscsi_endpoint *ep, enum iscsi_param param,
    	       char *buf)
  {
@@@ -2746,7 -2774,7 +2746,7 @@@ static int __init libcxgbi_init_module(
  {
    pr_info("%s", version);
- 	BUILD_BUG_ON(FIELD_SIZEOF(struct sk_buff, cb) <
+ 	BUILD_BUG_ON(sizeof_member(struct sk_buff, cb) <
    	     sizeof(struct cxgbi_skb_cb));
    return 0;
  }
diff --combined drivers/scsi/smartpqi/smartpqi_init.c
index 7b7ef3acb504,fafa4c1c2fea..e1499626cbbd
--- a/drivers/scsi/smartpqi/smartpqi_init.c
+++ b/drivers/scsi/smartpqi/smartpqi_init.c
@@@ -33,11 -33,11 +33,11 @@@
  #define BUILD_TIMESTAMP
  #endif
-#define DRIVER_VERSION		"1.2.8-026"
 +#define DRIVER_VERSION		"1.2.10-025"
  #define DRIVER_MAJOR		1
  #define DRIVER_MINOR		2
 -#define DRIVER_RELEASE		8
 -#define DRIVER_REVISION		26
 +#define DRIVER_RELEASE		10
 +#define DRIVER_REVISION		25
#define DRIVER_NAME		"Microsemi PQI Driver (v" \
    			DRIVER_VERSION BUILD_TIMESTAMP ")"
@@@ -211,11 -211,6 +211,11 @@@ static inline bool pqi_is_external_raid
    return scsi3addr[2] != 0;
  }
+static inline bool pqi_ctrl_offline(struct pqi_ctrl_info *ctrl_info)
 +{
 +	return !ctrl_info->controller_online;
 +}
 +
  static inline void pqi_check_ctrl_health(struct pqi_ctrl_info *ctrl_info)
  {
    if (ctrl_info->controller_online)
@@@ -240,21 -235,6 +240,21 @@@ static inline void pqi_save_ctrl_mode(s
    sis_write_driver_scratch(ctrl_info, mode);
  }
+static inline void pqi_ctrl_block_device_reset(struct pqi_ctrl_info *ctrl_info)
 +{
 +	ctrl_info->block_device_reset = true;
 +}
 +
 +static inline bool pqi_device_reset_blocked(struct pqi_ctrl_info *ctrl_info)
 +{
 +	return ctrl_info->block_device_reset;
 +}
 +
 +static inline bool pqi_ctrl_blocked(struct pqi_ctrl_info *ctrl_info)
 +{
 +	return ctrl_info->block_requests;
 +}
 +
  static inline void pqi_ctrl_block_requests(struct pqi_ctrl_info *ctrl_info)
  {
    ctrl_info->block_requests = true;
@@@ -351,16 -331,6 +351,16 @@@ static inline bool pqi_device_in_remove
    return device->in_remove && !ctrl_info->in_shutdown;
  }
+static inline void pqi_ctrl_shutdown_start(struct pqi_ctrl_info *ctrl_info)
 +{
 +	ctrl_info->in_shutdown = true;
 +}
 +
 +static inline bool pqi_ctrl_in_shutdown(struct pqi_ctrl_info *ctrl_info)
 +{
 +	return ctrl_info->in_shutdown;
 +}
 +
  static inline void pqi_schedule_rescan_worker_with_delay(
    struct pqi_ctrl_info *ctrl_info, unsigned long delay)
  {
@@@ -390,11 -360,6 +390,11 @@@ static inline void pqi_cancel_rescan_wo
    cancel_delayed_work_sync(&ctrl_info->rescan_work);
  }
+static inline void pqi_cancel_event_worker(struct pqi_ctrl_info *ctrl_info)
 +{
 +	cancel_work_sync(&ctrl_info->event_work);
 +}
 +
  static inline u32 pqi_read_heartbeat_counter(struct pqi_ctrl_info *ctrl_info)
  {
    if (!ctrl_info->heartbeat_counter)
@@@ -412,7 -377,7 +412,7 @@@ static inline u8 pqi_read_soft_reset_st
  }
static inline void pqi_clear_soft_reset_status(struct pqi_ctrl_info *ctrl_info,
 -						u8 clear)
 +	u8 clear)
  {
    u8 status;
@@@ -497,9 -462,9 +497,9 @@@ static int pqi_build_raid_path_request(
    	request->data_direction = SOP_READ_FLAG;
    	cdb[0] = cmd;
    	if (cmd == CISS_REPORT_PHYS)
 -			cdb[1] = CISS_REPORT_PHYS_EXTENDED;
 +			cdb[1] = CISS_REPORT_PHYS_FLAG_OTHER;
    	else
 -			cdb[1] = CISS_REPORT_LOG_EXTENDED;
 +			cdb[1] = CISS_REPORT_LOG_FLAG_UNIQUE_LUN_ID;
    	put_unaligned_be32(cdb_length, &cdb[6]);
    	break;
    case CISS_GET_RAID_MAP:
@@@ -602,12 -567,13 +602,12 @@@ static void pqi_free_io_request(struct 
  }
static int pqi_send_scsi_raid_request(struct pqi_ctrl_info *ctrl_info, u8 cmd,
 -		u8 *scsi3addr, void *buffer, size_t buffer_length, u16 vpd_page,
 -		struct pqi_raid_error_info *error_info,
 -		unsigned long timeout_msecs)
 +	u8 *scsi3addr, void *buffer, size_t buffer_length, u16 vpd_page,
 +	struct pqi_raid_error_info *error_info,	unsigned long timeout_msecs)
  {
    int rc;
 -	enum dma_data_direction dir;
    struct pqi_raid_path_request request;
 +	enum dma_data_direction dir;
rc = pqi_build_raid_path_request(ctrl_info, &request,
    	cmd, scsi3addr, buffer,
@@@ -615,44 -581,44 +615,44 @@@
    if (rc)
    	return rc;
-	rc = pqi_submit_raid_request_synchronous(ctrl_info, &request.header,
 -		 0, error_info, timeout_msecs);
 +	rc = pqi_submit_raid_request_synchronous(ctrl_info, &request.header, 0,
 +		error_info, timeout_msecs);
pqi_pci_unmap(ctrl_info->pci_dev, request.sg_descriptors, 1, dir);
 +
    return rc;
  }
-/* Helper functions for pqi_send_scsi_raid_request */
 +/* helper functions for pqi_send_scsi_raid_request */
static inline int pqi_send_ctrl_raid_request(struct pqi_ctrl_info *ctrl_info,
 -		u8 cmd, void *buffer, size_t buffer_length)
 +	u8 cmd, void *buffer, size_t buffer_length)
  {
    return pqi_send_scsi_raid_request(ctrl_info, cmd, RAID_CTLR_LUNID,
 -			buffer, buffer_length, 0, NULL, NO_TIMEOUT);
 +		buffer, buffer_length, 0, NULL, NO_TIMEOUT);
  }
static inline int pqi_send_ctrl_raid_with_error(struct pqi_ctrl_info *ctrl_info,
 -		u8 cmd, void *buffer, size_t buffer_length,
 -		struct pqi_raid_error_info *error_info)
 +	u8 cmd, void *buffer, size_t buffer_length,
 +	struct pqi_raid_error_info *error_info)
  {
    return pqi_send_scsi_raid_request(ctrl_info, cmd, RAID_CTLR_LUNID,
 -			buffer, buffer_length, 0, error_info, NO_TIMEOUT);
 +		buffer, buffer_length, 0, error_info, NO_TIMEOUT);
  }
-
  static inline int pqi_identify_controller(struct pqi_ctrl_info *ctrl_info,
 -		struct bmic_identify_controller *buffer)
 +	struct bmic_identify_controller *buffer)
  {
    return pqi_send_ctrl_raid_request(ctrl_info, BMIC_IDENTIFY_CONTROLLER,
 -			buffer, sizeof(*buffer));
 +		buffer, sizeof(*buffer));
  }
static inline int pqi_sense_subsystem_info(struct  pqi_ctrl_info *ctrl_info,
 -		struct bmic_sense_subsystem_info *sense_info)
 +	struct bmic_sense_subsystem_info *sense_info)
  {
    return pqi_send_ctrl_raid_request(ctrl_info,
 -			BMIC_SENSE_SUBSYSTEM_INFORMATION,
 -			sense_info, sizeof(*sense_info));
 +		BMIC_SENSE_SUBSYSTEM_INFORMATION, sense_info,
 +		sizeof(*sense_info));
  }
static inline int pqi_scsi_inquiry(struct pqi_ctrl_info *ctrl_info,
@@@ -662,9 -628,83 +662,9 @@@
    	buffer, buffer_length, vpd_page, NULL, NO_TIMEOUT);
  }
-static bool pqi_vpd_page_supported(struct pqi_ctrl_info *ctrl_info,
 -	u8 *scsi3addr, u16 vpd_page)
 -{
 -	int rc;
 -	int i;
 -	int pages;
 -	unsigned char *buf, bufsize;
 -
 -	buf = kzalloc(256, GFP_KERNEL);
 -	if (!buf)
 -		return false;
 -
 -	/* Get the size of the page list first */
 -	rc = pqi_scsi_inquiry(ctrl_info, scsi3addr,
 -				VPD_PAGE | SCSI_VPD_SUPPORTED_PAGES,
 -				buf, SCSI_VPD_HEADER_SZ);
 -	if (rc != 0)
 -		goto exit_unsupported;
 -
 -	pages = buf[3];
 -	if ((pages + SCSI_VPD_HEADER_SZ) <= 255)
 -		bufsize = pages + SCSI_VPD_HEADER_SZ;
 -	else
 -		bufsize = 255;
 -
 -	/* Get the whole VPD page list */
 -	rc = pqi_scsi_inquiry(ctrl_info, scsi3addr,
 -				VPD_PAGE | SCSI_VPD_SUPPORTED_PAGES,
 -				buf, bufsize);
 -	if (rc != 0)
 -		goto exit_unsupported;
 -
 -	pages = buf[3];
 -	for (i = 1; i <= pages; i++)
 -		if (buf[3 + i] == vpd_page)
 -			goto exit_supported;
 -
 -exit_unsupported:
 -	kfree(buf);
 -	return false;
 -
 -exit_supported:
 -	kfree(buf);
 -	return true;
 -}
 -
 -static int pqi_get_device_id(struct pqi_ctrl_info *ctrl_info,
 -	u8 *scsi3addr, u8 *device_id, int buflen)
 -{
 -	int rc;
 -	unsigned char *buf;
 -
 -	if (!pqi_vpd_page_supported(ctrl_info, scsi3addr, SCSI_VPD_DEVICE_ID))
 -		return 1; /* function not supported */
 -
 -	buf = kzalloc(64, GFP_KERNEL);
 -	if (!buf)
 -		return -ENOMEM;
 -
 -	rc = pqi_scsi_inquiry(ctrl_info, scsi3addr,
 -				VPD_PAGE | SCSI_VPD_DEVICE_ID,
 -				buf, 64);
 -	if (rc == 0) {
 -		if (buflen > 16)
 -			buflen = 16;
 -		memcpy(device_id, &buf[SCSI_VPD_DEVICE_ID_IDX], buflen);
 -	}
 -
 -	kfree(buf);
 -
 -	return rc;
 -}
 -
  static int pqi_identify_physical_device(struct pqi_ctrl_info *ctrl_info,
    struct pqi_scsi_dev *device,
 -	struct bmic_identify_physical_device *buffer,
 -	size_t buffer_length)
 +	struct bmic_identify_physical_device *buffer, size_t buffer_length)
  {
    int rc;
    enum dma_data_direction dir;
@@@ -685,7 -725,6 +685,7 @@@
    	0, NULL, NO_TIMEOUT);
pqi_pci_unmap(ctrl_info->pci_dev, request.sg_descriptors, 1, dir);
 +
    return rc;
  }
@@@ -724,7 -763,7 +724,7 @@@ int pqi_csmi_smp_passthru(struct pqi_ct
    	buffer, buffer_length, error_info);
  }
-#define PQI_FETCH_PTRAID_DATA (1UL<<31)
 +#define PQI_FETCH_PTRAID_DATA		(1 << 31)
static int pqi_set_diag_rescan(struct pqi_ctrl_info *ctrl_info)
  {
@@@ -736,15 -775,14 +736,15 @@@
    	return -ENOMEM;
rc = pqi_send_ctrl_raid_request(ctrl_info, BMIC_SENSE_DIAG_OPTIONS,
 -					diag, sizeof(*diag));
 +		diag, sizeof(*diag));
    if (rc)
    	goto out;
diag->options |= cpu_to_le32(PQI_FETCH_PTRAID_DATA);
-	rc = pqi_send_ctrl_raid_request(ctrl_info, BMIC_SET_DIAG_OPTIONS,
 -					diag, sizeof(*diag));
 +	rc = pqi_send_ctrl_raid_request(ctrl_info, BMIC_SET_DIAG_OPTIONS, diag,
 +		sizeof(*diag));
 +
  out:
    kfree(diag);
@@@ -755,7 -793,7 +755,7 @@@ static inline int pqi_write_host_wellne
    void *buffer, size_t buffer_length)
  {
    return pqi_send_ctrl_raid_request(ctrl_info, BMIC_WRITE_HOST_WELLNESS,
 -					buffer, buffer_length);
 +		buffer, buffer_length);
  }
#pragma pack(1)
@@@ -908,7 -946,7 +908,7 @@@ static inline int pqi_report_luns(struc
    void *buffer, size_t buffer_length)
  {
    return pqi_send_ctrl_raid_request(ctrl_info, cmd, buffer,
 -					buffer_length);
 +		buffer_length);
  }
static int pqi_report_phys_logical_luns(struct pqi_ctrl_info *ctrl_info, u8 cmd,
@@@ -1242,9 -1280,9 +1242,9 @@@ static void pqi_get_raid_bypass_status(
    if (rc)
    	goto out;
-#define RAID_BYPASS_STATUS	4
 -#define RAID_BYPASS_CONFIGURED	0x1
 -#define RAID_BYPASS_ENABLED	0x2
 +#define RAID_BYPASS_STATUS		4
 +#define RAID_BYPASS_CONFIGURED		0x1
 +#define RAID_BYPASS_ENABLED		0x2
bypass_status = buffer[RAID_BYPASS_STATUS];
    device->raid_bypass_configured =
@@@ -1347,6 -1385,14 +1347,6 @@@ static int pqi_get_device_info(struct p
    	}
    }
-	if (pqi_get_device_id(ctrl_info, device->scsi3addr,
 -		device->unique_id, sizeof(device->unique_id)) < 0)
 -		dev_warn(&ctrl_info->pci_dev->dev,
 -			"Can't get device id for scsi %d:%d:%d:%d\n",
 -			ctrl_info->scsi_host->host_no,
 -			device->bus, device->target,
 -			device->lun);
 -
  out:
    kfree(buffer);
@@@ -1367,7 -1413,6 +1367,7 @@@ static void pqi_get_physical_disk_info(
    	device->queue_depth = PQI_PHYSICAL_DISK_DEFAULT_MAX_QUEUE_DEPTH;
    	return;
    }
 +
    device->box_index = id_phys->box_index;
    device->phys_box_on_bus = id_phys->phys_box_on_bus;
    device->phy_connected_dev_type = id_phys->phy_connected_dev_type[0];
@@@ -1783,7 -1828,7 +1783,7 @@@ static void pqi_update_device_list(stru
    	device = new_device_list[i];
find_result = pqi_scsi_find_entry(ctrl_info, device,
 -						&matching_device);
 +			&matching_device);
switch (find_result) {
    	case DEVICE_SAME:
@@@ -2012,8 -2057,9 +2012,8 @@@ static int pqi_update_scsi_devices(stru
    		rc = -ENOMEM;
    		goto out;
    	}
 -		if (pqi_hide_vsep) {
 -			int i;
+		if (pqi_hide_vsep) {
    		for (i = num_physicals - 1; i >= 0; i--) {
    			phys_lun_ext_entry =
    					&physdev_list->lun_entries[i];
@@@ -2086,7 -2132,7 +2086,7 @@@
    	device->is_physical_device = is_physical_device;
    	if (is_physical_device) {
    		if (phys_lun_ext_entry->device_type ==
 -				SA_EXPANDER_SMP_DEVICE)
 +				SA_DEVICE_TYPE_EXPANDER_SMP)
    			device->is_expander_smp_device = true;
    	} else {
    		device->is_external_raid_device =
@@@ -2123,13 -2169,16 +2123,13 @@@
    	if (device->is_physical_device) {
    		device->wwid = phys_lun_ext_entry->wwid;
    		if ((phys_lun_ext_entry->device_flags &
 -				REPORT_PHYS_LUN_DEV_FLAG_AIO_ENABLED) &&
 +				CISS_REPORT_PHYS_DEV_FLAG_AIO_ENABLED) &&
    			phys_lun_ext_entry->aio_handle) {
    			device->aio_enabled = true;
 -					device->aio_handle =
 -						phys_lun_ext_entry->aio_handle;
 +				device->aio_handle =
 +					phys_lun_ext_entry->aio_handle;
    		}
 -
 -				pqi_get_physical_disk_info(ctrl_info,
 -					device, id_phys);
 -
 +			pqi_get_physical_disk_info(ctrl_info, device, id_phys);
    	} else {
    		memcpy(device->volume_id, log_lun_ext_entry->volume_id,
    			sizeof(device->volume_id));
@@@ -3109,7 -3158,7 +3109,7 @@@ static enum pqi_soft_reset_status pqi_p
  }
static void pqi_process_soft_reset(struct pqi_ctrl_info *ctrl_info,
 -		enum pqi_soft_reset_status reset_status)
 +	enum pqi_soft_reset_status reset_status)
  {
    int rc;
@@@ -3153,8 -3202,8 +3153,8 @@@ static void pqi_ofa_process_event(struc
if (event_id == PQI_EVENT_OFA_QUIESCE) {
    	dev_info(&ctrl_info->pci_dev->dev,
 -			 "Received Online Firmware Activation quiesce event for controller %u\n",
 -			 ctrl_info->ctrl_id);
 +			"Received Online Firmware Activation quiesce event for controller %u\n",
 +			ctrl_info->ctrl_id);
    	pqi_ofa_ctrl_quiesce(ctrl_info);
    	pqi_acknowledge_event(ctrl_info, event);
    	if (ctrl_info->soft_reset_handshake_supported) {
@@@ -3174,8 -3223,8 +3174,8 @@@
    	pqi_ofa_free_host_buffer(ctrl_info);
    	pqi_acknowledge_event(ctrl_info, event);
    	dev_info(&ctrl_info->pci_dev->dev,
 -			 "Online Firmware Activation(%u) cancel reason : %u\n",
 -			 ctrl_info->ctrl_id, event->ofa_cancel_reason);
 +			"Online Firmware Activation(%u) cancel reason : %u\n",
 +			ctrl_info->ctrl_id, event->ofa_cancel_reason);
    }
mutex_unlock(&ctrl_info->ofa_mutex);
@@@ -3354,7 -3403,7 +3354,7 @@@ static unsigned int pqi_process_event_i
  #define PQI_LEGACY_INTX_MASK	0x1
static inline void pqi_configure_legacy_intx(struct pqi_ctrl_info *ctrl_info,
 -						bool enable_intx)
 +	bool enable_intx)
  {
    u32 intx_mask;
    struct pqi_device_registers __iomem *pqi_registers;
@@@ -3792,7 -3841,7 +3792,7 @@@ static int pqi_create_admin_queues(stru
    	&pqi_registers->admin_oq_pi_addr);
reg = PQI_ADMIN_IQ_NUM_ELEMENTS |
 -		(PQI_ADMIN_OQ_NUM_ELEMENTS) << 8 |
 +		(PQI_ADMIN_OQ_NUM_ELEMENTS << 8) |
    	(admin_queues->int_msg_num << 16);
    writel(reg, &pqi_registers->admin_iq_num_elements);
    writel(PQI_CREATE_ADMIN_QUEUE_PAIR,
@@@ -3999,8 -4048,8 +3999,8 @@@ static void pqi_raid_synchronous_comple
    complete(waiting);
  }
-static int pqi_process_raid_io_error_synchronous(struct pqi_raid_error_info
 -						*error_info)
 +static int pqi_process_raid_io_error_synchronous(
 +	struct pqi_raid_error_info *error_info)
  {
    int rc = -EIO;
@@@ -4073,8 -4122,6 +4073,8 @@@ static int pqi_submit_raid_request_sync
    	goto out;
    }
+	atomic_inc(&ctrl_info->sync_cmds_outstanding);
 +
    io_request = pqi_alloc_io_request(ctrl_info);
put_unaligned_le16(io_request->index,
@@@ -4121,7 -4168,6 +4121,7 @@@
pqi_free_io_request(io_request);
+	atomic_dec(&ctrl_info->sync_cmds_outstanding);
  out:
    up(&ctrl_info->sync_request_sem);
@@@ -4619,11 -4665,11 +4619,11 @@@ static void pqi_free_all_io_requests(st
static inline int pqi_alloc_error_buffer(struct pqi_ctrl_info *ctrl_info)
  {
 -	ctrl_info->error_buffer = dma_alloc_coherent(&ctrl_info->pci_dev->dev,
 -						     ctrl_info->error_buffer_length,
 -						     &ctrl_info->error_buffer_dma_handle,
 -						     GFP_KERNEL);
+	ctrl_info->error_buffer = dma_alloc_coherent(&ctrl_info->pci_dev->dev,
 +				     ctrl_info->error_buffer_length,
 +				     &ctrl_info->error_buffer_dma_handle,
 +				     GFP_KERNEL);
    if (!ctrl_info->error_buffer)
    	return -ENOMEM;
@@@ -5356,7 -5402,7 +5356,7 @@@ static int pqi_scsi_queue_command(struc
pqi_ctrl_busy(ctrl_info);
    if (pqi_ctrl_blocked(ctrl_info) || pqi_device_in_reset(device) ||
 -	    pqi_ctrl_in_ofa(ctrl_info)) {
 +	    pqi_ctrl_in_ofa(ctrl_info) || pqi_ctrl_in_shutdown(ctrl_info)) {
    	rc = SCSI_MLQUEUE_HOST_BUSY;
    	goto out;
    }
@@@ -5373,7 -5419,7 +5373,7 @@@
    if (pqi_is_logical_device(device)) {
    	raid_bypassed = false;
    	if (device->raid_bypass_enabled &&
 -				!blk_rq_is_passthrough(scmd->request)) {
 +			!blk_rq_is_passthrough(scmd->request)) {
    		rc = pqi_raid_bypass_submit_scsi_cmd(ctrl_info, device,
    			scmd, queue_group);
    		if (rc == 0 || rc == SCSI_MLQUEUE_HOST_BUSY)
@@@ -5604,18 -5650,6 +5604,18 @@@ static int pqi_ctrl_wait_for_pending_io
    return 0;
  }
+static int pqi_ctrl_wait_for_pending_sync_cmds(struct pqi_ctrl_info *ctrl_info)
 +{
 +	while (atomic_read(&ctrl_info->sync_cmds_outstanding)) {
 +		pqi_check_ctrl_health(ctrl_info);
 +		if (pqi_ctrl_offline(ctrl_info))
 +			return -ENXIO;
 +		usleep_range(1000, 2000);
 +	}
 +
 +	return 0;
 +}
 +
  static void pqi_lun_reset_complete(struct pqi_io_request *io_request,
    void *context)
  {
@@@ -5624,8 -5658,7 +5624,8 @@@
    complete(waiting);
  }
-#define PQI_LUN_RESET_TIMEOUT_SECS	10
 +#define PQI_LUN_RESET_TIMEOUT_SECS		30
 +#define PQI_LUN_RESET_POLL_COMPLETION_SECS	10
static int pqi_wait_for_lun_reset_completion(struct pqi_ctrl_info *ctrl_info,
    struct pqi_scsi_dev *device, struct completion *wait)
@@@ -5634,7 -5667,7 +5634,7 @@@
while (1) {
    	if (wait_for_completion_io_timeout(wait,
 -			PQI_LUN_RESET_TIMEOUT_SECS * PQI_HZ)) {
 +			PQI_LUN_RESET_POLL_COMPLETION_SECS * PQI_HZ)) {
    		rc = 0;
    		break;
    	}
@@@ -5671,9 -5704,6 +5671,9 @@@ static int pqi_lun_reset(struct pqi_ctr
    memcpy(request->lun_number, device->scsi3addr,
    	sizeof(request->lun_number));
    request->task_management_function = SOP_TASK_MANAGEMENT_LUN_RESET;
 +	if (ctrl_info->tmf_iu_timeout_supported)
 +		put_unaligned_le16(PQI_LUN_RESET_TIMEOUT_SECS,
 +					&request->timeout);
pqi_start_io(ctrl_info,
    	&ctrl_info->queue_groups[PQI_DEFAULT_QUEUE_GROUP], RAID_PATH,
@@@ -5703,7 -5733,7 +5703,7 @@@ static int _pqi_device_reset(struct pqi
for (retries = 0;;) {
    	rc = pqi_lun_reset(ctrl_info, device);
 -		if (rc != -EAGAIN || ++retries > PQI_LUN_RESET_RETRIES)
 +		if (rc == 0 || ++retries > PQI_LUN_RESET_RETRIES)
    		break;
    	msleep(PQI_LUN_RESET_RETRY_INTERVAL_MSECS);
    }
@@@ -5757,17 -5787,17 +5757,17 @@@ static int pqi_eh_device_reset_handler(
    	shost->host_no, device->bus, device->target, device->lun);
pqi_check_ctrl_health(ctrl_info);
 -	if (pqi_ctrl_offline(ctrl_info)) {
 -		dev_err(&ctrl_info->pci_dev->dev,
 -			"controller %u offlined - cannot send device reset\n",
 -			ctrl_info->ctrl_id);
 +	if (pqi_ctrl_offline(ctrl_info) ||
 +		pqi_device_reset_blocked(ctrl_info)) {
    	rc = FAILED;
    	goto out;
    }
pqi_wait_until_ofa_finished(ctrl_info);
+	atomic_inc(&ctrl_info->sync_cmds_outstanding);
    rc = pqi_device_reset(ctrl_info, device);
 +	atomic_dec(&ctrl_info->sync_cmds_outstanding);
out:
    dev_err(&ctrl_info->pci_dev->dev,
@@@ -6036,9 -6066,6 +6036,9 @@@ static int pqi_passthru_ioctl(struct pq
put_unaligned_le16(iu_length, &request.header.iu_length);
+	if (ctrl_info->raid_iu_timeout_supported)
 +		put_unaligned_le32(iocommand.Request.Timeout, &request.timeout);
 +
    rc = pqi_submit_raid_request_synchronous(ctrl_info, &request.header,
    	PQI_SYNC_FLAGS_INTERRUPTABLE, &pqi_error_info, NO_TIMEOUT);
@@@ -6092,7 -6119,7 +6092,7 @@@ static int pqi_ioctl(struct scsi_devic
ctrl_info = shost_to_hba(sdev->host);
-	if (pqi_ctrl_in_ofa(ctrl_info))
 +	if (pqi_ctrl_in_ofa(ctrl_info) || pqi_ctrl_in_shutdown(ctrl_info))
    	return -EBUSY;
switch (cmd) {
@@@ -6133,8 -6160,14 +6133,8 @@@ static ssize_t pqi_firmware_version_sho
  static ssize_t pqi_driver_version_show(struct device *dev,
    struct device_attribute *attr, char *buffer)
  {
 -	struct Scsi_Host *shost;
 -	struct pqi_ctrl_info *ctrl_info;
 -
 -	shost = class_to_shost(dev);
 -	ctrl_info = shost_to_hba(shost);
 -
 -	return snprintf(buffer, PAGE_SIZE,
 -		"%s\n", DRIVER_VERSION BUILD_TIMESTAMP);
 +	return snprintf(buffer, PAGE_SIZE, "%s\n",
 +			DRIVER_VERSION BUILD_TIMESTAMP);
  }
static ssize_t pqi_serial_number_show(struct device *dev,
@@@ -6250,7 -6283,7 +6250,7 @@@ static ssize_t pqi_unique_id_show(struc
    struct scsi_device *sdev;
    struct pqi_scsi_dev *device;
    unsigned long flags;
 -	unsigned char uid[16];
 +	u8 unique_id[16];
sdev = to_scsi_device(dev);
    ctrl_info = shost_to_hba(sdev->host);
@@@ -6263,22 -6296,16 +6263,22 @@@
    		flags);
    	return -ENODEV;
    }
 -	memcpy(uid, device->unique_id, sizeof(uid));
 +
 +	if (device->is_physical_device) {
 +		memset(unique_id, 0, 8);
 +		memcpy(unique_id + 8, &device->wwid, sizeof(device->wwid));
 +	} else {
 +		memcpy(unique_id, device->volume_id, sizeof(device->volume_id));
 +	}
spin_unlock_irqrestore(&ctrl_info->scsi_device_list_lock, flags);
return snprintf(buffer, PAGE_SIZE,
    	"%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X\n",
 -		uid[0], uid[1], uid[2], uid[3],
 -		uid[4], uid[5], uid[6], uid[7],
 -		uid[8], uid[9], uid[10], uid[11],
 -		uid[12], uid[13], uid[14], uid[15]);
 +		unique_id[0], unique_id[1], unique_id[2], unique_id[3],
 +		unique_id[4], unique_id[5], unique_id[6], unique_id[7],
 +		unique_id[8], unique_id[9], unique_id[10], unique_id[11],
 +		unique_id[12], unique_id[13], unique_id[14], unique_id[15]);
  }
static ssize_t pqi_lunid_show(struct device *dev,
@@@ -6301,7 -6328,6 +6301,7 @@@
    		flags);
    	return -ENODEV;
    }
 +
    memcpy(lunid, device->scsi3addr, sizeof(lunid));
spin_unlock_irqrestore(&ctrl_info->scsi_device_list_lock, flags);
@@@ -6309,8 -6335,7 +6309,8 @@@
    return snprintf(buffer, PAGE_SIZE, "0x%8phN\n", lunid);
  }
-#define MAX_PATHS 8
 +#define MAX_PATHS	8
 +
  static ssize_t pqi_path_info_show(struct device *dev,
    struct device_attribute *attr, char *buf)
  {
@@@ -6322,9 -6347,9 +6322,9 @@@
    int output_len = 0;
    u8 box;
    u8 bay;
 -	u8 path_map_index = 0;
 +	u8 path_map_index;
    char *active;
 -	unsigned char phys_connector[2];
 +	u8 phys_connector[2];
sdev = to_scsi_device(dev);
    ctrl_info = shost_to_hba(sdev->host);
@@@ -6340,7 -6365,7 +6340,7 @@@
bay = device->bay;
    for (i = 0; i < MAX_PATHS; i++) {
 -		path_map_index = 1<<i;
 +		path_map_index = 1 << i;
    	if (i == device->active_path_index)
    		active = "Active";
    	else if (device->path_map & path_map_index)
@@@ -6391,10 -6416,10 +6391,10 @@@ end_buffer
    }
spin_unlock_irqrestore(&ctrl_info->scsi_device_list_lock, flags);
 +
    return output_len;
  }
-
  static ssize_t pqi_sas_address_show(struct device *dev,
    struct device_attribute *attr, char *buffer)
  {
@@@ -6415,7 -6440,6 +6415,7 @@@
    		flags);
    	return -ENODEV;
    }
 +
    sas_address = device->sas_address;
spin_unlock_irqrestore(&ctrl_info->scsi_device_list_lock, flags);
@@@ -6820,27 -6844,6 +6820,27 @@@ static void pqi_firmware_feature_status
    	firmware_feature->feature_name);
  }
+static void pqi_ctrl_update_feature_flags(struct pqi_ctrl_info *ctrl_info,
 +	struct pqi_firmware_feature *firmware_feature)
 +{
 +	switch (firmware_feature->feature_bit) {
 +	case PQI_FIRMWARE_FEATURE_SOFT_RESET_HANDSHAKE:
 +		ctrl_info->soft_reset_handshake_supported =
 +			firmware_feature->enabled;
 +		break;
 +	case PQI_FIRMWARE_FEATURE_RAID_IU_TIMEOUT:
 +		ctrl_info->raid_iu_timeout_supported =
 +			firmware_feature->enabled;
 +		break;
 +	case PQI_FIRMWARE_FEATURE_TMF_IU_TIMEOUT:
 +		ctrl_info->tmf_iu_timeout_supported =
 +			firmware_feature->enabled;
 +		break;
 +	}
 +
 +	pqi_firmware_feature_status(ctrl_info, firmware_feature);
 +}
 +
  static inline void pqi_firmware_feature_update(struct pqi_ctrl_info *ctrl_info,
    struct pqi_firmware_feature *firmware_feature)
  {
@@@ -6864,17 -6867,7 +6864,17 @@@ static struct pqi_firmware_feature pqi_
    {
    	.feature_name = "New Soft Reset Handshake",
    	.feature_bit = PQI_FIRMWARE_FEATURE_SOFT_RESET_HANDSHAKE,
 -		.feature_status = pqi_firmware_feature_status,
 +		.feature_status = pqi_ctrl_update_feature_flags,
 +	},
 +	{
 +		.feature_name = "RAID IU Timeout",
 +		.feature_bit = PQI_FIRMWARE_FEATURE_RAID_IU_TIMEOUT,
 +		.feature_status = pqi_ctrl_update_feature_flags,
 +	},
 +	{
 +		.feature_name = "TMF IU Timeout",
 +		.feature_bit = PQI_FIRMWARE_FEATURE_TMF_IU_TIMEOUT,
 +		.feature_status = pqi_ctrl_update_feature_flags,
    },
  };
@@@ -6928,6 -6921,7 +6928,6 @@@ static void pqi_process_firmware_featur
    	return;
    }
-	ctrl_info->soft_reset_handshake_supported = false;
    for (i = 0; i < ARRAY_SIZE(pqi_firmware_features); i++) {
    	if (!pqi_firmware_features[i].supported)
    		continue;
@@@ -6935,6 -6929,10 +6935,6 @@@
    		firmware_features_iomem_addr,
    		pqi_firmware_features[i].feature_bit)) {
    		pqi_firmware_features[i].enabled = true;
 -			if (pqi_firmware_features[i].feature_bit ==
 -			    PQI_FIRMWARE_FEATURE_SOFT_RESET_HANDSHAKE)
 -				ctrl_info->soft_reset_handshake_supported =
 -									true;
    	}
    	pqi_firmware_feature_update(ctrl_info,
    		&pqi_firmware_features[i]);
@@@ -7076,20 -7074,13 +7076,20 @@@ static int pqi_force_sis_mode(struct pq
    return pqi_revert_to_sis_mode(ctrl_info);
  }
+#define PQI_POST_RESET_DELAY_B4_MSGU_READY	5000
 +
  static int pqi_ctrl_init(struct pqi_ctrl_info *ctrl_info)
  {
    int rc;
-	rc = pqi_force_sis_mode(ctrl_info);
 -	if (rc)
 -		return rc;
 +	if (reset_devices) {
 +		sis_soft_reset(ctrl_info);
 +		msleep(PQI_POST_RESET_DELAY_B4_MSGU_READY);
 +	} else {
 +		rc = pqi_force_sis_mode(ctrl_info);
 +		if (rc)
 +			return rc;
 +	}
/*
     * Wait until the controller is ready to start accepting SIS
@@@ -7395,7 -7386,7 +7395,7 @@@ static int pqi_ctrl_init_resume(struct 
    rc = pqi_get_ctrl_product_details(ctrl_info);
    if (rc) {
    	dev_err(&ctrl_info->pci_dev->dev,
 -			"error obtaining product detail\n");
 +			"error obtaining product details\n");
    	return rc;
    }
@@@ -7523,7 -7514,6 +7523,7 @@@ static struct pqi_ctrl_info *pqi_alloc_
INIT_WORK(&ctrl_info->event_work, pqi_event_worker);
    atomic_set(&ctrl_info->num_interrupts, 0);
 +	atomic_set(&ctrl_info->sync_cmds_outstanding, 0);
INIT_DELAYED_WORK(&ctrl_info->rescan_work, pqi_rescan_worker);
    INIT_DELAYED_WORK(&ctrl_info->update_time_work, pqi_update_time_worker);
@@@ -7731,8 -7721,6 +7731,8 @@@ static void pqi_ofa_setup_host_buffer(s
    	dev_err(dev, "Failed to allocate host buffer of size = %u",
    		bytes_requested);
    }
 +
 +	return;
  }
static void pqi_ofa_free_host_buffer(struct pqi_ctrl_info *ctrl_info)
@@@ -7799,6 -7787,8 +7799,6 @@@ static int pqi_ofa_host_memory_update(s
    	0, NULL, NO_TIMEOUT);
  }
-#define PQI_POST_RESET_DELAY_B4_MSGU_READY	5000
 -
  static int pqi_ofa_ctrl_restart(struct pqi_ctrl_info *ctrl_info)
  {
    msleep(PQI_POST_RESET_DELAY_B4_MSGU_READY);
@@@ -7966,73 -7956,28 +7966,73 @@@ static void pqi_pci_remove(struct pci_d
    pqi_remove_ctrl(ctrl_info);
  }
+static void pqi_crash_if_pending_command(struct pqi_ctrl_info *ctrl_info)
 +{
 +	unsigned int i;
 +	struct pqi_io_request *io_request;
 +	struct scsi_cmnd *scmd;
 +
 +	for (i = 0; i < ctrl_info->max_io_slots; i++) {
 +		io_request = &ctrl_info->io_request_pool[i];
 +		if (atomic_read(&io_request->refcount) == 0)
 +			continue;
 +		scmd = io_request->scmd;
 +		WARN_ON(scmd != NULL); /* IO command from SML */
 +		WARN_ON(scmd == NULL); /* Non-IO cmd or driver initiated*/
 +	}
 +}
 +
  static void pqi_shutdown(struct pci_dev *pci_dev)
  {
    int rc;
    struct pqi_ctrl_info *ctrl_info;
ctrl_info = pci_get_drvdata(pci_dev);
 -	if (!ctrl_info)
 -		goto error;
 +	if (!ctrl_info) {
 +		dev_err(&pci_dev->dev,
 +			"cache could not be flushed\n");
 +		return;
 +	}
 +
 +	pqi_disable_events(ctrl_info);
 +	pqi_wait_until_ofa_finished(ctrl_info);
 +	pqi_cancel_update_time_worker(ctrl_info);
 +	pqi_cancel_rescan_worker(ctrl_info);
 +	pqi_cancel_event_worker(ctrl_info);
 +
 +	pqi_ctrl_shutdown_start(ctrl_info);
 +	pqi_ctrl_wait_until_quiesced(ctrl_info);
 +
 +	rc = pqi_ctrl_wait_for_pending_io(ctrl_info, NO_TIMEOUT);
 +	if (rc) {
 +		dev_err(&pci_dev->dev,
 +			"wait for pending I/O failed\n");
 +		return;
 +	}
 +
 +	pqi_ctrl_block_device_reset(ctrl_info);
 +	pqi_wait_until_lun_reset_finished(ctrl_info);
/*
     * Write all data in the controller's battery-backed cache to
     * storage.
     */
    rc = pqi_flush_cache(ctrl_info, SHUTDOWN);
 -	pqi_free_interrupts(ctrl_info);
 -	pqi_reset(ctrl_info);
 -	if (rc == 0)
 +	if (rc)
 +		dev_err(&pci_dev->dev,
 +			"unable to flush controller cache\n");
 +
 +	pqi_ctrl_block_requests(ctrl_info);
 +
 +	rc = pqi_ctrl_wait_for_pending_sync_cmds(ctrl_info);
 +	if (rc) {
 +		dev_err(&pci_dev->dev,
 +			"wait for pending sync cmds failed\n");
    	return;
 +	}
-error:
 -	dev_warn(&pci_dev->dev,
 -		"unable to flush controller cache\n");
 +	pqi_crash_if_pending_command(ctrl_info);
 +	pqi_reset(ctrl_info);
  }
static void pqi_process_lockup_action_param(void)
@@@ -8689,11 -8634,11 +8689,11 @@@ static void __attribute__((unused)) ver
    BUILD_BUG_ON(offsetof(struct pqi_general_admin_request,
    	data.delete_operational_queue.queue_id) != 12);
    BUILD_BUG_ON(sizeof(struct pqi_general_admin_request) != 64);
- 	BUILD_BUG_ON(FIELD_SIZEOF(struct pqi_general_admin_request,
+ 	BUILD_BUG_ON(sizeof_member(struct pqi_general_admin_request,
    	data.create_operational_iq) != 64 - 11);
- 	BUILD_BUG_ON(FIELD_SIZEOF(struct pqi_general_admin_request,
+ 	BUILD_BUG_ON(sizeof_member(struct pqi_general_admin_request,
    	data.create_operational_oq) != 64 - 11);
- 	BUILD_BUG_ON(FIELD_SIZEOF(struct pqi_general_admin_request,
+ 	BUILD_BUG_ON(sizeof_member(struct pqi_general_admin_request,
    	data.delete_operational_queue) != 64 - 11);
BUILD_BUG_ON(offsetof(struct pqi_general_admin_response,
@@@ -8740,8 -8685,6 +8740,8 @@@
    	error_index) != 27);
    BUILD_BUG_ON(offsetof(struct pqi_raid_path_request,
    	cdb) != 32);
 +	BUILD_BUG_ON(offsetof(struct pqi_raid_path_request,
 +		timeout) != 60);
    BUILD_BUG_ON(offsetof(struct pqi_raid_path_request,
    	sg_descriptors) != 64);
    BUILD_BUG_ON(sizeof(struct pqi_raid_path_request) !=
@@@ -8897,8 -8840,6 +8897,8 @@@
    BUILD_BUG_ON(offsetof(struct pqi_task_management_request,
    	nexus_id) != 10);
    BUILD_BUG_ON(offsetof(struct pqi_task_management_request,
 +		timeout) != 14);
 +	BUILD_BUG_ON(offsetof(struct pqi_task_management_request,
    	lun_number) != 16);
    BUILD_BUG_ON(offsetof(struct pqi_task_management_request,
    	protocol_specific) != 24);
diff --combined drivers/usb/gadget/function/f_fs.c
index ce1d0235969c,2539ea40e94c..b0f3aa67a040
--- a/drivers/usb/gadget/function/f_fs.c
+++ b/drivers/usb/gadget/function/f_fs.c
@@@ -1352,6 -1352,14 +1352,6 @@@ static long ffs_epfile_ioctl(struct fil
    return ret;
  }
-#ifdef CONFIG_COMPAT
 -static long ffs_epfile_compat_ioctl(struct file *file, unsigned code,
 -		unsigned long value)
 -{
 -	return ffs_epfile_ioctl(file, code, value);
 -}
 -#endif
 -
  static const struct file_operations ffs_epfile_operations = {
    .llseek =	no_llseek,
@@@ -1360,7 -1368,9 +1360,7 @@@
    .read_iter =	ffs_epfile_read_iter,
    .release =	ffs_epfile_release,
    .unlocked_ioctl =	ffs_epfile_ioctl,
 -#ifdef CONFIG_COMPAT
 -	.compat_ioctl = ffs_epfile_compat_ioctl,
 -#endif
 +	.compat_ioctl = compat_ptr_ioctl,
  };
@@@ -3509,7 -3519,7 +3509,7 @@@ static void ffs_free_inst(struct usb_fu
static int ffs_set_inst_name(struct usb_function_instance *fi, const char *name)
  {
- 	if (strlen(name) >= FIELD_SIZEOF(struct ffs_dev, name))
+ 	if (strlen(name) >= sizeof_member(struct ffs_dev, name))
    	return -ENAMETOOLONG;
    return ffs_name_dev(to_f_fs_opts(fi)->dev, name);
  }
diff --combined fs/fuse/virtio_fs.c
index a5c86048b96e,13f67ae37257..b77acea065d0
--- a/fs/fuse/virtio_fs.c
+++ b/fs/fuse/virtio_fs.c
@@@ -30,7 -30,6 +30,7 @@@ struct virtio_fs_vq 
    struct virtqueue *vq;     /* protected by ->lock */
    struct work_struct done_work;
    struct list_head queued_reqs;
 +	struct list_head end_reqs;	/* End these requests */
    struct delayed_work dispatch_work;
    struct fuse_dev *fud;
    bool connected;
@@@ -55,9 -54,6 +55,9 @@@ struct virtio_fs_forget 
    struct list_head list;
  };
+static int virtio_fs_enqueue_req(struct virtio_fs_vq *fsvq,
 +				 struct fuse_req *req, bool in_flight);
 +
  static inline struct virtio_fs_vq *vq_to_fsvq(struct virtqueue *vq)
  {
    struct virtio_fs *fs = vq->vdev->priv;
@@@ -70,19 -66,6 +70,19 @@@ static inline struct fuse_pqueue *vq_to
    return &vq_to_fsvq(vq)->fud->pq;
  }
+/* Should be called with fsvq->lock held. */
 +static inline void inc_in_flight_req(struct virtio_fs_vq *fsvq)
 +{
 +	fsvq->in_flight++;
 +}
 +
 +/* Should be called with fsvq->lock held. */
 +static inline void dec_in_flight_req(struct virtio_fs_vq *fsvq)
 +{
 +	WARN_ON(fsvq->in_flight <= 0);
 +	fsvq->in_flight--;
 +}
 +
  static void release_virtio_fs_obj(struct kref *ref)
  {
    struct virtio_fs *vfs = container_of(ref, struct virtio_fs, refcount);
@@@ -126,6 -109,22 +126,6 @@@ static void virtio_fs_drain_queue(struc
    flush_delayed_work(&fsvq->dispatch_work);
  }
-static inline void drain_hiprio_queued_reqs(struct virtio_fs_vq *fsvq)
 -{
 -	struct virtio_fs_forget *forget;
 -
 -	spin_lock(&fsvq->lock);
 -	while (1) {
 -		forget = list_first_entry_or_null(&fsvq->queued_reqs,
 -						struct virtio_fs_forget, list);
 -		if (!forget)
 -			break;
 -		list_del(&forget->list);
 -		kfree(forget);
 -	}
 -	spin_unlock(&fsvq->lock);
 -}
 -
  static void virtio_fs_drain_all_queues(struct virtio_fs *fs)
  {
    struct virtio_fs_vq *fsvq;
@@@ -133,6 -132,9 +133,6 @@@
for (i = 0; i < fs->nvqs; i++) {
    	fsvq = &fs->vqs[i];
 -		if (i == VQ_HIPRIO)
 -			drain_hiprio_queued_reqs(fsvq);
 -
    	virtio_fs_drain_queue(fsvq);
    }
  }
@@@ -213,7 -215,7 +213,7 @@@ static void virtio_fs_free_devs(struct 
  /* Read filesystem name from virtio config into fs->tag (must kfree()). */
  static int virtio_fs_read_tag(struct virtio_device *vdev, struct virtio_fs *fs)
  {
- 	char tag_buf[sizeof_field(struct virtio_fs_config, tag)];
+ 	char tag_buf[sizeof_member(struct virtio_fs_config, tag)];
    char *end;
    size_t len;
@@@ -251,66 -253,14 +251,66 @@@ static void virtio_fs_hiprio_done_work(
while ((req = virtqueue_get_buf(vq, &len)) != NULL) {
    		kfree(req);
 -			fsvq->in_flight--;
 +			dec_in_flight_req(fsvq);
    	}
    } while (!virtqueue_enable_cb(vq) && likely(!virtqueue_is_broken(vq)));
    spin_unlock(&fsvq->lock);
  }
-static void virtio_fs_dummy_dispatch_work(struct work_struct *work)
 +static void virtio_fs_request_dispatch_work(struct work_struct *work)
  {
 +	struct fuse_req *req;
 +	struct virtio_fs_vq *fsvq = container_of(work, struct virtio_fs_vq,
 +						 dispatch_work.work);
 +	struct fuse_conn *fc = fsvq->fud->fc;
 +	int ret;
 +
 +	pr_debug("virtio-fs: worker %s called.\n", __func__);
 +	while (1) {
 +		spin_lock(&fsvq->lock);
 +		req = list_first_entry_or_null(&fsvq->end_reqs, struct fuse_req,
 +					       list);
 +		if (!req) {
 +			spin_unlock(&fsvq->lock);
 +			break;
 +		}
 +
 +		list_del_init(&req->list);
 +		spin_unlock(&fsvq->lock);
 +		fuse_request_end(fc, req);
 +	}
 +
 +	/* Dispatch pending requests */
 +	while (1) {
 +		spin_lock(&fsvq->lock);
 +		req = list_first_entry_or_null(&fsvq->queued_reqs,
 +					       struct fuse_req, list);
 +		if (!req) {
 +			spin_unlock(&fsvq->lock);
 +			return;
 +		}
 +		list_del_init(&req->list);
 +		spin_unlock(&fsvq->lock);
 +
 +		ret = virtio_fs_enqueue_req(fsvq, req, true);
 +		if (ret < 0) {
 +			if (ret == -ENOMEM || ret == -ENOSPC) {
 +				spin_lock(&fsvq->lock);
 +				list_add_tail(&req->list, &fsvq->queued_reqs);
 +				schedule_delayed_work(&fsvq->dispatch_work,
 +						      msecs_to_jiffies(1));
 +				spin_unlock(&fsvq->lock);
 +				return;
 +			}
 +			req->out.h.error = ret;
 +			spin_lock(&fsvq->lock);
 +			dec_in_flight_req(fsvq);
 +			spin_unlock(&fsvq->lock);
 +			pr_err("virtio-fs: virtio_fs_enqueue_req() failed %d\n",
 +			       ret);
 +			fuse_request_end(fc, req);
 +		}
 +	}
  }
static void virtio_fs_hiprio_dispatch_work(struct work_struct *work)
@@@ -336,7 -286,6 +336,7 @@@
list_del(&forget->list);
    	if (!fsvq->connected) {
 +			dec_in_flight_req(fsvq);
    		spin_unlock(&fsvq->lock);
    		kfree(forget);
    		continue;
@@@ -358,13 -307,13 +358,13 @@@
    		} else {
    			pr_debug("virtio-fs: Could not queue FORGET: err=%d. Dropping it.\n",
    				 ret);
 +				dec_in_flight_req(fsvq);
    			kfree(forget);
    		}
    		spin_unlock(&fsvq->lock);
    		return;
    	}
-		fsvq->in_flight++;
    	notify = virtqueue_kick_prepare(vq);
    	spin_unlock(&fsvq->lock);
@@@ -503,7 -452,7 +503,7 @@@ static void virtio_fs_requests_done_wor
fuse_request_end(fc, req);
    	spin_lock(&fsvq->lock);
 -		fsvq->in_flight--;
 +		dec_in_flight_req(fsvq);
    	spin_unlock(&fsvq->lock);
    }
  }
@@@ -553,7 -502,6 +553,7 @@@ static int virtio_fs_setup_vqs(struct v
    names[VQ_HIPRIO] = fs->vqs[VQ_HIPRIO].name;
    INIT_WORK(&fs->vqs[VQ_HIPRIO].done_work, virtio_fs_hiprio_done_work);
    INIT_LIST_HEAD(&fs->vqs[VQ_HIPRIO].queued_reqs);
 +	INIT_LIST_HEAD(&fs->vqs[VQ_HIPRIO].end_reqs);
    INIT_DELAYED_WORK(&fs->vqs[VQ_HIPRIO].dispatch_work,
    		virtio_fs_hiprio_dispatch_work);
    spin_lock_init(&fs->vqs[VQ_HIPRIO].lock);
@@@ -563,9 -511,8 +563,9 @@@
    	spin_lock_init(&fs->vqs[i].lock);
    	INIT_WORK(&fs->vqs[i].done_work, virtio_fs_requests_done_work);
    	INIT_DELAYED_WORK(&fs->vqs[i].dispatch_work,
 -					virtio_fs_dummy_dispatch_work);
 +				  virtio_fs_request_dispatch_work);
    	INIT_LIST_HEAD(&fs->vqs[i].queued_reqs);
 +		INIT_LIST_HEAD(&fs->vqs[i].end_reqs);
    	snprintf(fs->vqs[i].name, sizeof(fs->vqs[i].name),
    		 "requests.%u", i - VQ_REQUEST);
    	callbacks[i] = virtio_fs_vq_done;
@@@ -761,7 -708,6 +761,7 @@@ __releases(fiq->lock
    		list_add_tail(&forget->list, &fsvq->queued_reqs);
    		schedule_delayed_work(&fsvq->dispatch_work,
    				msecs_to_jiffies(1));
 +			inc_in_flight_req(fsvq);
    	} else {
    		pr_debug("virtio-fs: Could not queue FORGET: err=%d. Dropping it.\n",
    			 ret);
@@@ -771,7 -717,7 +771,7 @@@
    	goto out;
    }
-	fsvq->in_flight++;
 +	inc_in_flight_req(fsvq);
    notify = virtqueue_kick_prepare(vq);
spin_unlock(&fsvq->lock);
@@@ -873,7 -819,7 +873,7 @@@ static unsigned int sg_init_fuse_args(s
/* Add a request to a virtqueue and kick the device */
  static int virtio_fs_enqueue_req(struct virtio_fs_vq *fsvq,
 -				 struct fuse_req *req)
 +				 struct fuse_req *req, bool in_flight)
  {
    /* requests need at least 4 elements */
    struct scatterlist *stack_sgs[6];
@@@ -889,7 -835,6 +889,7 @@@
    unsigned int i;
    int ret;
    bool notify;
 +	struct fuse_pqueue *fpq;
/* Does the sglist fit on the stack? */
    total_sgs = sg_count_fuse_req(req);
@@@ -944,17 -889,7 +944,17 @@@
    	goto out;
    }
-	fsvq->in_flight++;
 +	/* Request successfully sent. */
 +	fpq = &fsvq->fud->pq;
 +	spin_lock(&fpq->lock);
 +	list_add_tail(&req->list, fpq->processing);
 +	spin_unlock(&fpq->lock);
 +	set_bit(FR_SENT, &req->flags);
 +	/* matches barrier in request_wait_answer() */
 +	smp_mb__after_atomic();
 +
 +	if (!in_flight)
 +		inc_in_flight_req(fsvq);
    notify = virtqueue_kick_prepare(vq);
spin_unlock(&fsvq->lock);
@@@ -980,8 -915,9 +980,8 @@@ __releases(fiq->lock
  {
    unsigned int queue_id = VQ_REQUEST; /* TODO multiqueue */
    struct virtio_fs *fs;
 -	struct fuse_conn *fc;
    struct fuse_req *req;
 -	struct fuse_pqueue *fpq;
 +	struct virtio_fs_vq *fsvq;
    int ret;
WARN_ON(list_empty(&fiq->pending));
@@@ -992,36 -928,44 +992,36 @@@
    spin_unlock(&fiq->lock);
fs = fiq->priv;
 -	fc = fs->vqs[queue_id].fud->fc;
pr_debug("%s: opcode %u unique %#llx nodeid %#llx in.len %u out.len %u\n",
    	  __func__, req->in.h.opcode, req->in.h.unique,
    	 req->in.h.nodeid, req->in.h.len,
    	 fuse_len_args(req->args->out_numargs, req->args->out_args));
-	fpq = &fs->vqs[queue_id].fud->pq;
 -	spin_lock(&fpq->lock);
 -	if (!fpq->connected) {
 -		spin_unlock(&fpq->lock);
 -		req->out.h.error = -ENODEV;
 -		pr_err("virtio-fs: %s disconnected\n", __func__);
 -		fuse_request_end(fc, req);
 -		return;
 -	}
 -	list_add_tail(&req->list, fpq->processing);
 -	spin_unlock(&fpq->lock);
 -	set_bit(FR_SENT, &req->flags);
 -	/* matches barrier in request_wait_answer() */
 -	smp_mb__after_atomic();
 -
 -retry:
 -	ret = virtio_fs_enqueue_req(&fs->vqs[queue_id], req);
 +	fsvq = &fs->vqs[queue_id];
 +	ret = virtio_fs_enqueue_req(fsvq, req, false);
    if (ret < 0) {
    	if (ret == -ENOMEM || ret == -ENOSPC) {
 -			/* Virtqueue full. Retry submission */
 -			/* TODO use completion instead of timeout */
 -			usleep_range(20, 30);
 -			goto retry;
 +			/*
 +			 * Virtqueue full. Retry submission from worker
 +			 * context as we might be holding fc->bg_lock.
 +			 */
 +			spin_lock(&fsvq->lock);
 +			list_add_tail(&req->list, &fsvq->queued_reqs);
 +			inc_in_flight_req(fsvq);
 +			schedule_delayed_work(&fsvq->dispatch_work,
 +						msecs_to_jiffies(1));
 +			spin_unlock(&fsvq->lock);
 +			return;
    	}
    	req->out.h.error = ret;
    	pr_err("virtio-fs: virtio_fs_enqueue_req() failed %d\n", ret);
 -		spin_lock(&fpq->lock);
 -		clear_bit(FR_SENT, &req->flags);
 -		list_del_init(&req->list);
 -		spin_unlock(&fpq->lock);
 -		fuse_request_end(fc, req);
 +
 +		/* Can't end request in submission context. Use a worker */
 +		spin_lock(&fsvq->lock);
 +		list_add_tail(&req->list, &fsvq->end_reqs);
 +		schedule_delayed_work(&fsvq->dispatch_work, 0);
 +		spin_unlock(&fsvq->lock);
    	return;
    }
  }
@@@ -1048,7 -992,6 +1048,7 @@@ static int virtio_fs_fill_super(struct 
    	.destroy = true,
    	.no_control = true,
    	.no_force_umount = true,
 +		.no_mount_options = true,
    };
mutex_lock(&virtio_fs_mutex);
diff --combined include/linux/filter.h
index 7a6f8f6f1da4,fa2d921d7a22..d17f8eab899c
--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@@ -65,9 -65,6 +65,9 @@@ struct ctl_table_header
  /* unused opcode to mark special call to bpf_tail_call() helper */
  #define BPF_TAIL_CALL	0xf0
+/* unused opcode to mark special load instruction. Same as BPF_ABS */
 +#define BPF_PROBE_MEM	0x20
 +
  /* unused opcode to mark call to interpreter with arguments */
  #define BPF_CALL_ARGS	0xe0
@@@ -420,7 -417,7 +420,7 @@@ static inline bool insn_is_zext(const s
#define BPF_FIELD_SIZEOF(type, field)				\
    ({							\
- 		const int __size = bytes_to_bpf_size(FIELD_SIZEOF(type, field)); \
+ 		const int __size = bytes_to_bpf_size(sizeof_member(type, field)); \
    	BUILD_BUG_ON(__size < 0);			\
    	__size;						\
    })
@@@ -467,11 -464,10 +467,11 @@@
  #define BPF_CALL_x(x, name, ...)					       \
    static __always_inline						       \
    u64 ____##name(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_ARGS__));   \
 +	typedef u64 (*btf_##name)(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_ARGS__)); \
    u64 name(__BPF_REG(x, __BPF_DECL_REGS, __BPF_N, __VA_ARGS__));	       \
    u64 name(__BPF_REG(x, __BPF_DECL_REGS, __BPF_N, __VA_ARGS__))	       \
    {								       \
 -		return ____##name(__BPF_MAP(x,__BPF_CAST,__BPF_N,__VA_ARGS__));\
 +		return ((btf_##name)____##name)(__BPF_MAP(x,__BPF_CAST,__BPF_N,__VA_ARGS__));\
    }								       \
    static __always_inline						       \
    u64 ____##name(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_ARGS__))
@@@ -497,7 -493,7 +497,7 @@@
#define bpf_target_off(TYPE, MEMBER, SIZE, PTR_SIZE)				\
    ({									\
- 		BUILD_BUG_ON(FIELD_SIZEOF(TYPE, MEMBER) != (SIZE));		\
+ 		BUILD_BUG_ON(sizeof_member(TYPE, MEMBER) != (SIZE));		\
    	*(PTR_SIZE) = (SIZE);						\
    	offsetof(TYPE, MEMBER);						\
    })
@@@ -606,7 -602,7 +606,7 @@@ static inline void bpf_compute_data_poi
  {
    struct bpf_skb_data_end *cb = (struct bpf_skb_data_end *)skb->cb;
- 	BUILD_BUG_ON(sizeof(*cb) > FIELD_SIZEOF(struct sk_buff, cb));
+ 	BUILD_BUG_ON(sizeof(*cb) > sizeof_member(struct sk_buff, cb));
    cb->data_meta = skb->data - skb_metadata_len(skb);
    cb->data_end  = skb->data + skb_headlen(skb);
  }
@@@ -644,9 -640,9 +644,9 @@@ static inline u8 *bpf_skb_cb(struct sk_
     * attached to sockets, we need to clear the bpf_skb_cb() area
     * to not leak previous contents to user space.
     */
- 	BUILD_BUG_ON(FIELD_SIZEOF(struct __sk_buff, cb) != BPF_SKB_CB_LEN);
- 	BUILD_BUG_ON(FIELD_SIZEOF(struct __sk_buff, cb) !=
- 		     FIELD_SIZEOF(struct qdisc_skb_cb, data));
+ 	BUILD_BUG_ON(sizeof_member(struct __sk_buff, cb) != BPF_SKB_CB_LEN);
+ 	BUILD_BUG_ON(sizeof_member(struct __sk_buff, cb) !=
+ 		     sizeof_member(struct qdisc_skb_cb, data));
return qdisc_skb_cb(skb)->data;
  }
@@@ -1103,6 -1099,7 +1103,6 @@@ static inline void bpf_get_prog_name(co
#endif /* CONFIG_BPF_JIT */
-void bpf_prog_kallsyms_del_subprogs(struct bpf_prog *fp);
  void bpf_prog_kallsyms_del_all(struct bpf_prog *fp);
#define BPF_ANC		BIT(15)
diff --combined include/linux/kvm_host.h
index 7a26d5513471,ebbf4f1a221a..a1531ac88453
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@@ -149,7 -149,7 +149,7 @@@ static inline bool is_error_page(struc
  #define KVM_REQUEST_ARCH_BASE     8
#define KVM_ARCH_REQ_FLAGS(nr, flags) ({ \
- 	BUILD_BUG_ON((unsigned)(nr) >= (FIELD_SIZEOF(struct kvm_vcpu, requests) * 8) - KVM_REQUEST_ARCH_BASE); \
+ 	BUILD_BUG_ON((unsigned)(nr) >= (sizeof_member(struct kvm_vcpu, requests) * 8) - KVM_REQUEST_ARCH_BASE); \
    (unsigned)(((nr) + KVM_REQUEST_ARCH_BASE) | (flags)); \
  })
  #define KVM_ARCH_REQ(nr)           KVM_ARCH_REQ_FLAGS(nr, 0)
@@@ -746,28 -746,6 +746,28 @@@ int kvm_write_guest_offset_cached(struc
    			  unsigned long len);
  int kvm_gfn_to_hva_cache_init(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
    		      gpa_t gpa, unsigned long len);
 +
 +#define __kvm_put_guest(kvm, gfn, offset, value, type)			\
 +({									\
 +	unsigned long __addr = gfn_to_hva(kvm, gfn);			\
 +	type __user *__uaddr = (type __user *)(__addr + offset);	\
 +	int __ret = -EFAULT;						\
 +									\
 +	if (!kvm_is_error_hva(__addr))					\
 +		__ret = put_user(value, __uaddr);			\
 +	if (!__ret)							\
 +		mark_page_dirty(kvm, gfn);				\
 +	__ret;								\
 +})
 +
 +#define kvm_put_guest(kvm, gpa, value, type)				\
 +({									\
 +	gpa_t __gpa = gpa;						\
 +	struct kvm *__kvm = kvm;					\
 +	__kvm_put_guest(__kvm, __gpa >> PAGE_SHIFT,			\
 +			offset_in_page(__gpa), (value), type);		\
 +})
 +
  int kvm_clear_guest_page(struct kvm *kvm, gfn_t gfn, int offset, int len);
  int kvm_clear_guest(struct kvm *kvm, gpa_t gpa, unsigned long len);
  struct kvm_memory_slot *gfn_to_memslot(struct kvm *kvm, gfn_t gfn);
@@@ -1262,7 -1240,7 +1262,7 @@@ extern unsigned int halt_poll_ns_grow_s
  extern unsigned int halt_poll_ns_shrink;
struct kvm_device {
 -	struct kvm_device_ops *ops;
 +	const struct kvm_device_ops *ops;
    struct kvm *kvm;
    void *private;
    struct list_head vm_node;
@@@ -1315,7 -1293,7 +1315,7 @@@ struct kvm_device_ops 
  void kvm_device_get(struct kvm_device *dev);
  void kvm_device_put(struct kvm_device *dev);
  struct kvm_device *kvm_device_from_filp(struct file *filp);
 -int kvm_register_device_ops(struct kvm_device_ops *ops, u32 type);
 +int kvm_register_device_ops(const struct kvm_device_ops *ops, u32 type);
  void kvm_unregister_device_ops(u32 type);
extern struct kvm_device_ops kvm_mpic_ops;
diff --combined include/linux/slab.h
index 4d2a2fa55ed5,2afb630bce2a..6d52953dbdf0
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@@ -179,7 -179,7 +179,7 @@@ void memcg_deactivate_kmem_caches(struc
    		sizeof(struct __struct),			\
    		__alignof__(struct __struct), (__flags),	\
    		offsetof(struct __struct, __field),		\
- 			sizeof_field(struct __struct, __field), NULL)
+ 			sizeof_member(struct __struct, __field), NULL)
/*
   * Common kmalloc functions provided by all allocators
@@@ -493,10 -493,6 +493,10 @@@ static __always_inline void *kmalloc_la
   * kmalloc is the normal method of allocating memory
   * for objects smaller than page size in the kernel.
   *
 + * The allocated object address is aligned to at least ARCH_KMALLOC_MINALIGN
 + * bytes. For @size of power of two bytes, the alignment is also guaranteed
 + * to be at least to the size.
 + *
   * The @flags argument may be one of the GFP flags defined at
   * include/linux/gfp.h and described at
   * :ref:`Documentation/core-api/mm-api.rst <mm-api-gfp-flags>`
diff --combined include/net/sock.h
index f49d7a552f02,6a5a386410ff..1a0ed5a2e55b
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@@ -66,6 -66,7 +66,6 @@@
  #include <net/checksum.h>
  #include <net/tcp_states.h>
  #include <linux/net_tstamp.h>
 -#include <net/smc.h>
  #include <net/l3mdev.h>
/*
@@@ -877,17 -878,12 +877,17 @@@ static inline bool sk_acceptq_is_full(c
   */
  static inline int sk_stream_min_wspace(const struct sock *sk)
  {
 -	return sk->sk_wmem_queued >> 1;
 +	return READ_ONCE(sk->sk_wmem_queued) >> 1;
  }
static inline int sk_stream_wspace(const struct sock *sk)
  {
 -	return sk->sk_sndbuf - sk->sk_wmem_queued;
 +	return READ_ONCE(sk->sk_sndbuf) - READ_ONCE(sk->sk_wmem_queued);
 +}
 +
 +static inline void sk_wmem_queued_add(struct sock *sk, int val)
 +{
 +	WRITE_ONCE(sk->sk_wmem_queued, sk->sk_wmem_queued + val);
  }
void sk_stream_write_space(struct sock *sk);
@@@ -1211,7 -1207,7 +1211,7 @@@ static inline void sk_refcnt_debug_rele
static inline bool __sk_stream_memory_free(const struct sock *sk, int wake)
  {
 -	if (sk->sk_wmem_queued >= sk->sk_sndbuf)
 +	if (READ_ONCE(sk->sk_wmem_queued) >= READ_ONCE(sk->sk_sndbuf))
    	return false;
return sk->sk_prot->stream_memory_free ?
@@@ -1471,7 -1467,7 +1471,7 @@@ DECLARE_STATIC_KEY_FALSE(tcp_tx_skb_cac
  static inline void sk_wmem_free_skb(struct sock *sk, struct sk_buff *skb)
  {
    sock_set_flag(sk, SOCK_QUEUE_SHRUNK);
 -	sk->sk_wmem_queued -= skb->truesize;
 +	sk_wmem_queued_add(sk, -skb->truesize);
    sk_mem_uncharge(sk, skb->truesize);
    if (static_branch_unlikely(&tcp_tx_skb_cache_key) &&
        !sk->sk_tx_skb_cache && !skb_cloned(skb)) {
@@@ -1488,7 -1484,7 +1488,7 @@@ static inline void sock_release_ownersh
    	sk->sk_lock.owned = 0;
/* The sk_lock has mutex_unlock() semantics: */
 -		mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
 +		mutex_release(&sk->sk_lock.dep_map, _RET_IP_);
    }
  }
@@@ -2018,7 -2014,7 +2018,7 @@@ static inline int skb_copy_to_page_noca
    skb->len	     += copy;
    skb->data_len	     += copy;
    skb->truesize	     += copy;
 -	sk->sk_wmem_queued   += copy;
 +	sk_wmem_queued_add(sk, copy);
    sk_mem_charge(sk, copy);
    return 0;
  }
@@@ -2224,14 -2220,10 +2224,14 @@@ static inline void sk_wake_async(const
static inline void sk_stream_moderate_sndbuf(struct sock *sk)
  {
 -	if (!(sk->sk_userlocks & SOCK_SNDBUF_LOCK)) {
 -		sk->sk_sndbuf = min(sk->sk_sndbuf, sk->sk_wmem_queued >> 1);
 -		sk->sk_sndbuf = max_t(u32, sk->sk_sndbuf, SOCK_MIN_SNDBUF);
 -	}
 +	u32 val;
 +
 +	if (sk->sk_userlocks & SOCK_SNDBUF_LOCK)
 +		return;
 +
 +	val = min(sk->sk_sndbuf, sk->sk_wmem_queued >> 1);
 +
 +	WRITE_ONCE(sk->sk_sndbuf, max_t(u32, val, SOCK_MIN_SNDBUF));
  }
struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp,
@@@ -2241,17 -2233,12 +2241,17 @@@
   * sk_page_frag - return an appropriate page_frag
   * @sk: socket
   *
 - * If socket allocation mode allows current thread to sleep, it means its
 - * safe to use the per task page_frag instead of the per socket one.
 + * Use the per task page_frag instead of the per socket one for
 + * optimization when we know that we're in the normal context and owns
 + * everything that's associated with %current.
 + *
 + * gfpflags_allow_blocking() isn't enough here as direct reclaim may nest
 + * inside other socket operations and end up recursing into sk_page_frag()
 + * while it's already in use.
   */
  static inline struct page_frag *sk_page_frag(struct sock *sk)
  {
 -	if (gfpflags_allow_blocking(sk->sk_allocation))
 +	if (gfpflags_normal_context(sk->sk_allocation))
    	return &current->task_frag;
return &sk->sk_frag;
@@@ -2264,7 -2251,7 +2264,7 @@@ bool sk_page_frag_refill(struct sock *s
   */
  static inline bool sock_writeable(const struct sock *sk)
  {
 -	return refcount_read(&sk->sk_wmem_alloc) < (sk->sk_sndbuf >> 1);
 +	return refcount_read(&sk->sk_wmem_alloc) < (READ_ONCE(sk->sk_sndbuf) >> 1);
  }
static inline gfp_t gfp_any(void)
@@@ -2284,9 -2271,7 +2284,9 @@@ static inline long sock_sndtimeo(const
static inline int sock_rcvlowat(const struct sock *sk, int waitall, int len)
  {
 -	return (waitall ? len : min_t(int, sk->sk_rcvlowat, len)) ? : 1;
 +	int v = waitall ? len : min_t(int, READ_ONCE(sk->sk_rcvlowat), len);
 +
 +	return v ?: 1;
  }
/* Alas, with timeout socket operations are not restartable.
@@@ -2305,7 -2290,7 +2305,7 @@@ struct sock_skb_cb 
   * using skb->cb[] would keep using it directly and utilize its
   * alignement guarantee.
   */
- #define SOCK_SKB_CB_OFFSET ((FIELD_SIZEOF(struct sk_buff, cb) - \
+ #define SOCK_SKB_CB_OFFSET ((sizeof_member(struct sk_buff, cb) - \
    		    sizeof(struct sock_skb_cb)))
#define SOCK_SKB_CB(__skb) ((struct sock_skb_cb *)((__skb)->cb + \
@@@ -2527,7 -2512,7 +2527,7 @@@ static inline bool sk_listener(const st
    return (1 << sk->sk_state) & (TCPF_LISTEN | TCPF_NEW_SYN_RECV);
  }
-void sock_enable_timestamp(struct sock *sk, int flag);
 +void sock_enable_timestamp(struct sock *sk, enum sock_flags flag);
  int sock_recv_errqueue(struct sock *sk, struct msghdr *msg, int len, int level,
    	       int type);
diff --combined kernel/bpf/cgroup.c
index 9f90d3c92bda,3ff6df3ab022..b0adc5e83638
--- a/kernel/bpf/cgroup.c
+++ b/kernel/bpf/cgroup.c
@@@ -180,8 -180,8 +180,8 @@@ static void activate_effective_progs(st
    			     enum bpf_attach_type type,
    			     struct bpf_prog_array *old_array)
  {
 -	rcu_swap_protected(cgrp->bpf.effective[type], old_array,
 -			   lockdep_is_held(&cgroup_mutex));
 +	old_array = rcu_replace_pointer(cgrp->bpf.effective[type], old_array,
 +					lockdep_is_held(&cgroup_mutex));
    /* free prog array after grace period, since __cgroup_bpf_run_*()
     * might be still walking the array
     */
@@@ -1311,12 -1311,12 +1311,12 @@@ static bool sysctl_is_valid_access(int 
    	return false;
switch (off) {
 -	case offsetof(struct bpf_sysctl, write):
 +	case bpf_ctx_range(struct bpf_sysctl, write):
    	if (type != BPF_READ)
    		return false;
    	bpf_ctx_record_field_size(info, size_default);
    	return bpf_ctx_narrow_access_ok(off, size, size_default);
 -	case offsetof(struct bpf_sysctl, file_pos):
 +	case bpf_ctx_range(struct bpf_sysctl, file_pos):
    	if (type == BPF_READ) {
    		bpf_ctx_record_field_size(info, size_default);
    		return bpf_ctx_narrow_access_ok(off, size, size_default);
@@@ -1341,7 -1341,7 +1341,7 @@@ static u32 sysctl_convert_ctx_access(en
    	*insn++ = BPF_LDX_MEM(
    		BPF_SIZE(si->code), si->dst_reg, si->src_reg,
    		bpf_target_off(struct bpf_sysctl_kern, write,
- 				       FIELD_SIZEOF(struct bpf_sysctl_kern,
+ 				       sizeof_member(struct bpf_sysctl_kern,
    					    write),
    			       target_size));
    	break;
diff --combined kernel/fork.c
index bcdf53125210,1b45b28d4bf5..58cdbd95ef9a
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@@ -2688,7 -2688,7 +2688,7 @@@ void __init proc_caches_init(void
    		mm_size, ARCH_MIN_MMSTRUCT_ALIGN,
    		SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_ACCOUNT,
    		offsetof(struct mm_struct, saved_auxv),
- 			sizeof_field(struct mm_struct, saved_auxv),
+ 			sizeof_member(struct mm_struct, saved_auxv),
    		NULL);
    vm_area_cachep = KMEM_CACHE(vm_area_struct, SLAB_PANIC|SLAB_ACCOUNT);
    mmap_init();
@@@ -2925,7 -2925,7 +2925,7 @@@ int sysctl_max_threads(struct ctl_tabl
    struct ctl_table t;
    int ret;
    int threads = max_threads;
 -	int min = MIN_THREADS;
 +	int min = 1;
    int max = MAX_THREADS;
t = *table;
@@@ -2937,7 -2937,7 +2937,7 @@@
    if (ret || !write)
    	return ret;
-	set_max_threads(threads);
 +	max_threads = threads;
return 0;
  }
diff --combined kernel/signal.c
index bcd46f547db3,52628a975705..4c1a171eb68f
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@@ -2205,8 -2205,8 +2205,8 @@@ static void ptrace_stop(int exit_code, 
    	 */
    	preempt_disable();
    	read_unlock(&tasklist_lock);
 -		preempt_enable_no_resched();
    	cgroup_enter_frozen();
 +		preempt_enable_no_resched();
    	freezable_schedule();
    	cgroup_leave_frozen(true);
    } else {
@@@ -4548,11 -4548,11 +4548,11 @@@ static inline void siginfo_buildtime_ch
    BUILD_BUG_ON(offsetof(struct siginfo, si_pid) !=
    	     offsetof(struct siginfo, si_addr));
    if (sizeof(int) == sizeof(void __user *)) {
- 		BUILD_BUG_ON(sizeof_field(struct siginfo, si_pid) !=
+ 		BUILD_BUG_ON(sizeof_member(struct siginfo, si_pid) !=
    		     sizeof(void __user *));
    } else {
- 		BUILD_BUG_ON((sizeof_field(struct siginfo, si_pid) +
- 			      sizeof_field(struct siginfo, si_uid)) !=
+ 		BUILD_BUG_ON((sizeof_member(struct siginfo, si_pid) +
+ 			      sizeof_member(struct siginfo, si_uid)) !=
    		     sizeof(void __user *));
    	BUILD_BUG_ON(offsetofend(struct siginfo, si_pid) !=
    		     offsetof(struct siginfo, si_uid));
@@@ -4560,10 -4560,10 +4560,10 @@@
  #ifdef CONFIG_COMPAT
    BUILD_BUG_ON(offsetof(struct compat_siginfo, si_pid) !=
    	     offsetof(struct compat_siginfo, si_addr));
- 	BUILD_BUG_ON(sizeof_field(struct compat_siginfo, si_pid) !=
+ 	BUILD_BUG_ON(sizeof_member(struct compat_siginfo, si_pid) !=
    	     sizeof(compat_uptr_t));
- 	BUILD_BUG_ON(sizeof_field(struct compat_siginfo, si_pid) !=
- 		     sizeof_field(struct siginfo, si_pid));
+ 	BUILD_BUG_ON(sizeof_member(struct compat_siginfo, si_pid) !=
+ 		     sizeof_member(struct siginfo, si_pid));
  #endif
  }
diff --combined net/caif/caif_socket.c
index ef14da50a981,0dbd93bb1939..61bd13d3d637
--- a/net/caif/caif_socket.c
+++ b/net/caif/caif_socket.c
@@@ -953,7 -953,7 +953,7 @@@ static __poll_t caif_poll(struct file *
    	mask |= EPOLLRDHUP;
/* readable? */
 -	if (!skb_queue_empty(&sk->sk_receive_queue) ||
 +	if (!skb_queue_empty_lockless(&sk->sk_receive_queue) ||
    	(sk->sk_shutdown & RCV_SHUTDOWN))
    	mask |= EPOLLIN | EPOLLRDNORM;
@@@ -1033,7 -1033,7 +1033,7 @@@ static int caif_create(struct net *net
    	.owner = THIS_MODULE,
    	.obj_size = sizeof(struct caifsock),
    	.useroffset = offsetof(struct caifsock, conn_req.param),
- 		.usersize = sizeof_field(struct caifsock, conn_req.param)
+ 		.usersize = sizeof_member(struct caifsock, conn_req.param)
    };
if (!capable(CAP_SYS_ADMIN) && !capable(CAP_NET_ADMIN))
diff --combined net/core/dev.c
index af4c5430dd57,c434e94167ca..e6e8d5eaf672
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@@ -146,7 -146,6 +146,7 @@@
  #include "net-sysfs.h"
#define MAX_GRO_SKBS 8
 +#define MAX_NEST_DEV 8
/* This should be increased if a protocol with a bigger head is added. */
  #define GRO_MAX_HEAD (MAX_HEADER + 128)
@@@ -229,122 -228,6 +229,122 @@@ static inline void rps_unlock(struct so
  #endif
  }
+static struct netdev_name_node *netdev_name_node_alloc(struct net_device *dev,
 +						       const char *name)
 +{
 +	struct netdev_name_node *name_node;
 +
 +	name_node = kmalloc(sizeof(*name_node), GFP_KERNEL);
 +	if (!name_node)
 +		return NULL;
 +	INIT_HLIST_NODE(&name_node->hlist);
 +	name_node->dev = dev;
 +	name_node->name = name;
 +	return name_node;
 +}
 +
 +static struct netdev_name_node *
 +netdev_name_node_head_alloc(struct net_device *dev)
 +{
 +	struct netdev_name_node *name_node;
 +
 +	name_node = netdev_name_node_alloc(dev, dev->name);
 +	if (!name_node)
 +		return NULL;
 +	INIT_LIST_HEAD(&name_node->list);
 +	return name_node;
 +}
 +
 +static void netdev_name_node_free(struct netdev_name_node *name_node)
 +{
 +	kfree(name_node);
 +}
 +
 +static void netdev_name_node_add(struct net *net,
 +				 struct netdev_name_node *name_node)
 +{
 +	hlist_add_head_rcu(&name_node->hlist,
 +			   dev_name_hash(net, name_node->name));
 +}
 +
 +static void netdev_name_node_del(struct netdev_name_node *name_node)
 +{
 +	hlist_del_rcu(&name_node->hlist);
 +}
 +
 +static struct netdev_name_node *netdev_name_node_lookup(struct net *net,
 +							const char *name)
 +{
 +	struct hlist_head *head = dev_name_hash(net, name);
 +	struct netdev_name_node *name_node;
 +
 +	hlist_for_each_entry(name_node, head, hlist)
 +		if (!strcmp(name_node->name, name))
 +			return name_node;
 +	return NULL;
 +}
 +
 +static struct netdev_name_node *netdev_name_node_lookup_rcu(struct net *net,
 +							    const char *name)
 +{
 +	struct hlist_head *head = dev_name_hash(net, name);
 +	struct netdev_name_node *name_node;
 +
 +	hlist_for_each_entry_rcu(name_node, head, hlist)
 +		if (!strcmp(name_node->name, name))
 +			return name_node;
 +	return NULL;
 +}
 +
 +int netdev_name_node_alt_create(struct net_device *dev, const char *name)
 +{
 +	struct netdev_name_node *name_node;
 +	struct net *net = dev_net(dev);
 +
 +	name_node = netdev_name_node_lookup(net, name);
 +	if (name_node)
 +		return -EEXIST;
 +	name_node = netdev_name_node_alloc(dev, name);
 +	if (!name_node)
 +		return -ENOMEM;
 +	netdev_name_node_add(net, name_node);
 +	/* The node that holds dev->name acts as a head of per-device list. */
 +	list_add_tail(&name_node->list, &dev->name_node->list);
 +
 +	return 0;
 +}
 +EXPORT_SYMBOL(netdev_name_node_alt_create);
 +
 +static void __netdev_name_node_alt_destroy(struct netdev_name_node *name_node)
 +{
 +	list_del(&name_node->list);
 +	netdev_name_node_del(name_node);
 +	kfree(name_node->name);
 +	netdev_name_node_free(name_node);
 +}
 +
 +int netdev_name_node_alt_destroy(struct net_device *dev, const char *name)
 +{
 +	struct netdev_name_node *name_node;
 +	struct net *net = dev_net(dev);
 +
 +	name_node = netdev_name_node_lookup(net, name);
 +	if (!name_node)
 +		return -ENOENT;
 +	__netdev_name_node_alt_destroy(name_node);
 +
 +	return 0;
 +}
 +EXPORT_SYMBOL(netdev_name_node_alt_destroy);
 +
 +static void netdev_name_node_alt_flush(struct net_device *dev)
 +{
 +	struct netdev_name_node *name_node, *tmp;
 +
 +	list_for_each_entry_safe(name_node, tmp, &dev->name_node->list, list)
 +		__netdev_name_node_alt_destroy(name_node);
 +}
 +
  /* Device list insertion */
  static void list_netdevice(struct net_device *dev)
  {
@@@ -354,7 -237,7 +354,7 @@@
write_lock_bh(&dev_base_lock);
    list_add_tail_rcu(&dev->dev_list, &net->dev_base_head);
 -	hlist_add_head_rcu(&dev->name_hlist, dev_name_hash(net, dev->name));
 +	netdev_name_node_add(net, dev->name_node);
    hlist_add_head_rcu(&dev->index_hlist,
    		   dev_index_hash(net, dev->ifindex));
    write_unlock_bh(&dev_base_lock);
@@@ -372,7 -255,7 +372,7 @@@ static void unlist_netdevice(struct net
    /* Unlink dev from the device chain */
    write_lock_bh(&dev_base_lock);
    list_del_rcu(&dev->dev_list);
 -	hlist_del_rcu(&dev->name_hlist);
 +	netdev_name_node_del(dev->name_node);
    hlist_del_rcu(&dev->index_hlist);
    write_unlock_bh(&dev_base_lock);
@@@ -393,6 -276,88 +393,6 @@@ static RAW_NOTIFIER_HEAD(netdev_chain)
  DEFINE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
  EXPORT_PER_CPU_SYMBOL(softnet_data);
-#ifdef CONFIG_LOCKDEP
 -/*
 - * register_netdevice() inits txq->_xmit_lock and sets lockdep class
 - * according to dev->type
 - */
 -static const unsigned short netdev_lock_type[] = {
 -	 ARPHRD_NETROM, ARPHRD_ETHER, ARPHRD_EETHER, ARPHRD_AX25,
 -	 ARPHRD_PRONET, ARPHRD_CHAOS, ARPHRD_IEEE802, ARPHRD_ARCNET,
 -	 ARPHRD_APPLETLK, ARPHRD_DLCI, ARPHRD_ATM, ARPHRD_METRICOM,
 -	 ARPHRD_IEEE1394, ARPHRD_EUI64, ARPHRD_INFINIBAND, ARPHRD_SLIP,
 -	 ARPHRD_CSLIP, ARPHRD_SLIP6, ARPHRD_CSLIP6, ARPHRD_RSRVD,
 -	 ARPHRD_ADAPT, ARPHRD_ROSE, ARPHRD_X25, ARPHRD_HWX25,
 -	 ARPHRD_PPP, ARPHRD_CISCO, ARPHRD_LAPB, ARPHRD_DDCMP,
 -	 ARPHRD_RAWHDLC, ARPHRD_TUNNEL, ARPHRD_TUNNEL6, ARPHRD_FRAD,
 -	 ARPHRD_SKIP, ARPHRD_LOOPBACK, ARPHRD_LOCALTLK, ARPHRD_FDDI,
 -	 ARPHRD_BIF, ARPHRD_SIT, ARPHRD_IPDDP, ARPHRD_IPGRE,
 -	 ARPHRD_PIMREG, ARPHRD_HIPPI, ARPHRD_ASH, ARPHRD_ECONET,
 -	 ARPHRD_IRDA, ARPHRD_FCPP, ARPHRD_FCAL, ARPHRD_FCPL,
 -	 ARPHRD_FCFABRIC, ARPHRD_IEEE80211, ARPHRD_IEEE80211_PRISM,
 -	 ARPHRD_IEEE80211_RADIOTAP, ARPHRD_PHONET, ARPHRD_PHONET_PIPE,
 -	 ARPHRD_IEEE802154, ARPHRD_VOID, ARPHRD_NONE};
 -
 -static const char *const netdev_lock_name[] = {
 -	"_xmit_NETROM", "_xmit_ETHER", "_xmit_EETHER", "_xmit_AX25",
 -	"_xmit_PRONET", "_xmit_CHAOS", "_xmit_IEEE802", "_xmit_ARCNET",
 -	"_xmit_APPLETLK", "_xmit_DLCI", "_xmit_ATM", "_xmit_METRICOM",
 -	"_xmit_IEEE1394", "_xmit_EUI64", "_xmit_INFINIBAND", "_xmit_SLIP",
 -	"_xmit_CSLIP", "_xmit_SLIP6", "_xmit_CSLIP6", "_xmit_RSRVD",
 -	"_xmit_ADAPT", "_xmit_ROSE", "_xmit_X25", "_xmit_HWX25",
 -	"_xmit_PPP", "_xmit_CISCO", "_xmit_LAPB", "_xmit_DDCMP",
 -	"_xmit_RAWHDLC", "_xmit_TUNNEL", "_xmit_TUNNEL6", "_xmit_FRAD",
 -	"_xmit_SKIP", "_xmit_LOOPBACK", "_xmit_LOCALTLK", "_xmit_FDDI",
 -	"_xmit_BIF", "_xmit_SIT", "_xmit_IPDDP", "_xmit_IPGRE",
 -	"_xmit_PIMREG", "_xmit_HIPPI", "_xmit_ASH", "_xmit_ECONET",
 -	"_xmit_IRDA", "_xmit_FCPP", "_xmit_FCAL", "_xmit_FCPL",
 -	"_xmit_FCFABRIC", "_xmit_IEEE80211", "_xmit_IEEE80211_PRISM",
 -	"_xmit_IEEE80211_RADIOTAP", "_xmit_PHONET", "_xmit_PHONET_PIPE",
 -	"_xmit_IEEE802154", "_xmit_VOID", "_xmit_NONE"};
 -
 -static struct lock_class_key netdev_xmit_lock_key[ARRAY_SIZE(netdev_lock_type)];
 -static struct lock_class_key netdev_addr_lock_key[ARRAY_SIZE(netdev_lock_type)];
 -
 -static inline unsigned short netdev_lock_pos(unsigned short dev_type)
 -{
 -	int i;
 -
 -	for (i = 0; i < ARRAY_SIZE(netdev_lock_type); i++)
 -		if (netdev_lock_type[i] == dev_type)
 -			return i;
 -	/* the last key is used by default */
 -	return ARRAY_SIZE(netdev_lock_type) - 1;
 -}
 -
 -static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
 -						 unsigned short dev_type)
 -{
 -	int i;
 -
 -	i = netdev_lock_pos(dev_type);
 -	lockdep_set_class_and_name(lock, &netdev_xmit_lock_key[i],
 -				   netdev_lock_name[i]);
 -}
 -
 -static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
 -{
 -	int i;
 -
 -	i = netdev_lock_pos(dev->type);
 -	lockdep_set_class_and_name(&dev->addr_list_lock,
 -				   &netdev_addr_lock_key[i],
 -				   netdev_lock_name[i]);
 -}
 -#else
 -static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
 -						 unsigned short dev_type)
 -{
 -}
 -static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
 -{
 -}
 -#endif
 -
  /*******************************************************************************
   *
   *		Protocol management and registration routines
@@@ -768,10 -733,14 +768,10 @@@ EXPORT_SYMBOL_GPL(dev_fill_metadata_dst
struct net_device *__dev_get_by_name(struct net *net, const char *name)
  {
 -	struct net_device *dev;
 -	struct hlist_head *head = dev_name_hash(net, name);
 -
 -	hlist_for_each_entry(dev, head, name_hlist)
 -		if (!strncmp(dev->name, name, IFNAMSIZ))
 -			return dev;
 +	struct netdev_name_node *node_name;
-	return NULL;
 +	node_name = netdev_name_node_lookup(net, name);
 +	return node_name ? node_name->dev : NULL;
  }
  EXPORT_SYMBOL(__dev_get_by_name);
@@@ -789,10 -758,14 +789,10 @@@
struct net_device *dev_get_by_name_rcu(struct net *net, const char *name)
  {
 -	struct net_device *dev;
 -	struct hlist_head *head = dev_name_hash(net, name);
 +	struct netdev_name_node *node_name;
-	hlist_for_each_entry_rcu(dev, head, name_hlist)
 -		if (!strncmp(dev->name, name, IFNAMSIZ))
 -			return dev;
 -
 -	return NULL;
 +	node_name = netdev_name_node_lookup_rcu(net, name);
 +	return node_name ? node_name->dev : NULL;
  }
  EXPORT_SYMBOL(dev_get_by_name_rcu);
@@@ -1168,8 -1141,8 +1168,8 @@@ int dev_alloc_name(struct net_device *d
  }
  EXPORT_SYMBOL(dev_alloc_name);
-int dev_get_valid_name(struct net *net, struct net_device *dev,
 -		       const char *name)
 +static int dev_get_valid_name(struct net *net, struct net_device *dev,
 +			      const char *name)
  {
    BUG_ON(!net);
@@@ -1185,6 -1158,7 +1185,6 @@@
return 0;
  }
 -EXPORT_SYMBOL(dev_get_valid_name);
/**
   *	dev_change_name - change name of a device
@@@ -1258,13 -1232,13 +1258,13 @@@ rollback
    netdev_adjacent_rename_links(dev, oldname);
write_lock_bh(&dev_base_lock);
 -	hlist_del_rcu(&dev->name_hlist);
 +	netdev_name_node_del(dev->name_node);
    write_unlock_bh(&dev_base_lock);
synchronize_rcu();
write_lock_bh(&dev_base_lock);
 -	hlist_add_head_rcu(&dev->name_hlist, dev_name_hash(net, dev->name));
 +	netdev_name_node_add(net, dev->name_node);
    write_unlock_bh(&dev_base_lock);
ret = call_netdevice_notifiers(NETDEV_CHANGENAME, dev);
@@@ -1314,8 -1288,8 +1314,8 @@@ int dev_set_alias(struct net_device *de
    }
mutex_lock(&ifalias_mutex);
 -	rcu_swap_protected(dev->ifalias, new_alias,
 -			   mutex_is_locked(&ifalias_mutex));
 +	new_alias = rcu_replace_pointer(dev->ifalias, new_alias,
 +					mutex_is_locked(&ifalias_mutex));
    mutex_unlock(&ifalias_mutex);
if (new_alias)
@@@ -1643,62 -1617,6 +1643,62 @@@ static int call_netdevice_notifier(stru
    return nb->notifier_call(nb, val, &info);
  }
+static int call_netdevice_register_notifiers(struct notifier_block *nb,
 +					     struct net_device *dev)
 +{
 +	int err;
 +
 +	err = call_netdevice_notifier(nb, NETDEV_REGISTER, dev);
 +	err = notifier_to_errno(err);
 +	if (err)
 +		return err;
 +
 +	if (!(dev->flags & IFF_UP))
 +		return 0;
 +
 +	call_netdevice_notifier(nb, NETDEV_UP, dev);
 +	return 0;
 +}
 +
 +static void call_netdevice_unregister_notifiers(struct notifier_block *nb,
 +						struct net_device *dev)
 +{
 +	if (dev->flags & IFF_UP) {
 +		call_netdevice_notifier(nb, NETDEV_GOING_DOWN,
 +					dev);
 +		call_netdevice_notifier(nb, NETDEV_DOWN, dev);
 +	}
 +	call_netdevice_notifier(nb, NETDEV_UNREGISTER, dev);
 +}
 +
 +static int call_netdevice_register_net_notifiers(struct notifier_block *nb,
 +						 struct net *net)
 +{
 +	struct net_device *dev;
 +	int err;
 +
 +	for_each_netdev(net, dev) {
 +		err = call_netdevice_register_notifiers(nb, dev);
 +		if (err)
 +			goto rollback;
 +	}
 +	return 0;
 +
 +rollback:
 +	for_each_netdev_continue_reverse(net, dev)
 +		call_netdevice_unregister_notifiers(nb, dev);
 +	return err;
 +}
 +
 +static void call_netdevice_unregister_net_notifiers(struct notifier_block *nb,
 +						    struct net *net)
 +{
 +	struct net_device *dev;
 +
 +	for_each_netdev(net, dev)
 +		call_netdevice_unregister_notifiers(nb, dev);
 +}
 +
  static int dev_boot_phase = 1;
/**
@@@ -1717,6 -1635,8 +1717,6 @@@
int register_netdevice_notifier(struct notifier_block *nb)
  {
 -	struct net_device *dev;
 -	struct net_device *last;
    struct net *net;
    int err;
@@@ -1729,9 -1649,17 +1729,9 @@@
    if (dev_boot_phase)
    	goto unlock;
    for_each_net(net) {
 -		for_each_netdev(net, dev) {
 -			err = call_netdevice_notifier(nb, NETDEV_REGISTER, dev);
 -			err = notifier_to_errno(err);
 -			if (err)
 -				goto rollback;
 -
 -			if (!(dev->flags & IFF_UP))
 -				continue;
 -
 -			call_netdevice_notifier(nb, NETDEV_UP, dev);
 -		}
 +		err = call_netdevice_register_net_notifiers(nb, net);
 +		if (err)
 +			goto rollback;
    }
unlock:
@@@ -1740,9 -1668,22 +1740,9 @@@
    return err;
rollback:
 -	last = dev;
 -	for_each_net(net) {
 -		for_each_netdev(net, dev) {
 -			if (dev == last)
 -				goto outroll;
 -
 -			if (dev->flags & IFF_UP) {
 -				call_netdevice_notifier(nb, NETDEV_GOING_DOWN,
 -							dev);
 -				call_netdevice_notifier(nb, NETDEV_DOWN, dev);
 -			}
 -			call_netdevice_notifier(nb, NETDEV_UNREGISTER, dev);
 -		}
 -	}
 +	for_each_net_continue_reverse(net)
 +		call_netdevice_unregister_net_notifiers(nb, net);
-outroll:
    raw_notifier_chain_unregister(&netdev_chain, nb);
    goto unlock;
  }
@@@ -1792,80 -1733,6 +1792,80 @@@ unlock
  }
  EXPORT_SYMBOL(unregister_netdevice_notifier);
+/**
 + * register_netdevice_notifier_net - register a per-netns network notifier block
 + * @net: network namespace
 + * @nb: notifier
 + *
 + * Register a notifier to be called when network device events occur.
 + * The notifier passed is linked into the kernel structures and must
 + * not be reused until it has been unregistered. A negative errno code
 + * is returned on a failure.
 + *
 + * When registered all registration and up events are replayed
 + * to the new notifier to allow device to have a race free
 + * view of the network device list.
 + */
 +
 +int register_netdevice_notifier_net(struct net *net, struct notifier_block *nb)
 +{
 +	int err;
 +
 +	rtnl_lock();
 +	err = raw_notifier_chain_register(&net->netdev_chain, nb);
 +	if (err)
 +		goto unlock;
 +	if (dev_boot_phase)
 +		goto unlock;
 +
 +	err = call_netdevice_register_net_notifiers(nb, net);
 +	if (err)
 +		goto chain_unregister;
 +
 +unlock:
 +	rtnl_unlock();
 +	return err;
 +
 +chain_unregister:
 +	raw_notifier_chain_unregister(&netdev_chain, nb);
 +	goto unlock;
 +}
 +EXPORT_SYMBOL(register_netdevice_notifier_net);
 +
 +/**
 + * unregister_netdevice_notifier_net - unregister a per-netns
 + *                                     network notifier block
 + * @net: network namespace
 + * @nb: notifier
 + *
 + * Unregister a notifier previously registered by
 + * register_netdevice_notifier(). The notifier is unlinked into the
 + * kernel structures and may then be reused. A negative errno code
 + * is returned on a failure.
 + *
 + * After unregistering unregister and down device events are synthesized
 + * for all devices on the device list to the removed notifier to remove
 + * the need for special case cleanup code.
 + */
 +
 +int unregister_netdevice_notifier_net(struct net *net,
 +				      struct notifier_block *nb)
 +{
 +	int err;
 +
 +	rtnl_lock();
 +	err = raw_notifier_chain_unregister(&net->netdev_chain, nb);
 +	if (err)
 +		goto unlock;
 +
 +	call_netdevice_unregister_net_notifiers(nb, net);
 +
 +unlock:
 +	rtnl_unlock();
 +	return err;
 +}
 +EXPORT_SYMBOL(unregister_netdevice_notifier_net);
 +
  /**
   *	call_netdevice_notifiers_info - call all network notifier blocks
   *	@val: value passed unmodified to notifier function
@@@ -1878,18 -1745,7 +1878,18 @@@
  static int call_netdevice_notifiers_info(unsigned long val,
    				 struct netdev_notifier_info *info)
  {
 +	struct net *net = dev_net(info->dev);
 +	int ret;
 +
    ASSERT_RTNL();
 +
 +	/* Run per-netns notifier block chain first, then run the global one.
 +	 * Hopefully, one day, the global one is going to be removed after
 +	 * all notifier block registrators get converted to be per-netns.
 +	 */
 +	ret = raw_notifier_call_chain(&net->netdev_chain, val, info);
 +	if (ret & NOTIFY_STOP_MASK)
 +		return ret;
    return raw_notifier_call_chain(&netdev_chain, val, info);
  }
@@@ -2915,7 -2771,7 +2915,7 @@@ static struct dev_kfree_skb_cb *get_kfr
  void netif_schedule_queue(struct netdev_queue *txq)
  {
    rcu_read_lock();
 -	if (!(txq->state & QUEUE_STATE_ANY_XOFF)) {
 +	if (!netif_xmit_stopped(txq)) {
    	struct Qdisc *q = rcu_dereference(txq->qdisc);
__netif_schedule(q);
@@@ -3083,9 -2939,12 +3083,9 @@@ int skb_checksum_help(struct sk_buff *s
    offset += skb->csum_offset;
    BUG_ON(offset + sizeof(__sum16) > skb_headlen(skb));
-	if (skb_cloned(skb) &&
 -	    !skb_clone_writable(skb, offset + sizeof(__sum16))) {
 -		ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
 -		if (ret)
 -			goto out;
 -	}
 +	ret = skb_ensure_writable(skb, offset + sizeof(__sum16));
 +	if (ret)
 +		goto out;
*(__sum16 *)(skb->data + offset) = csum_fold(csum) ?: CSUM_MANGLED_0;
  out_set_summed:
@@@ -3120,11 -2979,12 +3120,11 @@@ int skb_crc32c_csum_help(struct sk_buf
    	ret = -EINVAL;
    	goto out;
    }
 -	if (skb_cloned(skb) &&
 -	    !skb_clone_writable(skb, offset + sizeof(__le32))) {
 -		ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
 -		if (ret)
 -			goto out;
 -	}
 +
 +	ret = skb_ensure_writable(skb, offset + sizeof(__le32));
 +	if (ret)
 +		goto out;
 +
    crc32c_csum = cpu_to_le32(~__skb_checksum(skb, start,
    					  skb->len - start, ~(__u32)0,
    					  crc32c_csum_stub));
@@@ -5803,26 -5663,6 +5803,26 @@@ struct packet_offload *gro_find_complet
  }
  EXPORT_SYMBOL(gro_find_complete_by_type);
+/* Pass the currently batched GRO_NORMAL SKBs up to the stack. */
 +static void gro_normal_list(struct napi_struct *napi)
 +{
 +	if (!napi->rx_count)
 +		return;
 +	netif_receive_skb_list_internal(&napi->rx_list);
 +	INIT_LIST_HEAD(&napi->rx_list);
 +	napi->rx_count = 0;
 +}
 +
 +/* Queue one GRO_NORMAL SKB up for list processing. If batch size exceeded,
 + * pass the whole batch up to the stack.
 + */
 +static void gro_normal_one(struct napi_struct *napi, struct sk_buff *skb)
 +{
 +	list_add_tail(&skb->list, &napi->rx_list);
 +	if (++napi->rx_count >= gro_normal_batch)
 +		gro_normal_list(napi);
 +}
 +
  static void napi_skb_free_stolen_head(struct sk_buff *skb)
  {
    skb_dst_drop(skb);
@@@ -5830,13 -5670,12 +5830,13 @@@
    kmem_cache_free(skbuff_head_cache, skb);
  }
-static gro_result_t napi_skb_finish(gro_result_t ret, struct sk_buff *skb)
 +static gro_result_t napi_skb_finish(struct napi_struct *napi,
 +				    struct sk_buff *skb,
 +				    gro_result_t ret)
  {
    switch (ret) {
    case GRO_NORMAL:
 -		if (netif_receive_skb_internal(skb))
 -			ret = GRO_DROP;
 +		gro_normal_one(napi, skb);
    	break;
case GRO_DROP:
@@@ -5868,7 -5707,7 +5868,7 @@@ gro_result_t napi_gro_receive(struct na
skb_gro_reset_offset(skb);
-	ret = napi_skb_finish(dev_gro_receive(napi, skb), skb);
 +	ret = napi_skb_finish(napi, skb, dev_gro_receive(napi, skb));
    trace_napi_gro_receive_exit(ret);
return ret;
@@@ -5914,6 -5753,26 +5914,6 @@@ struct sk_buff *napi_get_frags(struct n
  }
  EXPORT_SYMBOL(napi_get_frags);
-/* Pass the currently batched GRO_NORMAL SKBs up to the stack. */
 -static void gro_normal_list(struct napi_struct *napi)
 -{
 -	if (!napi->rx_count)
 -		return;
 -	netif_receive_skb_list_internal(&napi->rx_list);
 -	INIT_LIST_HEAD(&napi->rx_list);
 -	napi->rx_count = 0;
 -}
 -
 -/* Queue one GRO_NORMAL SKB up for list processing.  If batch size exceeded,
 - * pass the whole batch up to the stack.
 - */
 -static void gro_normal_one(struct napi_struct *napi, struct sk_buff *skb)
 -{
 -	list_add_tail(&skb->list, &napi->rx_list);
 -	if (++napi->rx_count >= gro_normal_batch)
 -		gro_normal_list(napi);
 -}
 -
  static gro_result_t napi_frags_finish(struct napi_struct *napi,
    			      struct sk_buff *skb,
    			      gro_result_t ret)
@@@ -6630,9 -6489,6 +6630,9 @@@ struct netdev_adjacent 
    /* upper master flag, there can only be one master device per list */
    bool master;
+	/* lookup ignore flag */
 +	bool ignore;
 +
    /* counter for the number of times this device was added to us */
    u16 ref_nr;
@@@ -6655,7 -6511,7 +6655,7 @@@ static struct netdev_adjacent *__netdev
    return NULL;
  }
-static int __netdev_has_upper_dev(struct net_device *upper_dev, void *data)
 +static int ____netdev_has_upper_dev(struct net_device *upper_dev, void *data)
  {
    struct net_device *dev = data;
@@@ -6676,7 -6532,7 +6676,7 @@@ bool netdev_has_upper_dev(struct net_de
  {
    ASSERT_RTNL();
-	return netdev_walk_all_upper_dev_rcu(dev, __netdev_has_upper_dev,
 +	return netdev_walk_all_upper_dev_rcu(dev, ____netdev_has_upper_dev,
    				     upper_dev);
  }
  EXPORT_SYMBOL(netdev_has_upper_dev);
@@@ -6694,7 -6550,7 +6694,7 @@@
  bool netdev_has_upper_dev_all_rcu(struct net_device *dev,
    			  struct net_device *upper_dev)
  {
 -	return !!netdev_walk_all_upper_dev_rcu(dev, __netdev_has_upper_dev,
 +	return !!netdev_walk_all_upper_dev_rcu(dev, ____netdev_has_upper_dev,
    				       upper_dev);
  }
  EXPORT_SYMBOL(netdev_has_upper_dev_all_rcu);
@@@ -6738,22 -6594,6 +6738,22 @@@ struct net_device *netdev_master_upper_
  }
  EXPORT_SYMBOL(netdev_master_upper_dev_get);
+static struct net_device *__netdev_master_upper_dev_get(struct net_device *dev)
 +{
 +	struct netdev_adjacent *upper;
 +
 +	ASSERT_RTNL();
 +
 +	if (list_empty(&dev->adj_list.upper))
 +		return NULL;
 +
 +	upper = list_first_entry(&dev->adj_list.upper,
 +				 struct netdev_adjacent, list);
 +	if (likely(upper->master) && !upper->ignore)
 +		return upper->dev;
 +	return NULL;
 +}
 +
  /**
   * netdev_has_any_lower_dev - Check if device is linked to some device
   * @dev: device
@@@ -6804,23 -6644,6 +6804,23 @@@ struct net_device *netdev_upper_get_nex
  }
  EXPORT_SYMBOL(netdev_upper_get_next_dev_rcu);
+static struct net_device *__netdev_next_upper_dev(struct net_device *dev,
 +						  struct list_head **iter,
 +						  bool *ignore)
 +{
 +	struct netdev_adjacent *upper;
 +
 +	upper = list_entry((*iter)->next, struct netdev_adjacent, list);
 +
 +	if (&upper->list == &dev->adj_list.upper)
 +		return NULL;
 +
 +	*iter = &upper->list;
 +	*ignore = upper->ignore;
 +
 +	return upper->dev;
 +}
 +
  static struct net_device *netdev_next_upper_dev_rcu(struct net_device *dev,
    					    struct list_head **iter)
  {
@@@ -6838,111 -6661,34 +6838,111 @@@
    return upper->dev;
  }
+static int __netdev_walk_all_upper_dev(struct net_device *dev,
 +				       int (*fn)(struct net_device *dev,
 +						 void *data),
 +				       void *data)
 +{
 +	struct net_device *udev, *next, *now, *dev_stack[MAX_NEST_DEV + 1];
 +	struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1];
 +	int ret, cur = 0;
 +	bool ignore;
 +
 +	now = dev;
 +	iter = &dev->adj_list.upper;
 +
 +	while (1) {
 +		if (now != dev) {
 +			ret = fn(now, data);
 +			if (ret)
 +				return ret;
 +		}
 +
 +		next = NULL;
 +		while (1) {
 +			udev = __netdev_next_upper_dev(now, &iter, &ignore);
 +			if (!udev)
 +				break;
 +			if (ignore)
 +				continue;
 +
 +			next = udev;
 +			niter = &udev->adj_list.upper;
 +			dev_stack[cur] = now;
 +			iter_stack[cur++] = iter;
 +			break;
 +		}
 +
 +		if (!next) {
 +			if (!cur)
 +				return 0;
 +			next = dev_stack[--cur];
 +			niter = iter_stack[cur];
 +		}
 +
 +		now = next;
 +		iter = niter;
 +	}
 +
 +	return 0;
 +}
 +
  int netdev_walk_all_upper_dev_rcu(struct net_device *dev,
    			  int (*fn)(struct net_device *dev,
    				    void *data),
    			  void *data)
  {
 -	struct net_device *udev;
 -	struct list_head *iter;
 -	int ret;
 +	struct net_device *udev, *next, *now, *dev_stack[MAX_NEST_DEV + 1];
 +	struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1];
 +	int ret, cur = 0;
-	for (iter = &dev->adj_list.upper,
 -	     udev = netdev_next_upper_dev_rcu(dev, &iter);
 -	     udev;
 -	     udev = netdev_next_upper_dev_rcu(dev, &iter)) {
 -		/* first is the upper device itself */
 -		ret = fn(udev, data);
 -		if (ret)
 -			return ret;
 +	now = dev;
 +	iter = &dev->adj_list.upper;
-		/* then look at all of its upper devices */
 -		ret = netdev_walk_all_upper_dev_rcu(udev, fn, data);
 -		if (ret)
 -			return ret;
 +	while (1) {
 +		if (now != dev) {
 +			ret = fn(now, data);
 +			if (ret)
 +				return ret;
 +		}
 +
 +		next = NULL;
 +		while (1) {
 +			udev = netdev_next_upper_dev_rcu(now, &iter);
 +			if (!udev)
 +				break;
 +
 +			next = udev;
 +			niter = &udev->adj_list.upper;
 +			dev_stack[cur] = now;
 +			iter_stack[cur++] = iter;
 +			break;
 +		}
 +
 +		if (!next) {
 +			if (!cur)
 +				return 0;
 +			next = dev_stack[--cur];
 +			niter = iter_stack[cur];
 +		}
 +
 +		now = next;
 +		iter = niter;
    }
return 0;
  }
  EXPORT_SYMBOL_GPL(netdev_walk_all_upper_dev_rcu);
+static bool __netdev_has_upper_dev(struct net_device *dev,
 +				   struct net_device *upper_dev)
 +{
 +	ASSERT_RTNL();
 +
 +	return __netdev_walk_all_upper_dev(dev, ____netdev_has_upper_dev,
 +					   upper_dev);
 +}
 +
  /**
   * netdev_lower_get_next_private - Get the next ->private from the
   *				   lower neighbour list
@@@ -7039,119 -6785,34 +7039,119 @@@ static struct net_device *netdev_next_l
    return lower->dev;
  }
+static struct net_device *__netdev_next_lower_dev(struct net_device *dev,
 +						  struct list_head **iter,
 +						  bool *ignore)
 +{
 +	struct netdev_adjacent *lower;
 +
 +	lower = list_entry((*iter)->next, struct netdev_adjacent, list);
 +
 +	if (&lower->list == &dev->adj_list.lower)
 +		return NULL;
 +
 +	*iter = &lower->list;
 +	*ignore = lower->ignore;
 +
 +	return lower->dev;
 +}
 +
  int netdev_walk_all_lower_dev(struct net_device *dev,
    		      int (*fn)(struct net_device *dev,
    				void *data),
    		      void *data)
  {
 -	struct net_device *ldev;
 -	struct list_head *iter;
 -	int ret;
 +	struct net_device *ldev, *next, *now, *dev_stack[MAX_NEST_DEV + 1];
 +	struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1];
 +	int ret, cur = 0;
-	for (iter = &dev->adj_list.lower,
 -	     ldev = netdev_next_lower_dev(dev, &iter);
 -	     ldev;
 -	     ldev = netdev_next_lower_dev(dev, &iter)) {
 -		/* first is the lower device itself */
 -		ret = fn(ldev, data);
 -		if (ret)
 -			return ret;
 +	now = dev;
 +	iter = &dev->adj_list.lower;
-		/* then look at all of its lower devices */
 -		ret = netdev_walk_all_lower_dev(ldev, fn, data);
 -		if (ret)
 -			return ret;
 +	while (1) {
 +		if (now != dev) {
 +			ret = fn(now, data);
 +			if (ret)
 +				return ret;
 +		}
 +
 +		next = NULL;
 +		while (1) {
 +			ldev = netdev_next_lower_dev(now, &iter);
 +			if (!ldev)
 +				break;
 +
 +			next = ldev;
 +			niter = &ldev->adj_list.lower;
 +			dev_stack[cur] = now;
 +			iter_stack[cur++] = iter;
 +			break;
 +		}
 +
 +		if (!next) {
 +			if (!cur)
 +				return 0;
 +			next = dev_stack[--cur];
 +			niter = iter_stack[cur];
 +		}
 +
 +		now = next;
 +		iter = niter;
    }
return 0;
  }
  EXPORT_SYMBOL_GPL(netdev_walk_all_lower_dev);
+static int __netdev_walk_all_lower_dev(struct net_device *dev,
 +				       int (*fn)(struct net_device *dev,
 +						 void *data),
 +				       void *data)
 +{
 +	struct net_device *ldev, *next, *now, *dev_stack[MAX_NEST_DEV + 1];
 +	struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1];
 +	int ret, cur = 0;
 +	bool ignore;
 +
 +	now = dev;
 +	iter = &dev->adj_list.lower;
 +
 +	while (1) {
 +		if (now != dev) {
 +			ret = fn(now, data);
 +			if (ret)
 +				return ret;
 +		}
 +
 +		next = NULL;
 +		while (1) {
 +			ldev = __netdev_next_lower_dev(now, &iter, &ignore);
 +			if (!ldev)
 +				break;
 +			if (ignore)
 +				continue;
 +
 +			next = ldev;
 +			niter = &ldev->adj_list.lower;
 +			dev_stack[cur] = now;
 +			iter_stack[cur++] = iter;
 +			break;
 +		}
 +
 +		if (!next) {
 +			if (!cur)
 +				return 0;
 +			next = dev_stack[--cur];
 +			niter = iter_stack[cur];
 +		}
 +
 +		now = next;
 +		iter = niter;
 +	}
 +
 +	return 0;
 +}
 +
  static struct net_device *netdev_next_lower_dev_rcu(struct net_device *dev,
    					    struct list_head **iter)
  {
@@@ -7166,99 -6827,28 +7166,99 @@@
    return lower->dev;
  }
-int netdev_walk_all_lower_dev_rcu(struct net_device *dev,
 -				  int (*fn)(struct net_device *dev,
 -					    void *data),
 -				  void *data)
 +static u8 __netdev_upper_depth(struct net_device *dev)
 +{
 +	struct net_device *udev;
 +	struct list_head *iter;
 +	u8 max_depth = 0;
 +	bool ignore;
 +
 +	for (iter = &dev->adj_list.upper,
 +	     udev = __netdev_next_upper_dev(dev, &iter, &ignore);
 +	     udev;
 +	     udev = __netdev_next_upper_dev(dev, &iter, &ignore)) {
 +		if (ignore)
 +			continue;
 +		if (max_depth < udev->upper_level)
 +			max_depth = udev->upper_level;
 +	}
 +
 +	return max_depth;
 +}
 +
 +static u8 __netdev_lower_depth(struct net_device *dev)
  {
    struct net_device *ldev;
    struct list_head *iter;
 -	int ret;
 +	u8 max_depth = 0;
 +	bool ignore;
for (iter = &dev->adj_list.lower,
 -	     ldev = netdev_next_lower_dev_rcu(dev, &iter);
 +	     ldev = __netdev_next_lower_dev(dev, &iter, &ignore);
         ldev;
 -	     ldev = netdev_next_lower_dev_rcu(dev, &iter)) {
 -		/* first is the lower device itself */
 -		ret = fn(ldev, data);
 -		if (ret)
 -			return ret;
 +	     ldev = __netdev_next_lower_dev(dev, &iter, &ignore)) {
 +		if (ignore)
 +			continue;
 +		if (max_depth < ldev->lower_level)
 +			max_depth = ldev->lower_level;
 +	}
-		/* then look at all of its lower devices */
 -		ret = netdev_walk_all_lower_dev_rcu(ldev, fn, data);
 -		if (ret)
 -			return ret;
 +	return max_depth;
 +}
 +
 +static int __netdev_update_upper_level(struct net_device *dev, void *data)
 +{
 +	dev->upper_level = __netdev_upper_depth(dev) + 1;
 +	return 0;
 +}
 +
 +static int __netdev_update_lower_level(struct net_device *dev, void *data)
 +{
 +	dev->lower_level = __netdev_lower_depth(dev) + 1;
 +	return 0;
 +}
 +
 +int netdev_walk_all_lower_dev_rcu(struct net_device *dev,
 +				  int (*fn)(struct net_device *dev,
 +					    void *data),
 +				  void *data)
 +{
 +	struct net_device *ldev, *next, *now, *dev_stack[MAX_NEST_DEV + 1];
 +	struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1];
 +	int ret, cur = 0;
 +
 +	now = dev;
 +	iter = &dev->adj_list.lower;
 +
 +	while (1) {
 +		if (now != dev) {
 +			ret = fn(now, data);
 +			if (ret)
 +				return ret;
 +		}
 +
 +		next = NULL;
 +		while (1) {
 +			ldev = netdev_next_lower_dev_rcu(now, &iter);
 +			if (!ldev)
 +				break;
 +
 +			next = ldev;
 +			niter = &ldev->adj_list.lower;
 +			dev_stack[cur] = now;
 +			iter_stack[cur++] = iter;
 +			break;
 +		}
 +
 +		if (!next) {
 +			if (!cur)
 +				return 0;
 +			next = dev_stack[--cur];
 +			niter = iter_stack[cur];
 +		}
 +
 +		now = next;
 +		iter = niter;
    }
return 0;
@@@ -7362,7 -6952,6 +7362,7 @@@ static int __netdev_adjacent_dev_insert
    adj->master = master;
    adj->ref_nr = 1;
    adj->private = private;
 +	adj->ignore = false;
    dev_hold(adj_dev);
pr_debug("Insert adjacency: dev %s adj_dev %s adj->ref_nr %d; dev_hold on %s\n",
@@@ -7513,17 -7102,14 +7513,17 @@@ static int __netdev_upper_dev_link(stru
    	return -EBUSY;
/* To prevent loops, check if dev is not upper device to upper_dev. */
 -	if (netdev_has_upper_dev(upper_dev, dev))
 +	if (__netdev_has_upper_dev(upper_dev, dev))
    	return -EBUSY;
+	if ((dev->lower_level + upper_dev->upper_level) > MAX_NEST_DEV)
 +		return -EMLINK;
 +
    if (!master) {
 -		if (netdev_has_upper_dev(dev, upper_dev))
 +		if (__netdev_has_upper_dev(dev, upper_dev))
    		return -EEXIST;
    } else {
 -		master_dev = netdev_master_upper_dev_get(dev);
 +		master_dev = __netdev_master_upper_dev_get(dev);
    	if (master_dev)
    		return master_dev == upper_dev ? -EEXIST : -EBUSY;
    }
@@@ -7545,13 -7131,6 +7545,13 @@@
    if (ret)
    	goto rollback;
+	__netdev_update_upper_level(dev, NULL);
 +	__netdev_walk_all_lower_dev(dev, __netdev_update_upper_level, NULL);
 +
 +	__netdev_update_lower_level(upper_dev, NULL);
 +	__netdev_walk_all_upper_dev(upper_dev, __netdev_update_lower_level,
 +				    NULL);
 +
    return 0;
rollback:
@@@ -7634,96 -7213,9 +7634,96 @@@ void netdev_upper_dev_unlink(struct net
call_netdevice_notifiers_info(NETDEV_CHANGEUPPER,
    			      &changeupper_info.info);
 +
 +	__netdev_update_upper_level(dev, NULL);
 +	__netdev_walk_all_lower_dev(dev, __netdev_update_upper_level, NULL);
 +
 +	__netdev_update_lower_level(upper_dev, NULL);
 +	__netdev_walk_all_upper_dev(upper_dev, __netdev_update_lower_level,
 +				    NULL);
  }
  EXPORT_SYMBOL(netdev_upper_dev_unlink);
+static void __netdev_adjacent_dev_set(struct net_device *upper_dev,
 +				      struct net_device *lower_dev,
 +				      bool val)
 +{
 +	struct netdev_adjacent *adj;
 +
 +	adj = __netdev_find_adj(lower_dev, &upper_dev->adj_list.lower);
 +	if (adj)
 +		adj->ignore = val;
 +
 +	adj = __netdev_find_adj(upper_dev, &lower_dev->adj_list.upper);
 +	if (adj)
 +		adj->ignore = val;
 +}
 +
 +static void netdev_adjacent_dev_disable(struct net_device *upper_dev,
 +					struct net_device *lower_dev)
 +{
 +	__netdev_adjacent_dev_set(upper_dev, lower_dev, true);
 +}
 +
 +static void netdev_adjacent_dev_enable(struct net_device *upper_dev,
 +				       struct net_device *lower_dev)
 +{
 +	__netdev_adjacent_dev_set(upper_dev, lower_dev, false);
 +}
 +
 +int netdev_adjacent_change_prepare(struct net_device *old_dev,
 +				   struct net_device *new_dev,
 +				   struct net_device *dev,
 +				   struct netlink_ext_ack *extack)
 +{
 +	int err;
 +
 +	if (!new_dev)
 +		return 0;
 +
 +	if (old_dev && new_dev != old_dev)
 +		netdev_adjacent_dev_disable(dev, old_dev);
 +
 +	err = netdev_upper_dev_link(new_dev, dev, extack);
 +	if (err) {
 +		if (old_dev && new_dev != old_dev)
 +			netdev_adjacent_dev_enable(dev, old_dev);
 +		return err;
 +	}
 +
 +	return 0;
 +}
 +EXPORT_SYMBOL(netdev_adjacent_change_prepare);
 +
 +void netdev_adjacent_change_commit(struct net_device *old_dev,
 +				   struct net_device *new_dev,
 +				   struct net_device *dev)
 +{
 +	if (!new_dev || !old_dev)
 +		return;
 +
 +	if (new_dev == old_dev)
 +		return;
 +
 +	netdev_adjacent_dev_enable(dev, old_dev);
 +	netdev_upper_dev_unlink(old_dev, dev);
 +}
 +EXPORT_SYMBOL(netdev_adjacent_change_commit);
 +
 +void netdev_adjacent_change_abort(struct net_device *old_dev,
 +				  struct net_device *new_dev,
 +				  struct net_device *dev)
 +{
 +	if (!new_dev)
 +		return;
 +
 +	if (old_dev && new_dev != old_dev)
 +		netdev_adjacent_dev_enable(dev, old_dev);
 +
 +	netdev_upper_dev_unlink(new_dev, dev);
 +}
 +EXPORT_SYMBOL(netdev_adjacent_change_abort);
 +
  /**
   * netdev_bonding_info_change - Dispatch event about slave change
   * @dev: device
@@@ -7837,6 -7329,25 +7837,6 @@@ void *netdev_lower_dev_get_private(stru
  EXPORT_SYMBOL(netdev_lower_dev_get_private);
-int dev_get_nest_level(struct net_device *dev)
 -{
 -	struct net_device *lower = NULL;
 -	struct list_head *iter;
 -	int max_nest = -1;
 -	int nest;
 -
 -	ASSERT_RTNL();
 -
 -	netdev_for_each_lower_dev(dev, lower, iter) {
 -		nest = dev_get_nest_level(lower);
 -		if (max_nest < nest)
 -			max_nest = nest;
 -	}
 -
 -	return max_nest + 1;
 -}
 -EXPORT_SYMBOL(dev_get_nest_level);
 -
  /**
   * netdev_lower_change - Dispatch event about lower device state change
   * @lower_dev: device
@@@ -8753,9 -8264,6 +8753,9 @@@ static void rollback_registered_many(st
    	dev_uc_flush(dev);
    	dev_mc_flush(dev);
+		netdev_name_node_alt_flush(dev);
 +		netdev_name_node_free(dev->name_node);
 +
    	if (dev->netdev_ops->ndo_uninit)
    		dev->netdev_ops->ndo_uninit(dev);
@@@ -9111,7 -8619,7 +9111,7 @@@ static void netdev_init_one_queue(struc
  {
    /* Initialize queue lock */
    spin_lock_init(&queue->_xmit_lock);
 -	netdev_set_xmit_lockdep_class(&queue->_xmit_lock, dev->type);
 +	lockdep_set_class(&queue->_xmit_lock, &dev->qdisc_xmit_lock_key);
    queue->xmit_lock_owner = -1;
    netdev_queue_numa_node_write(queue, NUMA_NO_NODE);
    queue->dev = dev;
@@@ -9158,43 -8666,6 +9158,43 @@@ void netif_tx_stop_all_queues(struct ne
  }
  EXPORT_SYMBOL(netif_tx_stop_all_queues);
+static void netdev_register_lockdep_key(struct net_device *dev)
 +{
 +	lockdep_register_key(&dev->qdisc_tx_busylock_key);
 +	lockdep_register_key(&dev->qdisc_running_key);
 +	lockdep_register_key(&dev->qdisc_xmit_lock_key);
 +	lockdep_register_key(&dev->addr_list_lock_key);
 +}
 +
 +static void netdev_unregister_lockdep_key(struct net_device *dev)
 +{
 +	lockdep_unregister_key(&dev->qdisc_tx_busylock_key);
 +	lockdep_unregister_key(&dev->qdisc_running_key);
 +	lockdep_unregister_key(&dev->qdisc_xmit_lock_key);
 +	lockdep_unregister_key(&dev->addr_list_lock_key);
 +}
 +
 +void netdev_update_lockdep_key(struct net_device *dev)
 +{
 +	struct netdev_queue *queue;
 +	int i;
 +
 +	lockdep_unregister_key(&dev->qdisc_xmit_lock_key);
 +	lockdep_unregister_key(&dev->addr_list_lock_key);
 +
 +	lockdep_register_key(&dev->qdisc_xmit_lock_key);
 +	lockdep_register_key(&dev->addr_list_lock_key);
 +
 +	lockdep_set_class(&dev->addr_list_lock, &dev->addr_list_lock_key);
 +	for (i = 0; i < dev->num_tx_queues; i++) {
 +		queue = netdev_get_tx_queue(dev, i);
 +
 +		lockdep_set_class(&queue->_xmit_lock,
 +				  &dev->qdisc_xmit_lock_key);
 +	}
 +}
 +EXPORT_SYMBOL(netdev_update_lockdep_key);
 +
  /**
   *	register_netdevice	- register a network device
   *	@dev: device to register
@@@ -9229,17 -8700,12 +9229,17 @@@ int register_netdevice(struct net_devic
    BUG_ON(!net);
spin_lock_init(&dev->addr_list_lock);
 -	netdev_set_addr_lockdep_class(dev);
 +	lockdep_set_class(&dev->addr_list_lock, &dev->addr_list_lock_key);
ret = dev_get_valid_name(net, dev, dev->name);
    if (ret < 0)
    	goto out;
+	ret = -ENOMEM;
 +	dev->name_node = netdev_name_node_head_alloc(dev);
 +	if (!dev->name_node)
 +		goto out;
 +
    /* Init, if this function is available */
    if (dev->netdev_ops->ndo_init) {
    	ret = dev->netdev_ops->ndo_init(dev);
@@@ -9361,8 -8827,6 +9361,8 @@@ out
    return ret;
err_uninit:
 +	if (dev->name_node)
 +		netdev_name_node_free(dev->name_node);
    if (dev->netdev_ops->ndo_uninit)
    	dev->netdev_ops->ndo_uninit(dev);
    if (dev->priv_destructor)
@@@ -9746,12 -9210,8 +9746,12 @@@ struct net_device *alloc_netdev_mqs(in
dev_net_set(dev, &init_net);
+	netdev_register_lockdep_key(dev);
 +
    dev->gso_max_size = GSO_MAX_SIZE;
    dev->gso_max_segs = GSO_MAX_SEGS;
 +	dev->upper_level = 1;
 +	dev->lower_level = 1;
INIT_LIST_HEAD(&dev->napi_list);
    INIT_LIST_HEAD(&dev->unreg_list);
@@@ -9832,8 -9292,6 +9832,8 @@@ void free_netdev(struct net_device *dev
    free_percpu(dev->pcpu_refcnt);
    dev->pcpu_refcnt = NULL;
+	netdev_unregister_lockdep_key(dev);
 +
    /*  Compatibility with error handling in drivers */
    if (dev->reg_state == NETREG_UNINITIALIZED) {
    	netdev_freemem(dev);
@@@ -10002,7 -9460,7 +10002,7 @@@ int dev_change_net_namespace(struct net
    call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
    rcu_barrier();
-	new_nsid = peernet2id_alloc(dev_net(dev), net);
 +	new_nsid = peernet2id_alloc(dev_net(dev), net, GFP_KERNEL);
    /* If there is an ifindex conflict assign a new one */
    if (__dev_get_by_index(net, dev->ifindex))
    	new_ifindex = dev_new_index(net);
@@@ -10164,7 -9622,7 +10164,7 @@@ static struct hlist_head * __net_init n
  static int __net_init netdev_init(struct net *net)
  {
    BUILD_BUG_ON(GRO_HASH_BUCKETS >
- 		     8 * FIELD_SIZEOF(struct napi_struct, gro_bitmask));
+ 		     8 * sizeof_member(struct napi_struct, gro_bitmask));
if (net != &init_net)
    	INIT_LIST_HEAD(&net->dev_base_head);
@@@ -10177,8 -9635,6 +10177,8 @@@
    if (net->dev_index_head == NULL)
    	goto err_idx;
+	RAW_INIT_NOTIFIER_HEAD(&net->netdev_chain);
 +
    return 0;
err_idx:
diff --combined net/core/filter.c
index fc303abec8fa,284f60695ba9..6644f1c56be9
--- a/net/core/filter.c
+++ b/net/core/filter.c
@@@ -274,7 -274,7 +274,7 @@@ static u32 convert_skb_access(int skb_f
switch (skb_field) {
    case SKF_AD_MARK:
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sk_buff, mark) != 4);
+ 		BUILD_BUG_ON(sizeof_member(struct sk_buff, mark) != 4);
*insn++ = BPF_LDX_MEM(BPF_W, dst_reg, src_reg,
    			      offsetof(struct sk_buff, mark));
@@@ -289,14 -289,14 +289,14 @@@
    	break;
case SKF_AD_QUEUE:
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sk_buff, queue_mapping) != 2);
+ 		BUILD_BUG_ON(sizeof_member(struct sk_buff, queue_mapping) != 2);
*insn++ = BPF_LDX_MEM(BPF_H, dst_reg, src_reg,
    			      offsetof(struct sk_buff, queue_mapping));
    	break;
case SKF_AD_VLAN_TAG:
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sk_buff, vlan_tci) != 2);
+ 		BUILD_BUG_ON(sizeof_member(struct sk_buff, vlan_tci) != 2);
/* dst_reg = *(u16 *) (src_reg + offsetof(vlan_tci)) */
    	*insn++ = BPF_LDX_MEM(BPF_H, dst_reg, src_reg,
@@@ -322,7 -322,7 +322,7 @@@ static bool convert_bpf_extensions(stru
switch (fp->k) {
    case SKF_AD_OFF + SKF_AD_PROTOCOL:
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sk_buff, protocol) != 2);
+ 		BUILD_BUG_ON(sizeof_member(struct sk_buff, protocol) != 2);
/* A = *(u16 *) (CTX + offsetof(protocol)) */
    	*insn++ = BPF_LDX_MEM(BPF_H, BPF_REG_A, BPF_REG_CTX,
@@@ -338,8 -338,8 +338,8 @@@
case SKF_AD_OFF + SKF_AD_IFINDEX:
    case SKF_AD_OFF + SKF_AD_HATYPE:
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct net_device, ifindex) != 4);
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct net_device, type) != 2);
+ 		BUILD_BUG_ON(sizeof_member(struct net_device, ifindex) != 4);
+ 		BUILD_BUG_ON(sizeof_member(struct net_device, type) != 2);
*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(struct sk_buff, dev),
    			      BPF_REG_TMP, BPF_REG_CTX,
@@@ -361,7 -361,7 +361,7 @@@
    	break;
case SKF_AD_OFF + SKF_AD_RXHASH:
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sk_buff, hash) != 4);
+ 		BUILD_BUG_ON(sizeof_member(struct sk_buff, hash) != 4);
*insn = BPF_LDX_MEM(BPF_W, BPF_REG_A, BPF_REG_CTX,
    			    offsetof(struct sk_buff, hash));
@@@ -385,7 -385,7 +385,7 @@@
    	break;
case SKF_AD_OFF + SKF_AD_VLAN_TPID:
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sk_buff, vlan_proto) != 2);
+ 		BUILD_BUG_ON(sizeof_member(struct sk_buff, vlan_proto) != 2);
/* A = *(u16 *) (CTX + offsetof(vlan_proto)) */
    	*insn++ = BPF_LDX_MEM(BPF_H, BPF_REG_A, BPF_REG_CTX,
@@@ -2245,7 -2245,7 +2245,7 @@@ BPF_CALL_4(bpf_msg_pull_data, struct sk
     * account for the headroom.
     */
    bytes_sg_total = start - offset + bytes;
 -	if (!msg->sg.copy[i] && bytes_sg_total <= len)
 +	if (!test_bit(i, &msg->sg.copy) && bytes_sg_total <= len)
    	goto out;
/* At this point we need to linearize multiple scatterlist
@@@ -2450,7 -2450,7 +2450,7 @@@ BPF_CALL_4(bpf_msg_push_data, struct sk
    /* Place newly allocated data buffer */
    sk_mem_charge(msg->sk, len);
    msg->sg.size += len;
 -	msg->sg.copy[new] = false;
 +	__clear_bit(new, &msg->sg.copy);
    sg_set_page(&msg->sg.data[new], page, len + copy, 0);
    if (rsge.length) {
    	get_page(sg_page(&rsge));
@@@ -3798,7 -3798,7 +3798,7 @@@ BPF_CALL_5(bpf_skb_event_output, struc
if (unlikely(flags & ~(BPF_F_CTXLEN_MASK | BPF_F_INDEX_MASK)))
    	return -EINVAL;
 -	if (unlikely(skb_size > skb->len))
 +	if (unlikely(!skb || skb_size > skb->len))
    	return -EFAULT;
return bpf_event_output(map, flags, meta, meta_size, skb, skb_size,
@@@ -3816,19 -3816,6 +3816,19 @@@ static const struct bpf_func_proto bpf_
    .arg5_type	= ARG_CONST_SIZE_OR_ZERO,
  };
+static u32 bpf_skb_output_btf_ids[5];
 +const struct bpf_func_proto bpf_skb_output_proto = {
 +	.func		= bpf_skb_event_output,
 +	.gpl_only	= true,
 +	.ret_type	= RET_INTEGER,
 +	.arg1_type	= ARG_PTR_TO_BTF_ID,
 +	.arg2_type	= ARG_CONST_MAP_PTR,
 +	.arg3_type	= ARG_ANYTHING,
 +	.arg4_type	= ARG_PTR_TO_MEM,
 +	.arg5_type	= ARG_CONST_SIZE_OR_ZERO,
 +	.btf_id		= bpf_skb_output_btf_ids,
 +};
 +
  static unsigned short bpf_tunnel_key_af(u64 flags)
  {
    return flags & BPF_F_TUNINFO_IPV6 ? AF_INET6 : AF_INET;
@@@ -4265,14 -4252,12 +4265,14 @@@ BPF_CALL_5(bpf_setsockopt, struct bpf_s
    	case SO_RCVBUF:
    		val = min_t(u32, val, sysctl_rmem_max);
    		sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
 -			sk->sk_rcvbuf = max_t(int, val * 2, SOCK_MIN_RCVBUF);
 +			WRITE_ONCE(sk->sk_rcvbuf,
 +				   max_t(int, val * 2, SOCK_MIN_RCVBUF));
    		break;
    	case SO_SNDBUF:
    		val = min_t(u32, val, sysctl_wmem_max);
    		sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
 -			sk->sk_sndbuf = max_t(int, val * 2, SOCK_MIN_SNDBUF);
 +			WRITE_ONCE(sk->sk_sndbuf,
 +				   max_t(int, val * 2, SOCK_MIN_SNDBUF));
    		break;
    	case SO_MAX_PACING_RATE: /* 32bit version */
    		if (val != ~0U)
@@@ -4289,7 -4274,7 +4289,7 @@@
    	case SO_RCVLOWAT:
    		if (val < 0)
    			val = INT_MAX;
 -			sk->sk_rcvlowat = val ? : 1;
 +			WRITE_ONCE(sk->sk_rcvlowat, val ? : 1);
    		break;
    	case SO_MARK:
    		if (sk->sk_mark != val) {
@@@ -5589,8 -5574,8 +5589,8 @@@ u32 bpf_tcp_sock_convert_ctx_access(enu
#define BPF_TCP_SOCK_GET_COMMON(FIELD)					\
    do {								\
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct tcp_sock, FIELD) >	\
- 			     FIELD_SIZEOF(struct bpf_tcp_sock, FIELD));	\
+ 		BUILD_BUG_ON(sizeof_member(struct tcp_sock, FIELD) >	\
+ 			     sizeof_member(struct bpf_tcp_sock, FIELD));	\
    	*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(struct tcp_sock, FIELD),\
    			      si->dst_reg, si->src_reg,		\
    			      offsetof(struct tcp_sock, FIELD)); \
@@@ -5598,9 -5583,9 +5598,9 @@@
#define BPF_INET_SOCK_GET_COMMON(FIELD)					\
    do {								\
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct inet_connection_sock,	\
+ 		BUILD_BUG_ON(sizeof_member(struct inet_connection_sock,	\
    				  FIELD) >			\
- 			     FIELD_SIZEOF(struct bpf_tcp_sock, FIELD));	\
+ 			     sizeof_member(struct bpf_tcp_sock, FIELD));	\
    	*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(			\
    				struct inet_connection_sock,	\
    				FIELD),				\
@@@ -5615,7 -5600,7 +5615,7 @@@
switch (si->off) {
    case offsetof(struct bpf_tcp_sock, rtt_min):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct tcp_sock, rtt_min) !=
+ 		BUILD_BUG_ON(sizeof_member(struct tcp_sock, rtt_min) !=
    		     sizeof(struct minmax));
    	BUILD_BUG_ON(sizeof(struct minmax) <
    		     sizeof(struct minmax_sample));
@@@ -5780,8 -5765,8 +5780,8 @@@ u32 bpf_xdp_sock_convert_ctx_access(enu
#define BPF_XDP_SOCK_GET(FIELD)						\
    do {								\
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct xdp_sock, FIELD) >	\
- 			     FIELD_SIZEOF(struct bpf_xdp_sock, FIELD));	\
+ 		BUILD_BUG_ON(sizeof_member(struct xdp_sock, FIELD) >	\
+ 			     sizeof_member(struct bpf_xdp_sock, FIELD));	\
    	*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(struct xdp_sock, FIELD),\
    			      si->dst_reg, si->src_reg,		\
    			      offsetof(struct xdp_sock, FIELD)); \
@@@ -7344,7 -7329,7 +7344,7 @@@ static u32 bpf_convert_ctx_access(enum
case offsetof(struct __sk_buff, cb[0]) ...
         offsetofend(struct __sk_buff, cb[4]) - 1:
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct qdisc_skb_cb, data) < 20);
+ 		BUILD_BUG_ON(sizeof_member(struct qdisc_skb_cb, data) < 20);
    	BUILD_BUG_ON((offsetof(struct sk_buff, cb) +
    		      offsetof(struct qdisc_skb_cb, data)) %
    		     sizeof(__u64));
@@@ -7363,7 -7348,7 +7363,7 @@@
    	break;
case offsetof(struct __sk_buff, tc_classid):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct qdisc_skb_cb, tc_classid) != 2);
+ 		BUILD_BUG_ON(sizeof_member(struct qdisc_skb_cb, tc_classid) != 2);
off  = si->off;
    	off -= offsetof(struct __sk_buff, tc_classid);
@@@ -7434,7 -7419,7 +7434,7 @@@
  #endif
    	break;
    case offsetof(struct __sk_buff, family):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common, skc_family) != 2);
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common, skc_family) != 2);
*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(struct sk_buff, sk),
    			      si->dst_reg, si->src_reg,
@@@ -7445,7 -7430,7 +7445,7 @@@
    					     2, target_size));
    	break;
    case offsetof(struct __sk_buff, remote_ip4):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common, skc_daddr) != 4);
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common, skc_daddr) != 4);
*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(struct sk_buff, sk),
    			      si->dst_reg, si->src_reg,
@@@ -7456,7 -7441,7 +7456,7 @@@
    					     4, target_size));
    	break;
    case offsetof(struct __sk_buff, local_ip4):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common,
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common,
    				  skc_rcv_saddr) != 4);
*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(struct sk_buff, sk),
@@@ -7470,7 -7455,7 +7470,7 @@@
    case offsetof(struct __sk_buff, remote_ip6[0]) ...
         offsetof(struct __sk_buff, remote_ip6[3]):
  #if IS_ENABLED(CONFIG_IPV6)
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common,
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common,
    				  skc_v6_daddr.s6_addr32[0]) != 4);
off = si->off;
@@@ -7490,7 -7475,7 +7490,7 @@@
    case offsetof(struct __sk_buff, local_ip6[0]) ...
         offsetof(struct __sk_buff, local_ip6[3]):
  #if IS_ENABLED(CONFIG_IPV6)
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common,
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common,
    				  skc_v6_rcv_saddr.s6_addr32[0]) != 4);
off = si->off;
@@@ -7509,7 -7494,7 +7509,7 @@@
    	break;
case offsetof(struct __sk_buff, remote_port):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common, skc_dport) != 2);
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common, skc_dport) != 2);
*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(struct sk_buff, sk),
    			      si->dst_reg, si->src_reg,
@@@ -7524,7 -7509,7 +7524,7 @@@
    	break;
case offsetof(struct __sk_buff, local_port):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common, skc_num) != 2);
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common, skc_num) != 2);
*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(struct sk_buff, sk),
    			      si->dst_reg, si->src_reg,
@@@ -7535,7 -7520,7 +7535,7 @@@
    	break;
case offsetof(struct __sk_buff, tstamp):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sk_buff, tstamp) != 8);
+ 		BUILD_BUG_ON(sizeof_member(struct sk_buff, tstamp) != 8);
if (type == BPF_WRITE)
    		*insn++ = BPF_STX_MEM(BPF_DW,
@@@ -7573,7 -7558,7 +7573,7 @@@
    					     target_size));
    	break;
    case offsetof(struct __sk_buff, wire_len):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct qdisc_skb_cb, pkt_len) != 4);
+ 		BUILD_BUG_ON(sizeof_member(struct qdisc_skb_cb, pkt_len) != 4);
off = si->off;
    	off -= offsetof(struct __sk_buff, wire_len);
@@@ -7603,7 -7588,7 +7603,7 @@@ u32 bpf_sock_convert_ctx_access(enum bp
switch (si->off) {
    case offsetof(struct bpf_sock, bound_dev_if):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock, sk_bound_dev_if) != 4);
+ 		BUILD_BUG_ON(sizeof_member(struct sock, sk_bound_dev_if) != 4);
if (type == BPF_WRITE)
    		*insn++ = BPF_STX_MEM(BPF_W, si->dst_reg, si->src_reg,
@@@ -7614,7 -7599,7 +7614,7 @@@
    	break;
case offsetof(struct bpf_sock, mark):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock, sk_mark) != 4);
+ 		BUILD_BUG_ON(sizeof_member(struct sock, sk_mark) != 4);
if (type == BPF_WRITE)
    		*insn++ = BPF_STX_MEM(BPF_W, si->dst_reg, si->src_reg,
@@@ -7625,7 -7610,7 +7625,7 @@@
    	break;
case offsetof(struct bpf_sock, priority):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock, sk_priority) != 4);
+ 		BUILD_BUG_ON(sizeof_member(struct sock, sk_priority) != 4);
if (type == BPF_WRITE)
    		*insn++ = BPF_STX_MEM(BPF_W, si->dst_reg, si->src_reg,
@@@ -7641,7 -7626,7 +7641,7 @@@
    		si->dst_reg, si->src_reg,
    		bpf_target_off(struct sock_common,
    			       skc_family,
- 				       FIELD_SIZEOF(struct sock_common,
+ 				       sizeof_member(struct sock_common,
    					    skc_family),
    			       target_size));
    	break;
@@@ -7668,7 -7653,7 +7668,7 @@@
    	*insn++ = BPF_LDX_MEM(
    		BPF_SIZE(si->code), si->dst_reg, si->src_reg,
    		bpf_target_off(struct sock_common, skc_rcv_saddr,
- 				       FIELD_SIZEOF(struct sock_common,
+ 				       sizeof_member(struct sock_common,
    					    skc_rcv_saddr),
    			       target_size));
    	break;
@@@ -7677,7 -7662,7 +7677,7 @@@
    	*insn++ = BPF_LDX_MEM(
    		BPF_SIZE(si->code), si->dst_reg, si->src_reg,
    		bpf_target_off(struct sock_common, skc_daddr,
- 				       FIELD_SIZEOF(struct sock_common,
+ 				       sizeof_member(struct sock_common,
    					    skc_daddr),
    			       target_size));
    	break;
@@@ -7691,7 -7676,7 +7691,7 @@@
    		bpf_target_off(
    			struct sock_common,
    			skc_v6_rcv_saddr.s6_addr32[0],
- 				FIELD_SIZEOF(struct sock_common,
+ 				sizeof_member(struct sock_common,
    				     skc_v6_rcv_saddr.s6_addr32[0]),
    			target_size) + off);
  #else
@@@ -7708,7 -7693,7 +7708,7 @@@
    		BPF_SIZE(si->code), si->dst_reg, si->src_reg,
    		bpf_target_off(struct sock_common,
    			       skc_v6_daddr.s6_addr32[0],
- 				       FIELD_SIZEOF(struct sock_common,
+ 				       sizeof_member(struct sock_common,
    					    skc_v6_daddr.s6_addr32[0]),
    			       target_size) + off);
  #else
@@@ -7722,7 -7707,7 +7722,7 @@@
    		BPF_FIELD_SIZEOF(struct sock_common, skc_num),
    		si->dst_reg, si->src_reg,
    		bpf_target_off(struct sock_common, skc_num,
- 				       FIELD_SIZEOF(struct sock_common,
+ 				       sizeof_member(struct sock_common,
    					    skc_num),
    			       target_size));
    	break;
@@@ -7732,7 -7717,7 +7732,7 @@@
    		BPF_FIELD_SIZEOF(struct sock_common, skc_dport),
    		si->dst_reg, si->src_reg,
    		bpf_target_off(struct sock_common, skc_dport,
- 				       FIELD_SIZEOF(struct sock_common,
+ 				       sizeof_member(struct sock_common,
    					    skc_dport),
    			       target_size));
    	break;
@@@ -7742,7 -7727,7 +7742,7 @@@
    		BPF_FIELD_SIZEOF(struct sock_common, skc_state),
    		si->dst_reg, si->src_reg,
    		bpf_target_off(struct sock_common, skc_state,
- 				       FIELD_SIZEOF(struct sock_common,
+ 				       sizeof_member(struct sock_common,
    					    skc_state),
    			       target_size));
    	break;
@@@ -7837,7 -7822,7 +7837,7 @@@ static u32 xdp_convert_ctx_access(enum 
    			      si->src_reg, offsetof(S, F));	       \
    	*insn++ = BPF_LDX_MEM(					       \
    		SIZE, si->dst_reg, si->dst_reg,			       \
- 			bpf_target_off(NS, NF, FIELD_SIZEOF(NS, NF),	       \
+ 			bpf_target_off(NS, NF, sizeof_member(NS, NF),	       \
    			       target_size)			       \
    			+ OFF);					       \
    } while (0)
@@@ -7868,7 -7853,7 +7868,7 @@@
    	*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(S, F), tmp_reg,	       \
    			      si->dst_reg, offsetof(S, F));	       \
    	*insn++ = BPF_STX_MEM(SIZE, tmp_reg, si->src_reg,	       \
- 			bpf_target_off(NS, NF, FIELD_SIZEOF(NS, NF),	       \
+ 			bpf_target_off(NS, NF, sizeof_member(NS, NF),	       \
    			       target_size)			       \
    			+ OFF);					       \
    	*insn++ = BPF_LDX_MEM(BPF_DW, tmp_reg, si->dst_reg,	       \
@@@ -7930,8 -7915,8 +7930,8 @@@ static u32 sock_addr_convert_ctx_access
    	 */
    	BUILD_BUG_ON(offsetof(struct sockaddr_in, sin_port) !=
    		     offsetof(struct sockaddr_in6, sin6_port));
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sockaddr_in, sin_port) !=
- 			     FIELD_SIZEOF(struct sockaddr_in6, sin6_port));
+ 		BUILD_BUG_ON(sizeof_member(struct sockaddr_in, sin_port) !=
+ 			     sizeof_member(struct sockaddr_in6, sin6_port));
    	SOCK_ADDR_LOAD_OR_STORE_NESTED_FIELD(struct bpf_sock_addr_kern,
    					     struct sockaddr_in6, uaddr,
    					     sin6_port, tmp_reg);
@@@ -7997,8 -7982,8 +7997,8 @@@ static u32 sock_ops_convert_ctx_access(
  /* Helper macro for adding read access to tcp_sock or sock fields. */
  #define SOCK_OPS_GET_FIELD(BPF_FIELD, OBJ_FIELD, OBJ)			      \
    do {								      \
- 		BUILD_BUG_ON(FIELD_SIZEOF(OBJ, OBJ_FIELD) >		      \
- 			     FIELD_SIZEOF(struct bpf_sock_ops, BPF_FIELD));   \
+ 		BUILD_BUG_ON(sizeof_member(OBJ, OBJ_FIELD) >		      \
+ 			     sizeof_member(struct bpf_sock_ops, BPF_FIELD));   \
    	*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(			      \
    					struct bpf_sock_ops_kern,     \
    					is_fullsock),		      \
@@@ -8031,8 -8016,8 +8031,8 @@@
  #define SOCK_OPS_SET_FIELD(BPF_FIELD, OBJ_FIELD, OBJ)			      \
    do {								      \
    	int reg = BPF_REG_9;					      \
- 		BUILD_BUG_ON(FIELD_SIZEOF(OBJ, OBJ_FIELD) >		      \
- 			     FIELD_SIZEOF(struct bpf_sock_ops, BPF_FIELD));   \
+ 		BUILD_BUG_ON(sizeof_member(OBJ, OBJ_FIELD) >		      \
+ 			     sizeof_member(struct bpf_sock_ops, BPF_FIELD));   \
    	if (si->dst_reg == reg || si->src_reg == reg)		      \
    		reg--;						      \
    	if (si->dst_reg == reg || si->src_reg == reg)		      \
@@@ -8073,12 -8058,12 +8073,12 @@@
    switch (si->off) {
    case offsetof(struct bpf_sock_ops, op) ...
         offsetof(struct bpf_sock_ops, replylong[3]):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct bpf_sock_ops, op) !=
- 			     FIELD_SIZEOF(struct bpf_sock_ops_kern, op));
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct bpf_sock_ops, reply) !=
- 			     FIELD_SIZEOF(struct bpf_sock_ops_kern, reply));
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct bpf_sock_ops, replylong) !=
- 			     FIELD_SIZEOF(struct bpf_sock_ops_kern, replylong));
+ 		BUILD_BUG_ON(sizeof_member(struct bpf_sock_ops, op) !=
+ 			     sizeof_member(struct bpf_sock_ops_kern, op));
+ 		BUILD_BUG_ON(sizeof_member(struct bpf_sock_ops, reply) !=
+ 			     sizeof_member(struct bpf_sock_ops_kern, reply));
+ 		BUILD_BUG_ON(sizeof_member(struct bpf_sock_ops, replylong) !=
+ 			     sizeof_member(struct bpf_sock_ops_kern, replylong));
    	off = si->off;
    	off -= offsetof(struct bpf_sock_ops, op);
    	off += offsetof(struct bpf_sock_ops_kern, op);
@@@ -8091,7 -8076,7 +8091,7 @@@
    	break;
case offsetof(struct bpf_sock_ops, family):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common, skc_family) != 2);
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common, skc_family) != 2);
*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(
    				      struct bpf_sock_ops_kern, sk),
@@@ -8102,7 -8087,7 +8102,7 @@@
    	break;
case offsetof(struct bpf_sock_ops, remote_ip4):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common, skc_daddr) != 4);
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common, skc_daddr) != 4);
*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(
    					struct bpf_sock_ops_kern, sk),
@@@ -8113,7 -8098,7 +8113,7 @@@
    	break;
case offsetof(struct bpf_sock_ops, local_ip4):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common,
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common,
    				  skc_rcv_saddr) != 4);
*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(
@@@ -8128,7 -8113,7 +8128,7 @@@
    case offsetof(struct bpf_sock_ops, remote_ip6[0]) ...
         offsetof(struct bpf_sock_ops, remote_ip6[3]):
  #if IS_ENABLED(CONFIG_IPV6)
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common,
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common,
    				  skc_v6_daddr.s6_addr32[0]) != 4);
off = si->off;
@@@ -8149,7 -8134,7 +8149,7 @@@
    case offsetof(struct bpf_sock_ops, local_ip6[0]) ...
         offsetof(struct bpf_sock_ops, local_ip6[3]):
  #if IS_ENABLED(CONFIG_IPV6)
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common,
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common,
    				  skc_v6_rcv_saddr.s6_addr32[0]) != 4);
off = si->off;
@@@ -8168,7 -8153,7 +8168,7 @@@
    	break;
case offsetof(struct bpf_sock_ops, remote_port):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common, skc_dport) != 2);
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common, skc_dport) != 2);
*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(
    					struct bpf_sock_ops_kern, sk),
@@@ -8182,7 -8167,7 +8182,7 @@@
    	break;
case offsetof(struct bpf_sock_ops, local_port):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common, skc_num) != 2);
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common, skc_num) != 2);
*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(
    					struct bpf_sock_ops_kern, sk),
@@@ -8202,7 -8187,7 +8202,7 @@@
    	break;
case offsetof(struct bpf_sock_ops, state):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common, skc_state) != 1);
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common, skc_state) != 1);
*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(
    					struct bpf_sock_ops_kern, sk),
@@@ -8213,7 -8198,7 +8213,7 @@@
    	break;
case offsetof(struct bpf_sock_ops, rtt_min):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct tcp_sock, rtt_min) !=
+ 		BUILD_BUG_ON(sizeof_member(struct tcp_sock, rtt_min) !=
    		     sizeof(struct minmax));
    	BUILD_BUG_ON(sizeof(struct minmax) <
    		     sizeof(struct minmax_sample));
@@@ -8224,7 -8209,7 +8224,7 @@@
    			      offsetof(struct bpf_sock_ops_kern, sk));
    	*insn++ = BPF_LDX_MEM(BPF_W, si->dst_reg, si->dst_reg,
    			      offsetof(struct tcp_sock, rtt_min) +
- 				      FIELD_SIZEOF(struct minmax_sample, t));
+ 				      sizeof_member(struct minmax_sample, t));
    	break;
case offsetof(struct bpf_sock_ops, bpf_sock_ops_cb_flags):
@@@ -8366,7 -8351,7 +8366,7 @@@ static u32 sk_msg_convert_ctx_access(en
    			      offsetof(struct sk_msg, data_end));
    	break;
    case offsetof(struct sk_msg_md, family):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common, skc_family) != 2);
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common, skc_family) != 2);
*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(
    				      struct sk_msg, sk),
@@@ -8377,7 -8362,7 +8377,7 @@@
    	break;
case offsetof(struct sk_msg_md, remote_ip4):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common, skc_daddr) != 4);
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common, skc_daddr) != 4);
*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(
    					struct sk_msg, sk),
@@@ -8388,7 -8373,7 +8388,7 @@@
    	break;
case offsetof(struct sk_msg_md, local_ip4):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common,
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common,
    				  skc_rcv_saddr) != 4);
*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(
@@@ -8403,7 -8388,7 +8403,7 @@@
    case offsetof(struct sk_msg_md, remote_ip6[0]) ...
         offsetof(struct sk_msg_md, remote_ip6[3]):
  #if IS_ENABLED(CONFIG_IPV6)
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common,
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common,
    				  skc_v6_daddr.s6_addr32[0]) != 4);
off = si->off;
@@@ -8424,7 -8409,7 +8424,7 @@@
    case offsetof(struct sk_msg_md, local_ip6[0]) ...
         offsetof(struct sk_msg_md, local_ip6[3]):
  #if IS_ENABLED(CONFIG_IPV6)
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common,
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common,
    				  skc_v6_rcv_saddr.s6_addr32[0]) != 4);
off = si->off;
@@@ -8443,7 -8428,7 +8443,7 @@@
    	break;
case offsetof(struct sk_msg_md, remote_port):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common, skc_dport) != 2);
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common, skc_dport) != 2);
*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(
    					struct sk_msg, sk),
@@@ -8457,7 -8442,7 +8457,7 @@@
    	break;
case offsetof(struct sk_msg_md, local_port):
- 		BUILD_BUG_ON(FIELD_SIZEOF(struct sock_common, skc_num) != 2);
+ 		BUILD_BUG_ON(sizeof_member(struct sock_common, skc_num) != 2);
*insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(
    					struct sk_msg, sk),
@@@ -8857,7 -8842,7 +8857,7 @@@ sk_reuseport_is_valid_access(int off, i
/* Fields that allow narrowing */
    case bpf_ctx_range(struct sk_reuseport_md, eth_protocol):
- 		if (size < FIELD_SIZEOF(struct sk_buff, protocol))
+ 		if (size < sizeof_member(struct sk_buff, protocol))
    		return false;
    	/* fall through */
    case bpf_ctx_range(struct sk_reuseport_md, ip_protocol):
@@@ -8875,7 -8860,7 +8875,7 @@@
    *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(struct sk_reuseport_kern, F), \
    		      si->dst_reg, si->src_reg,			\
    		      bpf_target_off(struct sk_reuseport_kern, F, \
- 					     FIELD_SIZEOF(struct sk_reuseport_kern, F), \
+ 					     sizeof_member(struct sk_reuseport_kern, F), \
    				     target_size));		\
    })
diff --combined net/core/flow_dissector.c
index 9a14b19c008f,3f5f61bc2bfa..57b884717851
--- a/net/core/flow_dissector.c
+++ b/net/core/flow_dissector.c
@@@ -114,50 -114,19 +114,50 @@@ int skb_flow_dissector_bpf_prog_attach(
  {
    struct bpf_prog *attached;
    struct net *net;
 +	int ret = 0;
net = current->nsproxy->net_ns;
    mutex_lock(&flow_dissector_mutex);
 +
 +	if (net == &init_net) {
 +		/* BPF flow dissector in the root namespace overrides
 +		 * any per-net-namespace one. When attaching to root,
 +		 * make sure we don't have any BPF program attached
 +		 * to the non-root namespaces.
 +		 */
 +		struct net *ns;
 +
 +		for_each_net(ns) {
 +			if (ns == &init_net)
 +				continue;
 +			if (rcu_access_pointer(ns->flow_dissector_prog)) {
 +				ret = -EEXIST;
 +				goto out;
 +			}
 +		}
 +	} else {
 +		/* Make sure root flow dissector is not attached
 +		 * when attaching to the non-root namespace.
 +		 */
 +		if (rcu_access_pointer(init_net.flow_dissector_prog)) {
 +			ret = -EEXIST;
 +			goto out;
 +		}
 +	}
 +
    attached = rcu_dereference_protected(net->flow_dissector_prog,
    				     lockdep_is_held(&flow_dissector_mutex));
 -	if (attached) {
 -		/* Only one BPF program can be attached at a time */
 -		mutex_unlock(&flow_dissector_mutex);
 -		return -EEXIST;
 +	if (attached == prog) {
 +		/* The same program cannot be attached twice */
 +		ret = -EINVAL;
 +		goto out;
    }
    rcu_assign_pointer(net->flow_dissector_prog, prog);
 +	if (attached)
 +		bpf_prog_put(attached);
 +out:
    mutex_unlock(&flow_dissector_mutex);
 -	return 0;
 +	return ret;
  }
int skb_flow_dissector_bpf_prog_detach(const union bpf_attr *attr)
@@@ -554,8 -523,8 +554,8 @@@ __skb_flow_dissect_gre(const struct sk_
    offset += sizeof(struct gre_base_hdr);
if (hdr->flags & GRE_CSUM)
- 		offset += FIELD_SIZEOF(struct gre_full_hdr, csum) +
- 			  FIELD_SIZEOF(struct gre_full_hdr, reserved1);
+ 		offset += sizeof_member(struct gre_full_hdr, csum) +
+ 			  sizeof_member(struct gre_full_hdr, reserved1);
if (hdr->flags & GRE_KEY) {
    	const __be32 *keyid;
@@@ -577,11 -546,11 +577,11 @@@
    		else
    			key_keyid->keyid = *keyid & GRE_PPTP_KEY_MASK;
    	}
- 		offset += FIELD_SIZEOF(struct gre_full_hdr, key);
+ 		offset += sizeof_member(struct gre_full_hdr, key);
    }
if (hdr->flags & GRE_SEQ)
- 		offset += FIELD_SIZEOF(struct pptp_gre_header, seq);
+ 		offset += sizeof_member(struct pptp_gre_header, seq);
if (gre_ver == 0) {
    	if (*p_proto == htons(ETH_P_TEB)) {
@@@ -608,7 -577,7 +608,7 @@@
    	u8 *ppp_hdr;
if (hdr->flags & GRE_ACK)
- 			offset += FIELD_SIZEOF(struct pptp_gre_header, ack);
+ 			offset += sizeof_member(struct pptp_gre_header, ack);
ppp_hdr = __skb_header_pointer(skb, *p_nhoff + offset,
    				       sizeof(_ppp_hdr),
@@@ -941,10 -910,7 +941,10 @@@ bool __skb_flow_dissect(const struct ne
    WARN_ON_ONCE(!net);
    if (net) {
    	rcu_read_lock();
 -		attached = rcu_dereference(net->flow_dissector_prog);
 +		attached = rcu_dereference(init_net.flow_dissector_prog);
 +
 +		if (!attached)
 +			attached = rcu_dereference(net->flow_dissector_prog);
if (attached) {
    		struct bpf_flow_keys flow_keys;
@@@ -1384,21 -1350,30 +1384,21 @@@ out_bad
  }
  EXPORT_SYMBOL(__skb_flow_dissect);
-static u32 hashrnd __read_mostly;
 +static siphash_key_t hashrnd __read_mostly;
  static __always_inline void __flow_hash_secret_init(void)
  {
    net_get_random_once(&hashrnd, sizeof(hashrnd));
  }
-static __always_inline u32 __flow_hash_words(const u32 *words, u32 length,
 -					     u32 keyval)
 +static const void *flow_keys_hash_start(const struct flow_keys *flow)
  {
 -	return jhash2(words, length, keyval);
 -}
 -
 -static inline const u32 *flow_keys_hash_start(const struct flow_keys *flow)
 -{
 -	const void *p = flow;
 -
 -	BUILD_BUG_ON(FLOW_KEYS_HASH_OFFSET % sizeof(u32));
 -	return (const u32 *)(p + FLOW_KEYS_HASH_OFFSET);
 +	BUILD_BUG_ON(FLOW_KEYS_HASH_OFFSET % SIPHASH_ALIGNMENT);
 +	return &flow->FLOW_KEYS_HASH_START_FIELD;
  }
static inline size_t flow_keys_hash_length(const struct flow_keys *flow)
  {
    size_t diff = FLOW_KEYS_HASH_OFFSET + sizeof(flow->addrs);
 -	BUILD_BUG_ON((sizeof(*flow) - FLOW_KEYS_HASH_OFFSET) % sizeof(u32));
    BUILD_BUG_ON(offsetof(typeof(*flow), addrs) !=
    	     sizeof(*flow) - sizeof(flow->addrs));
@@@ -1413,7 -1388,7 +1413,7 @@@
    	diff -= sizeof(flow->addrs.tipckey);
    	break;
    }
 -	return (sizeof(*flow) - diff) / sizeof(u32);
 +	return sizeof(*flow) - diff;
  }
__be32 flow_get_u32_src(const struct flow_keys *flow)
@@@ -1479,15 -1454,14 +1479,15 @@@ static inline void __flow_hash_consiste
    }
  }
-static inline u32 __flow_hash_from_keys(struct flow_keys *keys, u32 keyval)
 +static inline u32 __flow_hash_from_keys(struct flow_keys *keys,
 +					const siphash_key_t *keyval)
  {
    u32 hash;
__flow_hash_consistentify(keys);
-	hash = __flow_hash_words(flow_keys_hash_start(keys),
 -				 flow_keys_hash_length(keys), keyval);
 +	hash = siphash(flow_keys_hash_start(keys),
 +		       flow_keys_hash_length(keys), keyval);
    if (!hash)
    	hash = 1;
@@@ -1497,13 -1471,12 +1497,13 @@@
  u32 flow_hash_from_keys(struct flow_keys *keys)
  {
    __flow_hash_secret_init();
 -	return __flow_hash_from_keys(keys, hashrnd);
 +	return __flow_hash_from_keys(keys, &hashrnd);
  }
  EXPORT_SYMBOL(flow_hash_from_keys);
static inline u32 ___skb_get_hash(const struct sk_buff *skb,
 -				  struct flow_keys *keys, u32 keyval)
 +				  struct flow_keys *keys,
 +				  const siphash_key_t *keyval)
  {
    skb_flow_dissect_flow_keys(skb, keys,
    			   FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL);
@@@ -1551,7 -1524,7 +1551,7 @@@ u32 __skb_get_hash_symmetric(const stru
    		   &keys, NULL, 0, 0, 0,
    		   FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL);
-	return __flow_hash_from_keys(&keys, hashrnd);
 +	return __flow_hash_from_keys(&keys, &hashrnd);
  }
  EXPORT_SYMBOL_GPL(__skb_get_hash_symmetric);
@@@ -1571,14 -1544,13 +1571,14 @@@ void __skb_get_hash(struct sk_buff *skb
__flow_hash_secret_init();
-	hash = ___skb_get_hash(skb, &keys, hashrnd);
 +	hash = ___skb_get_hash(skb, &keys, &hashrnd);
__skb_set_sw_hash(skb, hash, flow_keys_have_l4(&keys));
  }
  EXPORT_SYMBOL(__skb_get_hash);
-__u32 skb_get_hash_perturb(const struct sk_buff *skb, u32 perturb)
 +__u32 skb_get_hash_perturb(const struct sk_buff *skb,
 +			   const siphash_key_t *perturb)
  {
    struct flow_keys keys;
diff --combined net/core/skbuff.c
index 867e61df00db,6054465875d8..31b8539c72c1
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@@ -4148,7 -4148,7 +4148,7 @@@ void __init skb_init(void
    				      0,
    				      SLAB_HWCACHE_ALIGN|SLAB_PANIC,
    				      offsetof(struct sk_buff, cb),
- 					      sizeof_field(struct sk_buff, cb),
+ 					      sizeof_member(struct sk_buff, cb),
    				      NULL);
    skbuff_fclone_cache = kmem_cache_create("skbuff_fclone_cache",
    					sizeof(struct sk_buff_fclones),
@@@ -4415,7 -4415,7 +4415,7 @@@ static void skb_set_err_queue(struct sk
  int sock_queue_err_skb(struct sock *sk, struct sk_buff *skb)
  {
    if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
 -	    (unsigned int)sk->sk_rcvbuf)
 +	    (unsigned int)READ_ONCE(sk->sk_rcvbuf))
    	return -ENOMEM;
skb_orphan(skb);
@@@ -5477,14 -5477,12 +5477,14 @@@ static void skb_mod_eth_type(struct sk_
   * @skb: buffer
   * @mpls_lse: MPLS label stack entry to push
   * @mpls_proto: ethertype of the new MPLS header (expects 0x8847 or 0x8848)
 + * @mac_len: length of the MAC header
   *
   * Expects skb->data at mac header.
   *
   * Returns 0 on success, -errno otherwise.
   */
 -int skb_mpls_push(struct sk_buff *skb, __be32 mpls_lse, __be16 mpls_proto)
 +int skb_mpls_push(struct sk_buff *skb, __be32 mpls_lse, __be16 mpls_proto,
 +		  int mac_len)
  {
    struct mpls_shim_hdr *lse;
    int err;
@@@ -5501,15 -5499,15 +5501,15 @@@
    	return err;
if (!skb->inner_protocol) {
 -		skb_set_inner_network_header(skb, skb->mac_len);
 +		skb_set_inner_network_header(skb, mac_len);
    	skb_set_inner_protocol(skb, skb->protocol);
    }
skb_push(skb, MPLS_HLEN);
    memmove(skb_mac_header(skb) - MPLS_HLEN, skb_mac_header(skb),
 -		skb->mac_len);
 +		mac_len);
    skb_reset_mac_header(skb);
 -	skb_set_network_header(skb, skb->mac_len);
 +	skb_set_network_header(skb, mac_len);
lse = mpls_hdr(skb);
    lse->label_stack_entry = mpls_lse;
@@@ -5528,30 -5526,29 +5528,30 @@@ EXPORT_SYMBOL_GPL(skb_mpls_push)
   *
   * @skb: buffer
   * @next_proto: ethertype of header after popped MPLS header
 + * @mac_len: length of the MAC header
   *
   * Expects skb->data at mac header.
   *
   * Returns 0 on success, -errno otherwise.
   */
 -int skb_mpls_pop(struct sk_buff *skb, __be16 next_proto)
 +int skb_mpls_pop(struct sk_buff *skb, __be16 next_proto, int mac_len)
  {
    int err;
if (unlikely(!eth_p_mpls(skb->protocol)))
 -		return -EINVAL;
 +		return 0;
-	err = skb_ensure_writable(skb, skb->mac_len + MPLS_HLEN);
 +	err = skb_ensure_writable(skb, mac_len + MPLS_HLEN);
    if (unlikely(err))
    	return err;
skb_postpull_rcsum(skb, mpls_hdr(skb), MPLS_HLEN);
    memmove(skb_mac_header(skb) + MPLS_HLEN, skb_mac_header(skb),
 -		skb->mac_len);
 +		mac_len);
__skb_pull(skb, MPLS_HLEN);
    skb_reset_mac_header(skb);
 -	skb_set_network_header(skb, skb->mac_len);
 +	skb_set_network_header(skb, mac_len);
if (skb->dev && skb->dev->type == ARPHRD_ETHER) {
    	struct ethhdr *hdr;
diff --combined net/core/xdp.c
index 20781ad5f9c3,621d6148b07a..cb6cc14c6455
--- a/net/core/xdp.c
+++ b/net/core/xdp.c
@@@ -36,7 -36,7 +36,7 @@@ static u32 xdp_mem_id_hashfn(const voi
    const u32 *k = data;
    const u32 key = *k;
- 	BUILD_BUG_ON(FIELD_SIZEOF(struct xdp_mem_allocator, mem.id)
+ 	BUILD_BUG_ON(sizeof_member(struct xdp_mem_allocator, mem.id)
    	     != sizeof(u32));
/* Use cyclic increasing ID as direct hash key */
@@@ -56,7 -56,7 +56,7 @@@ static const struct rhashtable_params m
    .nelem_hint = 64,
    .head_offset = offsetof(struct xdp_mem_allocator, node),
    .key_offset  = offsetof(struct xdp_mem_allocator, mem.id),
- 	.key_len = FIELD_SIZEOF(struct xdp_mem_allocator, mem.id),
+ 	.key_len = sizeof_member(struct xdp_mem_allocator, mem.id),
    .max_size = MEM_ID_MAX,
    .min_size = 8,
    .automatic_shrinking = true,
@@@ -386,7 -386,7 +386,7 @@@ EXPORT_SYMBOL_GPL(xdp_rxq_info_reg_mem_
/* XDP RX runs under NAPI protection, and in different delivery error
   * scenarios (e.g. queue full), it is possible to return the xdp_frame
 - * while still leveraging this protection.  The @napi_direct boolian
 + * while still leveraging this protection.  The @napi_direct boolean
   * is used for those calls sites.  Thus, allowing for faster recycling
   * of xdp_frames/pages in those cases.
   */
diff --combined net/ipv4/ip_gre.c
index 10636fb6093e,9c9716f7ccdb..eabd38be7d43
--- a/net/ipv4/ip_gre.c
+++ b/net/ipv4/ip_gre.c
@@@ -509,9 -509,9 +509,9 @@@ static void erspan_fb_xmit(struct sk_bu
    key = &tun_info->key;
    if (!(tun_info->key.tun_flags & TUNNEL_ERSPAN_OPT))
    	goto err_free_skb;
 -	md = ip_tunnel_info_opts(tun_info);
 -	if (!md)
 +	if (tun_info->options_len < sizeof(*md))
    	goto err_free_skb;
 +	md = ip_tunnel_info_opts(tun_info);
/* ERSPAN has fixed 8 byte GRE header */
    version = md->version;
@@@ -1460,8 -1460,8 +1460,8 @@@ static const struct nla_policy ipgre_po
    [IFLA_GRE_OFLAGS]	= { .type = NLA_U16 },
    [IFLA_GRE_IKEY]		= { .type = NLA_U32 },
    [IFLA_GRE_OKEY]		= { .type = NLA_U32 },
- 	[IFLA_GRE_LOCAL]	= { .len = FIELD_SIZEOF(struct iphdr, saddr) },
- 	[IFLA_GRE_REMOTE]	= { .len = FIELD_SIZEOF(struct iphdr, daddr) },
+ 	[IFLA_GRE_LOCAL]	= { .len = sizeof_member(struct iphdr, saddr) },
+ 	[IFLA_GRE_REMOTE]	= { .len = sizeof_member(struct iphdr, daddr) },
    [IFLA_GRE_TTL]		= { .type = NLA_U8 },
    [IFLA_GRE_TOS]		= { .type = NLA_U8 },
    [IFLA_GRE_PMTUDISC]	= { .type = NLA_U8 },
diff --combined net/ipv4/tcp.c
index 1dd25189d83f,7d23503a1d2d..82ba960747b2
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@@ -326,7 -326,7 +326,7 @@@ void tcp_enter_memory_pressure(struct s
  {
    unsigned long val;
-	if (tcp_memory_pressure)
 +	if (READ_ONCE(tcp_memory_pressure))
    	return;
    val = jiffies;
@@@ -341,7 -341,7 +341,7 @@@ void tcp_leave_memory_pressure(struct s
  {
    unsigned long val;
-	if (!tcp_memory_pressure)
 +	if (!READ_ONCE(tcp_memory_pressure))
    	return;
    val = xchg(&tcp_memory_pressure, 0);
    if (val)
@@@ -450,8 -450,8 +450,8 @@@ void tcp_init_sock(struct sock *sk
icsk->icsk_sync_mss = tcp_sync_mss;
-	sk->sk_sndbuf = sock_net(sk)->ipv4.sysctl_tcp_wmem[1];
 -	sk->sk_rcvbuf = sock_net(sk)->ipv4.sysctl_tcp_rmem[1];
 +	WRITE_ONCE(sk->sk_sndbuf, sock_net(sk)->ipv4.sysctl_tcp_wmem[1]);
 +	WRITE_ONCE(sk->sk_rcvbuf, sock_net(sk)->ipv4.sysctl_tcp_rmem[1]);
sk_sockets_allocated_inc(sk);
    sk->sk_route_forced_caps = NETIF_F_GSO;
@@@ -477,7 -477,7 +477,7 @@@ static void tcp_tx_timestamp(struct soc
  static inline bool tcp_stream_is_readable(const struct tcp_sock *tp,
    				  int target, struct sock *sk)
  {
 -	return (tp->rcv_nxt - tp->copied_seq >= target) ||
 +	return (READ_ONCE(tp->rcv_nxt) - READ_ONCE(tp->copied_seq) >= target) ||
    	(sk->sk_prot->stream_memory_read ?
    	sk->sk_prot->stream_memory_read(sk) : false);
  }
@@@ -543,10 -543,10 +543,10 @@@ __poll_t tcp_poll(struct file *file, st
/* Connected or passive Fast Open socket? */
    if (state != TCP_SYN_SENT &&
 -	    (state != TCP_SYN_RECV || tp->fastopen_rsk)) {
 +	    (state != TCP_SYN_RECV || rcu_access_pointer(tp->fastopen_rsk))) {
    	int target = sock_rcvlowat(sk, 0, INT_MAX);
-		if (tp->urg_seq == tp->copied_seq &&
 +		if (READ_ONCE(tp->urg_seq) == READ_ONCE(tp->copied_seq) &&
    	    !sock_flag(sk, SOCK_URGINLINE) &&
    	    tp->urg_data)
    		target++;
@@@ -584,7 -584,7 +584,7 @@@
    }
    /* This barrier is coupled with smp_wmb() in tcp_reset() */
    smp_rmb();
 -	if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
 +	if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue))
    	mask |= EPOLLERR;
return mask;
@@@ -607,8 -607,7 +607,8 @@@ int tcp_ioctl(struct sock *sk, int cmd
    	unlock_sock_fast(sk, slow);
    	break;
    case SIOCATMARK:
 -		answ = tp->urg_data && tp->urg_seq == tp->copied_seq;
 +		answ = tp->urg_data &&
 +		       READ_ONCE(tp->urg_seq) == READ_ONCE(tp->copied_seq);
    	break;
    case SIOCOUTQ:
    	if (sk->sk_state == TCP_LISTEN)
@@@ -617,7 -616,7 +617,7 @@@
    	if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))
    		answ = 0;
    	else
 -			answ = tp->write_seq - tp->snd_una;
 +			answ = READ_ONCE(tp->write_seq) - tp->snd_una;
    	break;
    case SIOCOUTQNSD:
    	if (sk->sk_state == TCP_LISTEN)
@@@ -626,8 -625,7 +626,8 @@@
    	if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))
    		answ = 0;
    	else
 -			answ = tp->write_seq - tp->snd_nxt;
 +			answ = READ_ONCE(tp->write_seq) -
 +			       READ_ONCE(tp->snd_nxt);
    	break;
    default:
    	return -ENOIOCTLCMD;
@@@ -659,7 -657,7 +659,7 @@@ static void skb_entail(struct sock *sk
    tcb->sacked  = 0;
    __skb_header_release(skb);
    tcp_add_write_queue_tail(sk, skb);
 -	sk->sk_wmem_queued += skb->truesize;
 +	sk_wmem_queued_add(sk, skb->truesize);
    sk_mem_charge(sk, skb->truesize);
    if (tp->nonagle & TCP_NAGLE_PUSH)
    	tp->nonagle &= ~TCP_NAGLE_PUSH;
@@@ -1034,10 -1032,10 +1034,10 @@@ new_segment
    	skb->len += copy;
    	skb->data_len += copy;
    	skb->truesize += copy;
 -		sk->sk_wmem_queued += copy;
 +		sk_wmem_queued_add(sk, copy);
    	sk_mem_charge(sk, copy);
    	skb->ip_summed = CHECKSUM_PARTIAL;
 -		tp->write_seq += copy;
 +		WRITE_ONCE(tp->write_seq, tp->write_seq + copy);
    	TCP_SKB_CB(skb)->end_seq += copy;
    	tcp_skb_pcount_set(skb, 0);
@@@ -1364,7 -1362,7 +1364,7 @@@ new_segment
    	if (!copied)
    		TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_PSH;
-		tp->write_seq += copy;
 +		WRITE_ONCE(tp->write_seq, tp->write_seq + copy);
    	TCP_SKB_CB(skb)->end_seq += copy;
    	tcp_skb_pcount_set(skb, 0);
@@@ -1670,9 -1668,9 +1670,9 @@@ int tcp_read_sock(struct sock *sk, read
    	sk_eat_skb(sk, skb);
    	if (!desc->count)
    		break;
 -		tp->copied_seq = seq;
 +		WRITE_ONCE(tp->copied_seq, seq);
    }
 -	tp->copied_seq = seq;
 +	WRITE_ONCE(tp->copied_seq, seq);
tcp_rcv_space_adjust(sk);
@@@ -1701,7 -1699,7 +1701,7 @@@ int tcp_set_rcvlowat(struct sock *sk, i
    else
    	cap = sock_net(sk)->ipv4.sysctl_tcp_rmem[2] >> 1;
    val = min(val, cap);
 -	sk->sk_rcvlowat = val ? : 1;
 +	WRITE_ONCE(sk->sk_rcvlowat, val ? : 1);
/* Check if we need to signal EPOLLIN right now */
    tcp_data_ready(sk);
@@@ -1711,7 -1709,7 +1711,7 @@@
val <<= 1;
    if (val > sk->sk_rcvbuf) {
 -		sk->sk_rcvbuf = val;
 +		WRITE_ONCE(sk->sk_rcvbuf, val);
    	tcp_sk(sk)->window_clamp = tcp_win_from_space(sk, val);
    }
    return 0;
@@@ -1741,8 -1739,8 +1741,8 @@@ static int tcp_zerocopy_receive(struct 
    			struct tcp_zerocopy_receive *zc)
  {
    unsigned long address = (unsigned long)zc->address;
 +	u32 length = 0, seq, offset, zap_len;
    const skb_frag_t *frags = NULL;
 -	u32 length = 0, seq, offset;
    struct vm_area_struct *vma;
    struct sk_buff *skb = NULL;
    struct tcp_sock *tp;
@@@ -1769,12 -1767,12 +1769,12 @@@
    seq = tp->copied_seq;
    inq = tcp_inq(sk);
    zc->length = min_t(u32, zc->length, inq);
 -	zc->length &= ~(PAGE_SIZE - 1);
 -	if (zc->length) {
 -		zap_page_range(vma, address, zc->length);
 +	zap_len = zc->length & ~(PAGE_SIZE - 1);
 +	if (zap_len) {
 +		zap_page_range(vma, address, zap_len);
    	zc->recv_skip_hint = 0;
    } else {
 -		zc->recv_skip_hint = inq;
 +		zc->recv_skip_hint = zc->length;
    }
    ret = 0;
    while (length + PAGE_SIZE <= zc->length) {
@@@ -1821,7 -1819,7 +1821,7 @@@
  out:
    up_read(&current->mm->mmap_sem);
    if (length) {
 -		tp->copied_seq = seq;
 +		WRITE_ONCE(tp->copied_seq, seq);
    	tcp_rcv_space_adjust(sk);
/* Clean up data we have read: This will do ACK frames. */
@@@ -1964,7 -1962,7 +1964,7 @@@ int tcp_recvmsg(struct sock *sk, struc
    if (unlikely(flags & MSG_ERRQUEUE))
    	return inet_recv_error(sk, msg, len, addr_len);
-	if (sk_can_busy_loop(sk) && skb_queue_empty(&sk->sk_receive_queue) &&
 +	if (sk_can_busy_loop(sk) && skb_queue_empty_lockless(&sk->sk_receive_queue) &&
        (sk->sk_state == TCP_ESTABLISHED))
    	sk_busy_loop(sk, nonblock);
@@@ -2119,7 -2117,7 +2119,7 @@@ found_ok_skb
    		if (urg_offset < used) {
    			if (!urg_offset) {
    				if (!sock_flag(sk, SOCK_URGINLINE)) {
 -						++*seq;
 +						WRITE_ONCE(*seq, *seq + 1);
    					urg_hole++;
    					offset++;
    					used--;
@@@ -2141,7 -2139,7 +2141,7 @@@
    		}
    	}
-		*seq += used;
 +		WRITE_ONCE(*seq, *seq + used);
    	copied += used;
    	len -= used;
@@@ -2168,7 -2166,7 +2168,7 @@@ skip_copy
found_fin_ok:
    	/* Process the FIN. */
 -		++*seq;
 +		WRITE_ONCE(*seq, *seq + 1);
    	if (!(flags & MSG_PEEK))
    		sk_eat_skb(sk, skb);
    	break;
@@@ -2489,10 -2487,7 +2489,10 @@@ adjudge_to_death
    }
if (sk->sk_state == TCP_CLOSE) {
 -		struct request_sock *req = tcp_sk(sk)->fastopen_rsk;
 +		struct request_sock *req;
 +
 +		req = rcu_dereference_protected(tcp_sk(sk)->fastopen_rsk,
 +						lockdep_sock_is_held(sk));
    	/* We could get here with a non-NULL req if the socket is
    	 * aborted (e.g., closed with unread data) before 3WHS
    	 * finishes.
@@@ -2564,7 -2559,6 +2564,7 @@@ int tcp_disconnect(struct sock *sk, in
    struct inet_connection_sock *icsk = inet_csk(sk);
    struct tcp_sock *tp = tcp_sk(sk);
    int old_state = sk->sk_state;
 +	u32 seq;
if (old_state != TCP_CLOSE)
    	tcp_set_state(sk, TCP_CLOSE);
@@@ -2591,7 -2585,7 +2591,7 @@@
    	__kfree_skb(sk->sk_rx_skb_cache);
    	sk->sk_rx_skb_cache = NULL;
    }
 -	tp->copied_seq = tp->rcv_nxt;
 +	WRITE_ONCE(tp->copied_seq, tp->rcv_nxt);
    tp->urg_data = 0;
    tcp_write_queue_purge(sk);
    tcp_fastopen_active_disable_ofo_check(sk);
@@@ -2607,12 -2601,9 +2607,12 @@@
    tp->srtt_us = 0;
    tp->mdev_us = jiffies_to_usecs(TCP_TIMEOUT_INIT);
    tp->rcv_rtt_last_tsecr = 0;
 -	tp->write_seq += tp->max_window + 2;
 -	if (tp->write_seq == 0)
 -		tp->write_seq = 1;
 +
 +	seq = tp->write_seq + tp->max_window + 2;
 +	if (!seq)
 +		seq = 1;
 +	WRITE_ONCE(tp->write_seq, seq);
 +
    icsk->icsk_backoff = 0;
    tp->snd_cwnd = 2;
    icsk->icsk_probes_out = 0;
@@@ -2666,7 -2657,6 +2666,7 @@@
    /* Clean up fastopen related fields */
    tcp_free_fastopen_req(tp);
    inet->defer_connect = 0;
 +	tp->fastopen_client_fail = 0;
WARN_ON(inet->inet_num && !icsk->icsk_bind_hash);
@@@ -2940,9 -2930,9 +2940,9 @@@ static int do_tcp_setsockopt(struct soc
    	if (sk->sk_state != TCP_CLOSE)
    		err = -EPERM;
    	else if (tp->repair_queue == TCP_SEND_QUEUE)
 -			tp->write_seq = val;
 +			WRITE_ONCE(tp->write_seq, val);
    	else if (tp->repair_queue == TCP_RECV_QUEUE)
 -			tp->rcv_nxt = val;
 +			WRITE_ONCE(tp->rcv_nxt, val);
    	else
    		err = -EINVAL;
    	break;
@@@ -3306,7 -3296,6 +3306,7 @@@ void tcp_get_info(struct sock *sk, stru
    info->tcpi_reord_seen = tp->reord_seen;
    info->tcpi_rcv_ooopack = tp->rcv_ooopack;
    info->tcpi_snd_wnd = tp->snd_wnd;
 +	info->tcpi_fastopen_client_fail = tp->fastopen_client_fail;
    unlock_sock_fast(sk, slow);
  }
  EXPORT_SYMBOL_GPL(tcp_get_info);
@@@ -3842,13 -3831,7 +3842,13 @@@ EXPORT_SYMBOL(tcp_md5_hash_key)
void tcp_done(struct sock *sk)
  {
 -	struct request_sock *req = tcp_sk(sk)->fastopen_rsk;
 +	struct request_sock *req;
 +
 +	/* We might be called with a new socket, after
 +	 * inet_csk_prepare_forced_close() has been called
 +	 * so we can not use lockdep_sock_is_held(sk)
 +	 */
 +	req = rcu_dereference_protected(tcp_sk(sk)->fastopen_rsk, 1);
if (sk->sk_state == TCP_SYN_SENT || sk->sk_state == TCP_SYN_RECV)
    	TCP_INC_STATS(sock_net(sk), TCP_MIB_ATTEMPTFAILS);
@@@ -3947,7 -3930,7 +3947,7 @@@ void __init tcp_init(void
BUILD_BUG_ON(TCP_MIN_SND_MSS <= MAX_TCP_OPTION_SPACE);
    BUILD_BUG_ON(sizeof(struct tcp_skb_cb) >
- 		     FIELD_SIZEOF(struct sk_buff, cb));
+ 		     sizeof_member(struct sk_buff, cb));
percpu_counter_init(&tcp_sockets_allocated, 0, GFP_KERNEL);
    percpu_counter_init(&tcp_orphan_count, 0, GFP_KERNEL);
diff --combined net/ipv6/ip6_gre.c
index 923034c52ce4,be1a8c823b2a..f20561b7f667
--- a/net/ipv6/ip6_gre.c
+++ b/net/ipv6/ip6_gre.c
@@@ -980,9 -980,9 +980,9 @@@ static netdev_tx_t ip6erspan_tunnel_xmi
    	dsfield = key->tos;
    	if (!(tun_info->key.tun_flags & TUNNEL_ERSPAN_OPT))
    		goto tx_err;
 -		md = ip_tunnel_info_opts(tun_info);
 -		if (!md)
 +		if (tun_info->options_len < sizeof(*md))
    		goto tx_err;
 +		md = ip_tunnel_info_opts(tun_info);
tun_id = tunnel_id_to_key32(key->tun_id);
    	if (md->version == 1) {
@@@ -2170,8 -2170,8 +2170,8 @@@ static const struct nla_policy ip6gre_p
    [IFLA_GRE_OFLAGS]      = { .type = NLA_U16 },
    [IFLA_GRE_IKEY]        = { .type = NLA_U32 },
    [IFLA_GRE_OKEY]        = { .type = NLA_U32 },
- 	[IFLA_GRE_LOCAL]       = { .len = FIELD_SIZEOF(struct ipv6hdr, saddr) },
- 	[IFLA_GRE_REMOTE]      = { .len = FIELD_SIZEOF(struct ipv6hdr, daddr) },
+ 	[IFLA_GRE_LOCAL]       = { .len = sizeof_member(struct ipv6hdr, saddr) },
+ 	[IFLA_GRE_REMOTE]      = { .len = sizeof_member(struct ipv6hdr, daddr) },
    [IFLA_GRE_TTL]         = { .type = NLA_U8 },
    [IFLA_GRE_ENCAP_LIMIT] = { .type = NLA_U8 },
    [IFLA_GRE_FLOWINFO]    = { .type = NLA_U32 },
@@@ -2192,7 -2192,6 +2192,7 @@@ static void ip6erspan_tap_setup(struct 
  {
    ether_setup(dev);
+	dev->max_mtu = 0;
    dev->netdev_ops = &ip6erspan_netdev_ops;
    dev->needs_free_netdev = true;
    dev->priv_destructor = ip6gre_dev_free;
diff --combined net/netfilter/nf_tables_api.c
index 8f1e8c6a5cfd,ec252362d2ab..fa2574fc444e
--- a/net/netfilter/nf_tables_api.c
+++ b/net/netfilter/nf_tables_api.c
@@@ -151,64 -151,11 +151,64 @@@ static void nft_set_trans_bind(const st
    }
  }
+static int nft_netdev_register_hooks(struct net *net,
 +				     struct list_head *hook_list)
 +{
 +	struct nft_hook *hook;
 +	int err, j;
 +
 +	j = 0;
 +	list_for_each_entry(hook, hook_list, list) {
 +		err = nf_register_net_hook(net, &hook->ops);
 +		if (err < 0)
 +			goto err_register;
 +
 +		j++;
 +	}
 +	return 0;
 +
 +err_register:
 +	list_for_each_entry(hook, hook_list, list) {
 +		if (j-- <= 0)
 +			break;
 +
 +		nf_unregister_net_hook(net, &hook->ops);
 +	}
 +	return err;
 +}
 +
 +static void nft_netdev_unregister_hooks(struct net *net,
 +					struct list_head *hook_list)
 +{
 +	struct nft_hook *hook;
 +
 +	list_for_each_entry(hook, hook_list, list)
 +		nf_unregister_net_hook(net, &hook->ops);
 +}
 +
 +static int nft_register_basechain_hooks(struct net *net, int family,
 +					struct nft_base_chain *basechain)
 +{
 +	if (family == NFPROTO_NETDEV)
 +		return nft_netdev_register_hooks(net, &basechain->hook_list);
 +
 +	return nf_register_net_hook(net, &basechain->ops);
 +}
 +
 +static void nft_unregister_basechain_hooks(struct net *net, int family,
 +					   struct nft_base_chain *basechain)
 +{
 +	if (family == NFPROTO_NETDEV)
 +		nft_netdev_unregister_hooks(net, &basechain->hook_list);
 +	else
 +		nf_unregister_net_hook(net, &basechain->ops);
 +}
 +
  static int nf_tables_register_hook(struct net *net,
    			   const struct nft_table *table,
    			   struct nft_chain *chain)
  {
 -	const struct nft_base_chain *basechain;
 +	struct nft_base_chain *basechain;
    const struct nf_hook_ops *ops;
if (table->flags & NFT_TABLE_F_DORMANT ||
@@@ -221,14 -168,14 +221,14 @@@
    if (basechain->type->ops_register)
    	return basechain->type->ops_register(net, ops);
-	return nf_register_net_hook(net, ops);
 +	return nft_register_basechain_hooks(net, table->family, basechain);
  }
static void nf_tables_unregister_hook(struct net *net,
    			      const struct nft_table *table,
    			      struct nft_chain *chain)
  {
 -	const struct nft_base_chain *basechain;
 +	struct nft_base_chain *basechain;
    const struct nf_hook_ops *ops;
if (table->flags & NFT_TABLE_F_DORMANT ||
@@@ -240,7 -187,7 +240,7 @@@
    if (basechain->type->ops_unregister)
    	return basechain->type->ops_unregister(net, ops);
-	nf_unregister_net_hook(net, ops);
 +	nft_unregister_basechain_hooks(net, table->family, basechain);
  }
static int nft_trans_table_add(struct nft_ctx *ctx, int msg_type)
@@@ -795,8 -742,7 +795,8 @@@ static void nft_table_disable(struct ne
    	if (cnt && i++ == cnt)
    		break;
-		nf_unregister_net_hook(net, &nft_base_chain(chain)->ops);
 +		nft_unregister_basechain_hooks(net, table->family,
 +					       nft_base_chain(chain));
    }
  }
@@@ -811,16 -757,14 +811,16 @@@ static int nf_tables_table_enable(struc
    	if (!nft_is_base_chain(chain))
    		continue;
-		err = nf_register_net_hook(net, &nft_base_chain(chain)->ops);
 +		err = nft_register_basechain_hooks(net, table->family,
 +						   nft_base_chain(chain));
    	if (err < 0)
 -			goto err;
 +			goto err_register_hooks;
i++;
    }
    return 0;
 -err:
 +
 +err_register_hooks:
    if (i)
    	nft_table_disable(net, table, i);
    return err;
@@@ -1281,46 -1225,6 +1281,46 @@@ nla_put_failure
    return -ENOSPC;
  }
+static int nft_dump_basechain_hook(struct sk_buff *skb, int family,
 +				   const struct nft_base_chain *basechain)
 +{
 +	const struct nf_hook_ops *ops = &basechain->ops;
 +	struct nft_hook *hook, *first = NULL;
 +	struct nlattr *nest, *nest_devs;
 +	int n = 0;
 +
 +	nest = nla_nest_start_noflag(skb, NFTA_CHAIN_HOOK);
 +	if (nest == NULL)
 +		goto nla_put_failure;
 +	if (nla_put_be32(skb, NFTA_HOOK_HOOKNUM, htonl(ops->hooknum)))
 +		goto nla_put_failure;
 +	if (nla_put_be32(skb, NFTA_HOOK_PRIORITY, htonl(ops->priority)))
 +		goto nla_put_failure;
 +
 +	if (family == NFPROTO_NETDEV) {
 +		nest_devs = nla_nest_start_noflag(skb, NFTA_HOOK_DEVS);
 +		list_for_each_entry(hook, &basechain->hook_list, list) {
 +			if (!first)
 +				first = hook;
 +
 +			if (nla_put_string(skb, NFTA_DEVICE_NAME,
 +					   hook->ops.dev->name))
 +				goto nla_put_failure;
 +			n++;
 +		}
 +		nla_nest_end(skb, nest_devs);
 +
 +		if (n == 1 &&
 +		    nla_put_string(skb, NFTA_HOOK_DEV, first->ops.dev->name))
 +			goto nla_put_failure;
 +	}
 +	nla_nest_end(skb, nest);
 +
 +	return 0;
 +nla_put_failure:
 +	return -1;
 +}
 +
  static int nf_tables_fill_chain_info(struct sk_buff *skb, struct net *net,
    			     u32 portid, u32 seq, int event, u32 flags,
    			     int family, const struct nft_table *table,
@@@ -1349,10 -1253,21 +1349,10 @@@
if (nft_is_base_chain(chain)) {
    	const struct nft_base_chain *basechain = nft_base_chain(chain);
 -		const struct nf_hook_ops *ops = &basechain->ops;
    	struct nft_stats __percpu *stats;
 -		struct nlattr *nest;
-		nest = nla_nest_start_noflag(skb, NFTA_CHAIN_HOOK);
 -		if (nest == NULL)
 +		if (nft_dump_basechain_hook(skb, family, basechain))
    		goto nla_put_failure;
 -		if (nla_put_be32(skb, NFTA_HOOK_HOOKNUM, htonl(ops->hooknum)))
 -			goto nla_put_failure;
 -		if (nla_put_be32(skb, NFTA_HOOK_PRIORITY, htonl(ops->priority)))
 -			goto nla_put_failure;
 -		if (basechain->dev_name[0] &&
 -		    nla_put_string(skb, NFTA_HOOK_DEV, basechain->dev_name))
 -			goto nla_put_failure;
 -		nla_nest_end(skb, nest);
if (nla_put_be32(skb, NFTA_CHAIN_POLICY,
    			 htonl(basechain->policy)))
@@@ -1546,9 -1461,8 +1546,9 @@@ static void nft_chain_stats_replace(str
    if (!nft_trans_chain_stats(trans))
    	return;
-	rcu_swap_protected(chain->stats, nft_trans_chain_stats(trans),
 -			   lockdep_commit_lock_is_held(trans->ctx.net));
 +	nft_trans_chain_stats(trans) =
 +		rcu_replace_pointer(chain->stats, nft_trans_chain_stats(trans),
 +				    lockdep_commit_lock_is_held(trans->ctx.net));
if (!nft_trans_chain_stats(trans))
    	static_branch_inc(&nft_counters_enabled);
@@@ -1571,7 -1485,6 +1571,7 @@@ static void nf_tables_chain_free_chain_
  static void nf_tables_chain_destroy(struct nft_ctx *ctx)
  {
    struct nft_chain *chain = ctx->chain;
 +	struct nft_hook *hook, *next;
if (WARN_ON(chain->use > 0))
    	return;
@@@ -1582,13 -1495,6 +1582,13 @@@
    if (nft_is_base_chain(chain)) {
    	struct nft_base_chain *basechain = nft_base_chain(chain);
+		if (ctx->family == NFPROTO_NETDEV) {
 +			list_for_each_entry_safe(hook, next,
 +						 &basechain->hook_list, list) {
 +				list_del_rcu(&hook->list);
 +				kfree_rcu(hook, rcu);
 +			}
 +		}
    	module_put(basechain->type->owner);
    	if (rcu_access_pointer(basechain->stats)) {
    		static_branch_dec(&nft_counters_enabled);
@@@ -1602,125 -1508,13 +1602,125 @@@
    }
  }
+static struct nft_hook *nft_netdev_hook_alloc(struct net *net,
 +					      const struct nlattr *attr)
 +{
 +	struct net_device *dev;
 +	char ifname[IFNAMSIZ];
 +	struct nft_hook *hook;
 +	int err;
 +
 +	hook = kmalloc(sizeof(struct nft_hook), GFP_KERNEL);
 +	if (!hook) {
 +		err = -ENOMEM;
 +		goto err_hook_alloc;
 +	}
 +
 +	nla_strlcpy(ifname, attr, IFNAMSIZ);
 +	dev = __dev_get_by_name(net, ifname);
 +	if (!dev) {
 +		err = -ENOENT;
 +		goto err_hook_dev;
 +	}
 +	hook->ops.dev = dev;
 +
 +	return hook;
 +
 +err_hook_dev:
 +	kfree(hook);
 +err_hook_alloc:
 +	return ERR_PTR(err);
 +}
 +
 +static bool nft_hook_list_find(struct list_head *hook_list,
 +			       const struct nft_hook *this)
 +{
 +	struct nft_hook *hook;
 +
 +	list_for_each_entry(hook, hook_list, list) {
 +		if (this->ops.dev == hook->ops.dev)
 +			return true;
 +	}
 +
 +	return false;
 +}
 +
 +static int nf_tables_parse_netdev_hooks(struct net *net,
 +					const struct nlattr *attr,
 +					struct list_head *hook_list)
 +{
 +	struct nft_hook *hook, *next;
 +	const struct nlattr *tmp;
 +	int rem, n = 0, err;
 +
 +	nla_for_each_nested(tmp, attr, rem) {
 +		if (nla_type(tmp) != NFTA_DEVICE_NAME) {
 +			err = -EINVAL;
 +			goto err_hook;
 +		}
 +
 +		hook = nft_netdev_hook_alloc(net, tmp);
 +		if (IS_ERR(hook)) {
 +			err = PTR_ERR(hook);
 +			goto err_hook;
 +		}
 +		if (nft_hook_list_find(hook_list, hook)) {
 +			err = -EEXIST;
 +			goto err_hook;
 +		}
 +		list_add_tail(&hook->list, hook_list);
 +		n++;
 +
 +		if (n == NFT_NETDEVICE_MAX) {
 +			err = -EFBIG;
 +			goto err_hook;
 +		}
 +	}
 +	if (!n)
 +		return -EINVAL;
 +
 +	return 0;
 +
 +err_hook:
 +	list_for_each_entry_safe(hook, next, hook_list, list) {
 +		list_del(&hook->list);
 +		kfree(hook);
 +	}
 +	return err;
 +}
 +
  struct nft_chain_hook {
    u32				num;
    s32				priority;
    const struct nft_chain_type	*type;
 -	struct net_device		*dev;
 +	struct list_head		list;
  };
+static int nft_chain_parse_netdev(struct net *net,
 +				  struct nlattr *tb[],
 +				  struct list_head *hook_list)
 +{
 +	struct nft_hook *hook;
 +	int err;
 +
 +	if (tb[NFTA_HOOK_DEV]) {
 +		hook = nft_netdev_hook_alloc(net, tb[NFTA_HOOK_DEV]);
 +		if (IS_ERR(hook))
 +			return PTR_ERR(hook);
 +
 +		list_add_tail(&hook->list, hook_list);
 +	} else if (tb[NFTA_HOOK_DEVS]) {
 +		err = nf_tables_parse_netdev_hooks(net, tb[NFTA_HOOK_DEVS],
 +						   hook_list);
 +		if (err < 0)
 +			return err;
 +	} else {
 +		return -EINVAL;
 +	}
 +
 +	return 0;
 +}
 +
  static int nft_chain_parse_hook(struct net *net,
    			const struct nlattr * const nla[],
    			struct nft_chain_hook *hook, u8 family,
@@@ -1728,6 -1522,7 +1728,6 @@@
  {
    struct nlattr *ha[NFTA_HOOK_MAX + 1];
    const struct nft_chain_type *type;
 -	struct net_device *dev;
    int err;
lockdep_assert_held(&net->nft.commit_mutex);
@@@ -1765,14 -1560,23 +1765,14 @@@
hook->type = type;
-	hook->dev = NULL;
 +	INIT_LIST_HEAD(&hook->list);
    if (family == NFPROTO_NETDEV) {
 -		char ifname[IFNAMSIZ];
 -
 -		if (!ha[NFTA_HOOK_DEV]) {
 -			module_put(type->owner);
 -			return -EOPNOTSUPP;
 -		}
 -
 -		nla_strlcpy(ifname, ha[NFTA_HOOK_DEV], IFNAMSIZ);
 -		dev = __dev_get_by_name(net, ifname);
 -		if (!dev) {
 +		err = nft_chain_parse_netdev(net, ha, &hook->list);
 +		if (err < 0) {
    		module_put(type->owner);
 -			return -ENOENT;
 +			return err;
    	}
 -		hook->dev = dev;
 -	} else if (ha[NFTA_HOOK_DEV]) {
 +	} else if (ha[NFTA_HOOK_DEV] || ha[NFTA_HOOK_DEVS]) {
    	module_put(type->owner);
    	return -EOPNOTSUPP;
    }
@@@ -1782,12 -1586,6 +1782,12 @@@
static void nft_chain_release_hook(struct nft_chain_hook *hook)
  {
 +	struct nft_hook *h, *next;
 +
 +	list_for_each_entry_safe(h, next, &hook->list, list) {
 +		list_del(&h->list);
 +		kfree(h);
 +	}
    module_put(hook->type->owner);
  }
@@@ -1812,49 -1610,6 +1812,49 @@@ static struct nft_rule **nf_tables_chai
    return kvmalloc(alloc, GFP_KERNEL);
  }
+static void nft_basechain_hook_init(struct nf_hook_ops *ops, u8 family,
 +				    const struct nft_chain_hook *hook,
 +				    struct nft_chain *chain)
 +{
 +	ops->pf		= family;
 +	ops->hooknum	= hook->num;
 +	ops->priority	= hook->priority;
 +	ops->priv	= chain;
 +	ops->hook	= hook->type->hooks[ops->hooknum];
 +}
 +
 +static int nft_basechain_init(struct nft_base_chain *basechain, u8 family,
 +			      struct nft_chain_hook *hook, u32 flags)
 +{
 +	struct nft_chain *chain;
 +	struct nft_hook *h;
 +
 +	basechain->type = hook->type;
 +	INIT_LIST_HEAD(&basechain->hook_list);
 +	chain = &basechain->chain;
 +
 +	if (family == NFPROTO_NETDEV) {
 +		list_splice_init(&hook->list, &basechain->hook_list);
 +		list_for_each_entry(h, &basechain->hook_list, list)
 +			nft_basechain_hook_init(&h->ops, family, hook, chain);
 +
 +		basechain->ops.hooknum	= hook->num;
 +		basechain->ops.priority	= hook->priority;
 +	} else {
 +		nft_basechain_hook_init(&basechain->ops, family, hook, chain);
 +	}
 +
 +	chain->flags |= NFT_BASE_CHAIN | flags;
 +	basechain->policy = NF_ACCEPT;
 +	if (chain->flags & NFT_CHAIN_HW_OFFLOAD &&
 +	    nft_chain_offload_priority(basechain) < 0)
 +		return -EOPNOTSUPP;
 +
 +	flow_block_init(&basechain->flow_block);
 +
 +	return 0;
 +}
 +
  static int nf_tables_addchain(struct nft_ctx *ctx, u8 family, u8 genmask,
    		      u8 policy, u32 flags)
  {
@@@ -1873,6 -1628,7 +1873,6 @@@
if (nla[NFTA_CHAIN_HOOK]) {
    	struct nft_chain_hook hook;
 -		struct nf_hook_ops *ops;
err = nft_chain_parse_hook(net, nla, &hook, family, true);
    	if (err < 0)
@@@ -1883,7 -1639,9 +1883,7 @@@
    		nft_chain_release_hook(&hook);
    		return -ENOMEM;
    	}
 -
 -		if (hook.dev != NULL)
 -			strncpy(basechain->dev_name, hook.dev->name, IFNAMSIZ);
 +		chain = &basechain->chain;
if (nla[NFTA_CHAIN_COUNTERS]) {
    		stats = nft_stats_alloc(nla[NFTA_CHAIN_COUNTERS]);
@@@ -1896,12 -1654,24 +1896,12 @@@
    		static_branch_inc(&nft_counters_enabled);
    	}
-		basechain->type = hook.type;
 -		chain = &basechain->chain;
 -
 -		ops		= &basechain->ops;
 -		ops->pf		= family;
 -		ops->hooknum	= hook.num;
 -		ops->priority	= hook.priority;
 -		ops->priv	= chain;
 -		ops->hook	= hook.type->hooks[ops->hooknum];
 -		ops->dev	= hook.dev;
 -
 -		chain->flags |= NFT_BASE_CHAIN | flags;
 -		basechain->policy = NF_ACCEPT;
 -		if (chain->flags & NFT_CHAIN_HW_OFFLOAD &&
 -		    nft_chain_offload_priority(basechain) < 0)
 -			return -EOPNOTSUPP;
 -
 -		flow_block_init(&basechain->flow_block);
 +		err = nft_basechain_init(basechain, family, &hook, flags);
 +		if (err < 0) {
 +			nft_chain_release_hook(&hook);
 +			kfree(basechain);
 +			return err;
 +		}
    } else {
    	chain = kzalloc(sizeof(*chain), GFP_KERNEL);
    	if (chain == NULL)
@@@ -1961,25 -1731,6 +1961,25 @@@ err1
    return err;
  }
+static bool nft_hook_list_equal(struct list_head *hook_list1,
 +				struct list_head *hook_list2)
 +{
 +	struct nft_hook *hook;
 +	int n = 0, m = 0;
 +
 +	n = 0;
 +	list_for_each_entry(hook, hook_list2, list) {
 +		if (!nft_hook_list_find(hook_list1, hook))
 +			return false;
 +
 +		n++;
 +	}
 +	list_for_each_entry(hook, hook_list1, list)
 +		m++;
 +
 +	return n == m;
 +}
 +
  static int nf_tables_updchain(struct nft_ctx *ctx, u8 genmask, u8 policy,
    		      u32 flags)
  {
@@@ -2011,19 -1762,12 +2011,19 @@@
    		return -EBUSY;
    	}
-		ops = &basechain->ops;
 -		if (ops->hooknum != hook.num ||
 -		    ops->priority != hook.priority ||
 -		    ops->dev != hook.dev) {
 -			nft_chain_release_hook(&hook);
 -			return -EBUSY;
 +		if (ctx->family == NFPROTO_NETDEV) {
 +			if (!nft_hook_list_equal(&basechain->hook_list,
 +						 &hook.list)) {
 +				nft_chain_release_hook(&hook);
 +				return -EBUSY;
 +			}
 +		} else {
 +			ops = &basechain->ops;
 +			if (ops->hooknum != hook.num ||
 +			    ops->priority != hook.priority) {
 +				nft_chain_release_hook(&hook);
 +				return -EBUSY;
 +			}
    	}
    	nft_chain_release_hook(&hook);
    }
@@@ -5884,6 -5628,43 +5884,6 @@@ nft_flowtable_lookup_byhandle(const str
         return ERR_PTR(-ENOENT);
  }
-static int nf_tables_parse_devices(const struct nft_ctx *ctx,
 -				   const struct nlattr *attr,
 -				   struct net_device *dev_array[], int *len)
 -{
 -	const struct nlattr *tmp;
 -	struct net_device *dev;
 -	char ifname[IFNAMSIZ];
 -	int rem, n = 0, err;
 -
 -	nla_for_each_nested(tmp, attr, rem) {
 -		if (nla_type(tmp) != NFTA_DEVICE_NAME) {
 -			err = -EINVAL;
 -			goto err1;
 -		}
 -
 -		nla_strlcpy(ifname, tmp, IFNAMSIZ);
 -		dev = __dev_get_by_name(ctx->net, ifname);
 -		if (!dev) {
 -			err = -ENOENT;
 -			goto err1;
 -		}
 -
 -		dev_array[n++] = dev;
 -		if (n == NFT_FLOWTABLE_DEVICE_MAX) {
 -			err = -EFBIG;
 -			goto err1;
 -		}
 -	}
 -	if (!len)
 -		return -EINVAL;
 -
 -	err = 0;
 -err1:
 -	*len = n;
 -	return err;
 -}
 -
  static const struct nla_policy nft_flowtable_hook_policy[NFTA_FLOWTABLE_HOOK_MAX + 1] = {
    [NFTA_FLOWTABLE_HOOK_NUM]	= { .type = NLA_U32 },
    [NFTA_FLOWTABLE_HOOK_PRIORITY]	= { .type = NLA_U32 },
@@@ -5894,10 -5675,11 +5894,10 @@@ static int nf_tables_flowtable_parse_ho
    				  const struct nlattr *attr,
    				  struct nft_flowtable *flowtable)
  {
 -	struct net_device *dev_array[NFT_FLOWTABLE_DEVICE_MAX];
    struct nlattr *tb[NFTA_FLOWTABLE_HOOK_MAX + 1];
 -	struct nf_hook_ops *ops;
 +	struct nft_hook *hook;
    int hooknum, priority;
 -	int err, n = 0, i;
 +	int err;
err = nla_parse_nested_deprecated(tb, NFTA_FLOWTABLE_HOOK_MAX, attr,
    				  nft_flowtable_hook_policy, NULL);
@@@ -5915,21 -5697,27 +5915,21 @@@
priority = ntohl(nla_get_be32(tb[NFTA_FLOWTABLE_HOOK_PRIORITY]));
-	err = nf_tables_parse_devices(ctx, tb[NFTA_FLOWTABLE_HOOK_DEVS],
 -				      dev_array, &n);
 +	err = nf_tables_parse_netdev_hooks(ctx->net,
 +					   tb[NFTA_FLOWTABLE_HOOK_DEVS],
 +					   &flowtable->hook_list);
    if (err < 0)
    	return err;
-	ops = kcalloc(n, sizeof(struct nf_hook_ops), GFP_KERNEL);
 -	if (!ops)
 -		return -ENOMEM;
 -
 -	flowtable->hooknum	= hooknum;
 -	flowtable->priority	= priority;
 -	flowtable->ops		= ops;
 -	flowtable->ops_len	= n;
 +	flowtable->hooknum		= hooknum;
 +	flowtable->data.priority	= priority;
-	for (i = 0; i < n; i++) {
 -		flowtable->ops[i].pf		= NFPROTO_NETDEV;
 -		flowtable->ops[i].hooknum	= hooknum;
 -		flowtable->ops[i].priority	= priority;
 -		flowtable->ops[i].priv		= &flowtable->data;
 -		flowtable->ops[i].hook		= flowtable->data.type->hook;
 -		flowtable->ops[i].dev		= dev_array[i];
 +	list_for_each_entry(hook, &flowtable->hook_list, list) {
 +		hook->ops.pf		= NFPROTO_NETDEV;
 +		hook->ops.hooknum	= hooknum;
 +		hook->ops.priority	= priority;
 +		hook->ops.priv		= &flowtable->data;
 +		hook->ops.hook		= flowtable->data.type->hook;
    }
return err;
@@@ -5969,51 -5757,14 +5969,51 @@@ nft_flowtable_type_get(struct net *net
  static void nft_unregister_flowtable_net_hooks(struct net *net,
    				       struct nft_flowtable *flowtable)
  {
 -	int i;
 +	struct nft_hook *hook;
-	for (i = 0; i < flowtable->ops_len; i++) {
 -		if (!flowtable->ops[i].dev)
 -			continue;
 +	list_for_each_entry(hook, &flowtable->hook_list, list)
 +		nf_unregister_net_hook(net, &hook->ops);
 +}
-		nf_unregister_net_hook(net, &flowtable->ops[i]);
 +static int nft_register_flowtable_net_hooks(struct net *net,
 +					    struct nft_table *table,
 +					    struct nft_flowtable *flowtable)
 +{
 +	struct nft_hook *hook, *hook2, *next;
 +	struct nft_flowtable *ft;
 +	int err, i = 0;
 +
 +	list_for_each_entry(hook, &flowtable->hook_list, list) {
 +		list_for_each_entry(ft, &table->flowtables, list) {
 +			list_for_each_entry(hook2, &ft->hook_list, list) {
 +				if (hook->ops.dev == hook2->ops.dev &&
 +				    hook->ops.pf == hook2->ops.pf) {
 +					err = -EBUSY;
 +					goto err_unregister_net_hooks;
 +				}
 +			}
 +		}
 +
 +		err = nf_register_net_hook(net, &hook->ops);
 +		if (err < 0)
 +			goto err_unregister_net_hooks;
 +
 +		i++;
    }
 +
 +	return 0;
 +
 +err_unregister_net_hooks:
 +	list_for_each_entry_safe(hook, next, &flowtable->hook_list, list) {
 +		if (i-- <= 0)
 +			break;
 +
 +		nf_unregister_net_hook(net, &hook->ops);
 +		list_del_rcu(&hook->list);
 +		kfree_rcu(hook, rcu);
 +	}
 +
 +	return err;
  }
static int nf_tables_newflowtable(struct net *net, struct sock *nlsk,
@@@ -6024,13 -5775,12 +6024,13 @@@
  {
    const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
    const struct nf_flowtable_type *type;
 -	struct nft_flowtable *flowtable, *ft;
    u8 genmask = nft_genmask_next(net);
    int family = nfmsg->nfgen_family;
 +	struct nft_flowtable *flowtable;
 +	struct nft_hook *hook, *next;
    struct nft_table *table;
    struct nft_ctx ctx;
 -	int err, i, k;
 +	int err;
if (!nla[NFTA_FLOWTABLE_TABLE] ||
        !nla[NFTA_FLOWTABLE_NAME] ||
@@@ -6069,7 -5819,6 +6069,7 @@@
flowtable->table = table;
    flowtable->handle = nf_tables_alloc_handle(table);
 +	INIT_LIST_HEAD(&flowtable->hook_list);
flowtable->name = nla_strdup(nla[NFTA_FLOWTABLE_NAME], GFP_KERNEL);
    if (!flowtable->name) {
@@@ -6093,24 -5842,43 +6093,24 @@@
    if (err < 0)
    	goto err4;
-	for (i = 0; i < flowtable->ops_len; i++) {
 -		if (!flowtable->ops[i].dev)
 -			continue;
 -
 -		list_for_each_entry(ft, &table->flowtables, list) {
 -			for (k = 0; k < ft->ops_len; k++) {
 -				if (!ft->ops[k].dev)
 -					continue;
 -
 -				if (flowtable->ops[i].dev == ft->ops[k].dev &&
 -				    flowtable->ops[i].pf == ft->ops[k].pf) {
 -					err = -EBUSY;
 -					goto err5;
 -				}
 -			}
 -		}
 -
 -		err = nf_register_net_hook(net, &flowtable->ops[i]);
 -		if (err < 0)
 -			goto err5;
 -	}
 +	err = nft_register_flowtable_net_hooks(ctx.net, table, flowtable);
 +	if (err < 0)
 +		goto err4;
err = nft_trans_flowtable_add(&ctx, NFT_MSG_NEWFLOWTABLE, flowtable);
    if (err < 0)
 -		goto err6;
 +		goto err5;
list_add_tail_rcu(&flowtable->list, &table->flowtables);
    table->use++;
return 0;
 -err6:
 -	i = flowtable->ops_len;
  err5:
 -	for (k = i - 1; k >= 0; k--)
 -		nf_unregister_net_hook(net, &flowtable->ops[k]);
 -
 -	kfree(flowtable->ops);
 +	list_for_each_entry_safe(hook, next, &flowtable->hook_list, list) {
 +		nf_unregister_net_hook(net, &hook->ops);
 +		list_del_rcu(&hook->list);
 +		kfree_rcu(hook, rcu);
 +	}
  err4:
    flowtable->data.type->free(&flowtable->data);
  err3:
@@@ -6177,8 -5945,8 +6177,8 @@@ static int nf_tables_fill_flowtable_inf
  {
    struct nlattr *nest, *nest_devs;
    struct nfgenmsg *nfmsg;
 +	struct nft_hook *hook;
    struct nlmsghdr *nlh;
 -	int i;
event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event);
    nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg), flags);
@@@ -6201,15 -5969,18 +6201,15 @@@
    if (!nest)
    	goto nla_put_failure;
    if (nla_put_be32(skb, NFTA_FLOWTABLE_HOOK_NUM, htonl(flowtable->hooknum)) ||
 -	    nla_put_be32(skb, NFTA_FLOWTABLE_HOOK_PRIORITY, htonl(flowtable->priority)))
 +	    nla_put_be32(skb, NFTA_FLOWTABLE_HOOK_PRIORITY, htonl(flowtable->data.priority)))
    	goto nla_put_failure;
nest_devs = nla_nest_start_noflag(skb, NFTA_FLOWTABLE_HOOK_DEVS);
    if (!nest_devs)
    	goto nla_put_failure;
-	for (i = 0; i < flowtable->ops_len; i++) {
 -		const struct net_device *dev = READ_ONCE(flowtable->ops[i].dev);
 -
 -		if (dev &&
 -		    nla_put_string(skb, NFTA_DEVICE_NAME, dev->name))
 +	list_for_each_entry_rcu(hook, &flowtable->hook_list, list) {
 +		if (nla_put_string(skb, NFTA_DEVICE_NAME, hook->ops.dev->name))
    		goto nla_put_failure;
    }
    nla_nest_end(skb, nest_devs);
@@@ -6400,12 -6171,7 +6400,12 @@@ err
static void nf_tables_flowtable_destroy(struct nft_flowtable *flowtable)
  {
 -	kfree(flowtable->ops);
 +	struct nft_hook *hook, *next;
 +
 +	list_for_each_entry_safe(hook, next, &flowtable->hook_list, list) {
 +		list_del_rcu(&hook->list);
 +		kfree(hook);
 +	}
    kfree(flowtable->name);
    flowtable->data.type->free(&flowtable->data);
    module_put(flowtable->data.type->owner);
@@@ -6445,15 -6211,14 +6445,15 @@@ nla_put_failure
  static void nft_flowtable_event(unsigned long event, struct net_device *dev,
    			struct nft_flowtable *flowtable)
  {
 -	int i;
 +	struct nft_hook *hook;
-	for (i = 0; i < flowtable->ops_len; i++) {
 -		if (flowtable->ops[i].dev != dev)
 +	list_for_each_entry(hook, &flowtable->hook_list, list) {
 +		if (hook->ops.dev != dev)
    		continue;
-		nf_unregister_net_hook(dev_net(dev), &flowtable->ops[i]);
 -		flowtable->ops[i].dev = NULL;
 +		nf_unregister_net_hook(dev_net(dev), &hook->ops);
 +		list_del_rcu(&hook->list);
 +		kfree_rcu(hook, rcu);
    	break;
    }
  }
@@@ -7556,7 -7321,7 +7556,7 @@@ int nft_validate_register_load(enum nft
    	return -EINVAL;
    if (len == 0)
    	return -EINVAL;
- 	if (reg * NFT_REG32_SIZE + len > FIELD_SIZEOF(struct nft_regs, data))
+ 	if (reg * NFT_REG32_SIZE + len > sizeof_member(struct nft_regs, data))
    	return -ERANGE;
return 0;
@@@ -7604,7 -7369,7 +7604,7 @@@ int nft_validate_register_store(const s
    	if (len == 0)
    		return -EINVAL;
    	if (reg * NFT_REG32_SIZE + len >
- 		    FIELD_SIZEOF(struct nft_regs, data))
+ 		    sizeof_member(struct nft_regs, data))
    		return -ERANGE;
if (data != NULL && type != NFT_DATA_VALUE)
diff --combined net/openvswitch/datapath.c
index d8c364d637b1,4c412b2b27b4..4ebcb4d5af6f
--- a/net/openvswitch/datapath.c
+++ b/net/openvswitch/datapath.c
@@@ -1881,7 -1881,7 +1881,7 @@@ static struct genl_family dp_datapath_g
  /* Called with ovs_mutex or RCU read lock. */
  static int ovs_vport_cmd_fill_info(struct vport *vport, struct sk_buff *skb,
    			   struct net *net, u32 portid, u32 seq,
 -				   u32 flags, u8 cmd)
 +				   u32 flags, u8 cmd, gfp_t gfp)
  {
    struct ovs_header *ovs_header;
    struct ovs_vport_stats vport_stats;
@@@ -1902,7 -1902,7 +1902,7 @@@
    	goto nla_put_failure;
if (!net_eq(net, dev_net(vport->dev))) {
 -		int id = peernet2id_alloc(net, dev_net(vport->dev));
 +		int id = peernet2id_alloc(net, dev_net(vport->dev), gfp);
if (nla_put_s32(skb, OVS_VPORT_ATTR_NETNSID, id))
    		goto nla_put_failure;
@@@ -1943,12 -1943,11 +1943,12 @@@ struct sk_buff *ovs_vport_cmd_build_inf
    struct sk_buff *skb;
    int retval;
-	skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
 +	skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
    if (!skb)
    	return ERR_PTR(-ENOMEM);
-	retval = ovs_vport_cmd_fill_info(vport, skb, net, portid, seq, 0, cmd);
 +	retval = ovs_vport_cmd_fill_info(vport, skb, net, portid, seq, 0, cmd,
 +					 GFP_KERNEL);
    BUG_ON(retval < 0);
return skb;
@@@ -2090,7 -2089,7 +2090,7 @@@ restart
err = ovs_vport_cmd_fill_info(vport, reply, genl_info_net(info),
    			      info->snd_portid, info->snd_seq, 0,
 -				      OVS_VPORT_CMD_NEW);
 +				      OVS_VPORT_CMD_NEW, GFP_KERNEL);
new_headroom = netdev_get_fwd_headroom(vport->dev);
@@@ -2151,7 -2150,7 +2151,7 @@@ static int ovs_vport_cmd_set(struct sk_
err = ovs_vport_cmd_fill_info(vport, reply, genl_info_net(info),
    			      info->snd_portid, info->snd_seq, 0,
 -				      OVS_VPORT_CMD_SET);
 +				      OVS_VPORT_CMD_SET, GFP_KERNEL);
    BUG_ON(err < 0);
ovs_unlock();
@@@ -2191,7 -2190,7 +2191,7 @@@ static int ovs_vport_cmd_del(struct sk_
err = ovs_vport_cmd_fill_info(vport, reply, genl_info_net(info),
    			      info->snd_portid, info->snd_seq, 0,
 -				      OVS_VPORT_CMD_DEL);
 +				      OVS_VPORT_CMD_DEL, GFP_KERNEL);
    BUG_ON(err < 0);
/* the vport deletion may trigger dp headroom update */
@@@ -2238,7 -2237,7 +2238,7 @@@ static int ovs_vport_cmd_get(struct sk_
    	goto exit_unlock_free;
    err = ovs_vport_cmd_fill_info(vport, reply, genl_info_net(info),
    			      info->snd_portid, info->snd_seq, 0,
 -				      OVS_VPORT_CMD_GET);
 +				      OVS_VPORT_CMD_GET, GFP_ATOMIC);
    BUG_ON(err < 0);
    rcu_read_unlock();
@@@ -2274,8 -2273,7 +2274,8 @@@ static int ovs_vport_cmd_dump(struct sk
    					    NETLINK_CB(cb->skb).portid,
    					    cb->nlh->nlmsg_seq,
    					    NLM_F_MULTI,
 -						    OVS_VPORT_CMD_GET) < 0)
 +						    OVS_VPORT_CMD_GET,
 +						    GFP_ATOMIC) < 0)
    			goto out;
j++;
@@@ -2451,7 -2449,7 +2451,7 @@@ static int __init dp_init(void
  {
    int err;
- 	BUILD_BUG_ON(sizeof(struct ovs_skb_cb) > FIELD_SIZEOF(struct sk_buff, cb));
+ 	BUILD_BUG_ON(sizeof(struct ovs_skb_cb) > sizeof_member(struct sk_buff, cb));
pr_info("Open vSwitch switching datapath\n");
diff --combined net/sched/act_ct.c
index 2d5ab233349e,3ee22bbac3ff..e6df8da29383
--- a/net/sched/act_ct.c
+++ b/net/sched/act_ct.c
@@@ -312,7 -312,7 +312,7 @@@ static void tcf_ct_act_set_labels(struc
    			  u32 *labels_m)
  {
  #if IS_ENABLED(CONFIG_NF_CONNTRACK_LABELS)
- 	size_t labels_sz = FIELD_SIZEOF(struct tcf_ct_params, labels);
+ 	size_t labels_sz = sizeof_member(struct tcf_ct_params, labels);
if (!memchr_inv(labels_m, 0, labels_sz))
    	return;
@@@ -722,8 -722,7 +722,8 @@@ static int tcf_ct_init(struct net *net
spin_lock_bh(&c->tcf_lock);
    goto_ch = tcf_action_set_ctrlact(*a, parm->action, goto_ch);
 -	rcu_swap_protected(c->params, params, lockdep_is_held(&c->tcf_lock));
 +	params = rcu_replace_pointer(c->params, params,
 +				     lockdep_is_held(&c->tcf_lock));
    spin_unlock_bh(&c->tcf_lock);
if (goto_ch)
@@@ -930,7 -929,7 +930,7 @@@ static struct tc_action_ops act_ct_ops
static __net_init int ct_init_net(struct net *net)
  {
- 	unsigned int n_bits = FIELD_SIZEOF(struct tcf_ct_params, labels) * 8;
+ 	unsigned int n_bits = sizeof_member(struct tcf_ct_params, labels) * 8;
    struct tc_ct_action_net *tn = net_generic(net, ct_net_id);
if (nf_connlabels_get(net, n_bits - 1)) {
diff --combined net/sctp/socket.c
index ca81e06df165,4c3105d96dce..1d6ebc13ed35
--- a/net/sctp/socket.c
+++ b/net/sctp/socket.c
@@@ -8476,7 -8476,7 +8476,7 @@@ __poll_t sctp_poll(struct file *file, s
    mask = 0;
/* Is there any exceptional events?  */
 -	if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
 +	if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue))
    	mask |= EPOLLERR |
    		(sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
    if (sk->sk_shutdown & RCV_SHUTDOWN)
@@@ -8485,7 -8485,7 +8485,7 @@@
    	mask |= EPOLLHUP;
/* Is it readable?  Reconsider this code with TCP-style support.  */
 -	if (!skb_queue_empty(&sk->sk_receive_queue))
 +	if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
    	mask |= EPOLLIN | EPOLLRDNORM;
/* The association is either gone or not ready.  */
@@@ -8871,7 -8871,7 +8871,7 @@@ struct sk_buff *sctp_skb_recv_datagram(
    	if (sk_can_busy_loop(sk)) {
    		sk_busy_loop(sk, noblock);
-			if (!skb_queue_empty(&sk->sk_receive_queue))
 +			if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
    			continue;
    	}
@@@ -9500,12 -9500,12 +9500,12 @@@ struct proto sctp_prot = 
    .backlog_rcv =	sctp_backlog_rcv,
    .hash        =	sctp_hash,
    .unhash      =	sctp_unhash,
 -	.get_port    =	sctp_get_port,
 +	.no_autobind =	true,
    .obj_size    =  sizeof(struct sctp_sock),
    .useroffset  =  offsetof(struct sctp_sock, subscribe),
    .usersize    =  offsetof(struct sctp_sock, initmsg) -
    			offsetof(struct sctp_sock, subscribe) +
- 				sizeof_field(struct sctp_sock, initmsg),
+ 				sizeof_member(struct sctp_sock, initmsg),
    .sysctl_mem  =  sysctl_sctp_mem,
    .sysctl_rmem =  sysctl_sctp_rmem,
    .sysctl_wmem =  sysctl_sctp_wmem,
@@@ -9542,12 -9542,12 +9542,12 @@@ struct proto sctpv6_prot = 
    .backlog_rcv	= sctp_backlog_rcv,
    .hash		= sctp_hash,
    .unhash		= sctp_unhash,
 -	.get_port	= sctp_get_port,
 +	.no_autobind	= true,
    .obj_size	= sizeof(struct sctp6_sock),
    .useroffset	= offsetof(struct sctp6_sock, sctp.subscribe),
    .usersize	= offsetof(struct sctp6_sock, sctp.initmsg) -
    			offsetof(struct sctp6_sock, sctp.subscribe) +
- 				sizeof_field(struct sctp6_sock, sctp.initmsg),
+ 				sizeof_member(struct sctp6_sock, sctp.initmsg),
    .sysctl_mem	= sysctl_sctp_mem,
    .sysctl_rmem	= sysctl_sctp_rmem,
    .sysctl_wmem	= sysctl_sctp_wmem,
diff --combined net/unix/af_unix.c
index 7cfdce10de36,ee9b2d8684c3..f0a074356012
--- a/net/unix/af_unix.c
+++ b/net/unix/af_unix.c
@@@ -284,9 -284,11 +284,9 @@@ static struct sock *__unix_find_socket_
if (u->addr->len == len &&
    	    !memcmp(u->addr->name, sunname, len))
 -			goto found;
 +			return s;
    }
 -	s = NULL;
 -found:
 -	return s;
 +	return NULL;
  }
static inline struct sock *unix_find_socket_byname(struct net *net,
@@@ -644,9 -646,6 +644,9 @@@ static __poll_t unix_poll(struct file *
  static __poll_t unix_dgram_poll(struct file *, struct socket *,
    			    poll_table *);
  static int unix_ioctl(struct socket *, unsigned int, unsigned long);
 +#ifdef CONFIG_COMPAT
 +static int unix_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg);
 +#endif
  static int unix_shutdown(struct socket *, int);
  static int unix_stream_sendmsg(struct socket *, struct msghdr *, size_t);
  static int unix_stream_recvmsg(struct socket *, struct msghdr *, size_t, int);
@@@ -688,9 -687,6 +688,9 @@@ static const struct proto_ops unix_stre
    .getname =	unix_getname,
    .poll =		unix_poll,
    .ioctl =	unix_ioctl,
 +#ifdef CONFIG_COMPAT
 +	.compat_ioctl =	unix_compat_ioctl,
 +#endif
    .listen =	unix_listen,
    .shutdown =	unix_shutdown,
    .setsockopt =	sock_no_setsockopt,
@@@ -714,9 -710,6 +714,9 @@@ static const struct proto_ops unix_dgra
    .getname =	unix_getname,
    .poll =		unix_dgram_poll,
    .ioctl =	unix_ioctl,
 +#ifdef CONFIG_COMPAT
 +	.compat_ioctl =	unix_compat_ioctl,
 +#endif
    .listen =	sock_no_listen,
    .shutdown =	unix_shutdown,
    .setsockopt =	sock_no_setsockopt,
@@@ -739,9 -732,6 +739,9 @@@ static const struct proto_ops unix_seqp
    .getname =	unix_getname,
    .poll =		unix_dgram_poll,
    .ioctl =	unix_ioctl,
 +#ifdef CONFIG_COMPAT
 +	.compat_ioctl =	unix_compat_ioctl,
 +#endif
    .listen =	unix_listen,
    .shutdown =	unix_shutdown,
    .setsockopt =	sock_no_setsockopt,
@@@ -2592,13 -2582,6 +2592,13 @@@ static int unix_ioctl(struct socket *so
    return err;
  }
+#ifdef CONFIG_COMPAT
 +static int unix_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 +{
 +	return unix_ioctl(sock, cmd, (unsigned long)compat_ptr(arg));
 +}
 +#endif
 +
  static __poll_t unix_poll(struct file *file, struct socket *sock, poll_table *wait)
  {
    struct sock *sk = sock->sk;
@@@ -2616,7 -2599,7 +2616,7 @@@
    	mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
/* readable? */
 -	if (!skb_queue_empty(&sk->sk_receive_queue))
 +	if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
    	mask |= EPOLLIN | EPOLLRDNORM;
/* Connection-based need to check for termination and startup */
@@@ -2645,7 -2628,7 +2645,7 @@@ static __poll_t unix_dgram_poll(struct 
    mask = 0;
/* exceptional events? */
 -	if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
 +	if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue))
    	mask |= EPOLLERR |
    		(sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
@@@ -2655,7 -2638,7 +2655,7 @@@
    	mask |= EPOLLHUP;
/* readable? */
 -	if (!skb_queue_empty(&sk->sk_receive_queue))
 +	if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
    	mask |= EPOLLIN | EPOLLRDNORM;
/* Connection-based need to check for termination and startup */
@@@ -2865,7 -2848,7 +2865,7 @@@ static int __init af_unix_init(void
  {
    int rc = -1;
- 	BUILD_BUG_ON(sizeof(struct unix_skb_parms) > FIELD_SIZEOF(struct sk_buff, cb));
+ 	BUILD_BUG_ON(sizeof(struct unix_skb_parms) > sizeof_member(struct sk_buff, cb));
rc = proto_register(&unix_proto, 1);
    if (rc != 0) {
diff --combined sound/soc/codecs/hdmi-codec.c
index f8b5b960e597,c8b1ac22b2b2..841d1c608fe4
--- a/sound/soc/codecs/hdmi-codec.c
+++ b/sound/soc/codecs/hdmi-codec.c
@@@ -274,7 -274,7 +274,7 @@@ struct hdmi_codec_priv 
    uint8_t eld[MAX_ELD_BYTES];
    struct snd_pcm_chmap *chmap_info;
    unsigned int chmap_idx;
 -	struct mutex lock;
 +	unsigned long busy;
    struct snd_soc_jack *jack;
    unsigned int jack_status;
  };
@@@ -292,7 -292,7 +292,7 @@@ static int hdmi_eld_ctl_info(struct snd
    		     struct snd_ctl_elem_info *uinfo)
  {
    uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
- 	uinfo->count = FIELD_SIZEOF(struct hdmi_codec_priv, eld);
+ 	uinfo->count = sizeof_member(struct hdmi_codec_priv, eld);
return 0;
  }
@@@ -390,8 -390,8 +390,8 @@@ static int hdmi_codec_startup(struct sn
    struct hdmi_codec_priv *hcp = snd_soc_dai_get_drvdata(dai);
    int ret = 0;
-	ret = mutex_trylock(&hcp->lock);
 -	if (!ret) {
 +	ret = test_and_set_bit(0, &hcp->busy);
 +	if (ret) {
    	dev_err(dai->dev, "Only one simultaneous stream supported!\n");
    	return -EINVAL;
    }
@@@ -419,7 -419,7 +419,7 @@@
err:
    /* Release the exclusive lock on error */
 -	mutex_unlock(&hcp->lock);
 +	clear_bit(0, &hcp->busy);
    return ret;
  }
@@@ -431,7 -431,7 +431,7 @@@ static void hdmi_codec_shutdown(struct 
    hcp->chmap_idx = HDMI_CODEC_CHMAP_IDX_UNKNOWN;
    hcp->hcd.ops->audio_shutdown(dai->dev->parent, hcp->hcd.data);
-	mutex_unlock(&hcp->lock);
 +	clear_bit(0, &hcp->busy);
  }
static int hdmi_codec_hw_params(struct snd_pcm_substream *substream,
@@@ -811,6 -811,8 +811,6 @@@ static int hdmi_codec_probe(struct plat
    	return -ENOMEM;
hcp->hcd = *hcd;
 -	mutex_init(&hcp->lock);
 -
    daidrv = devm_kcalloc(dev, dai_count, sizeof(*daidrv), GFP_KERNEL);
    if (!daidrv)
    	return -ENOMEM;
diff --combined virt/kvm/kvm_main.c
index e9eb666eb6e8,777d3b125072..4df0aa6b8e5c
--- a/virt/kvm/kvm_main.c
+++ b/virt/kvm/kvm_main.c
@@@ -2360,23 -2360,20 +2360,23 @@@ out
    kvm_arch_vcpu_unblocking(vcpu);
    block_ns = ktime_to_ns(cur) - ktime_to_ns(start);
-	if (!vcpu_valid_wakeup(vcpu))
 -		shrink_halt_poll_ns(vcpu);
 -	else if (halt_poll_ns) {
 -		if (block_ns <= vcpu->halt_poll_ns)
 -			;
 -		/* we had a long block, shrink polling */
 -		else if (vcpu->halt_poll_ns && block_ns > halt_poll_ns)
 +	if (!kvm_arch_no_poll(vcpu)) {
 +		if (!vcpu_valid_wakeup(vcpu)) {
    		shrink_halt_poll_ns(vcpu);
 -		/* we had a short halt and our poll time is too small */
 -		else if (vcpu->halt_poll_ns < halt_poll_ns &&
 -			block_ns < halt_poll_ns)
 -			grow_halt_poll_ns(vcpu);
 -	} else
 -		vcpu->halt_poll_ns = 0;
 +		} else if (halt_poll_ns) {
 +			if (block_ns <= vcpu->halt_poll_ns)
 +				;
 +			/* we had a long block, shrink polling */
 +			else if (vcpu->halt_poll_ns && block_ns > halt_poll_ns)
 +				shrink_halt_poll_ns(vcpu);
 +			/* we had a short halt and our poll time is too small */
 +			else if (vcpu->halt_poll_ns < halt_poll_ns &&
 +				block_ns < halt_poll_ns)
 +				grow_halt_poll_ns(vcpu);
 +		} else {
 +			vcpu->halt_poll_ns = 0;
 +		}
 +	}
trace_kvm_vcpu_wakeup(block_ns, waited, vcpu_valid_wakeup(vcpu));
    kvm_arch_vcpu_block_finish(vcpu);
@@@ -3049,14 -3046,14 +3049,14 @@@ struct kvm_device *kvm_device_from_filp
    return filp->private_data;
  }
-static struct kvm_device_ops *kvm_device_ops_table[KVM_DEV_TYPE_MAX] = {
 +static const struct kvm_device_ops *kvm_device_ops_table[KVM_DEV_TYPE_MAX] = {
  #ifdef CONFIG_KVM_MPIC
    [KVM_DEV_TYPE_FSL_MPIC_20]	= &kvm_mpic_ops,
    [KVM_DEV_TYPE_FSL_MPIC_42]	= &kvm_mpic_ops,
  #endif
  };
-int kvm_register_device_ops(struct kvm_device_ops *ops, u32 type)
 +int kvm_register_device_ops(const struct kvm_device_ops *ops, u32 type)
  {
    if (type >= ARRAY_SIZE(kvm_device_ops_table))
    	return -ENOSPC;
@@@ -3077,7 -3074,7 +3077,7 @@@ void kvm_unregister_device_ops(u32 type
  static int kvm_ioctl_create_device(struct kvm *kvm,
    			   struct kvm_create_device *cd)
  {
 -	struct kvm_device_ops *ops = NULL;
 +	const struct kvm_device_ops *ops = NULL;
    struct kvm_device *dev;
    bool test = cd->flags & KVM_CREATE_DEVICE_TEST;
    int type;
@@@ -4296,7 -4293,7 +4296,7 @@@ int kvm_init(void *opaque, unsigned vcp
    	kmem_cache_create_usercopy("kvm_vcpu", vcpu_size, vcpu_align,
    				   SLAB_ACCOUNT,
    				   offsetof(struct kvm_vcpu, arch),
- 					   sizeof_field(struct kvm_vcpu, arch),
+ 					   sizeof_member(struct kvm_vcpu, arch),
    				   NULL);
    if (!kvm_vcpu_cache) {
    	r = -ENOMEM;
-- 
LinuxNextTracking

    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

[linux-next] LinuxNextTracking branch, master, updated. next-20191031