💐 Sync 2026-09-10 14:49:21

luci-app-mptcp/docs/mptcp-guide.md

@@ -31,7 +31,7 @@ options; older kernels (<6) show a different, longer set of legacy fields
 |---|---|
 | **Multipath TCP** | Read-only indicator of whether MPTCP is enabled network-wide. |
 | **Multipath TCP checksum** | Enables MPTCP-level checksums (extra integrity check, minor overhead). |
-| **Multipath TCP path-manager** | `default` or `fullmesh` (OMR's normal choice — creates subflows between every local/remote address pair). |
+| **Multipath TCP path-manager** | Populated live from `/proc/sys/net/mptcp/available_path_managers`: `kernel` (OMR's normal choice — the in-kernel netlink path manager, which creates the subflows itself) or `userspace` (delegates that to `mptcpd`), plus any BPF path manager the kernel registers. On a kernel that advertises no list, the out-of-tree v0.9x names (`default`/`fullmesh`, and on kernels <6 also `ndiffports`/`binder`/`netlink`) are offered instead. This value is also what gets pushed to the VPS. |
 | **Multipath TCP scheduler** | Which subflow the kernel picks to send data on. `default`, or a BPF scheduler (`bpf_burst`, `bpf_red`, `bpf_first`, `bpf_rr`, plus any custom `.o` dropped into `/usr/share/bpf/scheduler` — auto-discovered and listed here). On kernels <6, classic in-tree schedulers (round-robin, redundant, BLEST, ECF) are offered instead. |
 | **Congestion Control** | Populated live from `sysctl net.ipv4.tcp_available_congestion_control` — pick any congestion control algorithm your kernel has compiled in. Default is `cubic`; this bench uses `bbr`. |
 | **Path Manager type** *(kernel ≥6 only)* | In-kernel (simpler, default) vs. userspace (delegates subflow decisions to `mptcpd`). |

luci-app-mptcp/htdocs/luci-static/resources/view/mptcp/mptcp.js

@@ -20,13 +20,22 @@ var callSystemBoard = rpc.declare({
 return L.view.extend({
     load: function() {
 	return Promise.all([
-	    L.resolveDefault(callSystemBoard(), {})
+	    L.resolveDefault(callSystemBoard(), {}),
+	    L.resolveDefault(fs.read('/proc/sys/net/mptcp/available_path_managers'), '')
 	]);
     },
 
     render: function(res) {
 	var m, s, o;
 	var boardinfo = res[0];
+	// Mainline MPTCP registers its path managers by name and advertises the
+	// list here ('kernel userspace', plus any BPF path manager). A kernel
+	// that advertises nothing is either the out-of-tree v0.9x stack or a 6.x
+	// one predating net.mptcp.path_manager: there the legacy vocabulary below
+	// is all we have to go on.
+	var availablePathManagers = String(res[1] || '').trim().split(/\s+/).filter(function(name) {
+		return name.length > 0;
+	});
 
 	function normalizeSchedulerValue(value) {
 		if (value == null)
@@ -43,6 +52,27 @@ return L.view.extend({
 		return normalized;
 	}
 
+	// Every out-of-tree v0.9x path manager (default/fullmesh/ndiffports/
+	// binder/netlink) is an in-kernel one, so on a kernel that registers its
+	// path managers by name they all mean the same thing: 'kernel'. A config
+	// upgraded from that stack, or restored from such a backup, still carries
+	// one of those names, which is not in the list and would leave the
+	// dropdown showing nothing.
+	function normalizePathManagerValue(value) {
+		if (value == null)
+			return value;
+
+		var normalized = String(value).trim();
+
+		if (normalized === '' || availablePathManagers.indexOf(normalized) >= 0)
+			return normalized;
+
+		if (availablePathManagers.indexOf('kernel') >= 0)
+			return 'kernel';
+
+		return normalized;
+	}
+
 	m = new form.Map('network', _('MPTCP'),_('Networks MPTCP settings.'));
 
 	s = m.section(form.TypedSection, 'globals');
@@ -62,14 +92,28 @@ return L.view.extend({
 		o.value(0, _("disable"));
 	}
 
-	o = s.option(form.ListValue, "mptcp_path_manager", _("Multipath TCP path-manager"), _("Default is fullmesh"));
-	o.value("default", _("default"));
-	o.value("fullmesh", "fullmesh");
+	if (availablePathManagers.length > 0) {
+		o = s.option(form.ListValue, "mptcp_path_manager", _("Multipath TCP path-manager"),
+			_("Path managers registered by the running kernel. 'kernel' is the in-kernel one, which creates the extra subflows itself; 'userspace' hands that over to mptcpd."));
+		availablePathManagers.forEach(function(name) {
+			o.value(name, name);
+		});
+		o.cfgvalue = function(section_id) {
+			return normalizePathManagerValue(uci.get('network', section_id, 'mptcp_path_manager'));
+		};
+		o.write = function(section_id, value) {
+			uci.set('network', section_id, 'mptcp_path_manager', normalizePathManagerValue(value));
+		};
+	} else {
+		o = s.option(form.ListValue, "mptcp_path_manager", _("Multipath TCP path-manager"), _("Default is fullmesh"));
+		o.value("default", _("default"));
+		o.value("fullmesh", "fullmesh");
 
-	if (parseFloat(boardinfo.kernel.substring(0,4)) < 6) {
-		o.value("ndiffports", "ndiffports");
-		o.value("binder", "binder");
-		o.value("netlink", _("Netlink"));
+		if (parseFloat(boardinfo.kernel.substring(0,4)) < 6) {
+			o.value("ndiffports", "ndiffports");
+			o.value("binder", "binder");
+			o.value("netlink", _("Netlink"));
+		}
 	}
 
 	var scheduler = s.option(form.ListValue, "mptcp_scheduler", _("Multipath TCP scheduler"), _('BPF schedulers (not available on all platforms):') + '<br />' +

luci-app-mptcp/root/usr/share/rpcd/acl.d/luci-app-mptcp.json

@@ -6,10 +6,11 @@
 	    "file": {
 		"/usr/lib/mptcpd": [ "list" ],
 		"/usr/share/bpf/scheduler": [ "list" ],
+		"/proc/sys/net/mptcp/available_path_managers": [ "read" ],
 		"/sbin/sysctl -n net.ipv4.tcp_available_congestion_control": [ "exec" ]
 	    },
 	    "ubus": {
-		"file": [ "list", "exec" ],
+		"file": [ "read", "list", "exec" ],
 		"system": [ "board" ],
 		"network.interface": [ "dump" ],
 		"luci.mptcp": [