v8:

- address Matt's comments in v7.

v7:

- addresss Matt's comments in v6 [1].

- drop "type" from struct mptcp_pm_ops as Matt suggested.

- map "pm_type" to new sysctl as Matt suggested.

- mptcp: pm: code reorganisation, v2

Based-on: <20250228-mptcp-pm-reorg-code-v2-0-fa8b2542b7a5@kernel.org>

[1]

https://patchwork.kernel.org/project/mptcp/cover/cover.1740320007.git.tanggeliang@kylinos.cn/

v6:

- add "name" in struct mptcp_pm_ops.

- add some "sysctl" patches.

- drop "struct mptcp_pm_param".

- drop "pm_type" in mptcp_pm_data.

v5:

- use "struct mptcp_pm_param *param" as unified parameters for all

interfaces.

- register in-kernel mptcp_pm_ops too.

- only implement two interfaces "get_local_id" and "get_priority" in

this set.

v4:

- include a new patch "define BPF path manager type".

- add new interfaces:

    created established closed

    listerner_created listener_closed

- rename interfaces as:

    address_announced address_removed

    subflow_established subflow_closed

    get_priority set_priority

- rename functions as:

    mptcp_pm_validate

    mptcp_pm_register

    mptcp_pm_unregister

    mptcp_pm_initialize

    mptcp_pm_release

v3:

- rename the 2nd parameter of get_local_id() from 'local' to 'skc'.

- keep the 'msk_sport' check in mptcp_userspace_pm_get_local_id().

- return 'err' instead of '0' in userspace_pm_subflow_create().

- drop 'ret' variable inmptcp_pm_data_reset().

- fix typos in commit log.

v2:

- update get_local_id interface in patch 2.

get_addr() and dump_addr() interfaces of BPF userspace pm are dropped

as Matt suggested.

In order to implement BPF path manager, it's necessary to unify the

interfaces of the path manager. This set contains some cleanups and

refactoring to unify the interfaces in kernel space. Finally, define

a struct mptcp_pm_ops for a path manager.

Geliang Tang (12):

mptcp: pm: define struct mptcp_pm_ops

mptcp: sysctl: new sysctl to set path manager by name

mptcp: sysctl: map pm_type to path_manager

mptcp: sysctl: map path_manager to pm_type

mptcp: sysctl: add available_path_managers

mptcp: pm: in-kernel: register mptcp_pm_kernel

mptcp: pm: userspace: register mptcp_pm_userspace

mptcp: pm: initialize and release mptcp_pm_ops

mptcp: pm: add get_local_id() interface

mptcp: pm: add get_priority() interface

selftests: mptcp: add pm_type mapping tests

selftests: mptcp: add path_manager sysctl test

Documentation/networking/mptcp-sysctl.rst | 23 +++

include/net/mptcp.h | 19 +++

net/mptcp/ctrl.c | 112 +++++++++++++-

net/mptcp/pm.c | 145 ++++++++++++++----

net/mptcp/pm_kernel.c | 35 ++++-

net/mptcp/pm_userspace.c | 36 ++++-

net/mptcp/protocol.h | 18 ++-

.../testing/selftests/net/mptcp/mptcp_join.sh | 49 +++++-

8 files changed, 393 insertions(+), 44 deletions(-)

In order to allow users to develop their own BPF-based path manager,

this patch defines a struct ops "mptcp_pm_ops" for a userspace path

manager, which contains a set of interfaces.

Add a set of functions to register, unregister, find and validate a

given struct ops.

include/net/mptcp.h | 12 ++++++++++

net/mptcp/pm.c | 55 ++++++++++++++++++++++++++++++++++++++++++++

net/mptcp/protocol.h | 5 ++++

3 files changed, 72 insertions(+)

diff --git a/include/net/mptcp.h b/include/net/mptcp.h

--- a/include/net/mptcp.h

+++ b/include/net/mptcp.h

@@ -XXX,XX +XXX,XX @@

struct mptcp_info;

struct mptcp_sock;

+struct mptcp_pm_addr_entry;

struct seq_file;

/* MPTCP sk_buff extension data */

@@ -XXX,XX +XXX,XX @@ struct mptcp_sched_ops {

    void (*release)(struct mptcp_sock *msk);

} ____cacheline_aligned_in_smp;

+#define MPTCP_PM_NAME_MAX    16

+

+struct mptcp_pm_ops {

+    char            name[MPTCP_PM_NAME_MAX];

+    struct module        *owner;

+    struct list_head    list;

+

+    void (*init)(struct mptcp_sock *msk);

+    void (*release)(struct mptcp_sock *msk);

+} ____cacheline_aligned_in_smp;

+

#ifdef CONFIG_MPTCP

void mptcp_init(void);

diff --git a/net/mptcp/pm.c b/net/mptcp/pm.c

index XXXXXXX..XXXXXXX 100644

--- a/net/mptcp/pm.c

+++ b/net/mptcp/pm.c

@@ -XXX,XX +XXX,XX @@

*/

#define pr_fmt(fmt) "MPTCP: " fmt

+#include <linux/rculist.h>

+#include <linux/spinlock.h>

#include "protocol.h"

#include "mib.h"

@@ -XXX,XX +XXX,XX @@ struct mptcp_pm_add_entry {

    struct mptcp_sock    *sock;

};

+static DEFINE_SPINLOCK(mptcp_pm_list_lock);

+static LIST_HEAD(mptcp_pm_list);

+

/* path manager helpers */

/* if sk is ipv4 or ipv6_only allows only same-family local and remote addresses,

@@ -XXX,XX +XXX,XX @@ void __init mptcp_pm_init(void)

    mptcp_pm_kernel_register();

    mptcp_pm_nl_init();

+

+/* Must be called with rcu read lock held */

+struct mptcp_pm_ops *mptcp_pm_find(const char *name)

+    struct mptcp_pm_ops *pm;

+    list_for_each_entry_rcu(pm, &mptcp_pm_list, list) {

+        if (!strcmp(pm->name, name))

+            return pm;

+    }

+

+    return NULL;

+int mptcp_pm_validate(struct mptcp_pm_ops *pm)

+    if (!pm->init) {

+        pr_err("%s does not implement required ops\n", pm->name);

+        return -EINVAL;

+int mptcp_pm_register(struct mptcp_pm_ops *pm)

+{

+    int ret;

+

+    ret = mptcp_pm_validate(pm);

+    if (ret)

+        return ret;

+

+    spin_lock(&mptcp_pm_list_lock);

+    if (mptcp_pm_find(pm->name)) {

+        spin_unlock(&mptcp_pm_list_lock);

+        return -EEXIST;

+    }

+    list_add_tail_rcu(&pm->list, &mptcp_pm_list);

+    spin_unlock(&mptcp_pm_list_lock);

+

+    pr_debug("%s registered\n", pm->name);

+    return 0;

+}

+

+void mptcp_pm_unregister(struct mptcp_pm_ops *pm)

+{

+    spin_lock(&mptcp_pm_list_lock);

+    list_del_rcu(&pm->list);

+    spin_unlock(&mptcp_pm_list_lock);

+}

diff --git a/net/mptcp/protocol.h b/net/mptcp/protocol.h

index XXXXXXX..XXXXXXX 100644

--- a/net/mptcp/protocol.h

+++ b/net/mptcp/protocol.h

@@ -XXX,XX +XXX,XX @@ int mptcp_pm_remove_addr(struct mptcp_sock *msk, const struct mptcp_rm_list *rm_

void mptcp_pm_remove_addr_entry(struct mptcp_sock *msk,

                struct mptcp_pm_addr_entry *entry);

+struct mptcp_pm_ops *mptcp_pm_find(const char *name);

+int mptcp_pm_validate(struct mptcp_pm_ops *pm);

+int mptcp_pm_register(struct mptcp_pm_ops *pm);

+void mptcp_pm_unregister(struct mptcp_pm_ops *pm);

+

void mptcp_userspace_pm_free_local_addr_list(struct mptcp_sock *msk);

void mptcp_event(enum mptcp_event_type type, const struct mptcp_sock *msk,

A new net.mptcp.path_manager sysctl is added to determine which path

manager will be used by each newly-created MPTCP socket by setting the

name of it.

This sysctl makes the old one "pm_type" deprecated.

Documentation/networking/mptcp-sysctl.rst | 19 +++++++++

net/mptcp/ctrl.c | 50 +++++++++++++++++++++++

net/mptcp/protocol.h | 1 +

3 files changed, 70 insertions(+)

diff --git a/Documentation/networking/mptcp-sysctl.rst b/Documentation/networking/mptcp-sysctl.rst

--- a/Documentation/networking/mptcp-sysctl.rst

+++ b/Documentation/networking/mptcp-sysctl.rst

@@ -XXX,XX +XXX,XX @@ enabled - BOOLEAN

    Default: 1 (enabled)

+path_manager - STRING

+    Set the default path manager name to use for each new MPTCP

+    socket. In-kernel path management will control subflow

+    connections and address advertisements according to

+    per-namespace values configured over the MPTCP netlink

+    API. Userspace path management puts per-MPTCP-connection subflow

+    connection decisions and address advertisements under control of

+    a privileged userspace program, at the cost of more netlink

+    traffic to propagate all of the related events and commands.

+

+    This is a per-namespace sysctl.

+

+    * "kernel" - In-kernel path manager

+    * "userspace" - Userspace path manager

+

+    Default: "kernel"

+

pm_type - INTEGER

    Set the default path manager type to use for each new MPTCP

    socket. In-kernel path management will control subflow

@@ -XXX,XX +XXX,XX @@ pm_type - INTEGER

    This is a per-namespace sysctl.

+    Deprecated since v6.15, use path_manager instead.

+

    * 0 - In-kernel path manager

    * 1 - Userspace path manager

diff --git a/net/mptcp/ctrl.c b/net/mptcp/ctrl.c

index XXXXXXX..XXXXXXX 100644

--- a/net/mptcp/ctrl.c

+++ b/net/mptcp/ctrl.c

@@ -XXX,XX +XXX,XX @@ struct mptcp_pernet {

    u8 allow_join_initial_addr_port;

    u8 pm_type;

    char scheduler[MPTCP_SCHED_NAME_MAX];

+    char path_manager[MPTCP_PM_NAME_MAX];

};

static struct mptcp_pernet *mptcp_get_pernet(const struct net *net)

@@ -XXX,XX +XXX,XX @@ int mptcp_get_pm_type(const struct net *net)

    return mptcp_get_pernet(net)->pm_type;

+const char *mptcp_get_path_manager(const struct net *net)

+{

+    return mptcp_get_pernet(net)->path_manager;

+}

+

const char *mptcp_get_scheduler(const struct net *net)

    return mptcp_get_pernet(net)->scheduler;

@@ -XXX,XX +XXX,XX @@ static void mptcp_pernet_set_defaults(struct mptcp_pernet *pernet)

    pernet->stale_loss_cnt = 4;

    pernet->pm_type = MPTCP_PM_TYPE_KERNEL;

    strscpy(pernet->scheduler, "default", sizeof(pernet->scheduler));

+    strscpy(pernet->path_manager, "kernel", sizeof(pernet->path_manager));

}

#ifdef CONFIG_SYSCTL

@@ -XXX,XX +XXX,XX @@ static int proc_blackhole_detect_timeout(const struct ctl_table *table,

    return ret;

}

+static int mptcp_set_path_manager(char *path_manager, const char *name)

+{

+    struct mptcp_pm_ops *pm;

+    int ret = 0;

+    rcu_read_lock();

+    pm = mptcp_pm_find(name);

+    if (pm)

+        strscpy(path_manager, name, MPTCP_PM_NAME_MAX);

+    else

+        ret = -ENOENT;

+    rcu_read_unlock();

+

+    return ret;

+}

+

+static int proc_path_manager(const struct ctl_table *ctl, int write,

+             void *buffer, size_t *lenp, loff_t *ppos)

+{

+    char (*path_manager)[MPTCP_PM_NAME_MAX] = ctl->data;

+    char val[MPTCP_PM_NAME_MAX];

+    const struct ctl_table tbl = {

+        .data = val,

+        .maxlen = MPTCP_PM_NAME_MAX,

+    };

+    int ret;

+

+    strscpy(val, *path_manager, MPTCP_PM_NAME_MAX);

+

+    ret = proc_dostring(&tbl, write, buffer, lenp, ppos);

+    if (write && ret == 0)

+        ret = mptcp_set_path_manager(*path_manager, val);

+

+    return ret;

+}

+

static struct ctl_table mptcp_sysctl_table[] = {

    {

        .procname = "enabled",

@@ -XXX,XX +XXX,XX @@ static struct ctl_table mptcp_sysctl_table[] = {

        .mode = 0644,

        .proc_handler = proc_dou8vec_minmax,

    },

+    {

+        .procname = "path_manager",

+        .maxlen    = MPTCP_PM_NAME_MAX,

+        .mode = 0644,

+        .proc_handler = proc_path_manager,

+    },

};

static int mptcp_pernet_new_table(struct net *net, struct mptcp_pernet *pernet)

@@ -XXX,XX +XXX,XX @@ static int mptcp_pernet_new_table(struct net *net, struct mptcp_pernet *pernet)

    table[8].data = &pernet->close_timeout;

    table[9].data = &pernet->blackhole_timeout;

    table[10].data = &pernet->syn_retrans_before_tcp_fallback;

+    table[11].data = &pernet->path_manager;

    hdr = register_net_sysctl_sz(net, MPTCP_SYSCTL_PATH, table,

                 ARRAY_SIZE(mptcp_sysctl_table));

diff --git a/net/mptcp/protocol.h b/net/mptcp/protocol.h

index XXXXXXX..XXXXXXX 100644

--- a/net/mptcp/protocol.h

+++ b/net/mptcp/protocol.h

@@ -XXX,XX +XXX,XX @@ int mptcp_allow_join_id0(const struct net *net);

unsigned int mptcp_stale_loss_cnt(const struct net *net);

unsigned int mptcp_close_timeout(const struct sock *sk);

int mptcp_get_pm_type(const struct net *net);

+const char *mptcp_get_path_manager(const struct net *net);

const char *mptcp_get_scheduler(const struct net *net);

void mptcp_active_disable(struct sock *sk);

This patch adds a new proc_handler "proc_pm_type" for "pm_type" to

map old path manager sysctl "pm_type" to the newly added "path_manager".

net/mptcp/ctrl.c | 28 +++++++++++++++++++++++++++-

1 file changed, 27 insertions(+), 1 deletion(-)

diff --git a/net/mptcp/ctrl.c b/net/mptcp/ctrl.c

--- a/net/mptcp/ctrl.c

+++ b/net/mptcp/ctrl.c

@@ -XXX,XX +XXX,XX @@ static int proc_path_manager(const struct ctl_table *ctl, int write,

    return ret;

+static int proc_pm_type(const struct ctl_table *ctl, int write,

+            void *buffer, size_t *lenp, loff_t *ppos)

+{

+    struct mptcp_pernet *pernet = container_of(ctl->data,

+                         struct mptcp_pernet,

+                         pm_type);

+    u8 pm_type = READ_ONCE(*(u8 *)ctl->data);

+    const struct ctl_table tbl = {

+        .maxlen = sizeof(pm_type),

+        .data = &pm_type,

+    };

+    int ret;

+

+    ret = proc_dou8vec_minmax(&tbl, write, buffer, lenp, ppos);

+    if (write && ret == 0) {

+        char *path_manager = "kernel";

+

+        if (pm_type == MPTCP_PM_TYPE_USERSPACE)

+            path_manager = "userspace";

+        mptcp_set_path_manager(pernet->path_manager, path_manager);

+        WRITE_ONCE(*(u8 *)ctl->data, pm_type);

+    }

+

+    return ret;

+}

+

static struct ctl_table mptcp_sysctl_table[] = {

    {

        .procname = "enabled",

@@ -XXX,XX +XXX,XX @@ static struct ctl_table mptcp_sysctl_table[] = {

        .procname = "pm_type",

        .maxlen = sizeof(u8),

        .mode = 0644,

-        .proc_handler = proc_dou8vec_minmax,

+        .proc_handler = proc_pm_type,

        .extra1 = SYSCTL_ZERO,

        .extra2 = &mptcp_pm_type_max

    },

Similarly to net.mptcp.available_schedulers, this patch adds a new one

net.mptcp.available_path_managers to list the available path managers.

Documentation/networking/mptcp-sysctl.rst | 4 ++++

include/net/mptcp.h | 2 ++

net/mptcp/ctrl.c | 25 +++++++++++++++++++++++

net/mptcp/pm.c | 19 +++++++++++++++++

net/mptcp/protocol.h | 1 +

5 files changed, 51 insertions(+)

diff --git a/Documentation/networking/mptcp-sysctl.rst b/Documentation/networking/mptcp-sysctl.rst

--- a/Documentation/networking/mptcp-sysctl.rst

+++ b/Documentation/networking/mptcp-sysctl.rst

@@ -XXX,XX +XXX,XX @@ allow_join_initial_addr_port - BOOLEAN

    Default: 1

+available_path_managers - STRING

+    Shows the available path managers choices that are registered. More

+    path managers may be available, but not loaded.

+

available_schedulers - STRING

    Shows the available schedulers choices that are registered. More packet

    schedulers may be available, but not loaded.

diff --git a/include/net/mptcp.h b/include/net/mptcp.h

index XXXXXXX..XXXXXXX 100644

--- a/include/net/mptcp.h

+++ b/include/net/mptcp.h

@@ -XXX,XX +XXX,XX @@ struct mptcp_sched_ops {

} ____cacheline_aligned_in_smp;

#define MPTCP_PM_NAME_MAX    16

+#define MPTCP_PM_MAX        128

+#define MPTCP_PM_BUF_MAX    (MPTCP_PM_NAME_MAX * MPTCP_PM_MAX)

struct mptcp_pm_ops {

    char            name[MPTCP_PM_NAME_MAX];

diff --git a/net/mptcp/ctrl.c b/net/mptcp/ctrl.c

index XXXXXXX..XXXXXXX 100644

--- a/net/mptcp/ctrl.c

+++ b/net/mptcp/ctrl.c

@@ -XXX,XX +XXX,XX @@ static int proc_pm_type(const struct ctl_table *ctl, int write,

    return ret;

+static int proc_available_path_managers(const struct ctl_table *ctl,

+                    int write, void *buffer,

+                    size_t *lenp, loff_t *ppos)

+    struct ctl_table tbl = { .maxlen = MPTCP_PM_BUF_MAX, };

+    int ret;

+    tbl.data = kmalloc(tbl.maxlen, GFP_USER);

+    if (!tbl.data)

+        return -ENOMEM;

+    mptcp_pm_get_available(tbl.data, MPTCP_PM_BUF_MAX);

+    ret = proc_dostring(&tbl, write, buffer, lenp, ppos);

+    kfree(tbl.data);

+    return ret;

static struct ctl_table mptcp_sysctl_table[] = {

    {

        .procname = "enabled",

@@ -XXX,XX +XXX,XX @@ static struct ctl_table mptcp_sysctl_table[] = {

        .mode = 0644,

        .proc_handler = proc_path_manager,

    },

+    {

+        .procname = "available_path_managers",

+        .maxlen    = MPTCP_PM_BUF_MAX,

+        .mode = 0444,

+        .proc_handler = proc_available_path_managers,

+    },

static int mptcp_pernet_new_table(struct net *net, struct mptcp_pernet *pernet)

@@ -XXX,XX +XXX,XX @@ static int mptcp_pernet_new_table(struct net *net, struct mptcp_pernet *pernet)

    table[9].data = &pernet->blackhole_timeout;

    table[10].data = &pernet->syn_retrans_before_tcp_fallback;

    table[11].data = &pernet->path_manager;

+    /* table[12] is for available_path_managers which is read-only info */

    hdr = register_net_sysctl_sz(net, MPTCP_SYSCTL_PATH, table,

                 ARRAY_SIZE(mptcp_sysctl_table));

diff --git a/net/mptcp/pm.c b/net/mptcp/pm.c

index XXXXXXX..XXXXXXX 100644

--- a/net/mptcp/pm.c

+++ b/net/mptcp/pm.c

@@ -XXX,XX +XXX,XX @@ void mptcp_pm_unregister(struct mptcp_pm_ops *pm)

    list_del_rcu(&pm->list);

    spin_unlock(&mptcp_pm_list_lock);

}

+

+/* Build string with list of available path manager values.

+ * Similar to tcp_get_available_congestion_control()

+ */

+void mptcp_pm_get_available(char *buf, size_t maxlen)

+{

+    struct mptcp_pm_ops *pm;

+    size_t offs = 0;

+

+    rcu_read_lock();

+    list_for_each_entry_rcu(pm, &mptcp_pm_list, list) {

+        offs += snprintf(buf + offs, maxlen - offs, "%s%s",

+                 offs == 0 ? "" : " ", pm->name);

+

+        if (WARN_ON_ONCE(offs >= maxlen))

+            break;

+    }

+    rcu_read_unlock();

+}

diff --git a/net/mptcp/protocol.h b/net/mptcp/protocol.h

index XXXXXXX..XXXXXXX 100644

--- a/net/mptcp/protocol.h

+++ b/net/mptcp/protocol.h

@@ -XXX,XX +XXX,XX @@ struct mptcp_pm_ops *mptcp_pm_find(const char *name);

int mptcp_pm_validate(struct mptcp_pm_ops *pm);

int mptcp_pm_register(struct mptcp_pm_ops *pm);

void mptcp_pm_unregister(struct mptcp_pm_ops *pm);

+void mptcp_pm_get_available(char *buf, size_t maxlen);

void mptcp_userspace_pm_free_local_addr_list(struct mptcp_sock *msk);

This patch defines the original userspace path manager as a new

struct mptcp_pm_ops named "mptcp_userspace_pm", and register it

in mptcp_pm_init(). mptcp_userspace_pm_is_release() is a wrapper

of mptcp_userspace_pm_free_local_addr_list().

net/mptcp/pm.c | 1 +

net/mptcp/pm_userspace.c | 26 ++++++++++++++++++++++++++

net/mptcp/protocol.h | 1 +

3 files changed, 28 insertions(+)

@@ -XXX,XX +XXX,XX @@ int mptcp_userspace_pm_get_addr(u8 id, struct mptcp_pm_addr_entry *addr,

    sock_put(sk);

    return ret;

+

+static void mptcp_userspace_pm_init(struct mptcp_sock *msk)

+    struct mptcp_pm_data *pm = &msk->pm;

+    WRITE_ONCE(pm->work_pending, 0);

+    WRITE_ONCE(pm->accept_addr, 0);

+    WRITE_ONCE(pm->accept_subflow, 0);

+static void mptcp_userspace_pm_release(struct mptcp_sock *msk)

+{

+    mptcp_userspace_pm_free_local_addr_list(msk);

+}

+

+static struct mptcp_pm_ops mptcp_pm_userspace = {

+    .init            = mptcp_userspace_pm_init,

+    .release        = mptcp_userspace_pm_release,

+    .name            = "userspace",

+    .owner            = THIS_MODULE,

+};

+

+void __init mptcp_pm_userspace_register(void)

+{

+    mptcp_pm_register(&mptcp_pm_userspace);

+}

diff --git a/net/mptcp/protocol.h b/net/mptcp/protocol.h

index XXXXXXX..XXXXXXX 100644

--- a/net/mptcp/protocol.h

+++ b/net/mptcp/protocol.h

@@ -XXX,XX +XXX,XX @@ static inline u8 subflow_get_local_id(const struct mptcp_subflow_context *subflo

void __init mptcp_pm_kernel_register(void);

+void __init mptcp_pm_userspace_register(void);

void __init mptcp_pm_nl_init(void);

void mptcp_pm_worker(struct mptcp_sock *msk);

void __mptcp_pm_kernel_worker(struct mptcp_sock *msk);

Add a struct mptcp_pm_ops pointer "ops" in struct mptcp_pm_data, and two

functions mptcp_pm_initialize() and mptcp_pm_release(), to set and release

this pointer. mptcp_pm_initialize() is invoked in mptcp_pm_data_reset(),

while mptcp_pm_release() is invoked in mptcp_pm_destroy().

net/mptcp/pm.c | 57 +++++++++++++++++++++++++++-----------------

net/mptcp/protocol.h | 1 +

2 files changed, 36 insertions(+), 22 deletions(-)

diff --git a/net/mptcp/pm.c b/net/mptcp/pm.c

--- a/net/mptcp/pm.c

+++ b/net/mptcp/pm.c

@@ -XXX,XX +XXX,XX @@ void mptcp_pm_worker(struct mptcp_sock *msk)

+static void mptcp_pm_initialize(struct mptcp_sock *msk,

+                struct mptcp_pm_ops *pm)

+    if (!pm || !bpf_try_module_get(pm, pm->owner)) {

+        pr_warn_once("pm %s fails, fallback to default pm",

+             pm->name);

+        pm = &mptcp_pm_kernel;

+    msk->pm.ops = pm;

+    if (msk->pm.ops->init)

+        msk->pm.ops->init(msk);

+    pr_debug("pm %s initialized\n", pm->name);

+static void mptcp_pm_release(struct mptcp_sock *msk)

+{

+    struct mptcp_pm_ops *pm = msk->pm.ops;

+

+    if (!pm)

+        return;

+

+    msk->pm.ops = NULL;

+    if (pm->release)

+        pm->release(msk);

+

+    bpf_module_put(pm, pm->owner);

+}

+

void mptcp_pm_destroy(struct mptcp_sock *msk)

    mptcp_pm_free_anno_list(msk);

-

-    if (mptcp_pm_is_userspace(msk))

-        mptcp_userspace_pm_free_local_addr_list(msk);

+    mptcp_pm_release(msk);

}

void mptcp_pm_data_reset(struct mptcp_sock *msk)

{

+    const char *path_manager = mptcp_get_path_manager(sock_net((struct sock *)msk));

    u8 pm_type = mptcp_get_pm_type(sock_net((struct sock *)msk));

    struct mptcp_pm_data *pm = &msk->pm;

@@ -XXX,XX +XXX,XX @@ void mptcp_pm_data_reset(struct mptcp_sock *msk)

    pm->rm_list_rx.nr = 0;

    WRITE_ONCE(pm->pm_type, pm_type);

-    if (pm_type == MPTCP_PM_TYPE_KERNEL) {

-        bool subflows_allowed = !!mptcp_pm_get_subflows_max(msk);

-

-        /* pm->work_pending must be only be set to 'true' when

-         * pm->pm_type is set to MPTCP_PM_TYPE_KERNEL

-         */

-        WRITE_ONCE(pm->work_pending,

-             (!!mptcp_pm_get_local_addr_max(msk) &&

-             subflows_allowed) ||

-             !!mptcp_pm_get_add_addr_signal_max(msk));

-        WRITE_ONCE(pm->accept_addr,

-             !!mptcp_pm_get_add_addr_accept_max(msk) &&

-             subflows_allowed);

-        WRITE_ONCE(pm->accept_subflow, subflows_allowed);

-    } else {

-        WRITE_ONCE(pm->work_pending, 0);

-        WRITE_ONCE(pm->accept_addr, 0);

-        WRITE_ONCE(pm->accept_subflow, 0);

+    rcu_read_lock();

+    mptcp_pm_initialize(msk, mptcp_pm_find(path_manager));

+    rcu_read_unlock();

    WRITE_ONCE(pm->addr_signal, 0);

    WRITE_ONCE(pm->remote_deny_join_id0, false);

diff --git a/net/mptcp/protocol.h b/net/mptcp/protocol.h

index XXXXXXX..XXXXXXX 100644

--- a/net/mptcp/protocol.h

+++ b/net/mptcp/protocol.h

@@ -XXX,XX +XXX,XX @@ struct mptcp_pm_data {

    struct mptcp_addr_info remote;

    struct list_head anno_list;

    struct list_head userspace_pm_local_addr_list;

+    struct mptcp_pm_ops *ops;

    spinlock_t    lock;        /*protects the whole PM data */

Now mptcp_pm_get_local_id() can directly invoke get_local_id() interface

through "ops" of "msk->pm". Instead of using mptcp_pm_is_userspace() to

check which get_local_id() helper to invoke.

Then mptcp_pm_nl_get_local_id() and mptcp_userspace_pm_get_local_id()

helpers can be static.

include/net/mptcp.h | 3 +++

net/mptcp/pm.c | 6 ++----

net/mptcp/pm_kernel.c | 5 +++--

net/mptcp/pm_userspace.c | 5 +++--

net/mptcp/protocol.h | 4 ----

5 files changed, 11 insertions(+), 12 deletions(-)

@@ -XXX,XX +XXX,XX @@ mptcp_userspace_pm_lookup_addr_by_id(struct mptcp_sock *msk, unsigned int id)

-int mptcp_userspace_pm_get_local_id(struct mptcp_sock *msk,

-                 struct mptcp_pm_addr_entry *skc)

+static int mptcp_userspace_pm_get_local_id(struct mptcp_sock *msk,

+                     struct mptcp_pm_addr_entry *skc)

    __be16 msk_sport = ((struct inet_sock *)

             inet_sk((struct sock *)msk))->inet_sport;

@@ -XXX,XX +XXX,XX @@ static void mptcp_userspace_pm_release(struct mptcp_sock *msk)

}

static struct mptcp_pm_ops mptcp_pm_userspace = {

+    .get_local_id        = mptcp_userspace_pm_get_local_id,

    .init            = mptcp_userspace_pm_init,

    .release        = mptcp_userspace_pm_release,

    .name            = "userspace",

diff --git a/net/mptcp/protocol.h b/net/mptcp/protocol.h

index XXXXXXX..XXXXXXX 100644

--- a/net/mptcp/protocol.h

+++ b/net/mptcp/protocol.h

@@ -XXX,XX +XXX,XX @@ bool mptcp_pm_add_addr_signal(struct mptcp_sock *msk, const struct sk_buff *skb,

bool mptcp_pm_rm_addr_signal(struct mptcp_sock *msk, unsigned int remaining,

             struct mptcp_rm_list *rm_list);

int mptcp_pm_get_local_id(struct mptcp_sock *msk, struct sock_common *skc);

-int mptcp_pm_nl_get_local_id(struct mptcp_sock *msk,

-             struct mptcp_pm_addr_entry *skc);

-int mptcp_userspace_pm_get_local_id(struct mptcp_sock *msk,

-                 struct mptcp_pm_addr_entry *skc);

bool mptcp_pm_is_backup(struct mptcp_sock *msk, struct sock_common *skc);

bool mptcp_pm_nl_is_backup(struct mptcp_sock *msk, struct mptcp_addr_info *skc);

bool mptcp_userspace_pm_is_backup(struct mptcp_sock *msk, struct mptcp_addr_info *skc);

Now mptcp_pm_is_backup() can directly invoke get_priority() interface

through "ops" of "msk->pm". Instead of using mptcp_pm_is_userspace()