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 (genl_get_cmd(hdr->cmd, family, &op)) 761 return -EOPNOTSUPP; 762 763 if ((op.flags & GENL_ADMIN_PERM) && 764 !netlink_capable(skb, CAP_NET_ADMIN)) 765 return -EPERM; 766 767 if ((op.flags & GENL_UNS_ADMIN_PERM) && 768 !netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN)) 769 return -EPERM; 770 771 if ((nlh->nlmsg_flags & NLM_F_DUMP) == NLM_F_DUMP) 772 return genl_family_rcv_msg_dumpit(family, skb, nlh, extack, 773 &op, hdrlen, net); 774 else 775 return genl_family_rcv_msg_doit(family, skb, nlh, extack, 776 &op, hdrlen, net); 777 } 778 779 static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, 780 struct netlink_ext_ack *extack) 781 { 782 const struct genl_family *family; 783 int err; 784 785 family = genl_family_find_byid(nlh->nlmsg_type); 786 if (family == NULL) 787 return -ENOENT; 788 789 if (!family->parallel_ops) 790 genl_lock(); 791 792 err = genl_family_rcv_msg(family, skb, nlh, extack); 793 794 if (!family->parallel_ops) 795 genl_unlock(); 796 797 return err; 798 } 799 800 static void genl_rcv(struct sk_buff *skb) 801 { 802 down_read(&cb_lock); 803 netlink_rcv_skb(skb, &genl_rcv_msg); 804 up_read(&cb_lock); 805 } 806 807 /************************************************************************** 808 * Controller 809 **************************************************************************/ 810 811 static struct genl_family genl_ctrl; 812 813 static int ctrl_fill_info(const struct genl_family *family, u32 portid, u32 seq, 814 u32 flags, struct sk_buff *skb, u8 cmd) 815 { 816 void *hdr; 817 818 hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd); 819 if (hdr == NULL) 820 return -1; 821 822 if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, family->name) || 823 nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, family->id) || 824 nla_put_u32(skb, CTRL_ATTR_VERSION, family->version) || 825 nla_put_u32(skb, CTRL_ATTR_HDRSIZE, family->hdrsize) || 826 nla_put_u32(skb, CTRL_ATTR_MAXATTR, family->maxattr)) 827 goto nla_put_failure; 828 829 if (genl_get_cmd_cnt(family)) { 830 struct nlattr *nla_ops; 831 int i; 832 833 nla_ops = nla_nest_start_noflag(skb, CTRL_ATTR_OPS); 834 if (nla_ops == NULL) 835 goto nla_put_failure; 836 837 for (i = 0; i < genl_get_cmd_cnt(family); i++) { 838 struct nlattr *nest; 839 struct genl_ops op; 840 u32 op_flags; 841 842 genl_get_cmd_by_index(i, family, &op); 843 op_flags = op.flags; 844 if (op.dumpit) 845 op_flags |= GENL_CMD_CAP_DUMP; 846 if (op.doit) 847 op_flags |= GENL_CMD_CAP_DO; 848 if (op.policy) 849 op_flags |= GENL_CMD_CAP_HASPOL; 850 851 nest = nla_nest_start_noflag(skb, i + 1); 852 if (nest == NULL) 853 goto nla_put_failure; 854 855 if (nla_put_u32(skb, CTRL_ATTR_OP_ID, op.cmd) || 856 nla_put_u32(skb, CTRL_ATTR_OP_FLAGS, op_flags)) 857 goto nla_put_failure; 858 859 nla_nest_end(skb, nest); 860 } 861 862 nla_nest_end(skb, nla_ops); 863 } 864 865 if (family->n_mcgrps) { 866 struct nlattr *nla_grps; 867 int i; 868 869 nla_grps = nla_nest_start_noflag(skb, CTRL_ATTR_MCAST_GROUPS); 870 if (nla_grps == NULL) 871 goto nla_put_failure; 872 873 for (i = 0; i < family->n_mcgrps; i++) { 874 struct nlattr *nest; 875 const struct genl_multicast_group *grp; 876 877 grp = &family->mcgrps[i]; 878 879 nest = nla_nest_start_noflag(skb, i + 1); 880 if (nest == NULL) 881 goto nla_put_failure; 882 883 if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID, 884 family->mcgrp_offset + i) || 885 nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME, 886 grp->name)) 887 goto nla_put_failure; 888 889 nla_nest_end(skb, nest); 890 } 891 nla_nest_end(skb, nla_grps); 892 } 893 894 genlmsg_end(skb, hdr); 895 return 0; 896 897 nla_put_failure: 898 genlmsg_cancel(skb, hdr); 899 return -EMSGSIZE; 900 } 901 902 static int ctrl_fill_mcgrp_info(const struct genl_family *family, 903 const struct genl_multicast_group *grp, 904 int grp_id, u32 portid, u32 seq, u32 flags, 905 struct sk_buff *skb, u8 cmd) 906 { 907 void *hdr; 908 struct nlattr *nla_grps; 909 struct nlattr *nest; 910 911 hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd); 912 if (hdr == NULL) 913 return -1; 914 915 if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, family->name) || 916 nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, family->id)) 917 goto nla_put_failure; 918 919 nla_grps = nla_nest_start_noflag(skb, CTRL_ATTR_MCAST_GROUPS); 920 if (nla_grps == NULL) 921 goto nla_put_failure; 922 923 nest = nla_nest_start_noflag(skb, 1); 924 if (nest == NULL) 925 goto nla_put_failure; 926 927 if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID, grp_id) || 928 nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME, 929 grp->name)) 930 goto nla_put_failure; 931 932 nla_nest_end(skb, nest); 933 nla_nest_end(skb, nla_grps); 934 935 genlmsg_end(skb, hdr); 936 return 0; 937 938 nla_put_failure: 939 genlmsg_cancel(skb, hdr); 940 return -EMSGSIZE; 941 } 942 943 static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb) 944 { 945 int n = 0; 946 struct genl_family *rt; 947 struct net *net = sock_net(skb->sk); 948 int fams_to_skip = cb->args[0]; 949 unsigned int id; 950 951 idr_for_each_entry(&genl_fam_idr, rt, id) { 952 if (!rt->netnsok && !net_eq(net, &init_net)) 953 continue; 954 955 if (n++ < fams_to_skip) 956 continue; 957 958 if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).portid, 959 cb->nlh->nlmsg_seq, NLM_F_MULTI, 960 skb, CTRL_CMD_NEWFAMILY) < 0) { 961 n--; 962 break; 963 } 964 } 965 966 cb->args[0] = n; 967 return skb->len; 968 } 969 970 static struct sk_buff *ctrl_build_family_msg(const struct genl_family *family, 971 u32 portid, int seq, u8 cmd) 972 { 973 struct sk_buff *skb; 974 int err; 975 976 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 977 if (skb == NULL) 978 return ERR_PTR(-ENOBUFS); 979 980 err = ctrl_fill_info(family, portid, seq, 0, skb, cmd); 981 if (err < 0) { 982 nlmsg_free(skb); 983 return ERR_PTR(err); 984 } 985 986 return skb; 987 } 988 989 static struct sk_buff * 990 ctrl_build_mcgrp_msg(const struct genl_family *family, 991 const struct genl_multicast_group *grp, 992 int grp_id, u32 portid, int seq, u8 cmd) 993 { 994 struct sk_buff *skb; 995 int err; 996 997 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 998 if (skb == NULL) 999 return ERR_PTR(-ENOBUFS); 1000 1001 err = ctrl_fill_mcgrp_info(family, grp, grp_id, portid, 1002 seq, 0, skb, cmd); 1003 if (err < 0) { 1004 nlmsg_free(skb); 1005 return ERR_PTR(err); 1006 } 1007 1008 return skb; 1009 } 1010 1011 static const struct nla_policy ctrl_policy_family[] = { 1012 [CTRL_ATTR_FAMILY_ID] = { .type = NLA_U16 }, 1013 [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_NUL_STRING, 1014 .len = GENL_NAMSIZ - 1 }, 1015 }; 1016 1017 static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info) 1018 { 1019 struct sk_buff *msg; 1020 const struct genl_family *res = NULL; 1021 int err = -EINVAL; 1022 1023 if (info->attrs[CTRL_ATTR_FAMILY_ID]) { 1024 u16 id = nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]); 1025 res = genl_family_find_byid(id); 1026 err = -ENOENT; 1027 } 1028 1029 if (info->attrs[CTRL_ATTR_FAMILY_NAME]) { 1030 char *name; 1031 1032 name = nla_data(info->attrs[CTRL_ATTR_FAMILY_NAME]); 1033 res = genl_family_find_byname(name); 1034 #ifdef CONFIG_MODULES 1035 if (res == NULL) { 1036 genl_unlock(); 1037 up_read(&cb_lock); 1038 request_module("net-pf-%d-proto-%d-family-%s", 1039 PF_NETLINK, NETLINK_GENERIC, name); 1040 down_read(&cb_lock); 1041 genl_lock(); 1042 res = genl_family_find_byname(name); 1043 } 1044 #endif 1045 err = -ENOENT; 1046 } 1047 1048 if (res == NULL) 1049 return err; 1050 1051 if (!res->netnsok && !net_eq(genl_info_net(info), &init_net)) { 1052 /* family doesn't exist here */ 1053 return -ENOENT; 1054 } 1055 1056 msg = ctrl_build_family_msg(res, info->snd_portid, info->snd_seq, 1057 CTRL_CMD_NEWFAMILY); 1058 if (IS_ERR(msg)) 1059 return PTR_ERR(msg); 1060 1061 return genlmsg_reply(msg, info); 1062 } 1063 1064 static int genl_ctrl_event(int event, const struct genl_family *family, 1065 const struct genl_multicast_group *grp, 1066 int grp_id) 1067 { 1068 struct sk_buff *msg; 1069 1070 /* genl is still initialising */ 1071 if (!init_net.genl_sock) 1072 return 0; 1073 1074 switch (event) { 1075 case CTRL_CMD_NEWFAMILY: 1076 case CTRL_CMD_DELFAMILY: 1077 WARN_ON(grp); 1078 msg = ctrl_build_family_msg(family, 0, 0, event); 1079 break; 1080 case CTRL_CMD_NEWMCAST_GRP: 1081 case CTRL_CMD_DELMCAST_GRP: 1082 BUG_ON(!grp); 1083 msg = ctrl_build_mcgrp_msg(family, grp, grp_id, 0, 0, event); 1084 break; 1085 default: 1086 return -EINVAL; 1087 } 1088 1089 if (IS_ERR(msg)) 1090 return PTR_ERR(msg); 1091 1092 if (!family->netnsok) { 1093 genlmsg_multicast_netns(&genl_ctrl, &init_net, msg, 0, 1094 0, GFP_KERNEL); 1095 } else { 1096 rcu_read_lock(); 1097 genlmsg_multicast_allns(&genl_ctrl, msg, 0, 1098 0, GFP_ATOMIC); 1099 rcu_read_unlock(); 1100 } 1101 1102 return 0; 1103 } 1104 1105 struct ctrl_dump_policy_ctx { 1106 struct netlink_policy_dump_state *state; 1107 const struct genl_family *rt; 1108 unsigned int opidx; 1109 u32 op; 1110 u16 fam_id; 1111 u8 policies:1, 1112 single_op:1; 1113 }; 1114 1115 static const struct nla_policy ctrl_policy_policy[] = { 1116 [CTRL_ATTR_FAMILY_ID] = { .type = NLA_U16 }, 1117 [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_NUL_STRING, 1118 .len = GENL_NAMSIZ - 1 }, 1119 [CTRL_ATTR_OP] = { .type = NLA_U32 }, 1120 }; 1121 1122 static int ctrl_dumppolicy_start(struct netlink_callback *cb) 1123 { 1124 const struct genl_dumpit_info *info = genl_dumpit_info(cb); 1125 struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx; 1126 struct nlattr **tb = info->attrs; 1127 const struct genl_family *rt; 1128 struct genl_ops op; 1129 int err, i; 1130 1131 BUILD_BUG_ON(sizeof(*ctx) > sizeof(cb->ctx)); 1132 1133 if (!tb[CTRL_ATTR_FAMILY_ID] && !tb[CTRL_ATTR_FAMILY_NAME]) 1134 return -EINVAL; 1135 1136 if (tb[CTRL_ATTR_FAMILY_ID]) { 1137 ctx->fam_id = nla_get_u16(tb[CTRL_ATTR_FAMILY_ID]); 1138 } else { 1139 rt = genl_family_find_byname( 1140 nla_data(tb[CTRL_ATTR_FAMILY_NAME])); 1141 if (!rt) 1142 return -ENOENT; 1143 ctx->fam_id = rt->id; 1144 } 1145 1146 rt = genl_family_find_byid(ctx->fam_id); 1147 if (!rt) 1148 return -ENOENT; 1149 1150 ctx->rt = rt; 1151 1152 if (tb[CTRL_ATTR_OP]) { 1153 ctx->single_op = true; 1154 ctx->op = nla_get_u32(tb[CTRL_ATTR_OP]); 1155 1156 err = genl_get_cmd(ctx->op, rt, &op); 1157 if (err) { 1158 NL_SET_BAD_ATTR(cb->extack, tb[CTRL_ATTR_OP]); 1159 return err; 1160 } 1161 1162 if (!op.policy) 1163 return -ENODATA; 1164 1165 return netlink_policy_dump_add_policy(&ctx->state, op.policy, 1166 op.maxattr); 1167 } 1168 1169 for (i = 0; i < genl_get_cmd_cnt(rt); i++) { 1170 genl_get_cmd_by_index(i, rt, &op); 1171 1172 if (op.policy) { 1173 err = netlink_policy_dump_add_policy(&ctx->state, 1174 op.policy, 1175 op.maxattr); 1176 if (err) 1177 goto err_free_state; 1178 } 1179 } 1180 1181 if (!ctx->state) 1182 return -ENODATA; 1183 return 0; 1184 1185 err_free_state: 1186 netlink_policy_dump_free(ctx->state); 1187 return err; 1188 } 1189 1190 static void *ctrl_dumppolicy_prep(struct sk_buff *skb, 1191 struct netlink_callback *cb) 1192 { 1193 struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx; 1194 void *hdr; 1195 1196 hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, 1197 cb->nlh->nlmsg_seq, &genl_ctrl, 1198 NLM_F_MULTI, CTRL_CMD_GETPOLICY); 1199 if (!hdr) 1200 return NULL; 1201 1202 if (nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, ctx->fam_id)) 1203 return NULL; 1204 1205 return hdr; 1206 } 1207 1208 static int ctrl_dumppolicy_put_op(struct sk_buff *skb, 1209 struct netlink_callback *cb, 1210 struct genl_ops *op) 1211 { 1212 struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx; 1213 struct nlattr *nest_pol, *nest_op; 1214 void *hdr; 1215 int idx; 1216 1217 /* skip if we have nothing to show */ 1218 if (!op->policy) 1219 return 0; 1220 if (!op->doit && 1221 (!op->dumpit || op->validate & GENL_DONT_VALIDATE_DUMP)) 1222 return 0; 1223 1224 hdr = ctrl_dumppolicy_prep(skb, cb); 1225 if (!hdr) 1226 return -ENOBUFS; 1227 1228 nest_pol = nla_nest_start(skb, CTRL_ATTR_OP_POLICY); 1229 if (!nest_pol) 1230 goto err; 1231 1232 nest_op = nla_nest_start(skb, op->cmd); 1233 if (!nest_op) 1234 goto err; 1235 1236 /* for now both do/dump are always the same */ 1237 idx = netlink_policy_dump_get_policy_idx(ctx->state, 1238 op->policy, 1239 op->maxattr); 1240 1241 if (op->doit && nla_put_u32(skb, CTRL_ATTR_POLICY_DO, idx)) 1242 goto err; 1243 1244 if (op->dumpit && !(op->validate & GENL_DONT_VALIDATE_DUMP) && 1245 nla_put_u32(skb, CTRL_ATTR_POLICY_DUMP, idx)) 1246 goto err; 1247 1248 nla_nest_end(skb, nest_op); 1249 nla_nest_end(skb, nest_pol); 1250 genlmsg_end(skb, hdr); 1251 1252 return 0; 1253 err: 1254 genlmsg_cancel(skb, hdr); 1255 return -ENOBUFS; 1256 } 1257 1258 static int ctrl_dumppolicy(struct sk_buff *skb, struct netlink_callback *cb) 1259 { 1260 struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx; 1261 void *hdr; 1262 1263 if (!ctx->policies) { 1264 while (ctx->opidx < genl_get_cmd_cnt(ctx->rt)) { 1265 struct genl_ops op; 1266 1267 if (ctx->single_op) { 1268 int err; 1269 1270 err = genl_get_cmd(ctx->op, ctx->rt, &op); 1271 if (WARN_ON(err)) 1272 return skb->len; 1273 1274 /* break out of the loop after this one */ 1275 ctx->opidx = genl_get_cmd_cnt(ctx->rt); 1276 } else { 1277 genl_get_cmd_by_index(ctx->opidx, ctx->rt, &op); 1278 } 1279 1280 if (ctrl_dumppolicy_put_op(skb, cb, &op)) 1281 return skb->len; 1282 1283 ctx->opidx++; 1284 } 1285 1286 /* completed with the per-op policy index list */ 1287 ctx->policies = true; 1288 } 1289 1290 while (netlink_policy_dump_loop(ctx->state)) { 1291 struct nlattr *nest; 1292 1293 hdr = ctrl_dumppolicy_prep(skb, cb); 1294 if (!hdr) 1295 goto nla_put_failure; 1296 1297 nest = nla_nest_start(skb, CTRL_ATTR_POLICY); 1298 if (!nest) 1299 goto nla_put_failure; 1300 1301 if (netlink_policy_dump_write(skb, ctx->state)) 1302 goto nla_put_failure; 1303 1304 nla_nest_end(skb, nest); 1305 1306 genlmsg_end(skb, hdr); 1307 } 1308 1309 return skb->len; 1310 1311 nla_put_failure: 1312 genlmsg_cancel(skb, hdr); 1313 return skb->len; 1314 } 1315 1316 static int ctrl_dumppolicy_done(struct netlink_callback *cb) 1317 { 1318 struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx; 1319 1320 netlink_policy_dump_free(ctx->state); 1321 return 0; 1322 } 1323 1324 static const struct genl_ops genl_ctrl_ops[] = { 1325 { 1326 .cmd = CTRL_CMD_GETFAMILY, 1327 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 1328 .policy = ctrl_policy_family, 1329 .maxattr = ARRAY_SIZE(ctrl_policy_family) - 1, 1330 .doit = ctrl_getfamily, 1331 .dumpit = ctrl_dumpfamily, 1332 }, 1333 { 1334 .cmd = CTRL_CMD_GETPOLICY, 1335 .policy = ctrl_policy_policy, 1336 .maxattr = ARRAY_SIZE(ctrl_policy_policy) - 1, 1337 .start = ctrl_dumppolicy_start, 1338 .dumpit = ctrl_dumppolicy, 1339 .done = ctrl_dumppolicy_done, 1340 }, 1341 }; 1342 1343 static const struct genl_multicast_group genl_ctrl_groups[] = { 1344 { .name = "notify", }, 1345 }; 1346 1347 static struct genl_family genl_ctrl __ro_after_init = { 1348 .module = THIS_MODULE, 1349 .ops = genl_ctrl_ops, 1350 .n_ops = ARRAY_SIZE(genl_ctrl_ops), 1351 .mcgrps = genl_ctrl_groups, 1352 .n_mcgrps = ARRAY_SIZE(genl_ctrl_groups), 1353 .id = GENL_ID_CTRL, 1354 .name = "nlctrl", 1355 .version = 0x2, 1356 .netnsok = true, 1357 }; 1358 1359 static int genl_bind(struct net *net, int group) 1360 { 1361 const struct genl_family *family; 1362 unsigned int id; 1363 int ret = 0; 1364 1365 genl_lock_all(); 1366 1367 idr_for_each_entry(&genl_fam_idr, family, id) { 1368 const struct genl_multicast_group *grp; 1369 int i; 1370 1371 if (family->n_mcgrps == 0) 1372 continue; 1373 1374 i = group - family->mcgrp_offset; 1375 if (i < 0 || i >= family->n_mcgrps) 1376 continue; 1377 1378 grp = &family->mcgrps[i]; 1379 if ((grp->flags & GENL_UNS_ADMIN_PERM) && 1380 !ns_capable(net->user_ns, CAP_NET_ADMIN)) 1381 ret = -EPERM; 1382 1383 break; 1384 } 1385 1386 genl_unlock_all(); 1387 return ret; 1388 } 1389 1390 static int __net_init genl_pernet_init(struct net *net) 1391 { 1392 struct netlink_kernel_cfg cfg = { 1393 .input = genl_rcv, 1394 .flags = NL_CFG_F_NONROOT_RECV, 1395 .bind = genl_bind, 1396 }; 1397 1398 /* we'll bump the group number right afterwards */ 1399 net->genl_sock = netlink_kernel_create(net, NETLINK_GENERIC, &cfg); 1400 1401 if (!net->genl_sock && net_eq(net, &init_net)) 1402 panic("GENL: Cannot initialize generic netlink\n"); 1403 1404 if (!net->genl_sock) 1405 return -ENOMEM; 1406 1407 return 0; 1408 } 1409 1410 static void __net_exit genl_pernet_exit(struct net *net) 1411 { 1412 netlink_kernel_release(net->genl_sock); 1413 net->genl_sock = NULL; 1414 } 1415 1416 static struct pernet_operations genl_pernet_ops = { 1417 .init = genl_pernet_init, 1418 .exit = genl_pernet_exit, 1419 }; 1420 1421 static int __init genl_init(void) 1422 { 1423 int err; 1424 1425 err = genl_register_family(&genl_ctrl); 1426 if (err < 0) 1427 goto problem; 1428 1429 err = register_pernet_subsys(&genl_pernet_ops); 1430 if (err) 1431 goto problem; 1432 1433 return 0; 1434 1435 problem: 1436 panic("GENL: Cannot register controller: %d\n", err); 1437 } 1438 1439 core_initcall(genl_init); 1440 1441 static int genlmsg_mcast(struct sk_buff *skb, u32 portid, unsigned long group, 1442 gfp_t flags) 1443 { 1444 struct sk_buff *tmp; 1445 struct net *net, *prev = NULL; 1446 bool delivered = false; 1447 int err; 1448 1449 for_each_net_rcu(net) { 1450 if (prev) { 1451 tmp = skb_clone(skb, flags); 1452 if (!tmp) { 1453 err = -ENOMEM; 1454 goto error; 1455 } 1456 err = nlmsg_multicast(prev->genl_sock, tmp, 1457 portid, group, flags); 1458 if (!err) 1459 delivered = true; 1460 else if (err != -ESRCH) 1461 goto error; 1462 } 1463 1464 prev = net; 1465 } 1466 1467 err = nlmsg_multicast(prev->genl_sock, skb, portid, group, flags); 1468 if (!err) 1469 delivered = true; 1470 else if (err != -ESRCH) 1471 return err; 1472 return delivered ? 0 : -ESRCH; 1473 error: 1474 kfree_skb(skb); 1475 return err; 1476 } 1477 1478 int genlmsg_multicast_allns(const struct genl_family *family, 1479 struct sk_buff *skb, u32 portid, 1480 unsigned int group, gfp_t flags) 1481 { 1482 if (WARN_ON_ONCE(group >= family->n_mcgrps)) 1483 return -EINVAL; 1484 1485 group = family->mcgrp_offset + group; 1486 return genlmsg_mcast(skb, portid, group, flags); 1487 } 1488 EXPORT_SYMBOL(genlmsg_multicast_allns); 1489 1490 void genl_notify(const struct genl_family *family, struct sk_buff *skb, 1491 struct genl_info *info, u32 group, gfp_t flags) 1492 { 1493 struct net *net = genl_info_net(info); 1494 struct sock *sk = net->genl_sock; 1495 1496 if (WARN_ON_ONCE(group >= family->n_mcgrps)) 1497 return; 1498 1499 group = family->mcgrp_offset + group; 1500 nlmsg_notify(sk, skb, info->snd_portid, group, 1501 nlmsg_report(info->nlhdr), flags); 1502 } 1503 EXPORT_SYMBOL(genl_notify); 1504