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