pm_netlink.c

  1// SPDX-License-Identifier: GPL-2.0
  2/* Multipath TCP
  3 *
  4 * Copyright (c) 2020, Red Hat, Inc.
  5 */
  6
  7#define pr_fmt(fmt) "MPTCP: " fmt
  8
  9#include "protocol.h"
 10#include "mptcp_pm_gen.h"
 11
 12#define MPTCP_PM_CMD_GRP_OFFSET       0
 13#define MPTCP_PM_EV_GRP_OFFSET        1
 14
 15static const struct genl_multicast_group mptcp_pm_mcgrps[] = {
 16	[MPTCP_PM_CMD_GRP_OFFSET]	= { .name = MPTCP_PM_CMD_GRP_NAME, },
 17	[MPTCP_PM_EV_GRP_OFFSET]        = { .name = MPTCP_PM_EV_GRP_NAME,
 18					    .flags = GENL_MCAST_CAP_NET_ADMIN,
 19					  },
 20};
 21
 22static int mptcp_pm_family_to_addr(int family)
 23{
 24#if IS_ENABLED(CONFIG_MPTCP_IPV6)
 25	if (family == AF_INET6)
 26		return MPTCP_PM_ADDR_ATTR_ADDR6;
 27#endif
 28	return MPTCP_PM_ADDR_ATTR_ADDR4;
 29}
 30
 31static int mptcp_pm_parse_pm_addr_attr(struct nlattr *tb[],
 32				       const struct nlattr *attr,
 33				       struct genl_info *info,
 34				       struct mptcp_addr_info *addr,
 35				       bool require_family)
 36{
 37	int err, addr_addr;
 38
 39	if (!attr) {
 40		GENL_SET_ERR_MSG(info, "missing address info");
 41		return -EINVAL;
 42	}
 43
 44	/* no validation needed - was already done via nested policy */
 45	err = nla_parse_nested_deprecated(tb, MPTCP_PM_ADDR_ATTR_MAX, attr,
 46					  mptcp_pm_address_nl_policy, info->extack);
 47	if (err)
 48		return err;
 49
 50	if (tb[MPTCP_PM_ADDR_ATTR_ID])
 51		addr->id = nla_get_u8(tb[MPTCP_PM_ADDR_ATTR_ID]);
 52
 53	if (!tb[MPTCP_PM_ADDR_ATTR_FAMILY]) {
 54		if (!require_family)
 55			return 0;
 56
 57		NL_SET_ERR_MSG_ATTR(info->extack, attr,
 58				    "missing family");
 59		return -EINVAL;
 60	}
 61
 62	addr->family = nla_get_u16(tb[MPTCP_PM_ADDR_ATTR_FAMILY]);
 63	if (addr->family != AF_INET
 64#if IS_ENABLED(CONFIG_MPTCP_IPV6)
 65	    && addr->family != AF_INET6
 66#endif
 67	    ) {
 68		NL_SET_ERR_MSG_ATTR(info->extack, attr,
 69				    "unknown address family");
 70		return -EINVAL;
 71	}
 72	addr_addr = mptcp_pm_family_to_addr(addr->family);
 73	if (!tb[addr_addr]) {
 74		NL_SET_ERR_MSG_ATTR(info->extack, attr,
 75				    "missing address data");
 76		return -EINVAL;
 77	}
 78
 79#if IS_ENABLED(CONFIG_MPTCP_IPV6)
 80	if (addr->family == AF_INET6)
 81		addr->addr6 = nla_get_in6_addr(tb[addr_addr]);
 82	else
 83#endif
 84		addr->addr.s_addr = nla_get_in_addr(tb[addr_addr]);
 85
 86	if (tb[MPTCP_PM_ADDR_ATTR_PORT])
 87		addr->port = htons(nla_get_u16(tb[MPTCP_PM_ADDR_ATTR_PORT]));
 88
 89	return 0;
 90}
 91
 92int mptcp_pm_parse_addr(struct nlattr *attr, struct genl_info *info,
 93			struct mptcp_addr_info *addr)
 94{
 95	struct nlattr *tb[MPTCP_PM_ADDR_ATTR_MAX + 1];
 96
 97	memset(addr, 0, sizeof(*addr));
 98
 99	return mptcp_pm_parse_pm_addr_attr(tb, attr, info, addr, true);
100}
101
102int mptcp_pm_parse_entry(struct nlattr *attr, struct genl_info *info,
103			 bool require_family,
104			 struct mptcp_pm_addr_entry *entry)
105{
106	struct nlattr *tb[MPTCP_PM_ADDR_ATTR_MAX + 1];
107	int err;
108
109	memset(entry, 0, sizeof(*entry));
110
111	err = mptcp_pm_parse_pm_addr_attr(tb, attr, info, &entry->addr, require_family);
112	if (err)
113		return err;
114
115	if (tb[MPTCP_PM_ADDR_ATTR_IF_IDX]) {
116		s32 val = nla_get_s32(tb[MPTCP_PM_ADDR_ATTR_IF_IDX]);
117
118		entry->ifindex = val;
119	}
120
121	if (tb[MPTCP_PM_ADDR_ATTR_FLAGS])
122		entry->flags = nla_get_u32(tb[MPTCP_PM_ADDR_ATTR_FLAGS]) &
123			       MPTCP_PM_ADDR_FLAGS_MASK;
124
125	if (tb[MPTCP_PM_ADDR_ATTR_PORT])
126		entry->addr.port = htons(nla_get_u16(tb[MPTCP_PM_ADDR_ATTR_PORT]));
127
128	return 0;
129}
130
131static int mptcp_nl_fill_addr(struct sk_buff *skb,
132			      struct mptcp_pm_addr_entry *entry)
133{
134	struct mptcp_addr_info *addr = &entry->addr;
135	struct nlattr *attr;
136
137	attr = nla_nest_start(skb, MPTCP_PM_ATTR_ADDR);
138	if (!attr)
139		return -EMSGSIZE;
140
141	if (nla_put_u16(skb, MPTCP_PM_ADDR_ATTR_FAMILY, addr->family))
142		goto nla_put_failure;
143	if (nla_put_u16(skb, MPTCP_PM_ADDR_ATTR_PORT, ntohs(addr->port)))
144		goto nla_put_failure;
145	if (nla_put_u8(skb, MPTCP_PM_ADDR_ATTR_ID, addr->id))
146		goto nla_put_failure;
147	if (nla_put_u32(skb, MPTCP_PM_ADDR_ATTR_FLAGS, entry->flags))
148		goto nla_put_failure;
149	if (entry->ifindex &&
150	    nla_put_s32(skb, MPTCP_PM_ADDR_ATTR_IF_IDX, entry->ifindex))
151		goto nla_put_failure;
152
153	if (addr->family == AF_INET &&
154	    nla_put_in_addr(skb, MPTCP_PM_ADDR_ATTR_ADDR4,
155			    addr->addr.s_addr))
156		goto nla_put_failure;
157#if IS_ENABLED(CONFIG_MPTCP_IPV6)
158	else if (addr->family == AF_INET6 &&
159		 nla_put_in6_addr(skb, MPTCP_PM_ADDR_ATTR_ADDR6, &addr->addr6))
160		goto nla_put_failure;
161#endif
162	nla_nest_end(skb, attr);
163	return 0;
164
165nla_put_failure:
166	nla_nest_cancel(skb, attr);
167	return -EMSGSIZE;
168}
169
170static int mptcp_pm_get_addr(u8 id, struct mptcp_pm_addr_entry *addr,
171			     struct genl_info *info)
172{
173	if (info->attrs[MPTCP_PM_ATTR_TOKEN])
174		return mptcp_userspace_pm_get_addr(id, addr, info);
175	return mptcp_pm_nl_get_addr(id, addr, info);
176}
177
178int mptcp_pm_nl_get_addr_doit(struct sk_buff *skb, struct genl_info *info)
179{
180	struct mptcp_pm_addr_entry addr;
181	struct nlattr *attr;
182	struct sk_buff *msg;
183	void *reply;
184	int ret;
185
186	if (GENL_REQ_ATTR_CHECK(info, MPTCP_PM_ENDPOINT_ADDR))
187		return -EINVAL;
188
189	attr = info->attrs[MPTCP_PM_ENDPOINT_ADDR];
190	ret = mptcp_pm_parse_entry(attr, info, false, &addr);
191	if (ret < 0)
192		return ret;
193
194	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
195	if (!msg)
196		return -ENOMEM;
197
198	reply = genlmsg_put_reply(msg, info, &mptcp_genl_family, 0,
199				  info->genlhdr->cmd);
200	if (!reply) {
201		GENL_SET_ERR_MSG(info, "not enough space in Netlink message");
202		ret = -EMSGSIZE;
203		goto fail;
204	}
205
206	ret = mptcp_pm_get_addr(addr.addr.id, &addr, info);
207	if (ret) {
208		NL_SET_ERR_MSG_ATTR(info->extack, attr, "address not found");
209		goto fail;
210	}
211
212	ret = mptcp_nl_fill_addr(msg, &addr);
213	if (ret)
214		goto fail;
215
216	genlmsg_end(msg, reply);
217	ret = genlmsg_reply(msg, info);
218	return ret;
219
220fail:
221	nlmsg_free(msg);
222	return ret;
223}
224
225int mptcp_pm_genl_fill_addr(struct sk_buff *msg,
226			    struct netlink_callback *cb,
227			    struct mptcp_pm_addr_entry *entry)
228{
229	void *hdr;
230
231	hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).portid,
232			  cb->nlh->nlmsg_seq, &mptcp_genl_family,
233			  NLM_F_MULTI, MPTCP_PM_CMD_GET_ADDR);
234	if (!hdr)
235		return -EINVAL;
236
237	if (mptcp_nl_fill_addr(msg, entry) < 0) {
238		genlmsg_cancel(msg, hdr);
239		return -EINVAL;
240	}
241
242	genlmsg_end(msg, hdr);
243	return 0;
244}
245
246static int mptcp_pm_dump_addr(struct sk_buff *msg, struct netlink_callback *cb)
247{
248	const struct genl_info *info = genl_info_dump(cb);
249
250	if (info->attrs[MPTCP_PM_ATTR_TOKEN])
251		return mptcp_userspace_pm_dump_addr(msg, cb);
252	return mptcp_pm_nl_dump_addr(msg, cb);
253}
254
255int mptcp_pm_nl_get_addr_dumpit(struct sk_buff *msg,
256				struct netlink_callback *cb)
257{
258	return mptcp_pm_dump_addr(msg, cb);
259}
260
261static int mptcp_pm_set_flags(struct genl_info *info)
262{
263	struct mptcp_pm_addr_entry loc = { .addr = { .family = AF_UNSPEC }, };
264	struct nlattr *attr_loc;
265	int ret = -EINVAL;
266
267	if (GENL_REQ_ATTR_CHECK(info, MPTCP_PM_ATTR_ADDR))
268		return ret;
269
270	attr_loc = info->attrs[MPTCP_PM_ATTR_ADDR];
271	ret = mptcp_pm_parse_entry(attr_loc, info, false, &loc);
272	if (ret < 0)
273		return ret;
274
275	if (info->attrs[MPTCP_PM_ATTR_TOKEN])
276		return mptcp_userspace_pm_set_flags(&loc, info);
277	return mptcp_pm_nl_set_flags(&loc, info);
278}
279
280int mptcp_pm_nl_set_flags_doit(struct sk_buff *skb, struct genl_info *info)
281{
282	return mptcp_pm_set_flags(info);
283}
284
285static void mptcp_nl_mcast_send(struct net *net, struct sk_buff *nlskb, gfp_t gfp)
286{
287	genlmsg_multicast_netns(&mptcp_genl_family, net,
288				nlskb, 0, MPTCP_PM_EV_GRP_OFFSET, gfp);
289}
290
291bool mptcp_userspace_pm_active(const struct mptcp_sock *msk)
292{
293	return genl_has_listeners(&mptcp_genl_family,
294				  sock_net((const struct sock *)msk),
295				  MPTCP_PM_EV_GRP_OFFSET);
296}
297
298static int mptcp_event_add_subflow(struct sk_buff *skb, const struct sock *ssk)
299{
300	const struct inet_sock *issk = inet_sk(ssk);
301	const struct mptcp_subflow_context *sf;
302
303	if (nla_put_u16(skb, MPTCP_ATTR_FAMILY, ssk->sk_family))
304		return -EMSGSIZE;
305
306	switch (ssk->sk_family) {
307	case AF_INET:
308		if (nla_put_in_addr(skb, MPTCP_ATTR_SADDR4, issk->inet_saddr))
309			return -EMSGSIZE;
310		if (nla_put_in_addr(skb, MPTCP_ATTR_DADDR4, issk->inet_daddr))
311			return -EMSGSIZE;
312		break;
313#if IS_ENABLED(CONFIG_MPTCP_IPV6)
314	case AF_INET6: {
315		if (nla_put_in6_addr(skb, MPTCP_ATTR_SADDR6, &issk->pinet6->saddr))
316			return -EMSGSIZE;
317		if (nla_put_in6_addr(skb, MPTCP_ATTR_DADDR6, &ssk->sk_v6_daddr))
318			return -EMSGSIZE;
319		break;
320	}
321#endif
322	default:
323		WARN_ON_ONCE(1);
324		return -EMSGSIZE;
325	}
326
327	if (nla_put_be16(skb, MPTCP_ATTR_SPORT, issk->inet_sport))
328		return -EMSGSIZE;
329	if (nla_put_be16(skb, MPTCP_ATTR_DPORT, issk->inet_dport))
330		return -EMSGSIZE;
331
332	sf = mptcp_subflow_ctx(ssk);
333	if (WARN_ON_ONCE(!sf))
334		return -EINVAL;
335
336	if (nla_put_u8(skb, MPTCP_ATTR_LOC_ID, subflow_get_local_id(sf)))
337		return -EMSGSIZE;
338
339	if (nla_put_u8(skb, MPTCP_ATTR_REM_ID, sf->remote_id))
340		return -EMSGSIZE;
341
342	return 0;
343}
344
345static int mptcp_event_put_token_and_ssk(struct sk_buff *skb,
346					 const struct mptcp_sock *msk,
347					 const struct sock *ssk)
348{
349	const struct sock *sk = (const struct sock *)msk;
350	const struct mptcp_subflow_context *sf;
351	u8 sk_err;
352
353	if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, READ_ONCE(msk->token)))
354		return -EMSGSIZE;
355
356	if (mptcp_event_add_subflow(skb, ssk))
357		return -EMSGSIZE;
358
359	sf = mptcp_subflow_ctx(ssk);
360	if (WARN_ON_ONCE(!sf))
361		return -EINVAL;
362
363	if (nla_put_u8(skb, MPTCP_ATTR_BACKUP, sf->backup))
364		return -EMSGSIZE;
365
366	if (ssk->sk_bound_dev_if &&
367	    nla_put_s32(skb, MPTCP_ATTR_IF_IDX, ssk->sk_bound_dev_if))
368		return -EMSGSIZE;
369
370	sk_err = READ_ONCE(ssk->sk_err);
371	if (sk_err && sk->sk_state == TCP_ESTABLISHED &&
372	    nla_put_u8(skb, MPTCP_ATTR_ERROR, sk_err))
373		return -EMSGSIZE;
374
375	return 0;
376}
377
378static int mptcp_event_sub_established(struct sk_buff *skb,
379				       const struct mptcp_sock *msk,
380				       const struct sock *ssk)
381{
382	return mptcp_event_put_token_and_ssk(skb, msk, ssk);
383}
384
385static int mptcp_event_sub_closed(struct sk_buff *skb,
386				  const struct mptcp_sock *msk,
387				  const struct sock *ssk)
388{
389	const struct mptcp_subflow_context *sf;
390
391	if (mptcp_event_put_token_and_ssk(skb, msk, ssk))
392		return -EMSGSIZE;
393
394	sf = mptcp_subflow_ctx(ssk);
395	if (!sf->reset_seen)
396		return 0;
397
398	if (nla_put_u32(skb, MPTCP_ATTR_RESET_REASON, sf->reset_reason))
399		return -EMSGSIZE;
400
401	if (nla_put_u32(skb, MPTCP_ATTR_RESET_FLAGS, sf->reset_transient))
402		return -EMSGSIZE;
403
404	return 0;
405}
406
407static int mptcp_event_created(struct sk_buff *skb,
408			       const struct mptcp_sock *msk,
409			       const struct sock *ssk)
410{
411	int err = nla_put_u32(skb, MPTCP_ATTR_TOKEN, READ_ONCE(msk->token));
412	u16 flags = 0;
413
414	if (err)
415		return err;
416
417	if (READ_ONCE(msk->pm.server_side)) {
418		flags |= MPTCP_PM_EV_FLAG_SERVER_SIDE;
419
420		/* Deprecated, and only set when it is the server side */
421		if (nla_put_u8(skb, MPTCP_ATTR_SERVER_SIDE, 1))
422			return -EMSGSIZE;
423	}
424
425	if (READ_ONCE(msk->pm.remote_deny_join_id0))
426		flags |= MPTCP_PM_EV_FLAG_DENY_JOIN_ID0;
427
428	if (flags && nla_put_u16(skb, MPTCP_ATTR_FLAGS, flags))
429		return -EMSGSIZE;
430
431	return mptcp_event_add_subflow(skb, ssk);
432}
433
434void mptcp_event_addr_removed(const struct mptcp_sock *msk, uint8_t id)
435{
436	struct net *net = sock_net((const struct sock *)msk);
437	struct nlmsghdr *nlh;
438	struct sk_buff *skb;
439
440	if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET))
441		return;
442
443	skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
444	if (!skb)
445		return;
446
447	nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0, MPTCP_EVENT_REMOVED);
448	if (!nlh)
449		goto nla_put_failure;
450
451	if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, READ_ONCE(msk->token)))
452		goto nla_put_failure;
453
454	if (nla_put_u8(skb, MPTCP_ATTR_REM_ID, id))
455		goto nla_put_failure;
456
457	genlmsg_end(skb, nlh);
458	mptcp_nl_mcast_send(net, skb, GFP_ATOMIC);
459	return;
460
461nla_put_failure:
462	nlmsg_free(skb);
463}
464
465void mptcp_event_addr_announced(const struct sock *ssk,
466				const struct mptcp_addr_info *info)
467{
468	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
469	struct mptcp_sock *msk = mptcp_sk(subflow->conn);
470	struct net *net = sock_net(ssk);
471	struct nlmsghdr *nlh;
472	struct sk_buff *skb;
473
474	if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET))
475		return;
476
477	skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
478	if (!skb)
479		return;
480
481	nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0,
482			  MPTCP_EVENT_ANNOUNCED);
483	if (!nlh)
484		goto nla_put_failure;
485
486	if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, READ_ONCE(msk->token)))
487		goto nla_put_failure;
488
489	if (nla_put_u8(skb, MPTCP_ATTR_REM_ID, info->id))
490		goto nla_put_failure;
491
492	if (nla_put_be16(skb, MPTCP_ATTR_DPORT,
493			 info->port == 0 ?
494			 inet_sk(ssk)->inet_dport :
495			 info->port))
496		goto nla_put_failure;
497
498	switch (info->family) {
499	case AF_INET:
500		if (nla_put_in_addr(skb, MPTCP_ATTR_DADDR4, info->addr.s_addr))
501			goto nla_put_failure;
502		break;
503#if IS_ENABLED(CONFIG_MPTCP_IPV6)
504	case AF_INET6:
505		if (nla_put_in6_addr(skb, MPTCP_ATTR_DADDR6, &info->addr6))
506			goto nla_put_failure;
507		break;
508#endif
509	default:
510		WARN_ON_ONCE(1);
511		goto nla_put_failure;
512	}
513
514	genlmsg_end(skb, nlh);
515	mptcp_nl_mcast_send(net, skb, GFP_ATOMIC);
516	return;
517
518nla_put_failure:
519	nlmsg_free(skb);
520}
521
522void mptcp_event_pm_listener(const struct sock *ssk,
523			     enum mptcp_event_type event)
524{
525	const struct inet_sock *issk = inet_sk(ssk);
526	struct net *net = sock_net(ssk);
527	struct nlmsghdr *nlh;
528	struct sk_buff *skb;
529
530	if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET))
531		return;
532
533	skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
534	if (!skb)
535		return;
536
537	nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0, event);
538	if (!nlh)
539		goto nla_put_failure;
540
541	if (nla_put_u16(skb, MPTCP_ATTR_FAMILY, ssk->sk_family))
542		goto nla_put_failure;
543
544	if (nla_put_be16(skb, MPTCP_ATTR_SPORT, issk->inet_sport))
545		goto nla_put_failure;
546
547	switch (ssk->sk_family) {
548	case AF_INET:
549		if (nla_put_in_addr(skb, MPTCP_ATTR_SADDR4, issk->inet_saddr))
550			goto nla_put_failure;
551		break;
552#if IS_ENABLED(CONFIG_MPTCP_IPV6)
553	case AF_INET6: {
554		if (nla_put_in6_addr(skb, MPTCP_ATTR_SADDR6, &issk->pinet6->saddr))
555			goto nla_put_failure;
556		break;
557	}
558#endif
559	default:
560		WARN_ON_ONCE(1);
561		goto nla_put_failure;
562	}
563
564	genlmsg_end(skb, nlh);
565	mptcp_nl_mcast_send(net, skb, GFP_KERNEL);
566	return;
567
568nla_put_failure:
569	nlmsg_free(skb);
570}
571
572void mptcp_event(enum mptcp_event_type type, const struct mptcp_sock *msk,
573		 const struct sock *ssk, gfp_t gfp)
574{
575	struct net *net = sock_net((const struct sock *)msk);
576	struct nlmsghdr *nlh;
577	struct sk_buff *skb;
578
579	if (!genl_has_listeners(&mptcp_genl_family, net, MPTCP_PM_EV_GRP_OFFSET))
580		return;
581
582	skb = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
583	if (!skb)
584		return;
585
586	nlh = genlmsg_put(skb, 0, 0, &mptcp_genl_family, 0, type);
587	if (!nlh)
588		goto nla_put_failure;
589
590	switch (type) {
591	case MPTCP_EVENT_UNSPEC:
592		WARN_ON_ONCE(1);
593		break;
594	case MPTCP_EVENT_CREATED:
595	case MPTCP_EVENT_ESTABLISHED:
596		if (mptcp_event_created(skb, msk, ssk) < 0)
597			goto nla_put_failure;
598		break;
599	case MPTCP_EVENT_CLOSED:
600		if (nla_put_u32(skb, MPTCP_ATTR_TOKEN, READ_ONCE(msk->token)) < 0)
601			goto nla_put_failure;
602		break;
603	case MPTCP_EVENT_ANNOUNCED:
604	case MPTCP_EVENT_REMOVED:
605		/* call mptcp_event_addr_announced()/removed instead */
606		WARN_ON_ONCE(1);
607		break;
608	case MPTCP_EVENT_SUB_ESTABLISHED:
609	case MPTCP_EVENT_SUB_PRIORITY:
610		if (mptcp_event_sub_established(skb, msk, ssk) < 0)
611			goto nla_put_failure;
612		break;
613	case MPTCP_EVENT_SUB_CLOSED:
614		if (mptcp_event_sub_closed(skb, msk, ssk) < 0)
615			goto nla_put_failure;
616		break;
617	case MPTCP_EVENT_LISTENER_CREATED:
618	case MPTCP_EVENT_LISTENER_CLOSED:
619		break;
620	}
621
622	genlmsg_end(skb, nlh);
623	mptcp_nl_mcast_send(net, skb, gfp);
624	return;
625
626nla_put_failure:
627	nlmsg_free(skb);
628}
629
630struct genl_family mptcp_genl_family __ro_after_init = {
631	.name		= MPTCP_PM_NAME,
632	.version	= MPTCP_PM_VER,
633	.netnsok	= true,
634	.module		= THIS_MODULE,
635	.ops		= mptcp_pm_nl_ops,
636	.n_ops		= ARRAY_SIZE(mptcp_pm_nl_ops),
637	.resv_start_op	= MPTCP_PM_CMD_SUBFLOW_DESTROY + 1,
638	.mcgrps		= mptcp_pm_mcgrps,
639	.n_mcgrps	= ARRAY_SIZE(mptcp_pm_mcgrps),
640};
641
642void __init mptcp_pm_nl_init(void)
643{
644	if (genl_register_family(&mptcp_genl_family))
645		panic("Failed to register MPTCP PM netlink family\n");
646}