1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * NETLINK Generic Netlink Family 4 * 5 * Authors: Jamal Hadi Salim 6 * Thomas Graf <tgraf@suug.ch> 7 * Johannes Berg <johannes@sipsolutions.net> 8 */ 9 10 #include <linux/module.h> 11 #include <linux/kernel.h> 12 #include <linux/slab.h> 13 #include <linux/errno.h> 14 #include <linux/types.h> 15 #include <linux/socket.h> 16 #include <linux/string.h> 17 #include <linux/skbuff.h> 18 #include <linux/mutex.h> 19 #include <linux/bitmap.h> 20 #include <linux/rwsem.h> 21 #include <linux/idr.h> 22 #include <net/sock.h> 23 #include <net/genetlink.h> 24 25 static DEFINE_MUTEX(genl_mutex); /* serialization of message processing */ 26 static DECLARE_RWSEM(cb_lock); 27 28 atomic_t genl_sk_destructing_cnt = ATOMIC_INIT(0); 29 DECLARE_WAIT_QUEUE_HEAD(genl_sk_destructing_waitq); 30 31 void genl_lock(void) 32 { 33 mutex_lock(&genl_mutex); 34 } 35 EXPORT_SYMBOL(genl_lock); 36 37 void genl_unlock(void) 38 { 39 mutex_unlock(&genl_mutex); 40 } 41 EXPORT_SYMBOL(genl_unlock); 42 43 static void genl_lock_all(void) 44 { 45 down_write(&cb_lock); 46 genl_lock(); 47 } 48 49 static void genl_unlock_all(void) 50 { 51 genl_unlock(); 52 up_write(&cb_lock); 53 } 54 55 static DEFINE_IDR(genl_fam_idr); 56 57 /* 58 * Bitmap of multicast groups that are currently in use. 59 * 60 * To avoid an allocation at boot of just one unsigned long, 61 * declare it global instead. 62 * Bit 0 is marked as already used since group 0 is invalid. 63 * Bit 1 is marked as already used since the drop-monitor code 64 * abuses the API and thinks it can statically use group 1. 65 * That group will typically conflict with other groups that 66 * any proper users use. 67 * Bit 16 is marked as used since it's used for generic netlink 68 * and the code no longer marks pre-reserved IDs as used. 69 * Bit 17 is marked as already used since the VFS quota code 70 * also abused this API and relied on family == group ID, we 71 * cater to that by giving it a static family and group ID. 72 * Bit 18 is marked as already used since the PMCRAID driver 73 * did the same thing as the VFS quota code (maybe copied?) 74 */ 75 static unsigned long mc_group_start = 0x3 | BIT(GENL_ID_CTRL) | 76 BIT(GENL_ID_VFS_DQUOT) | 77 BIT(GENL_ID_PMCRAID); 78 static unsigned long *mc_groups = &mc_group_start; 79 static unsigned long mc_groups_longs = 1; 80 81 static int genl_ctrl_event(int event, const struct genl_family *family, 82 const struct genl_multicast_group *grp, 83 int grp_id); 84 85 static const struct genl_family *genl_family_find_byid(unsigned int id) 86 { 87 return idr_find(&genl_fam_idr, id); 88 } 89 90 static const struct genl_family *genl_family_find_byname(char *name) 91 { 92 const struct genl_family *family; 93 unsigned int id; 94 95 idr_for_each_entry(&genl_fam_idr, family, id) 96 if (strcmp(family->name, name) == 0) 97 return family; 98 99 return NULL; 100 } 101 102 static int genl_get_cmd_cnt(const struct genl_family *family) 103 { 104 return family->n_ops + family->n_small_ops; 105 } 106 107 static void genl_op_from_full(const struct genl_family *family, 108 unsigned int i, struct genl_ops *op) 109 { 110 *op = family->ops[i]; 111 112 if (!op->maxattr) 113 op->maxattr = family->maxattr; 114 if (!op->policy) 115 op->policy = family->policy; 116 } 117 118 static int genl_get_cmd_full(u32 cmd, const struct genl_family *family, 119 struct genl_ops *op) 120 { 121 int i; 122 123 for (i = 0; i < family->n_ops; i++) 124 if (family->ops[i].cmd == cmd) { 125 genl_op_from_full(family, i, op); 126 return 0; 127 } 128 129 return -ENOENT; 130 } 131 132 static void genl_op_from_small(const struct genl_family *family, 133 unsigned int i, struct genl_ops *op) 134 { 135 memset(op, 0, sizeof(*op)); 136 op->doit = family->small_ops[i].doit; 137 op->dumpit = family->small_ops[i].dumpit; 138 op->cmd = family->small_ops[i].cmd; 139 op->internal_flags = family->small_ops[i].internal_flags; 140 op->flags = family->small_ops[i].flags; 141 op->validate = family->small_ops[i].validate; 142 143 op->maxattr = family->maxattr; 144 op->policy = family->policy; 145 } 146 147 static int genl_get_cmd_small(u32 cmd, const struct genl_family *family, 148 struct genl_ops *op) 149 { 150 int i; 151 152 for (i = 0; i < family->n_small_ops; i++) 153 if (family->small_ops[i].cmd == cmd) { 154 genl_op_from_small(family, i, op); 155 return 0; 156 } 157 158 return -ENOENT; 159 } 160 161 static int genl_get_cmd(u32 cmd, const struct genl_family *family, 162 struct genl_ops *op) 163 { 164 if (!genl_get_cmd_full(cmd, family, op)) 165 return 0; 166 return genl_get_cmd_small(cmd, family, op); 167 } 168 169 static void genl_get_cmd_by_index(unsigned int i, 170 const struct genl_family *family, 171 struct genl_ops *op) 172 { 173 if (i < family->n_ops) 174 genl_op_from_full(family, i, op); 175 else if (i < family->n_ops + family->n_small_ops) 176 genl_op_from_small(family, i - family->n_ops, op); 177 else 178 WARN_ON_ONCE(1); 179 } 180 181 static int genl_allocate_reserve_groups(int n_groups, int *first_id) 182 { 183 unsigned long *new_groups; 184 int start = 0; 185 int i; 186 int id; 187 bool fits; 188 189 do { 190 if (start == 0) 191 id = find_first_zero_bit(mc_groups, 192 mc_groups_longs * 193 BITS_PER_LONG); 194 else 195 id = find_next_zero_bit(mc_groups, 196 mc_groups_longs * BITS_PER_LONG, 197 start); 198 199 fits = true; 200 for (i = id; 201 i < min_t(int, id + n_groups, 202 mc_groups_longs * BITS_PER_LONG); 203 i++) { 204 if (test_bit(i, mc_groups)) { 205 start = i; 206 fits = false; 207 break; 208 } 209 } 210 211 if (id + n_groups > mc_groups_longs * BITS_PER_LONG) { 212 unsigned long new_longs = mc_groups_longs + 213 BITS_TO_LONGS(n_groups); 214 size_t nlen = new_longs * sizeof(unsigned long); 215 216 if (mc_groups == &mc_group_start) { 217 new_groups = kzalloc(nlen, GFP_KERNEL); 218 if (!new_groups) 219 return -ENOMEM; 220 mc_groups = new_groups; 221 *mc_groups = mc_group_start; 222 } else { 223 new_groups = krealloc(mc_groups, nlen, 224 GFP_KERNEL); 225 if (!new_groups) 226 return -ENOMEM; 227 mc_groups = new_groups; 228 for (i = 0; i < BITS_TO_LONGS(n_groups); i++) 229 mc_groups[mc_groups_longs + i] = 0; 230 } 231 mc_groups_longs = new_longs; 232 } 233 } while (!fits); 234 235 for (i = id; i < id + n_groups; i++) 236 set_bit(i, mc_groups); 237 *first_id = id; 238 return 0; 239 } 240 241 static struct genl_family genl_ctrl; 242 243 static int genl_validate_assign_mc_groups(struct genl_family *family) 244 { 245 int first_id; 246 int n_groups = family->n_mcgrps; 247 int err = 0, i; 248 bool groups_allocated = false; 249 250 if (!n_groups) 251 return 0; 252 253 for (i = 0; i < n_groups; i++) { 254 const struct genl_multicast_group *grp = &family->mcgrps[i]; 255 256 if (WARN_ON(grp->name[0] == '\0')) 257 return -EINVAL; 258 if (WARN_ON(memchr(grp->name, '\0', GENL_NAMSIZ) == NULL)) 259 return -EINVAL; 260 } 261 262 /* special-case our own group and hacks */ 263 if (family == &genl_ctrl) { 264 first_id = GENL_ID_CTRL; 265 BUG_ON(n_groups != 1); 266 } else if (strcmp(family->name, "NET_DM") == 0) { 267 first_id = 1; 268 BUG_ON(n_groups != 1); 269 } else if (family->id == GENL_ID_VFS_DQUOT) { 270 first_id = GENL_ID_VFS_DQUOT; 271 BUG_ON(n_groups != 1); 272 } else if (family->id == GENL_ID_PMCRAID) { 273 first_id = GENL_ID_PMCRAID; 274 BUG_ON(n_groups != 1); 275 } else { 276 groups_allocated = true; 277 err = genl_allocate_reserve_groups(n_groups, &first_id); 278 if (err) 279 return err; 280 } 281 282 family->mcgrp_offset = first_id; 283 284 /* if still initializing, can't and don't need to realloc bitmaps */ 285 if (!init_net.genl_sock) 286 return 0; 287 288 if (family->netnsok) { 289 struct net *net; 290 291 netlink_table_grab(); 292 rcu_read_lock(); 293 for_each_net_rcu(net) { 294 err = __netlink_change_ngroups(net->genl_sock, 295 mc_groups_longs * BITS_PER_LONG); 296 if (err) { 297 /* 298 * No need to roll back, can only fail if 299 * memory allocation fails and then the 300 * number of _possible_ groups has been 301 * increased on some sockets which is ok. 302 */ 303 break; 304 } 305 } 306 rcu_read_unlock(); 307 netlink_table_ungrab(); 308 } else { 309 err = netlink_change_ngroups(init_net.genl_sock, 310 mc_groups_longs * BITS_PER_LONG); 311 } 312 313 if (groups_allocated && err) { 314 for (i = 0; i < family->n_mcgrps; i++) 315 clear_bit(family->mcgrp_offset + i, mc_groups); 316 } 317 318 return err; 319 } 320 321 static void genl_unregister_mc_groups(const struct genl_family *family) 322 { 323 struct net *net; 324 int i; 325 326 netlink_table_grab(); 327 rcu_read_lock(); 328 for_each_net_rcu(net) { 329 for (i = 0; i < family->n_mcgrps; i++) 330 __netlink_clear_multicast_users( 331 net->genl_sock, family->mcgrp_offset + i); 332 } 333 rcu_read_unlock(); 334 netlink_table_ungrab(); 335 336 for (i = 0; i < family->n_mcgrps; i++) { 337 int grp_id = family->mcgrp_offset + i; 338 339 if (grp_id != 1) 340 clear_bit(grp_id, mc_groups); 341 genl_ctrl_event(CTRL_CMD_DELMCAST_GRP, family, 342 &family->mcgrps[i], grp_id); 343 } 344 } 345 346 static int genl_validate_ops(const struct genl_family *family) 347 { 348 int i, j; 349 350 if (WARN_ON(family->n_ops && !family->ops) || 351 WARN_ON(family->n_small_ops && !family->small_ops)) 352 return -EINVAL; 353 354 for (i = 0; i < genl_get_cmd_cnt(family); i++) { 355 struct genl_ops op; 356 357 genl_get_cmd_by_index(i, family, &op); 358 if (op.dumpit == NULL && op.doit == NULL) 359 return -EINVAL; 360 for (j = i + 1; j < genl_get_cmd_cnt(family); j++) { 361 struct genl_ops op2; 362 363 genl_get_cmd_by_index(j, family, &op2); 364 if (op.cmd == op2.cmd) 365 return -EINVAL; 366 } 367 } 368 369 return 0; 370 } 371 372 /** 373 * genl_register_family - register a generic netlink family 374 * @family: generic netlink family 375 * 376 * Registers the specified family after validating it first. Only one 377 * family may be registered with the same family name or identifier. 378 * 379 * The family's ops, multicast groups and module pointer must already 380 * be assigned. 381 * 382 * Return 0 on success or a negative error code. 383 */ 384 int genl_register_family(struct genl_family *family) 385 { 386 int err, i; 387 int start = GENL_START_ALLOC, end = GENL_MAX_ID; 388 389 err = genl_validate_ops(family); 390 if (err) 391 return err; 392 393 genl_lock_all(); 394 395 if (genl_family_find_byname(family->name)) { 396 err = -EEXIST; 397 goto errout_locked; 398 } 399 400 /* 401 * Sadly, a few cases need to be special-cased 402 * due to them having previously abused the API 403 * and having used their family ID also as their 404 * multicast group ID, so we use reserved IDs 405 * for both to be sure we can do that mapping. 406 */ 407 if (family == &genl_ctrl) { 408 /* and this needs to be special for initial family lookups */ 409 start = end = GENL_ID_CTRL; 410 } else if (strcmp(family->name, "pmcraid") == 0) { 411 start = end = GENL_ID_PMCRAID; 412 } else if (strcmp(family->name, "VFS_DQUOT") == 0) { 413 start = end = GENL_ID_VFS_DQUOT; 414 } 415 416 family->id = idr_alloc_cyclic(&genl_fam_idr, family, 417 start, end + 1, GFP_KERNEL); 418 if (family->id < 0) { 419 err = family->id; 420 goto errout_locked; 421 } 422 423 err = genl_validate_assign_mc_groups(family); 424 if (err) 425 goto errout_remove; 426 427 genl_unlock_all(); 428 429 /* send all events */ 430 genl_ctrl_event(CTRL_CMD_NEWFAMILY, family, NULL, 0); 431 for (i = 0; i < family->n_mcgrps; i++) 432 genl_ctrl_event(CTRL_CMD_NEWMCAST_GRP, family, 433 &family->mcgrps[i], family->mcgrp_offset + i); 434 435 return 0; 436 437 errout_remove: 438 idr_remove(&genl_fam_idr, family->id); 439 errout_locked: 440 genl_unlock_all(); 441 return err; 442 } 443 EXPORT_SYMBOL(genl_register_family); 444 445 /** 446 * genl_unregister_family - unregister generic netlink family 447 * @family: generic netlink family 448 * 449 * Unregisters the specified family. 450 * 451 * Returns 0 on success or a negative error code. 452 */ 453 int genl_unregister_family(const struct genl_family *family) 454 { 455 genl_lock_all(); 456 457 if (!genl_family_find_byid(family->id)) { 458 genl_unlock_all(); 459 return -ENOENT; 460 } 461 462 genl_unregister_mc_groups(family); 463 464 idr_remove(&genl_fam_idr, family->id); 465 466 up_write(&cb_lock); 467 wait_event(genl_sk_destructing_waitq, 468 atomic_read(&genl_sk_destructing_cnt) == 0); 469 genl_unlock(); 470 471 genl_ctrl_event(CTRL_CMD_DELFAMILY, family, NULL, 0); 472 473 return 0; 474 } 475 EXPORT_SYMBOL(genl_unregister_family); 476 477 /** 478 * genlmsg_put - Add generic netlink header to netlink message 479 * @skb: socket buffer holding the message 480 * @portid: netlink portid the message is addressed to 481 * @seq: sequence number (usually the one of the sender) 482 * @family: generic netlink family 483 * @flags: netlink message flags 484 * @cmd: generic netlink command 485 * 486 * Returns pointer to user specific header 487 */ 488 void *genlmsg_put(struct sk_buff *skb, u32 portid, u32 seq, 489 const struct genl_family *family, int flags, u8 cmd) 490 { 491 struct nlmsghdr *nlh; 492 struct genlmsghdr *hdr; 493 494 nlh = nlmsg_put(skb, portid, seq, family->id, GENL_HDRLEN + 495 family->hdrsize, flags); 496 if (nlh == NULL) 497 return NULL; 498 499 hdr = nlmsg_data(nlh); 500 hdr->cmd = cmd; 501 hdr->version = family->version; 502 hdr->reserved = 0; 503 504 return (char *) hdr + GENL_HDRLEN; 505 } 506 EXPORT_SYMBOL(genlmsg_put); 507 508 static struct genl_dumpit_info *genl_dumpit_info_alloc(void) 509 { 510 return kmalloc(sizeof(struct genl_dumpit_info), GFP_KERNEL); 511 } 512 513 static void genl_dumpit_info_free(const struct genl_dumpit_info *info) 514 { 515 kfree(info); 516 } 517 518 static struct nlattr ** 519 genl_family_rcv_msg_attrs_parse(const struct genl_family *family, 520 struct nlmsghdr *nlh, 521 struct netlink_ext_ack *extack, 522 const struct genl_ops *ops, 523 int hdrlen, 524 enum genl_validate_flags no_strict_flag) 525 { 526 enum netlink_validation validate = ops->validate & no_strict_flag ? 527 NL_VALIDATE_LIBERAL : 528 NL_VALIDATE_STRICT; 529 struct nlattr **attrbuf; 530 int err; 531 532 if (!ops->maxattr) 533 return NULL; 534 535 attrbuf = kmalloc_array(ops->maxattr + 1, 536 sizeof(struct nlattr *), GFP_KERNEL); 537 if (!attrbuf) 538 return ERR_PTR(-ENOMEM); 539 540 err = __nlmsg_parse(nlh, hdrlen, attrbuf, ops->maxattr, ops->policy, 541 validate, extack); 542 if (err) { 543 kfree(attrbuf); 544 return ERR_PTR(err); 545 } 546 return attrbuf; 547 } 548 549 static void genl_family_rcv_msg_attrs_free(struct nlattr **attrbuf) 550 { 551 kfree(attrbuf); 552 } 553 554 struct genl_start_context { 555 const struct genl_family *family; 556 struct nlmsghdr *nlh; 557 struct netlink_ext_ack *extack; 558 const struct genl_ops *ops; 559 int hdrlen; 560 }; 561 562 static int genl_start(struct netlink_callback *cb) 563 { 564 struct genl_start_context *ctx = cb->data; 565 const struct genl_ops *ops = ctx->ops; 566 struct genl_dumpit_info *info; 567 struct nlattr **attrs = NULL; 568 int rc = 0; 569 570 if (ops->validate & GENL_DONT_VALIDATE_DUMP) 571 goto no_attrs; 572 573 if (ctx->nlh->nlmsg_len < nlmsg_msg_size(ctx->hdrlen)) 574 return -EINVAL; 575 576 attrs = genl_family_rcv_msg_attrs_parse(ctx->family, ctx->nlh, ctx->extack, 577 ops, ctx->hdrlen, 578 GENL_DONT_VALIDATE_DUMP_STRICT); 579 if (IS_ERR(attrs)) 580 return PTR_ERR(attrs); 581 582 no_attrs: 583 info = genl_dumpit_info_alloc(); 584 if (!info) { 585 genl_family_rcv_msg_attrs_free(attrs); 586 return -ENOMEM; 587 } 588 info->family = ctx->family; 589 info->op = *ops; 590 info->attrs = attrs; 591 592 cb->data = info; 593 if (ops->start) { 594 if (!ctx->family->parallel_ops) 595 genl_lock(); 596 rc = ops->start(cb); 597 if (!ctx->family->parallel_ops) 598 genl_unlock(); 599 } 600 601 if (rc) { 602 genl_family_rcv_msg_attrs_free(info->attrs); 603 genl_dumpit_info_free(info); 604 cb->data = NULL; 605 } 606 return rc; 607 } 608 609 static int genl_lock_dumpit(struct sk_buff *skb, struct netlink_callback *cb) 610 { 611 const struct genl_ops *ops = &genl_dumpit_info(cb)->op; 612 int rc; 613 614 genl_lock(); 615 rc = ops->dumpit(skb, cb); 616 genl_unlock(); 617 return rc; 618 } 619 620 static int genl_lock_done(struct netlink_callback *cb) 621 { 622 const struct genl_dumpit_info *info = genl_dumpit_info(cb); 623 const struct genl_ops *ops = &info->op; 624 int rc = 0; 625 626 if (ops->done) { 627 genl_lock(); 628 rc = ops->done(cb); 629 genl_unlock(); 630 } 631 genl_family_rcv_msg_attrs_free(info->attrs); 632 genl_dumpit_info_free(info); 633 return rc; 634 } 635 636 static int genl_parallel_done(struct netlink_callback *cb) 637 { 638 const struct genl_dumpit_info *info = genl_dumpit_info(cb); 639 const struct genl_ops *ops = &info->op; 640 int rc = 0; 641 642 if (ops->done) 643 rc = ops->done(cb); 644 genl_family_rcv_msg_attrs_free(info->attrs); 645 genl_dumpit_info_free(info); 646 return rc; 647 } 648 649 static int genl_family_rcv_msg_dumpit(const struct genl_family *family, 650 struct sk_buff *skb, 651 struct nlmsghdr *nlh, 652 struct netlink_ext_ack *extack, 653 const struct genl_ops *ops, 654 int hdrlen, struct net *net) 655 { 656 struct genl_start_context ctx; 657 int err; 658 659 if (!ops->dumpit) 660 return -EOPNOTSUPP; 661 662 ctx.family = family; 663 ctx.nlh = nlh; 664 ctx.extack = extack; 665 ctx.ops = ops; 666 ctx.hdrlen = hdrlen; 667 668 if (!family->parallel_ops) { 669 struct netlink_dump_control c = { 670 .module = family->module, 671 .data = &ctx, 672 .start = genl_start, 673 .dump = genl_lock_dumpit, 674 .done = genl_lock_done, 675 }; 676 677 genl_unlock(); 678 err = __netlink_dump_start(net->genl_sock, skb, nlh, &c); 679 genl_lock(); 680 } else { 681 struct netlink_dump_control c = { 682 .module = family->module, 683 .data = &ctx, 684 .start = genl_start, 685 .dump = ops->dumpit, 686 .done = genl_parallel_done, 687 }; 688 689 err = __netlink_dump_start(net->genl_sock, skb, nlh, &c); 690 } 691 692 return err; 693 } 694 695 static int genl_family_rcv_msg_doit(const struct genl_family *family, 696 struct sk_buff *skb, 697 struct nlmsghdr *nlh, 698 struct netlink_ext_ack *extack, 699 const struct genl_ops *ops, 700 int hdrlen, struct net *net) 701 { 702 struct nlattr **attrbuf; 703 struct genl_info info; 704 int err; 705 706 if (!ops->doit) 707 return -EOPNOTSUPP; 708 709 attrbuf = genl_family_rcv_msg_attrs_parse(family, nlh, extack, 710 ops, hdrlen, 711 GENL_DONT_VALIDATE_STRICT); 712 if (IS_ERR(attrbuf)) 713 return PTR_ERR(attrbuf); 714 715 info.snd_seq = nlh->nlmsg_seq; 716 info.snd_portid = NETLINK_CB(skb).portid; 717 info.nlhdr = nlh; 718 info.genlhdr = nlmsg_data(nlh); 719 info.userhdr = nlmsg_data(nlh) + GENL_HDRLEN; 720 info.attrs = attrbuf; 721 info.extack = extack; 722 genl_info_net_set(&info, net); 723 memset(&info.user_ptr, 0, sizeof(info.user_ptr)); 724 725 if (family->pre_doit) { 726 err = family->pre_doit(ops, skb, &info); 727 if (err) 728 goto out; 729 } 730 731 err = ops->doit(skb, &info); 732 733 if (family->post_doit) 734 family->post_doit(ops, skb, &info); 735 736 out: 737 genl_family_rcv_msg_attrs_free(attrbuf); 738 739 return err; 740 } 741 742 static int genl_family_rcv_msg(const struct genl_family *family, 743 struct sk_buff *skb, 744 struct nlmsghdr *nlh, 745 struct netlink_ext_ack *extack) 746 { 747 struct net *net = sock_net(skb->sk); 748 struct genlmsghdr *hdr = nlmsg_data(nlh); 749 struct genl_ops op; 750 int hdrlen; 751 752 /* this family doesn't exist in this netns */ 753 if (!family->netnsok && !net_eq(net, &init_net)) 754 return -ENOENT; 755 756 hdrlen = GENL_HDRLEN + family->hdrsize; 757 if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen)) 758 return -EINVAL; 759 760 if (hdr->cmd >= family->resv_start_op && hdr->reserved) 761 return -EINVAL; 762 763 if (genl_get_cmd(hdr->cmd, family, &op)) 764 return -EOPNOTSUPP; 765 766 if ((op.flags & GENL_ADMIN_PERM) && 767 !netlink_capable(skb, CAP_NET_ADMIN)) 768 return -EPERM; 769 770 if ((op.flags & GENL_UNS_ADMIN_PERM) && 771 !netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN)) 772 return -EPERM; 773 774 if ((nlh->nlmsg_flags & NLM_F_DUMP) == NLM_F_DUMP) 775 return genl_family_rcv_msg_dumpit(family, skb, nlh, extack, 776 &op, hdrlen, net); 777 else 778 return genl_family_rcv_msg_doit(family, skb, nlh, extack, 779 &op, hdrlen, net); 780 } 781 782 static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, 783 struct netlink_ext_ack *extack) 784 { 785 const struct genl_family *family; 786 int err; 787 788 family = genl_family_find_byid(nlh->nlmsg_type); 789 if (family == NULL) 790 return -ENOENT; 791 792 if (!family->parallel_ops) 793 genl_lock(); 794 795 err = genl_family_rcv_msg(family, skb, nlh, extack); 796 797 if (!family->parallel_ops) 798 genl_unlock(); 799 800 return err; 801 } 802 803 static void genl_rcv(struct sk_buff *skb) 804 { 805 down_read(&cb_lock); 806 netlink_rcv_skb(skb, &genl_rcv_msg); 807 up_read(&cb_lock); 808 } 809 810 /************************************************************************** 811 * Controller 812 **************************************************************************/ 813 814 static struct genl_family genl_ctrl; 815 816 static int ctrl_fill_info(const struct genl_family *family, u32 portid, u32 seq, 817 u32 flags, struct sk_buff *skb, u8 cmd) 818 { 819 void *hdr; 820 821 hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd); 822 if (hdr == NULL) 823 return -1; 824 825 if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, family->name) || 826 nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, family->id) || 827 nla_put_u32(skb, CTRL_ATTR_VERSION, family->version) || 828 nla_put_u32(skb, CTRL_ATTR_HDRSIZE, family->hdrsize) || 829 nla_put_u32(skb, CTRL_ATTR_MAXATTR, family->maxattr)) 830 goto nla_put_failure; 831 832 if (genl_get_cmd_cnt(family)) { 833 struct nlattr *nla_ops; 834 int i; 835 836 nla_ops = nla_nest_start_noflag(skb, CTRL_ATTR_OPS); 837 if (nla_ops == NULL) 838 goto nla_put_failure; 839 840 for (i = 0; i < genl_get_cmd_cnt(family); i++) { 841 struct nlattr *nest; 842 struct genl_ops op; 843 u32 op_flags; 844 845 genl_get_cmd_by_index(i, family, &op); 846 op_flags = op.flags; 847 if (op.dumpit) 848 op_flags |= GENL_CMD_CAP_DUMP; 849 if (op.doit) 850 op_flags |= GENL_CMD_CAP_DO; 851 if (op.policy) 852 op_flags |= GENL_CMD_CAP_HASPOL; 853 854 nest = nla_nest_start_noflag(skb, i + 1); 855 if (nest == NULL) 856 goto nla_put_failure; 857 858 if (nla_put_u32(skb, CTRL_ATTR_OP_ID, op.cmd) || 859 nla_put_u32(skb, CTRL_ATTR_OP_FLAGS, op_flags)) 860 goto nla_put_failure; 861 862 nla_nest_end(skb, nest); 863 } 864 865 nla_nest_end(skb, nla_ops); 866 } 867 868 if (family->n_mcgrps) { 869 struct nlattr *nla_grps; 870 int i; 871 872 nla_grps = nla_nest_start_noflag(skb, CTRL_ATTR_MCAST_GROUPS); 873 if (nla_grps == NULL) 874 goto nla_put_failure; 875 876 for (i = 0; i < family->n_mcgrps; i++) { 877 struct nlattr *nest; 878 const struct genl_multicast_group *grp; 879 880 grp = &family->mcgrps[i]; 881 882 nest = nla_nest_start_noflag(skb, i + 1); 883 if (nest == NULL) 884 goto nla_put_failure; 885 886 if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID, 887 family->mcgrp_offset + i) || 888 nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME, 889 grp->name)) 890 goto nla_put_failure; 891 892 nla_nest_end(skb, nest); 893 } 894 nla_nest_end(skb, nla_grps); 895 } 896 897 genlmsg_end(skb, hdr); 898 return 0; 899 900 nla_put_failure: 901 genlmsg_cancel(skb, hdr); 902 return -EMSGSIZE; 903 } 904 905 static int ctrl_fill_mcgrp_info(const struct genl_family *family, 906 const struct genl_multicast_group *grp, 907 int grp_id, u32 portid, u32 seq, u32 flags, 908 struct sk_buff *skb, u8 cmd) 909 { 910 void *hdr; 911 struct nlattr *nla_grps; 912 struct nlattr *nest; 913 914 hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd); 915 if (hdr == NULL) 916 return -1; 917 918 if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, family->name) || 919 nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, family->id)) 920 goto nla_put_failure; 921 922 nla_grps = nla_nest_start_noflag(skb, CTRL_ATTR_MCAST_GROUPS); 923 if (nla_grps == NULL) 924 goto nla_put_failure; 925 926 nest = nla_nest_start_noflag(skb, 1); 927 if (nest == NULL) 928 goto nla_put_failure; 929 930 if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID, grp_id) || 931 nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME, 932 grp->name)) 933 goto nla_put_failure; 934 935 nla_nest_end(skb, nest); 936 nla_nest_end(skb, nla_grps); 937 938 genlmsg_end(skb, hdr); 939 return 0; 940 941 nla_put_failure: 942 genlmsg_cancel(skb, hdr); 943 return -EMSGSIZE; 944 } 945 946 static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb) 947 { 948 int n = 0; 949 struct genl_family *rt; 950 struct net *net = sock_net(skb->sk); 951 int fams_to_skip = cb->args[0]; 952 unsigned int id; 953 954 idr_for_each_entry(&genl_fam_idr, rt, id) { 955 if (!rt->netnsok && !net_eq(net, &init_net)) 956 continue; 957 958 if (n++ < fams_to_skip) 959 continue; 960 961 if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).portid, 962 cb->nlh->nlmsg_seq, NLM_F_MULTI, 963 skb, CTRL_CMD_NEWFAMILY) < 0) { 964 n--; 965 break; 966 } 967 } 968 969 cb->args[0] = n; 970 return skb->len; 971 } 972 973 static struct sk_buff *ctrl_build_family_msg(const struct genl_family *family, 974 u32 portid, int seq, u8 cmd) 975 { 976 struct sk_buff *skb; 977 int err; 978 979 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 980 if (skb == NULL) 981 return ERR_PTR(-ENOBUFS); 982 983 err = ctrl_fill_info(family, portid, seq, 0, skb, cmd); 984 if (err < 0) { 985 nlmsg_free(skb); 986 return ERR_PTR(err); 987 } 988 989 return skb; 990 } 991 992 static struct sk_buff * 993 ctrl_build_mcgrp_msg(const struct genl_family *family, 994 const struct genl_multicast_group *grp, 995 int grp_id, u32 portid, int seq, u8 cmd) 996 { 997 struct sk_buff *skb; 998 int err; 999 1000 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1001 if (skb == NULL) 1002 return ERR_PTR(-ENOBUFS); 1003 1004 err = ctrl_fill_mcgrp_info(family, grp, grp_id, portid, 1005 seq, 0, skb, cmd); 1006 if (err < 0) { 1007 nlmsg_free(skb); 1008 return ERR_PTR(err); 1009 } 1010 1011 return skb; 1012 } 1013 1014 static const struct nla_policy ctrl_policy_family[] = { 1015 [CTRL_ATTR_FAMILY_ID] = { .type = NLA_U16 }, 1016 [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_NUL_STRING, 1017 .len = GENL_NAMSIZ - 1 }, 1018 }; 1019 1020 static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info) 1021 { 1022 struct sk_buff *msg; 1023 const struct genl_family *res = NULL; 1024 int err = -EINVAL; 1025 1026 if (info->attrs[CTRL_ATTR_FAMILY_ID]) { 1027 u16 id = nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]); 1028 res = genl_family_find_byid(id); 1029 err = -ENOENT; 1030 } 1031 1032 if (info->attrs[CTRL_ATTR_FAMILY_NAME]) { 1033 char *name; 1034 1035 name = nla_data(info->attrs[CTRL_ATTR_FAMILY_NAME]); 1036 res = genl_family_find_byname(name); 1037 #ifdef CONFIG_MODULES 1038 if (res == NULL) { 1039 genl_unlock(); 1040 up_read(&cb_lock); 1041 request_module("net-pf-%d-proto-%d-family-%s", 1042 PF_NETLINK, NETLINK_GENERIC, name); 1043 down_read(&cb_lock); 1044 genl_lock(); 1045 res = genl_family_find_byname(name); 1046 } 1047 #endif 1048 err = -ENOENT; 1049 } 1050 1051 if (res == NULL) 1052 return err; 1053 1054 if (!res->netnsok && !net_eq(genl_info_net(info), &init_net)) { 1055 /* family doesn't exist here */ 1056 return -ENOENT; 1057 } 1058 1059 msg = ctrl_build_family_msg(res, info->snd_portid, info->snd_seq, 1060 CTRL_CMD_NEWFAMILY); 1061 if (IS_ERR(msg)) 1062 return PTR_ERR(msg); 1063 1064 return genlmsg_reply(msg, info); 1065 } 1066 1067 static int genl_ctrl_event(int event, const struct genl_family *family, 1068 const struct genl_multicast_group *grp, 1069 int grp_id) 1070 { 1071 struct sk_buff *msg; 1072 1073 /* genl is still initialising */ 1074 if (!init_net.genl_sock) 1075 return 0; 1076 1077 switch (event) { 1078 case CTRL_CMD_NEWFAMILY: 1079 case CTRL_CMD_DELFAMILY: 1080 WARN_ON(grp); 1081 msg = ctrl_build_family_msg(family, 0, 0, event); 1082 break; 1083 case CTRL_CMD_NEWMCAST_GRP: 1084 case CTRL_CMD_DELMCAST_GRP: 1085 BUG_ON(!grp); 1086 msg = ctrl_build_mcgrp_msg(family, grp, grp_id, 0, 0, event); 1087 break; 1088 default: 1089 return -EINVAL; 1090 } 1091 1092 if (IS_ERR(msg)) 1093 return PTR_ERR(msg); 1094 1095 if (!family->netnsok) { 1096 genlmsg_multicast_netns(&genl_ctrl, &init_net, msg, 0, 1097 0, GFP_KERNEL); 1098 } else { 1099 rcu_read_lock(); 1100 genlmsg_multicast_allns(&genl_ctrl, msg, 0, 1101 0, GFP_ATOMIC); 1102 rcu_read_unlock(); 1103 } 1104 1105 return 0; 1106 } 1107 1108 struct ctrl_dump_policy_ctx { 1109 struct netlink_policy_dump_state *state; 1110 const struct genl_family *rt; 1111 unsigned int opidx; 1112 u32 op; 1113 u16 fam_id; 1114 u8 policies:1, 1115 single_op:1; 1116 }; 1117 1118 static const struct nla_policy ctrl_policy_policy[] = { 1119 [CTRL_ATTR_FAMILY_ID] = { .type = NLA_U16 }, 1120 [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_NUL_STRING, 1121 .len = GENL_NAMSIZ - 1 }, 1122 [CTRL_ATTR_OP] = { .type = NLA_U32 }, 1123 }; 1124 1125 static int ctrl_dumppolicy_start(struct netlink_callback *cb) 1126 { 1127 const struct genl_dumpit_info *info = genl_dumpit_info(cb); 1128 struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx; 1129 struct nlattr **tb = info->attrs; 1130 const struct genl_family *rt; 1131 struct genl_ops op; 1132 int err, i; 1133 1134 BUILD_BUG_ON(sizeof(*ctx) > sizeof(cb->ctx)); 1135 1136 if (!tb[CTRL_ATTR_FAMILY_ID] && !tb[CTRL_ATTR_FAMILY_NAME]) 1137 return -EINVAL; 1138 1139 if (tb[CTRL_ATTR_FAMILY_ID]) { 1140 ctx->fam_id = nla_get_u16(tb[CTRL_ATTR_FAMILY_ID]); 1141 } else { 1142 rt = genl_family_find_byname( 1143 nla_data(tb[CTRL_ATTR_FAMILY_NAME])); 1144 if (!rt) 1145 return -ENOENT; 1146 ctx->fam_id = rt->id; 1147 } 1148 1149 rt = genl_family_find_byid(ctx->fam_id); 1150 if (!rt) 1151 return -ENOENT; 1152 1153 ctx->rt = rt; 1154 1155 if (tb[CTRL_ATTR_OP]) { 1156 ctx->single_op = true; 1157 ctx->op = nla_get_u32(tb[CTRL_ATTR_OP]); 1158 1159 err = genl_get_cmd(ctx->op, rt, &op); 1160 if (err) { 1161 NL_SET_BAD_ATTR(cb->extack, tb[CTRL_ATTR_OP]); 1162 return err; 1163 } 1164 1165 if (!op.policy) 1166 return -ENODATA; 1167 1168 return netlink_policy_dump_add_policy(&ctx->state, op.policy, 1169 op.maxattr); 1170 } 1171 1172 for (i = 0; i < genl_get_cmd_cnt(rt); i++) { 1173 genl_get_cmd_by_index(i, rt, &op); 1174 1175 if (op.policy) { 1176 err = netlink_policy_dump_add_policy(&ctx->state, 1177 op.policy, 1178 op.maxattr); 1179 if (err) 1180 goto err_free_state; 1181 } 1182 } 1183 1184 if (!ctx->state) 1185 return -ENODATA; 1186 return 0; 1187 1188 err_free_state: 1189 netlink_policy_dump_free(ctx->state); 1190 return err; 1191 } 1192 1193 static void *ctrl_dumppolicy_prep(struct sk_buff *skb, 1194 struct netlink_callback *cb) 1195 { 1196 struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx; 1197 void *hdr; 1198 1199 hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, 1200 cb->nlh->nlmsg_seq, &genl_ctrl, 1201 NLM_F_MULTI, CTRL_CMD_GETPOLICY); 1202 if (!hdr) 1203 return NULL; 1204 1205 if (nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, ctx->fam_id)) 1206 return NULL; 1207 1208 return hdr; 1209 } 1210 1211 static int ctrl_dumppolicy_put_op(struct sk_buff *skb, 1212 struct netlink_callback *cb, 1213 struct genl_ops *op) 1214 { 1215 struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx; 1216 struct nlattr *nest_pol, *nest_op; 1217 void *hdr; 1218 int idx; 1219 1220 /* skip if we have nothing to show */ 1221 if (!op->policy) 1222 return 0; 1223 if (!op->doit && 1224 (!op->dumpit || op->validate & GENL_DONT_VALIDATE_DUMP)) 1225 return 0; 1226 1227 hdr = ctrl_dumppolicy_prep(skb, cb); 1228 if (!hdr) 1229 return -ENOBUFS; 1230 1231 nest_pol = nla_nest_start(skb, CTRL_ATTR_OP_POLICY); 1232 if (!nest_pol) 1233 goto err; 1234 1235 nest_op = nla_nest_start(skb, op->cmd); 1236 if (!nest_op) 1237 goto err; 1238 1239 /* for now both do/dump are always the same */ 1240 idx = netlink_policy_dump_get_policy_idx(ctx->state, 1241 op->policy, 1242 op->maxattr); 1243 1244 if (op->doit && nla_put_u32(skb, CTRL_ATTR_POLICY_DO, idx)) 1245 goto err; 1246 1247 if (op->dumpit && !(op->validate & GENL_DONT_VALIDATE_DUMP) && 1248 nla_put_u32(skb, CTRL_ATTR_POLICY_DUMP, idx)) 1249 goto err; 1250 1251 nla_nest_end(skb, nest_op); 1252 nla_nest_end(skb, nest_pol); 1253 genlmsg_end(skb, hdr); 1254 1255 return 0; 1256 err: 1257 genlmsg_cancel(skb, hdr); 1258 return -ENOBUFS; 1259 } 1260 1261 static int ctrl_dumppolicy(struct sk_buff *skb, struct netlink_callback *cb) 1262 { 1263 struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx; 1264 void *hdr; 1265 1266 if (!ctx->policies) { 1267 while (ctx->opidx < genl_get_cmd_cnt(ctx->rt)) { 1268 struct genl_ops op; 1269 1270 if (ctx->single_op) { 1271 int err; 1272 1273 err = genl_get_cmd(ctx->op, ctx->rt, &op); 1274 if (WARN_ON(err)) 1275 return skb->len; 1276 1277 /* break out of the loop after this one */ 1278 ctx->opidx = genl_get_cmd_cnt(ctx->rt); 1279 } else { 1280 genl_get_cmd_by_index(ctx->opidx, ctx->rt, &op); 1281 } 1282 1283 if (ctrl_dumppolicy_put_op(skb, cb, &op)) 1284 return skb->len; 1285 1286 ctx->opidx++; 1287 } 1288 1289 /* completed with the per-op policy index list */ 1290 ctx->policies = true; 1291 } 1292 1293 while (netlink_policy_dump_loop(ctx->state)) { 1294 struct nlattr *nest; 1295 1296 hdr = ctrl_dumppolicy_prep(skb, cb); 1297 if (!hdr) 1298 goto nla_put_failure; 1299 1300 nest = nla_nest_start(skb, CTRL_ATTR_POLICY); 1301 if (!nest) 1302 goto nla_put_failure; 1303 1304 if (netlink_policy_dump_write(skb, ctx->state)) 1305 goto nla_put_failure; 1306 1307 nla_nest_end(skb, nest); 1308 1309 genlmsg_end(skb, hdr); 1310 } 1311 1312 return skb->len; 1313 1314 nla_put_failure: 1315 genlmsg_cancel(skb, hdr); 1316 return skb->len; 1317 } 1318 1319 static int ctrl_dumppolicy_done(struct netlink_callback *cb) 1320 { 1321 struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx; 1322 1323 netlink_policy_dump_free(ctx->state); 1324 return 0; 1325 } 1326 1327 static const struct genl_ops genl_ctrl_ops[] = { 1328 { 1329 .cmd = CTRL_CMD_GETFAMILY, 1330 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 1331 .policy = ctrl_policy_family, 1332 .maxattr = ARRAY_SIZE(ctrl_policy_family) - 1, 1333 .doit = ctrl_getfamily, 1334 .dumpit = ctrl_dumpfamily, 1335 }, 1336 { 1337 .cmd = CTRL_CMD_GETPOLICY, 1338 .policy = ctrl_policy_policy, 1339 .maxattr = ARRAY_SIZE(ctrl_policy_policy) - 1, 1340 .start = ctrl_dumppolicy_start, 1341 .dumpit = ctrl_dumppolicy, 1342 .done = ctrl_dumppolicy_done, 1343 }, 1344 }; 1345 1346 static const struct genl_multicast_group genl_ctrl_groups[] = { 1347 { .name = "notify", }, 1348 }; 1349 1350 static struct genl_family genl_ctrl __ro_after_init = { 1351 .module = THIS_MODULE, 1352 .ops = genl_ctrl_ops, 1353 .n_ops = ARRAY_SIZE(genl_ctrl_ops), 1354 .resv_start_op = CTRL_CMD_GETPOLICY + 1, 1355 .mcgrps = genl_ctrl_groups, 1356 .n_mcgrps = ARRAY_SIZE(genl_ctrl_groups), 1357 .id = GENL_ID_CTRL, 1358 .name = "nlctrl", 1359 .version = 0x2, 1360 .netnsok = true, 1361 }; 1362 1363 static int genl_bind(struct net *net, int group) 1364 { 1365 const struct genl_family *family; 1366 unsigned int id; 1367 int ret = 0; 1368 1369 down_read(&cb_lock); 1370 1371 idr_for_each_entry(&genl_fam_idr, family, id) { 1372 const struct genl_multicast_group *grp; 1373 int i; 1374 1375 if (family->n_mcgrps == 0) 1376 continue; 1377 1378 i = group - family->mcgrp_offset; 1379 if (i < 0 || i >= family->n_mcgrps) 1380 continue; 1381 1382 grp = &family->mcgrps[i]; 1383 if ((grp->flags & GENL_UNS_ADMIN_PERM) && 1384 !ns_capable(net->user_ns, CAP_NET_ADMIN)) 1385 ret = -EPERM; 1386 1387 break; 1388 } 1389 1390 up_read(&cb_lock); 1391 return ret; 1392 } 1393 1394 static int __net_init genl_pernet_init(struct net *net) 1395 { 1396 struct netlink_kernel_cfg cfg = { 1397 .input = genl_rcv, 1398 .flags = NL_CFG_F_NONROOT_RECV, 1399 .bind = genl_bind, 1400 }; 1401 1402 /* we'll bump the group number right afterwards */ 1403 net->genl_sock = netlink_kernel_create(net, NETLINK_GENERIC, &cfg); 1404 1405 if (!net->genl_sock && net_eq(net, &init_net)) 1406 panic("GENL: Cannot initialize generic netlink\n"); 1407 1408 if (!net->genl_sock) 1409 return -ENOMEM; 1410 1411 return 0; 1412 } 1413 1414 static void __net_exit genl_pernet_exit(struct net *net) 1415 { 1416 netlink_kernel_release(net->genl_sock); 1417 net->genl_sock = NULL; 1418 } 1419 1420 static struct pernet_operations genl_pernet_ops = { 1421 .init = genl_pernet_init, 1422 .exit = genl_pernet_exit, 1423 }; 1424 1425 static int __init genl_init(void) 1426 { 1427 int err; 1428 1429 err = genl_register_family(&genl_ctrl); 1430 if (err < 0) 1431 goto problem; 1432 1433 err = register_pernet_subsys(&genl_pernet_ops); 1434 if (err) 1435 goto problem; 1436 1437 return 0; 1438 1439 problem: 1440 panic("GENL: Cannot register controller: %d\n", err); 1441 } 1442 1443 core_initcall(genl_init); 1444 1445 static int genlmsg_mcast(struct sk_buff *skb, u32 portid, unsigned long group, 1446 gfp_t flags) 1447 { 1448 struct sk_buff *tmp; 1449 struct net *net, *prev = NULL; 1450 bool delivered = false; 1451 int err; 1452 1453 for_each_net_rcu(net) { 1454 if (prev) { 1455 tmp = skb_clone(skb, flags); 1456 if (!tmp) { 1457 err = -ENOMEM; 1458 goto error; 1459 } 1460 err = nlmsg_multicast(prev->genl_sock, tmp, 1461 portid, group, flags); 1462 if (!err) 1463 delivered = true; 1464 else if (err != -ESRCH) 1465 goto error; 1466 } 1467 1468 prev = net; 1469 } 1470 1471 err = nlmsg_multicast(prev->genl_sock, skb, portid, group, flags); 1472 if (!err) 1473 delivered = true; 1474 else if (err != -ESRCH) 1475 return err; 1476 return delivered ? 0 : -ESRCH; 1477 error: 1478 kfree_skb(skb); 1479 return err; 1480 } 1481 1482 int genlmsg_multicast_allns(const struct genl_family *family, 1483 struct sk_buff *skb, u32 portid, 1484 unsigned int group, gfp_t flags) 1485 { 1486 if (WARN_ON_ONCE(group >= family->n_mcgrps)) 1487 return -EINVAL; 1488 1489 group = family->mcgrp_offset + group; 1490 return genlmsg_mcast(skb, portid, group, flags); 1491 } 1492 EXPORT_SYMBOL(genlmsg_multicast_allns); 1493 1494 void genl_notify(const struct genl_family *family, struct sk_buff *skb, 1495 struct genl_info *info, u32 group, gfp_t flags) 1496 { 1497 struct net *net = genl_info_net(info); 1498 struct sock *sk = net->genl_sock; 1499 1500 if (WARN_ON_ONCE(group >= family->n_mcgrps)) 1501 return; 1502 1503 group = family->mcgrp_offset + group; 1504 nlmsg_notify(sk, skb, info->snd_portid, group, 1505 nlmsg_report(info->nlhdr), flags); 1506 } 1507 EXPORT_SYMBOL(genl_notify); 1508