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