1 /* 2 * NETLINK Generic Netlink Family 3 * 4 * Authors: Jamal Hadi Salim 5 * Thomas Graf <tgraf@suug.ch> 6 * Johannes Berg <johannes@sipsolutions.net> 7 */ 8 9 #include <linux/module.h> 10 #include <linux/kernel.h> 11 #include <linux/slab.h> 12 #include <linux/errno.h> 13 #include <linux/types.h> 14 #include <linux/socket.h> 15 #include <linux/string.h> 16 #include <linux/skbuff.h> 17 #include <linux/mutex.h> 18 #include <linux/bitmap.h> 19 #include <linux/rwsem.h> 20 #include <net/sock.h> 21 #include <net/genetlink.h> 22 23 static DEFINE_MUTEX(genl_mutex); /* serialization of message processing */ 24 static DECLARE_RWSEM(cb_lock); 25 26 void genl_lock(void) 27 { 28 mutex_lock(&genl_mutex); 29 } 30 EXPORT_SYMBOL(genl_lock); 31 32 void genl_unlock(void) 33 { 34 mutex_unlock(&genl_mutex); 35 } 36 EXPORT_SYMBOL(genl_unlock); 37 38 #ifdef CONFIG_LOCKDEP 39 int lockdep_genl_is_held(void) 40 { 41 return lockdep_is_held(&genl_mutex); 42 } 43 EXPORT_SYMBOL(lockdep_genl_is_held); 44 #endif 45 46 static void genl_lock_all(void) 47 { 48 down_write(&cb_lock); 49 genl_lock(); 50 } 51 52 static void genl_unlock_all(void) 53 { 54 genl_unlock(); 55 up_write(&cb_lock); 56 } 57 58 #define GENL_FAM_TAB_SIZE 16 59 #define GENL_FAM_TAB_MASK (GENL_FAM_TAB_SIZE - 1) 60 61 static struct list_head family_ht[GENL_FAM_TAB_SIZE]; 62 /* 63 * Bitmap of multicast groups that are currently in use. 64 * 65 * To avoid an allocation at boot of just one unsigned long, 66 * declare it global instead. 67 * Bit 0 is marked as already used since group 0 is invalid. 68 * Bit 1 is marked as already used since the drop-monitor code 69 * abuses the API and thinks it can statically use group 1. 70 * That group will typically conflict with other groups that 71 * any proper users use. 72 * Bit 16 is marked as used since it's used for generic netlink 73 * and the code no longer marks pre-reserved IDs as used. 74 * Bit 17 is marked as already used since the VFS quota code 75 * also abused this API and relied on family == group ID, we 76 * cater to that by giving it a static family and group ID. 77 */ 78 static unsigned long mc_group_start = 0x3 | BIT(GENL_ID_CTRL) | 79 BIT(GENL_ID_VFS_DQUOT); 80 static unsigned long *mc_groups = &mc_group_start; 81 static unsigned long mc_groups_longs = 1; 82 83 static int genl_ctrl_event(int event, struct genl_family *family, 84 const struct genl_multicast_group *grp, 85 int grp_id); 86 87 static inline unsigned int genl_family_hash(unsigned int id) 88 { 89 return id & GENL_FAM_TAB_MASK; 90 } 91 92 static inline struct list_head *genl_family_chain(unsigned int id) 93 { 94 return &family_ht[genl_family_hash(id)]; 95 } 96 97 static struct genl_family *genl_family_find_byid(unsigned int id) 98 { 99 struct genl_family *f; 100 101 list_for_each_entry(f, genl_family_chain(id), family_list) 102 if (f->id == id) 103 return f; 104 105 return NULL; 106 } 107 108 static struct genl_family *genl_family_find_byname(char *name) 109 { 110 struct genl_family *f; 111 int i; 112 113 for (i = 0; i < GENL_FAM_TAB_SIZE; i++) 114 list_for_each_entry(f, genl_family_chain(i), family_list) 115 if (strcmp(f->name, name) == 0) 116 return f; 117 118 return NULL; 119 } 120 121 static const struct genl_ops *genl_get_cmd(u8 cmd, struct genl_family *family) 122 { 123 int i; 124 125 for (i = 0; i < family->n_ops; i++) 126 if (family->ops[i].cmd == cmd) 127 return &family->ops[i]; 128 129 return NULL; 130 } 131 132 /* Of course we are going to have problems once we hit 133 * 2^16 alive types, but that can only happen by year 2K 134 */ 135 static u16 genl_generate_id(void) 136 { 137 static u16 id_gen_idx = GENL_MIN_ID; 138 int i; 139 140 for (i = 0; i <= GENL_MAX_ID - GENL_MIN_ID; i++) { 141 if (id_gen_idx != GENL_ID_VFS_DQUOT && 142 !genl_family_find_byid(id_gen_idx)) 143 return id_gen_idx; 144 if (++id_gen_idx > GENL_MAX_ID) 145 id_gen_idx = GENL_MIN_ID; 146 } 147 148 return 0; 149 } 150 151 static int genl_allocate_reserve_groups(int n_groups, int *first_id) 152 { 153 unsigned long *new_groups; 154 int start = 0; 155 int i; 156 int id; 157 bool fits; 158 159 do { 160 if (start == 0) 161 id = find_first_zero_bit(mc_groups, 162 mc_groups_longs * 163 BITS_PER_LONG); 164 else 165 id = find_next_zero_bit(mc_groups, 166 mc_groups_longs * BITS_PER_LONG, 167 start); 168 169 fits = true; 170 for (i = id; 171 i < min_t(int, id + n_groups, 172 mc_groups_longs * BITS_PER_LONG); 173 i++) { 174 if (test_bit(i, mc_groups)) { 175 start = i; 176 fits = false; 177 break; 178 } 179 } 180 181 if (id >= mc_groups_longs * BITS_PER_LONG) { 182 unsigned long new_longs = mc_groups_longs + 183 BITS_TO_LONGS(n_groups); 184 size_t nlen = new_longs * sizeof(unsigned long); 185 186 if (mc_groups == &mc_group_start) { 187 new_groups = kzalloc(nlen, GFP_KERNEL); 188 if (!new_groups) 189 return -ENOMEM; 190 mc_groups = new_groups; 191 *mc_groups = mc_group_start; 192 } else { 193 new_groups = krealloc(mc_groups, nlen, 194 GFP_KERNEL); 195 if (!new_groups) 196 return -ENOMEM; 197 mc_groups = new_groups; 198 for (i = 0; i < BITS_TO_LONGS(n_groups); i++) 199 mc_groups[mc_groups_longs + i] = 0; 200 } 201 mc_groups_longs = new_longs; 202 } 203 } while (!fits); 204 205 for (i = id; i < id + n_groups; i++) 206 set_bit(i, mc_groups); 207 *first_id = id; 208 return 0; 209 } 210 211 static struct genl_family genl_ctrl; 212 213 static int genl_validate_assign_mc_groups(struct genl_family *family) 214 { 215 int first_id; 216 int n_groups = family->n_mcgrps; 217 int err, i; 218 bool groups_allocated = false; 219 220 if (!n_groups) 221 return 0; 222 223 for (i = 0; i < n_groups; i++) { 224 const struct genl_multicast_group *grp = &family->mcgrps[i]; 225 226 if (WARN_ON(grp->name[0] == '\0')) 227 return -EINVAL; 228 if (WARN_ON(memchr(grp->name, '\0', GENL_NAMSIZ) == NULL)) 229 return -EINVAL; 230 } 231 232 /* special-case our own group and hacks */ 233 if (family == &genl_ctrl) { 234 first_id = GENL_ID_CTRL; 235 BUG_ON(n_groups != 1); 236 } else if (strcmp(family->name, "NET_DM") == 0) { 237 first_id = 1; 238 BUG_ON(n_groups != 1); 239 } else if (strcmp(family->name, "VFS_DQUOT") == 0) { 240 first_id = GENL_ID_VFS_DQUOT; 241 BUG_ON(n_groups != 1); 242 } else { 243 groups_allocated = true; 244 err = genl_allocate_reserve_groups(n_groups, &first_id); 245 if (err) 246 return err; 247 } 248 249 family->mcgrp_offset = first_id; 250 251 /* if still initializing, can't and don't need to to realloc bitmaps */ 252 if (!init_net.genl_sock) 253 return 0; 254 255 if (family->netnsok) { 256 struct net *net; 257 258 netlink_table_grab(); 259 rcu_read_lock(); 260 for_each_net_rcu(net) { 261 err = __netlink_change_ngroups(net->genl_sock, 262 mc_groups_longs * BITS_PER_LONG); 263 if (err) { 264 /* 265 * No need to roll back, can only fail if 266 * memory allocation fails and then the 267 * number of _possible_ groups has been 268 * increased on some sockets which is ok. 269 */ 270 break; 271 } 272 } 273 rcu_read_unlock(); 274 netlink_table_ungrab(); 275 } else { 276 err = netlink_change_ngroups(init_net.genl_sock, 277 mc_groups_longs * BITS_PER_LONG); 278 } 279 280 if (groups_allocated && err) { 281 for (i = 0; i < family->n_mcgrps; i++) 282 clear_bit(family->mcgrp_offset + i, mc_groups); 283 } 284 285 return err; 286 } 287 288 static void genl_unregister_mc_groups(struct genl_family *family) 289 { 290 struct net *net; 291 int i; 292 293 netlink_table_grab(); 294 rcu_read_lock(); 295 for_each_net_rcu(net) { 296 for (i = 0; i < family->n_mcgrps; i++) 297 __netlink_clear_multicast_users( 298 net->genl_sock, family->mcgrp_offset + i); 299 } 300 rcu_read_unlock(); 301 netlink_table_ungrab(); 302 303 for (i = 0; i < family->n_mcgrps; i++) { 304 int grp_id = family->mcgrp_offset + i; 305 306 if (grp_id != 1) 307 clear_bit(grp_id, mc_groups); 308 genl_ctrl_event(CTRL_CMD_DELMCAST_GRP, family, 309 &family->mcgrps[i], grp_id); 310 } 311 } 312 313 static int genl_validate_ops(struct genl_family *family) 314 { 315 const struct genl_ops *ops = family->ops; 316 unsigned int n_ops = family->n_ops; 317 int i, j; 318 319 if (WARN_ON(n_ops && !ops)) 320 return -EINVAL; 321 322 if (!n_ops) 323 return 0; 324 325 for (i = 0; i < n_ops; i++) { 326 if (ops[i].dumpit == NULL && ops[i].doit == NULL) 327 return -EINVAL; 328 for (j = i + 1; j < n_ops; j++) 329 if (ops[i].cmd == ops[j].cmd) 330 return -EINVAL; 331 } 332 333 /* family is not registered yet, so no locking needed */ 334 family->ops = ops; 335 family->n_ops = n_ops; 336 337 return 0; 338 } 339 340 /** 341 * __genl_register_family - register a generic netlink family 342 * @family: generic netlink family 343 * 344 * Registers the specified family after validating it first. Only one 345 * family may be registered with the same family name or identifier. 346 * The family id may equal GENL_ID_GENERATE causing an unique id to 347 * be automatically generated and assigned. 348 * 349 * The family's ops array must already be assigned, you can use the 350 * genl_register_family_with_ops() helper function. 351 * 352 * Return 0 on success or a negative error code. 353 */ 354 int __genl_register_family(struct genl_family *family) 355 { 356 int err = -EINVAL, i; 357 358 if (family->id && family->id < GENL_MIN_ID) 359 goto errout; 360 361 if (family->id > GENL_MAX_ID) 362 goto errout; 363 364 err = genl_validate_ops(family); 365 if (err) 366 return err; 367 368 genl_lock_all(); 369 370 if (genl_family_find_byname(family->name)) { 371 err = -EEXIST; 372 goto errout_locked; 373 } 374 375 if (family->id == GENL_ID_GENERATE) { 376 u16 newid = genl_generate_id(); 377 378 if (!newid) { 379 err = -ENOMEM; 380 goto errout_locked; 381 } 382 383 family->id = newid; 384 } else if (genl_family_find_byid(family->id)) { 385 err = -EEXIST; 386 goto errout_locked; 387 } 388 389 if (family->maxattr && !family->parallel_ops) { 390 family->attrbuf = kmalloc((family->maxattr+1) * 391 sizeof(struct nlattr *), GFP_KERNEL); 392 if (family->attrbuf == NULL) { 393 err = -ENOMEM; 394 goto errout_locked; 395 } 396 } else 397 family->attrbuf = NULL; 398 399 err = genl_validate_assign_mc_groups(family); 400 if (err) 401 goto errout_locked; 402 403 list_add_tail(&family->family_list, genl_family_chain(family->id)); 404 genl_unlock_all(); 405 406 /* send all events */ 407 genl_ctrl_event(CTRL_CMD_NEWFAMILY, family, NULL, 0); 408 for (i = 0; i < family->n_mcgrps; i++) 409 genl_ctrl_event(CTRL_CMD_NEWMCAST_GRP, family, 410 &family->mcgrps[i], family->mcgrp_offset + i); 411 412 return 0; 413 414 errout_locked: 415 genl_unlock_all(); 416 errout: 417 return err; 418 } 419 EXPORT_SYMBOL(__genl_register_family); 420 421 /** 422 * genl_unregister_family - unregister generic netlink family 423 * @family: generic netlink family 424 * 425 * Unregisters the specified family. 426 * 427 * Returns 0 on success or a negative error code. 428 */ 429 int genl_unregister_family(struct genl_family *family) 430 { 431 struct genl_family *rc; 432 433 genl_lock_all(); 434 435 genl_unregister_mc_groups(family); 436 437 list_for_each_entry(rc, genl_family_chain(family->id), family_list) { 438 if (family->id != rc->id || strcmp(rc->name, family->name)) 439 continue; 440 441 list_del(&rc->family_list); 442 family->n_ops = 0; 443 genl_unlock_all(); 444 445 kfree(family->attrbuf); 446 genl_ctrl_event(CTRL_CMD_DELFAMILY, family, NULL, 0); 447 return 0; 448 } 449 450 genl_unlock_all(); 451 452 return -ENOENT; 453 } 454 EXPORT_SYMBOL(genl_unregister_family); 455 456 /** 457 * genlmsg_put - Add generic netlink header to netlink message 458 * @skb: socket buffer holding the message 459 * @portid: netlink portid the message is addressed to 460 * @seq: sequence number (usually the one of the sender) 461 * @family: generic netlink family 462 * @flags: netlink message flags 463 * @cmd: generic netlink command 464 * 465 * Returns pointer to user specific header 466 */ 467 void *genlmsg_put(struct sk_buff *skb, u32 portid, u32 seq, 468 struct genl_family *family, int flags, u8 cmd) 469 { 470 struct nlmsghdr *nlh; 471 struct genlmsghdr *hdr; 472 473 nlh = nlmsg_put(skb, portid, seq, family->id, GENL_HDRLEN + 474 family->hdrsize, flags); 475 if (nlh == NULL) 476 return NULL; 477 478 hdr = nlmsg_data(nlh); 479 hdr->cmd = cmd; 480 hdr->version = family->version; 481 hdr->reserved = 0; 482 483 return (char *) hdr + GENL_HDRLEN; 484 } 485 EXPORT_SYMBOL(genlmsg_put); 486 487 static int genl_lock_dumpit(struct sk_buff *skb, struct netlink_callback *cb) 488 { 489 /* our ops are always const - netlink API doesn't propagate that */ 490 const struct genl_ops *ops = cb->data; 491 int rc; 492 493 genl_lock(); 494 rc = ops->dumpit(skb, cb); 495 genl_unlock(); 496 return rc; 497 } 498 499 static int genl_lock_done(struct netlink_callback *cb) 500 { 501 /* our ops are always const - netlink API doesn't propagate that */ 502 const struct genl_ops *ops = cb->data; 503 int rc = 0; 504 505 if (ops->done) { 506 genl_lock(); 507 rc = ops->done(cb); 508 genl_unlock(); 509 } 510 return rc; 511 } 512 513 static int genl_family_rcv_msg(struct genl_family *family, 514 struct sk_buff *skb, 515 struct nlmsghdr *nlh) 516 { 517 const struct genl_ops *ops; 518 struct net *net = sock_net(skb->sk); 519 struct genl_info info; 520 struct genlmsghdr *hdr = nlmsg_data(nlh); 521 struct nlattr **attrbuf; 522 int hdrlen, err; 523 524 /* this family doesn't exist in this netns */ 525 if (!family->netnsok && !net_eq(net, &init_net)) 526 return -ENOENT; 527 528 hdrlen = GENL_HDRLEN + family->hdrsize; 529 if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen)) 530 return -EINVAL; 531 532 ops = genl_get_cmd(hdr->cmd, family); 533 if (ops == NULL) 534 return -EOPNOTSUPP; 535 536 if ((ops->flags & GENL_ADMIN_PERM) && 537 !capable(CAP_NET_ADMIN)) 538 return -EPERM; 539 540 if ((nlh->nlmsg_flags & NLM_F_DUMP) == NLM_F_DUMP) { 541 int rc; 542 543 if (ops->dumpit == NULL) 544 return -EOPNOTSUPP; 545 546 if (!family->parallel_ops) { 547 struct netlink_dump_control c = { 548 .module = family->module, 549 /* we have const, but the netlink API doesn't */ 550 .data = (void *)ops, 551 .dump = genl_lock_dumpit, 552 .done = genl_lock_done, 553 }; 554 555 genl_unlock(); 556 rc = __netlink_dump_start(net->genl_sock, skb, nlh, &c); 557 genl_lock(); 558 559 } else { 560 struct netlink_dump_control c = { 561 .module = family->module, 562 .dump = ops->dumpit, 563 .done = ops->done, 564 }; 565 566 rc = __netlink_dump_start(net->genl_sock, skb, nlh, &c); 567 } 568 569 return rc; 570 } 571 572 if (ops->doit == NULL) 573 return -EOPNOTSUPP; 574 575 if (family->maxattr && family->parallel_ops) { 576 attrbuf = kmalloc((family->maxattr+1) * 577 sizeof(struct nlattr *), GFP_KERNEL); 578 if (attrbuf == NULL) 579 return -ENOMEM; 580 } else 581 attrbuf = family->attrbuf; 582 583 if (attrbuf) { 584 err = nlmsg_parse(nlh, hdrlen, attrbuf, family->maxattr, 585 ops->policy); 586 if (err < 0) 587 goto out; 588 } 589 590 info.snd_seq = nlh->nlmsg_seq; 591 info.snd_portid = NETLINK_CB(skb).portid; 592 info.nlhdr = nlh; 593 info.genlhdr = nlmsg_data(nlh); 594 info.userhdr = nlmsg_data(nlh) + GENL_HDRLEN; 595 info.attrs = attrbuf; 596 genl_info_net_set(&info, net); 597 memset(&info.user_ptr, 0, sizeof(info.user_ptr)); 598 599 if (family->pre_doit) { 600 err = family->pre_doit(ops, skb, &info); 601 if (err) 602 goto out; 603 } 604 605 err = ops->doit(skb, &info); 606 607 if (family->post_doit) 608 family->post_doit(ops, skb, &info); 609 610 out: 611 if (family->parallel_ops) 612 kfree(attrbuf); 613 614 return err; 615 } 616 617 static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh) 618 { 619 struct genl_family *family; 620 int err; 621 622 family = genl_family_find_byid(nlh->nlmsg_type); 623 if (family == NULL) 624 return -ENOENT; 625 626 if (!family->parallel_ops) 627 genl_lock(); 628 629 err = genl_family_rcv_msg(family, skb, nlh); 630 631 if (!family->parallel_ops) 632 genl_unlock(); 633 634 return err; 635 } 636 637 static void genl_rcv(struct sk_buff *skb) 638 { 639 down_read(&cb_lock); 640 netlink_rcv_skb(skb, &genl_rcv_msg); 641 up_read(&cb_lock); 642 } 643 644 /************************************************************************** 645 * Controller 646 **************************************************************************/ 647 648 static struct genl_family genl_ctrl = { 649 .id = GENL_ID_CTRL, 650 .name = "nlctrl", 651 .version = 0x2, 652 .maxattr = CTRL_ATTR_MAX, 653 .netnsok = true, 654 }; 655 656 static int ctrl_fill_info(struct genl_family *family, u32 portid, u32 seq, 657 u32 flags, struct sk_buff *skb, u8 cmd) 658 { 659 void *hdr; 660 661 hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd); 662 if (hdr == NULL) 663 return -1; 664 665 if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, family->name) || 666 nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, family->id) || 667 nla_put_u32(skb, CTRL_ATTR_VERSION, family->version) || 668 nla_put_u32(skb, CTRL_ATTR_HDRSIZE, family->hdrsize) || 669 nla_put_u32(skb, CTRL_ATTR_MAXATTR, family->maxattr)) 670 goto nla_put_failure; 671 672 if (family->n_ops) { 673 struct nlattr *nla_ops; 674 int i; 675 676 nla_ops = nla_nest_start(skb, CTRL_ATTR_OPS); 677 if (nla_ops == NULL) 678 goto nla_put_failure; 679 680 for (i = 0; i < family->n_ops; i++) { 681 struct nlattr *nest; 682 const struct genl_ops *ops = &family->ops[i]; 683 u32 op_flags = ops->flags; 684 685 if (ops->dumpit) 686 op_flags |= GENL_CMD_CAP_DUMP; 687 if (ops->doit) 688 op_flags |= GENL_CMD_CAP_DO; 689 if (ops->policy) 690 op_flags |= GENL_CMD_CAP_HASPOL; 691 692 nest = nla_nest_start(skb, i + 1); 693 if (nest == NULL) 694 goto nla_put_failure; 695 696 if (nla_put_u32(skb, CTRL_ATTR_OP_ID, ops->cmd) || 697 nla_put_u32(skb, CTRL_ATTR_OP_FLAGS, op_flags)) 698 goto nla_put_failure; 699 700 nla_nest_end(skb, nest); 701 } 702 703 nla_nest_end(skb, nla_ops); 704 } 705 706 if (family->n_mcgrps) { 707 struct nlattr *nla_grps; 708 int i; 709 710 nla_grps = nla_nest_start(skb, CTRL_ATTR_MCAST_GROUPS); 711 if (nla_grps == NULL) 712 goto nla_put_failure; 713 714 for (i = 0; i < family->n_mcgrps; i++) { 715 struct nlattr *nest; 716 const struct genl_multicast_group *grp; 717 718 grp = &family->mcgrps[i]; 719 720 nest = nla_nest_start(skb, i + 1); 721 if (nest == NULL) 722 goto nla_put_failure; 723 724 if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID, 725 family->mcgrp_offset + i) || 726 nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME, 727 grp->name)) 728 goto nla_put_failure; 729 730 nla_nest_end(skb, nest); 731 } 732 nla_nest_end(skb, nla_grps); 733 } 734 735 return genlmsg_end(skb, hdr); 736 737 nla_put_failure: 738 genlmsg_cancel(skb, hdr); 739 return -EMSGSIZE; 740 } 741 742 static int ctrl_fill_mcgrp_info(struct genl_family *family, 743 const struct genl_multicast_group *grp, 744 int grp_id, u32 portid, u32 seq, u32 flags, 745 struct sk_buff *skb, u8 cmd) 746 { 747 void *hdr; 748 struct nlattr *nla_grps; 749 struct nlattr *nest; 750 751 hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd); 752 if (hdr == NULL) 753 return -1; 754 755 if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, family->name) || 756 nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, family->id)) 757 goto nla_put_failure; 758 759 nla_grps = nla_nest_start(skb, CTRL_ATTR_MCAST_GROUPS); 760 if (nla_grps == NULL) 761 goto nla_put_failure; 762 763 nest = nla_nest_start(skb, 1); 764 if (nest == NULL) 765 goto nla_put_failure; 766 767 if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID, grp_id) || 768 nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME, 769 grp->name)) 770 goto nla_put_failure; 771 772 nla_nest_end(skb, nest); 773 nla_nest_end(skb, nla_grps); 774 775 return genlmsg_end(skb, hdr); 776 777 nla_put_failure: 778 genlmsg_cancel(skb, hdr); 779 return -EMSGSIZE; 780 } 781 782 static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb) 783 { 784 785 int i, n = 0; 786 struct genl_family *rt; 787 struct net *net = sock_net(skb->sk); 788 int chains_to_skip = cb->args[0]; 789 int fams_to_skip = cb->args[1]; 790 791 for (i = chains_to_skip; i < GENL_FAM_TAB_SIZE; i++) { 792 n = 0; 793 list_for_each_entry(rt, genl_family_chain(i), family_list) { 794 if (!rt->netnsok && !net_eq(net, &init_net)) 795 continue; 796 if (++n < fams_to_skip) 797 continue; 798 if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).portid, 799 cb->nlh->nlmsg_seq, NLM_F_MULTI, 800 skb, CTRL_CMD_NEWFAMILY) < 0) 801 goto errout; 802 } 803 804 fams_to_skip = 0; 805 } 806 807 errout: 808 cb->args[0] = i; 809 cb->args[1] = n; 810 811 return skb->len; 812 } 813 814 static struct sk_buff *ctrl_build_family_msg(struct genl_family *family, 815 u32 portid, int seq, u8 cmd) 816 { 817 struct sk_buff *skb; 818 int err; 819 820 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 821 if (skb == NULL) 822 return ERR_PTR(-ENOBUFS); 823 824 err = ctrl_fill_info(family, portid, seq, 0, skb, cmd); 825 if (err < 0) { 826 nlmsg_free(skb); 827 return ERR_PTR(err); 828 } 829 830 return skb; 831 } 832 833 static struct sk_buff * 834 ctrl_build_mcgrp_msg(struct genl_family *family, 835 const struct genl_multicast_group *grp, 836 int grp_id, u32 portid, int seq, u8 cmd) 837 { 838 struct sk_buff *skb; 839 int err; 840 841 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 842 if (skb == NULL) 843 return ERR_PTR(-ENOBUFS); 844 845 err = ctrl_fill_mcgrp_info(family, grp, grp_id, portid, 846 seq, 0, skb, cmd); 847 if (err < 0) { 848 nlmsg_free(skb); 849 return ERR_PTR(err); 850 } 851 852 return skb; 853 } 854 855 static const struct nla_policy ctrl_policy[CTRL_ATTR_MAX+1] = { 856 [CTRL_ATTR_FAMILY_ID] = { .type = NLA_U16 }, 857 [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_NUL_STRING, 858 .len = GENL_NAMSIZ - 1 }, 859 }; 860 861 static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info) 862 { 863 struct sk_buff *msg; 864 struct genl_family *res = NULL; 865 int err = -EINVAL; 866 867 if (info->attrs[CTRL_ATTR_FAMILY_ID]) { 868 u16 id = nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]); 869 res = genl_family_find_byid(id); 870 err = -ENOENT; 871 } 872 873 if (info->attrs[CTRL_ATTR_FAMILY_NAME]) { 874 char *name; 875 876 name = nla_data(info->attrs[CTRL_ATTR_FAMILY_NAME]); 877 res = genl_family_find_byname(name); 878 #ifdef CONFIG_MODULES 879 if (res == NULL) { 880 genl_unlock(); 881 up_read(&cb_lock); 882 request_module("net-pf-%d-proto-%d-family-%s", 883 PF_NETLINK, NETLINK_GENERIC, name); 884 down_read(&cb_lock); 885 genl_lock(); 886 res = genl_family_find_byname(name); 887 } 888 #endif 889 err = -ENOENT; 890 } 891 892 if (res == NULL) 893 return err; 894 895 if (!res->netnsok && !net_eq(genl_info_net(info), &init_net)) { 896 /* family doesn't exist here */ 897 return -ENOENT; 898 } 899 900 msg = ctrl_build_family_msg(res, info->snd_portid, info->snd_seq, 901 CTRL_CMD_NEWFAMILY); 902 if (IS_ERR(msg)) 903 return PTR_ERR(msg); 904 905 return genlmsg_reply(msg, info); 906 } 907 908 static int genl_ctrl_event(int event, struct genl_family *family, 909 const struct genl_multicast_group *grp, 910 int grp_id) 911 { 912 struct sk_buff *msg; 913 914 /* genl is still initialising */ 915 if (!init_net.genl_sock) 916 return 0; 917 918 switch (event) { 919 case CTRL_CMD_NEWFAMILY: 920 case CTRL_CMD_DELFAMILY: 921 WARN_ON(grp); 922 msg = ctrl_build_family_msg(family, 0, 0, event); 923 break; 924 case CTRL_CMD_NEWMCAST_GRP: 925 case CTRL_CMD_DELMCAST_GRP: 926 BUG_ON(!grp); 927 msg = ctrl_build_mcgrp_msg(family, grp, grp_id, 0, 0, event); 928 break; 929 default: 930 return -EINVAL; 931 } 932 933 if (IS_ERR(msg)) 934 return PTR_ERR(msg); 935 936 if (!family->netnsok) { 937 genlmsg_multicast_netns(&genl_ctrl, &init_net, msg, 0, 938 0, GFP_KERNEL); 939 } else { 940 rcu_read_lock(); 941 genlmsg_multicast_allns(&genl_ctrl, msg, 0, 942 0, GFP_ATOMIC); 943 rcu_read_unlock(); 944 } 945 946 return 0; 947 } 948 949 static struct genl_ops genl_ctrl_ops[] = { 950 { 951 .cmd = CTRL_CMD_GETFAMILY, 952 .doit = ctrl_getfamily, 953 .dumpit = ctrl_dumpfamily, 954 .policy = ctrl_policy, 955 }, 956 }; 957 958 static struct genl_multicast_group genl_ctrl_groups[] = { 959 { .name = "notify", }, 960 }; 961 962 static int __net_init genl_pernet_init(struct net *net) 963 { 964 struct netlink_kernel_cfg cfg = { 965 .input = genl_rcv, 966 .flags = NL_CFG_F_NONROOT_RECV, 967 }; 968 969 /* we'll bump the group number right afterwards */ 970 net->genl_sock = netlink_kernel_create(net, NETLINK_GENERIC, &cfg); 971 972 if (!net->genl_sock && net_eq(net, &init_net)) 973 panic("GENL: Cannot initialize generic netlink\n"); 974 975 if (!net->genl_sock) 976 return -ENOMEM; 977 978 return 0; 979 } 980 981 static void __net_exit genl_pernet_exit(struct net *net) 982 { 983 netlink_kernel_release(net->genl_sock); 984 net->genl_sock = NULL; 985 } 986 987 static struct pernet_operations genl_pernet_ops = { 988 .init = genl_pernet_init, 989 .exit = genl_pernet_exit, 990 }; 991 992 static int __init genl_init(void) 993 { 994 int i, err; 995 996 for (i = 0; i < GENL_FAM_TAB_SIZE; i++) 997 INIT_LIST_HEAD(&family_ht[i]); 998 999 err = genl_register_family_with_ops_groups(&genl_ctrl, genl_ctrl_ops, 1000 genl_ctrl_groups); 1001 if (err < 0) 1002 goto problem; 1003 1004 err = register_pernet_subsys(&genl_pernet_ops); 1005 if (err) 1006 goto problem; 1007 1008 return 0; 1009 1010 problem: 1011 panic("GENL: Cannot register controller: %d\n", err); 1012 } 1013 1014 subsys_initcall(genl_init); 1015 1016 static int genlmsg_mcast(struct sk_buff *skb, u32 portid, unsigned long group, 1017 gfp_t flags) 1018 { 1019 struct sk_buff *tmp; 1020 struct net *net, *prev = NULL; 1021 int err; 1022 1023 for_each_net_rcu(net) { 1024 if (prev) { 1025 tmp = skb_clone(skb, flags); 1026 if (!tmp) { 1027 err = -ENOMEM; 1028 goto error; 1029 } 1030 err = nlmsg_multicast(prev->genl_sock, tmp, 1031 portid, group, flags); 1032 if (err) 1033 goto error; 1034 } 1035 1036 prev = net; 1037 } 1038 1039 return nlmsg_multicast(prev->genl_sock, skb, portid, group, flags); 1040 error: 1041 kfree_skb(skb); 1042 return err; 1043 } 1044 1045 int genlmsg_multicast_allns(struct genl_family *family, struct sk_buff *skb, 1046 u32 portid, unsigned int group, gfp_t flags) 1047 { 1048 if (WARN_ON_ONCE(group >= family->n_mcgrps)) 1049 return -EINVAL; 1050 group = family->mcgrp_offset + group; 1051 return genlmsg_mcast(skb, portid, group, flags); 1052 } 1053 EXPORT_SYMBOL(genlmsg_multicast_allns); 1054 1055 void genl_notify(struct genl_family *family, 1056 struct sk_buff *skb, struct net *net, u32 portid, u32 group, 1057 struct nlmsghdr *nlh, gfp_t flags) 1058 { 1059 struct sock *sk = net->genl_sock; 1060 int report = 0; 1061 1062 if (nlh) 1063 report = nlmsg_report(nlh); 1064 1065 if (WARN_ON_ONCE(group >= family->n_mcgrps)) 1066 return; 1067 group = family->mcgrp_offset + group; 1068 nlmsg_notify(sk, skb, portid, group, report, flags); 1069 } 1070 EXPORT_SYMBOL(genl_notify); 1071