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

net/devlink/leftover.c / net/core/devlink.c:
  565b4824c39f ("devlink: change port event netdev notifier from per-net to global")
  f05bd8ebeb69 ("devlink: move code to a dedicated directory")
  687125b5799c ("devlink: split out core code")
https://lore.kernel.org/all/20230208094657.379f2b1a@canb.auug.org.au/

Signed-off-by: Jakub Kicinski <kuba@kernel.org>

diff --cc MAINTAINERS
Simple merge

diff --cc drivers/net/dsa/mt7530.c
Simple merge

diff --cc drivers/net/ethernet/cadence/macb_main.c
Simple merge

diff --cc drivers/net/ethernet/intel/ice/ice_common.c
Simple merge

diff --cc drivers/net/ethernet/intel/ice/ice_main.c
Simple merge

diff --cc drivers/net/ethernet/intel/ice/ice_tc_lib.c
Simple merge

diff --cc drivers/net/ethernet/intel/igc/igc_main.c
Simple merge

diff --cc drivers/net/ethernet/mediatek/mtk_eth_soc.c
Simple merge

diff --cc drivers/net/ethernet/mellanox/mlx5/core/diag/fw_tracer.c
Simple merge

diff --cc drivers/net/ethernet/mellanox/mlx5/core/ecpf.c
index b70e36025d922bdb885a37a3dd9c9a9d299c5c1e,cdc87ecae5d399ffdb95961e06330e5a074bd6b1..9a3878f9e58246a19d555ed27c33c5563e08da95
--- 1/drivers/net/ethernet/mellanox/mlx5/core/ecpf.c
--- 2/drivers/net/ethernet/mellanox/mlx5/core/ecpf.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/ecpf.c
@@@ -89,13 -85,9 +89,13 @@@ void mlx5_ec_cleanup(struct mlx5_core_d
        if (!mlx5_core_is_ecpf(dev))
                return;
  
 +      /* Management PF don't have a peer PF */
 +      if (mlx5_core_is_management_pf(dev))
 +              return;
 +
        mlx5_host_pf_cleanup(dev);
  
-       err = mlx5_wait_for_pages(dev, &dev->priv.host_pf_pages);
+       err = mlx5_wait_for_pages(dev, &dev->priv.page_counters[MLX5_HOST_PF]);
        if (err)
                mlx5_core_warn(dev, "Timeout reclaiming external host PF pages err(%d)\n", err);
  }

diff --cc drivers/net/ethernet/mellanox/mlx5/core/en_fs.c
Simple merge

diff --cc drivers/net/ethernet/mellanox/mlx5/core/en_main.c
Simple merge

diff --cc drivers/net/ethernet/mellanox/mlx5/core/ipoib/ethtool.c
Simple merge

diff --cc drivers/net/ethernet/mellanox/mlx5/core/main.c
Simple merge

diff --cc drivers/net/ethernet/mellanox/mlx5/core/pagealloc.c
Simple merge

diff --cc drivers/net/ethernet/microchip/sparx5/sparx5_ptp.c
Simple merge

diff --cc drivers/net/ethernet/netronome/nfp/nfp_net_ethtool.c
Simple merge

diff --cc drivers/net/phy/phylink.c
Simple merge

diff --cc include/linux/mlx5/driver.h
Simple merge

diff --cc lib/Kconfig.debug
Simple merge

diff --cc net/core/neighbour.c
Simple merge

diff --cc net/core/sock.c
Simple merge

diff --cc net/devlink/core.c
index aeffd1b8206d6478998f00e1e34cb7130ca503bb,0000000000000000000000000000000000000000..a4f47dafb8644597f6a002889522321887a3508a
mode 100644,000000..100644
--- 1/net/devlink/core.c
--- /dev/null
+++ b/net/devlink/core.c
@@@ -1,321 -1,0 +1,320 @@@
-       ret = register_netdevice_notifier_net(net, &devlink->netdevice_nb);
 +// SPDX-License-Identifier: GPL-2.0-or-later
 +/*
 + * Copyright (c) 2016 Mellanox Technologies. All rights reserved.
 + * Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com>
 + */
 +
 +#include <net/genetlink.h>
 +
 +#include "devl_internal.h"
 +
 +DEFINE_XARRAY_FLAGS(devlinks, XA_FLAGS_ALLOC);
 +
 +void *devlink_priv(struct devlink *devlink)
 +{
 +      return &devlink->priv;
 +}
 +EXPORT_SYMBOL_GPL(devlink_priv);
 +
 +struct devlink *priv_to_devlink(void *priv)
 +{
 +      return container_of(priv, struct devlink, priv);
 +}
 +EXPORT_SYMBOL_GPL(priv_to_devlink);
 +
 +struct device *devlink_to_dev(const struct devlink *devlink)
 +{
 +      return devlink->dev;
 +}
 +EXPORT_SYMBOL_GPL(devlink_to_dev);
 +
 +struct net *devlink_net(const struct devlink *devlink)
 +{
 +      return read_pnet(&devlink->_net);
 +}
 +EXPORT_SYMBOL_GPL(devlink_net);
 +
 +void devl_assert_locked(struct devlink *devlink)
 +{
 +      lockdep_assert_held(&devlink->lock);
 +}
 +EXPORT_SYMBOL_GPL(devl_assert_locked);
 +
 +#ifdef CONFIG_LOCKDEP
 +/* For use in conjunction with LOCKDEP only e.g. rcu_dereference_protected() */
 +bool devl_lock_is_held(struct devlink *devlink)
 +{
 +      return lockdep_is_held(&devlink->lock);
 +}
 +EXPORT_SYMBOL_GPL(devl_lock_is_held);
 +#endif
 +
 +void devl_lock(struct devlink *devlink)
 +{
 +      mutex_lock(&devlink->lock);
 +}
 +EXPORT_SYMBOL_GPL(devl_lock);
 +
 +int devl_trylock(struct devlink *devlink)
 +{
 +      return mutex_trylock(&devlink->lock);
 +}
 +EXPORT_SYMBOL_GPL(devl_trylock);
 +
 +void devl_unlock(struct devlink *devlink)
 +{
 +      mutex_unlock(&devlink->lock);
 +}
 +EXPORT_SYMBOL_GPL(devl_unlock);
 +
 +/**
 + * devlink_try_get() - try to obtain a reference on a devlink instance
 + * @devlink: instance to reference
 + *
 + * Obtain a reference on a devlink instance. A reference on a devlink instance
 + * only implies that it's safe to take the instance lock. It does not imply
 + * that the instance is registered, use devl_is_registered() after taking
 + * the instance lock to check registration status.
 + */
 +struct devlink *__must_check devlink_try_get(struct devlink *devlink)
 +{
 +      if (refcount_inc_not_zero(&devlink->refcount))
 +              return devlink;
 +      return NULL;
 +}
 +
 +static void devlink_release(struct work_struct *work)
 +{
 +      struct devlink *devlink;
 +
 +      devlink = container_of(to_rcu_work(work), struct devlink, rwork);
 +
 +      mutex_destroy(&devlink->lock);
 +      lockdep_unregister_key(&devlink->lock_key);
 +      kfree(devlink);
 +}
 +
 +void devlink_put(struct devlink *devlink)
 +{
 +      if (refcount_dec_and_test(&devlink->refcount))
 +              queue_rcu_work(system_wq, &devlink->rwork);
 +}
 +
 +struct devlink *devlinks_xa_find_get(struct net *net, unsigned long *indexp)
 +{
 +      struct devlink *devlink = NULL;
 +
 +      rcu_read_lock();
 +retry:
 +      devlink = xa_find(&devlinks, indexp, ULONG_MAX, DEVLINK_REGISTERED);
 +      if (!devlink)
 +              goto unlock;
 +
 +      if (!devlink_try_get(devlink))
 +              goto next;
 +      if (!net_eq(devlink_net(devlink), net)) {
 +              devlink_put(devlink);
 +              goto next;
 +      }
 +unlock:
 +      rcu_read_unlock();
 +      return devlink;
 +
 +next:
 +      (*indexp)++;
 +      goto retry;
 +}
 +
 +/**
 + * devl_register - Register devlink instance
 + * @devlink: devlink
 + */
 +int devl_register(struct devlink *devlink)
 +{
 +      ASSERT_DEVLINK_NOT_REGISTERED(devlink);
 +      devl_assert_locked(devlink);
 +
 +      xa_set_mark(&devlinks, devlink->index, DEVLINK_REGISTERED);
 +      devlink_notify_register(devlink);
 +
 +      return 0;
 +}
 +EXPORT_SYMBOL_GPL(devl_register);
 +
 +void devlink_register(struct devlink *devlink)
 +{
 +      devl_lock(devlink);
 +      devl_register(devlink);
 +      devl_unlock(devlink);
 +}
 +EXPORT_SYMBOL_GPL(devlink_register);
 +
 +/**
 + * devl_unregister - Unregister devlink instance
 + * @devlink: devlink
 + */
 +void devl_unregister(struct devlink *devlink)
 +{
 +      ASSERT_DEVLINK_REGISTERED(devlink);
 +      devl_assert_locked(devlink);
 +
 +      devlink_notify_unregister(devlink);
 +      xa_clear_mark(&devlinks, devlink->index, DEVLINK_REGISTERED);
 +}
 +EXPORT_SYMBOL_GPL(devl_unregister);
 +
 +void devlink_unregister(struct devlink *devlink)
 +{
 +      devl_lock(devlink);
 +      devl_unregister(devlink);
 +      devl_unlock(devlink);
 +}
 +EXPORT_SYMBOL_GPL(devlink_unregister);
 +
 +/**
 + *    devlink_alloc_ns - Allocate new devlink instance resources
 + *    in specific namespace
 + *
 + *    @ops: ops
 + *    @priv_size: size of user private data
 + *    @net: net namespace
 + *    @dev: parent device
 + *
 + *    Allocate new devlink instance resources, including devlink index
 + *    and name.
 + */
 +struct devlink *devlink_alloc_ns(const struct devlink_ops *ops,
 +                               size_t priv_size, struct net *net,
 +                               struct device *dev)
 +{
 +      struct devlink *devlink;
 +      static u32 last_id;
 +      int ret;
 +
 +      WARN_ON(!ops || !dev);
 +      if (!devlink_reload_actions_valid(ops))
 +              return NULL;
 +
 +      devlink = kzalloc(sizeof(*devlink) + priv_size, GFP_KERNEL);
 +      if (!devlink)
 +              return NULL;
 +
 +      ret = xa_alloc_cyclic(&devlinks, &devlink->index, devlink, xa_limit_31b,
 +                            &last_id, GFP_KERNEL);
 +      if (ret < 0)
 +              goto err_xa_alloc;
 +
 +      devlink->netdevice_nb.notifier_call = devlink_port_netdevice_event;
-       WARN_ON_ONCE(unregister_netdevice_notifier_net(devlink_net(devlink),
-                                                      &devlink->netdevice_nb));
++      ret = register_netdevice_notifier(&devlink->netdevice_nb);
 +      if (ret)
 +              goto err_register_netdevice_notifier;
 +
 +      devlink->dev = dev;
 +      devlink->ops = ops;
 +      xa_init_flags(&devlink->ports, XA_FLAGS_ALLOC);
 +      xa_init_flags(&devlink->snapshot_ids, XA_FLAGS_ALLOC);
 +      write_pnet(&devlink->_net, net);
 +      INIT_LIST_HEAD(&devlink->rate_list);
 +      INIT_LIST_HEAD(&devlink->linecard_list);
 +      INIT_LIST_HEAD(&devlink->sb_list);
 +      INIT_LIST_HEAD_RCU(&devlink->dpipe_table_list);
 +      INIT_LIST_HEAD(&devlink->resource_list);
 +      INIT_LIST_HEAD(&devlink->param_list);
 +      INIT_LIST_HEAD(&devlink->region_list);
 +      INIT_LIST_HEAD(&devlink->reporter_list);
 +      INIT_LIST_HEAD(&devlink->trap_list);
 +      INIT_LIST_HEAD(&devlink->trap_group_list);
 +      INIT_LIST_HEAD(&devlink->trap_policer_list);
 +      INIT_RCU_WORK(&devlink->rwork, devlink_release);
 +      lockdep_register_key(&devlink->lock_key);
 +      mutex_init(&devlink->lock);
 +      lockdep_set_class(&devlink->lock, &devlink->lock_key);
 +      refcount_set(&devlink->refcount, 1);
 +
 +      return devlink;
 +
 +err_register_netdevice_notifier:
 +      xa_erase(&devlinks, devlink->index);
 +err_xa_alloc:
 +      kfree(devlink);
 +      return NULL;
 +}
 +EXPORT_SYMBOL_GPL(devlink_alloc_ns);
 +
 +/**
 + *    devlink_free - Free devlink instance resources
 + *
 + *    @devlink: devlink
 + */
 +void devlink_free(struct devlink *devlink)
 +{
 +      ASSERT_DEVLINK_NOT_REGISTERED(devlink);
 +
 +      WARN_ON(!list_empty(&devlink->trap_policer_list));
 +      WARN_ON(!list_empty(&devlink->trap_group_list));
 +      WARN_ON(!list_empty(&devlink->trap_list));
 +      WARN_ON(!list_empty(&devlink->reporter_list));
 +      WARN_ON(!list_empty(&devlink->region_list));
 +      WARN_ON(!list_empty(&devlink->param_list));
 +      WARN_ON(!list_empty(&devlink->resource_list));
 +      WARN_ON(!list_empty(&devlink->dpipe_table_list));
 +      WARN_ON(!list_empty(&devlink->sb_list));
 +      WARN_ON(!list_empty(&devlink->rate_list));
 +      WARN_ON(!list_empty(&devlink->linecard_list));
 +      WARN_ON(!xa_empty(&devlink->ports));
 +
 +      xa_destroy(&devlink->snapshot_ids);
 +      xa_destroy(&devlink->ports);
 +
++      WARN_ON_ONCE(unregister_netdevice_notifier(&devlink->netdevice_nb));
 +
 +      xa_erase(&devlinks, devlink->index);
 +
 +      devlink_put(devlink);
 +}
 +EXPORT_SYMBOL_GPL(devlink_free);
 +
 +static void __net_exit devlink_pernet_pre_exit(struct net *net)
 +{
 +      struct devlink *devlink;
 +      u32 actions_performed;
 +      unsigned long index;
 +      int err;
 +
 +      /* In case network namespace is getting destroyed, reload
 +       * all devlink instances from this namespace into init_net.
 +       */
 +      devlinks_xa_for_each_registered_get(net, index, devlink) {
 +              devl_lock(devlink);
 +              err = 0;
 +              if (devl_is_registered(devlink))
 +                      err = devlink_reload(devlink, &init_net,
 +                                           DEVLINK_RELOAD_ACTION_DRIVER_REINIT,
 +                                           DEVLINK_RELOAD_LIMIT_UNSPEC,
 +                                           &actions_performed, NULL);
 +              devl_unlock(devlink);
 +              devlink_put(devlink);
 +              if (err && err != -EOPNOTSUPP)
 +                      pr_warn("Failed to reload devlink instance into init_net\n");
 +      }
 +}
 +
 +static struct pernet_operations devlink_pernet_ops __net_initdata = {
 +      .pre_exit = devlink_pernet_pre_exit,
 +};
 +
 +static int __init devlink_init(void)
 +{
 +      int err;
 +
 +      err = genl_register_family(&devlink_nl_family);
 +      if (err)
 +              goto out;
 +      err = register_pernet_subsys(&devlink_pernet_ops);
 +
 +out:
 +      WARN_ON(err);
 +      return err;
 +}
 +
 +subsys_initcall(devlink_init);

diff --cc net/devlink/leftover.c
Simple merge

diff --cc net/ipv4/af_inet.c
Simple merge

diff --cc net/ipv4/inet_connection_sock.c
Simple merge

diff --cc net/mptcp/pm_netlink.c
Simple merge

diff --cc net/mptcp/protocol.c
Simple merge

diff --cc net/mptcp/sockopt.c
Simple merge

diff --cc net/mptcp/subflow.c
Simple merge

diff --cc net/xfrm/xfrm_state.c
Simple merge

diff --cc tools/testing/selftests/net/forwarding/lib.sh
Simple merge

diff --cc tools/testing/selftests/net/mptcp/mptcp_join.sh
Simple merge