1 /* 2 * NETLINK Kernel-user communication protocol. 3 * 4 * Authors: Alan Cox <alan@lxorguk.ukuu.org.uk> 5 * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru> 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation; either version 10 * 2 of the License, or (at your option) any later version. 11 * 12 * Tue Jun 26 14:36:48 MEST 2001 Herbert "herp" Rosmanith 13 * added netlink_proto_exit 14 * Tue Jan 22 18:32:44 BRST 2002 Arnaldo C. de Melo <acme@conectiva.com.br> 15 * use nlk_sk, as sk->protinfo is on a diet 8) 16 * Fri Jul 22 19:51:12 MEST 2005 Harald Welte <laforge@gnumonks.org> 17 * - inc module use count of module that owns 18 * the kernel socket in case userspace opens 19 * socket of same protocol 20 * - remove all module support, since netlink is 21 * mandatory if CONFIG_NET=y these days 22 */ 23 24 #include <linux/module.h> 25 26 #include <linux/capability.h> 27 #include <linux/kernel.h> 28 #include <linux/init.h> 29 #include <linux/signal.h> 30 #include <linux/sched.h> 31 #include <linux/errno.h> 32 #include <linux/string.h> 33 #include <linux/stat.h> 34 #include <linux/socket.h> 35 #include <linux/un.h> 36 #include <linux/fcntl.h> 37 #include <linux/termios.h> 38 #include <linux/sockios.h> 39 #include <linux/net.h> 40 #include <linux/fs.h> 41 #include <linux/slab.h> 42 #include <asm/uaccess.h> 43 #include <linux/skbuff.h> 44 #include <linux/netdevice.h> 45 #include <linux/rtnetlink.h> 46 #include <linux/proc_fs.h> 47 #include <linux/seq_file.h> 48 #include <linux/notifier.h> 49 #include <linux/security.h> 50 #include <linux/jhash.h> 51 #include <linux/jiffies.h> 52 #include <linux/random.h> 53 #include <linux/bitops.h> 54 #include <linux/mm.h> 55 #include <linux/types.h> 56 #include <linux/audit.h> 57 #include <linux/mutex.h> 58 59 #include <net/net_namespace.h> 60 #include <net/sock.h> 61 #include <net/scm.h> 62 #include <net/netlink.h> 63 64 #define NLGRPSZ(x) (ALIGN(x, sizeof(unsigned long) * 8) / 8) 65 #define NLGRPLONGS(x) (NLGRPSZ(x)/sizeof(unsigned long)) 66 67 struct netlink_sock { 68 /* struct sock has to be the first member of netlink_sock */ 69 struct sock sk; 70 u32 portid; 71 u32 dst_portid; 72 u32 dst_group; 73 u32 flags; 74 u32 subscriptions; 75 u32 ngroups; 76 unsigned long *groups; 77 unsigned long state; 78 wait_queue_head_t wait; 79 struct netlink_callback *cb; 80 struct mutex *cb_mutex; 81 struct mutex cb_def_mutex; 82 void (*netlink_rcv)(struct sk_buff *skb); 83 void (*netlink_bind)(int group); 84 struct module *module; 85 }; 86 87 struct listeners { 88 struct rcu_head rcu; 89 unsigned long masks[0]; 90 }; 91 92 #define NETLINK_KERNEL_SOCKET 0x1 93 #define NETLINK_RECV_PKTINFO 0x2 94 #define NETLINK_BROADCAST_SEND_ERROR 0x4 95 #define NETLINK_RECV_NO_ENOBUFS 0x8 96 97 static inline struct netlink_sock *nlk_sk(struct sock *sk) 98 { 99 return container_of(sk, struct netlink_sock, sk); 100 } 101 102 static inline int netlink_is_kernel(struct sock *sk) 103 { 104 return nlk_sk(sk)->flags & NETLINK_KERNEL_SOCKET; 105 } 106 107 struct nl_portid_hash { 108 struct hlist_head *table; 109 unsigned long rehash_time; 110 111 unsigned int mask; 112 unsigned int shift; 113 114 unsigned int entries; 115 unsigned int max_shift; 116 117 u32 rnd; 118 }; 119 120 struct netlink_table { 121 struct nl_portid_hash hash; 122 struct hlist_head mc_list; 123 struct listeners __rcu *listeners; 124 unsigned int flags; 125 unsigned int groups; 126 struct mutex *cb_mutex; 127 struct module *module; 128 void (*bind)(int group); 129 int registered; 130 }; 131 132 static struct netlink_table *nl_table; 133 134 static DECLARE_WAIT_QUEUE_HEAD(nl_table_wait); 135 136 static int netlink_dump(struct sock *sk); 137 138 static DEFINE_RWLOCK(nl_table_lock); 139 static atomic_t nl_table_users = ATOMIC_INIT(0); 140 141 #define nl_deref_protected(X) rcu_dereference_protected(X, lockdep_is_held(&nl_table_lock)); 142 143 static ATOMIC_NOTIFIER_HEAD(netlink_chain); 144 145 static inline u32 netlink_group_mask(u32 group) 146 { 147 return group ? 1 << (group - 1) : 0; 148 } 149 150 static inline struct hlist_head *nl_portid_hashfn(struct nl_portid_hash *hash, u32 portid) 151 { 152 return &hash->table[jhash_1word(portid, hash->rnd) & hash->mask]; 153 } 154 155 static void netlink_destroy_callback(struct netlink_callback *cb) 156 { 157 kfree_skb(cb->skb); 158 kfree(cb); 159 } 160 161 static void netlink_consume_callback(struct netlink_callback *cb) 162 { 163 consume_skb(cb->skb); 164 kfree(cb); 165 } 166 167 static void netlink_sock_destruct(struct sock *sk) 168 { 169 struct netlink_sock *nlk = nlk_sk(sk); 170 171 if (nlk->cb) { 172 if (nlk->cb->done) 173 nlk->cb->done(nlk->cb); 174 175 module_put(nlk->cb->module); 176 netlink_destroy_callback(nlk->cb); 177 } 178 179 skb_queue_purge(&sk->sk_receive_queue); 180 181 if (!sock_flag(sk, SOCK_DEAD)) { 182 printk(KERN_ERR "Freeing alive netlink socket %p\n", sk); 183 return; 184 } 185 186 WARN_ON(atomic_read(&sk->sk_rmem_alloc)); 187 WARN_ON(atomic_read(&sk->sk_wmem_alloc)); 188 WARN_ON(nlk_sk(sk)->groups); 189 } 190 191 /* This lock without WQ_FLAG_EXCLUSIVE is good on UP and it is _very_ bad on 192 * SMP. Look, when several writers sleep and reader wakes them up, all but one 193 * immediately hit write lock and grab all the cpus. Exclusive sleep solves 194 * this, _but_ remember, it adds useless work on UP machines. 195 */ 196 197 void netlink_table_grab(void) 198 __acquires(nl_table_lock) 199 { 200 might_sleep(); 201 202 write_lock_irq(&nl_table_lock); 203 204 if (atomic_read(&nl_table_users)) { 205 DECLARE_WAITQUEUE(wait, current); 206 207 add_wait_queue_exclusive(&nl_table_wait, &wait); 208 for (;;) { 209 set_current_state(TASK_UNINTERRUPTIBLE); 210 if (atomic_read(&nl_table_users) == 0) 211 break; 212 write_unlock_irq(&nl_table_lock); 213 schedule(); 214 write_lock_irq(&nl_table_lock); 215 } 216 217 __set_current_state(TASK_RUNNING); 218 remove_wait_queue(&nl_table_wait, &wait); 219 } 220 } 221 222 void netlink_table_ungrab(void) 223 __releases(nl_table_lock) 224 { 225 write_unlock_irq(&nl_table_lock); 226 wake_up(&nl_table_wait); 227 } 228 229 static inline void 230 netlink_lock_table(void) 231 { 232 /* read_lock() synchronizes us to netlink_table_grab */ 233 234 read_lock(&nl_table_lock); 235 atomic_inc(&nl_table_users); 236 read_unlock(&nl_table_lock); 237 } 238 239 static inline void 240 netlink_unlock_table(void) 241 { 242 if (atomic_dec_and_test(&nl_table_users)) 243 wake_up(&nl_table_wait); 244 } 245 246 static struct sock *netlink_lookup(struct net *net, int protocol, u32 portid) 247 { 248 struct nl_portid_hash *hash = &nl_table[protocol].hash; 249 struct hlist_head *head; 250 struct sock *sk; 251 struct hlist_node *node; 252 253 read_lock(&nl_table_lock); 254 head = nl_portid_hashfn(hash, portid); 255 sk_for_each(sk, node, head) { 256 if (net_eq(sock_net(sk), net) && (nlk_sk(sk)->portid == portid)) { 257 sock_hold(sk); 258 goto found; 259 } 260 } 261 sk = NULL; 262 found: 263 read_unlock(&nl_table_lock); 264 return sk; 265 } 266 267 static struct hlist_head *nl_portid_hash_zalloc(size_t size) 268 { 269 if (size <= PAGE_SIZE) 270 return kzalloc(size, GFP_ATOMIC); 271 else 272 return (struct hlist_head *) 273 __get_free_pages(GFP_ATOMIC | __GFP_ZERO, 274 get_order(size)); 275 } 276 277 static void nl_portid_hash_free(struct hlist_head *table, size_t size) 278 { 279 if (size <= PAGE_SIZE) 280 kfree(table); 281 else 282 free_pages((unsigned long)table, get_order(size)); 283 } 284 285 static int nl_portid_hash_rehash(struct nl_portid_hash *hash, int grow) 286 { 287 unsigned int omask, mask, shift; 288 size_t osize, size; 289 struct hlist_head *otable, *table; 290 int i; 291 292 omask = mask = hash->mask; 293 osize = size = (mask + 1) * sizeof(*table); 294 shift = hash->shift; 295 296 if (grow) { 297 if (++shift > hash->max_shift) 298 return 0; 299 mask = mask * 2 + 1; 300 size *= 2; 301 } 302 303 table = nl_portid_hash_zalloc(size); 304 if (!table) 305 return 0; 306 307 otable = hash->table; 308 hash->table = table; 309 hash->mask = mask; 310 hash->shift = shift; 311 get_random_bytes(&hash->rnd, sizeof(hash->rnd)); 312 313 for (i = 0; i <= omask; i++) { 314 struct sock *sk; 315 struct hlist_node *node, *tmp; 316 317 sk_for_each_safe(sk, node, tmp, &otable[i]) 318 __sk_add_node(sk, nl_portid_hashfn(hash, nlk_sk(sk)->portid)); 319 } 320 321 nl_portid_hash_free(otable, osize); 322 hash->rehash_time = jiffies + 10 * 60 * HZ; 323 return 1; 324 } 325 326 static inline int nl_portid_hash_dilute(struct nl_portid_hash *hash, int len) 327 { 328 int avg = hash->entries >> hash->shift; 329 330 if (unlikely(avg > 1) && nl_portid_hash_rehash(hash, 1)) 331 return 1; 332 333 if (unlikely(len > avg) && time_after(jiffies, hash->rehash_time)) { 334 nl_portid_hash_rehash(hash, 0); 335 return 1; 336 } 337 338 return 0; 339 } 340 341 static const struct proto_ops netlink_ops; 342 343 static void 344 netlink_update_listeners(struct sock *sk) 345 { 346 struct netlink_table *tbl = &nl_table[sk->sk_protocol]; 347 struct hlist_node *node; 348 unsigned long mask; 349 unsigned int i; 350 struct listeners *listeners; 351 352 listeners = nl_deref_protected(tbl->listeners); 353 if (!listeners) 354 return; 355 356 for (i = 0; i < NLGRPLONGS(tbl->groups); i++) { 357 mask = 0; 358 sk_for_each_bound(sk, node, &tbl->mc_list) { 359 if (i < NLGRPLONGS(nlk_sk(sk)->ngroups)) 360 mask |= nlk_sk(sk)->groups[i]; 361 } 362 listeners->masks[i] = mask; 363 } 364 /* this function is only called with the netlink table "grabbed", which 365 * makes sure updates are visible before bind or setsockopt return. */ 366 } 367 368 static int netlink_insert(struct sock *sk, struct net *net, u32 portid) 369 { 370 struct nl_portid_hash *hash = &nl_table[sk->sk_protocol].hash; 371 struct hlist_head *head; 372 int err = -EADDRINUSE; 373 struct sock *osk; 374 struct hlist_node *node; 375 int len; 376 377 netlink_table_grab(); 378 head = nl_portid_hashfn(hash, portid); 379 len = 0; 380 sk_for_each(osk, node, head) { 381 if (net_eq(sock_net(osk), net) && (nlk_sk(osk)->portid == portid)) 382 break; 383 len++; 384 } 385 if (node) 386 goto err; 387 388 err = -EBUSY; 389 if (nlk_sk(sk)->portid) 390 goto err; 391 392 err = -ENOMEM; 393 if (BITS_PER_LONG > 32 && unlikely(hash->entries >= UINT_MAX)) 394 goto err; 395 396 if (len && nl_portid_hash_dilute(hash, len)) 397 head = nl_portid_hashfn(hash, portid); 398 hash->entries++; 399 nlk_sk(sk)->portid = portid; 400 sk_add_node(sk, head); 401 err = 0; 402 403 err: 404 netlink_table_ungrab(); 405 return err; 406 } 407 408 static void netlink_remove(struct sock *sk) 409 { 410 netlink_table_grab(); 411 if (sk_del_node_init(sk)) 412 nl_table[sk->sk_protocol].hash.entries--; 413 if (nlk_sk(sk)->subscriptions) 414 __sk_del_bind_node(sk); 415 netlink_table_ungrab(); 416 } 417 418 static struct proto netlink_proto = { 419 .name = "NETLINK", 420 .owner = THIS_MODULE, 421 .obj_size = sizeof(struct netlink_sock), 422 }; 423 424 static int __netlink_create(struct net *net, struct socket *sock, 425 struct mutex *cb_mutex, int protocol) 426 { 427 struct sock *sk; 428 struct netlink_sock *nlk; 429 430 sock->ops = &netlink_ops; 431 432 sk = sk_alloc(net, PF_NETLINK, GFP_KERNEL, &netlink_proto); 433 if (!sk) 434 return -ENOMEM; 435 436 sock_init_data(sock, sk); 437 438 nlk = nlk_sk(sk); 439 if (cb_mutex) { 440 nlk->cb_mutex = cb_mutex; 441 } else { 442 nlk->cb_mutex = &nlk->cb_def_mutex; 443 mutex_init(nlk->cb_mutex); 444 } 445 init_waitqueue_head(&nlk->wait); 446 447 sk->sk_destruct = netlink_sock_destruct; 448 sk->sk_protocol = protocol; 449 return 0; 450 } 451 452 static int netlink_create(struct net *net, struct socket *sock, int protocol, 453 int kern) 454 { 455 struct module *module = NULL; 456 struct mutex *cb_mutex; 457 struct netlink_sock *nlk; 458 void (*bind)(int group); 459 int err = 0; 460 461 sock->state = SS_UNCONNECTED; 462 463 if (sock->type != SOCK_RAW && sock->type != SOCK_DGRAM) 464 return -ESOCKTNOSUPPORT; 465 466 if (protocol < 0 || protocol >= MAX_LINKS) 467 return -EPROTONOSUPPORT; 468 469 netlink_lock_table(); 470 #ifdef CONFIG_MODULES 471 if (!nl_table[protocol].registered) { 472 netlink_unlock_table(); 473 request_module("net-pf-%d-proto-%d", PF_NETLINK, protocol); 474 netlink_lock_table(); 475 } 476 #endif 477 if (nl_table[protocol].registered && 478 try_module_get(nl_table[protocol].module)) 479 module = nl_table[protocol].module; 480 else 481 err = -EPROTONOSUPPORT; 482 cb_mutex = nl_table[protocol].cb_mutex; 483 bind = nl_table[protocol].bind; 484 netlink_unlock_table(); 485 486 if (err < 0) 487 goto out; 488 489 err = __netlink_create(net, sock, cb_mutex, protocol); 490 if (err < 0) 491 goto out_module; 492 493 local_bh_disable(); 494 sock_prot_inuse_add(net, &netlink_proto, 1); 495 local_bh_enable(); 496 497 nlk = nlk_sk(sock->sk); 498 nlk->module = module; 499 nlk->netlink_bind = bind; 500 out: 501 return err; 502 503 out_module: 504 module_put(module); 505 goto out; 506 } 507 508 static int netlink_release(struct socket *sock) 509 { 510 struct sock *sk = sock->sk; 511 struct netlink_sock *nlk; 512 513 if (!sk) 514 return 0; 515 516 netlink_remove(sk); 517 sock_orphan(sk); 518 nlk = nlk_sk(sk); 519 520 /* 521 * OK. Socket is unlinked, any packets that arrive now 522 * will be purged. 523 */ 524 525 sock->sk = NULL; 526 wake_up_interruptible_all(&nlk->wait); 527 528 skb_queue_purge(&sk->sk_write_queue); 529 530 if (nlk->portid) { 531 struct netlink_notify n = { 532 .net = sock_net(sk), 533 .protocol = sk->sk_protocol, 534 .portid = nlk->portid, 535 }; 536 atomic_notifier_call_chain(&netlink_chain, 537 NETLINK_URELEASE, &n); 538 } 539 540 module_put(nlk->module); 541 542 netlink_table_grab(); 543 if (netlink_is_kernel(sk)) { 544 BUG_ON(nl_table[sk->sk_protocol].registered == 0); 545 if (--nl_table[sk->sk_protocol].registered == 0) { 546 struct listeners *old; 547 548 old = nl_deref_protected(nl_table[sk->sk_protocol].listeners); 549 RCU_INIT_POINTER(nl_table[sk->sk_protocol].listeners, NULL); 550 kfree_rcu(old, rcu); 551 nl_table[sk->sk_protocol].module = NULL; 552 nl_table[sk->sk_protocol].bind = NULL; 553 nl_table[sk->sk_protocol].flags = 0; 554 nl_table[sk->sk_protocol].registered = 0; 555 } 556 } else if (nlk->subscriptions) { 557 netlink_update_listeners(sk); 558 } 559 netlink_table_ungrab(); 560 561 kfree(nlk->groups); 562 nlk->groups = NULL; 563 564 local_bh_disable(); 565 sock_prot_inuse_add(sock_net(sk), &netlink_proto, -1); 566 local_bh_enable(); 567 sock_put(sk); 568 return 0; 569 } 570 571 static int netlink_autobind(struct socket *sock) 572 { 573 struct sock *sk = sock->sk; 574 struct net *net = sock_net(sk); 575 struct nl_portid_hash *hash = &nl_table[sk->sk_protocol].hash; 576 struct hlist_head *head; 577 struct sock *osk; 578 struct hlist_node *node; 579 s32 portid = task_tgid_vnr(current); 580 int err; 581 static s32 rover = -4097; 582 583 retry: 584 cond_resched(); 585 netlink_table_grab(); 586 head = nl_portid_hashfn(hash, portid); 587 sk_for_each(osk, node, head) { 588 if (!net_eq(sock_net(osk), net)) 589 continue; 590 if (nlk_sk(osk)->portid == portid) { 591 /* Bind collision, search negative portid values. */ 592 portid = rover--; 593 if (rover > -4097) 594 rover = -4097; 595 netlink_table_ungrab(); 596 goto retry; 597 } 598 } 599 netlink_table_ungrab(); 600 601 err = netlink_insert(sk, net, portid); 602 if (err == -EADDRINUSE) 603 goto retry; 604 605 /* If 2 threads race to autobind, that is fine. */ 606 if (err == -EBUSY) 607 err = 0; 608 609 return err; 610 } 611 612 static inline int netlink_capable(const struct socket *sock, unsigned int flag) 613 { 614 return (nl_table[sock->sk->sk_protocol].flags & flag) || 615 ns_capable(sock_net(sock->sk)->user_ns, CAP_NET_ADMIN); 616 } 617 618 static void 619 netlink_update_subscriptions(struct sock *sk, unsigned int subscriptions) 620 { 621 struct netlink_sock *nlk = nlk_sk(sk); 622 623 if (nlk->subscriptions && !subscriptions) 624 __sk_del_bind_node(sk); 625 else if (!nlk->subscriptions && subscriptions) 626 sk_add_bind_node(sk, &nl_table[sk->sk_protocol].mc_list); 627 nlk->subscriptions = subscriptions; 628 } 629 630 static int netlink_realloc_groups(struct sock *sk) 631 { 632 struct netlink_sock *nlk = nlk_sk(sk); 633 unsigned int groups; 634 unsigned long *new_groups; 635 int err = 0; 636 637 netlink_table_grab(); 638 639 groups = nl_table[sk->sk_protocol].groups; 640 if (!nl_table[sk->sk_protocol].registered) { 641 err = -ENOENT; 642 goto out_unlock; 643 } 644 645 if (nlk->ngroups >= groups) 646 goto out_unlock; 647 648 new_groups = krealloc(nlk->groups, NLGRPSZ(groups), GFP_ATOMIC); 649 if (new_groups == NULL) { 650 err = -ENOMEM; 651 goto out_unlock; 652 } 653 memset((char *)new_groups + NLGRPSZ(nlk->ngroups), 0, 654 NLGRPSZ(groups) - NLGRPSZ(nlk->ngroups)); 655 656 nlk->groups = new_groups; 657 nlk->ngroups = groups; 658 out_unlock: 659 netlink_table_ungrab(); 660 return err; 661 } 662 663 static int netlink_bind(struct socket *sock, struct sockaddr *addr, 664 int addr_len) 665 { 666 struct sock *sk = sock->sk; 667 struct net *net = sock_net(sk); 668 struct netlink_sock *nlk = nlk_sk(sk); 669 struct sockaddr_nl *nladdr = (struct sockaddr_nl *)addr; 670 int err; 671 672 if (nladdr->nl_family != AF_NETLINK) 673 return -EINVAL; 674 675 /* Only superuser is allowed to listen multicasts */ 676 if (nladdr->nl_groups) { 677 if (!netlink_capable(sock, NL_CFG_F_NONROOT_RECV)) 678 return -EPERM; 679 err = netlink_realloc_groups(sk); 680 if (err) 681 return err; 682 } 683 684 if (nlk->portid) { 685 if (nladdr->nl_pid != nlk->portid) 686 return -EINVAL; 687 } else { 688 err = nladdr->nl_pid ? 689 netlink_insert(sk, net, nladdr->nl_pid) : 690 netlink_autobind(sock); 691 if (err) 692 return err; 693 } 694 695 if (!nladdr->nl_groups && (nlk->groups == NULL || !(u32)nlk->groups[0])) 696 return 0; 697 698 netlink_table_grab(); 699 netlink_update_subscriptions(sk, nlk->subscriptions + 700 hweight32(nladdr->nl_groups) - 701 hweight32(nlk->groups[0])); 702 nlk->groups[0] = (nlk->groups[0] & ~0xffffffffUL) | nladdr->nl_groups; 703 netlink_update_listeners(sk); 704 netlink_table_ungrab(); 705 706 if (nlk->netlink_bind && nlk->groups[0]) { 707 int i; 708 709 for (i=0; i<nlk->ngroups; i++) { 710 if (test_bit(i, nlk->groups)) 711 nlk->netlink_bind(i); 712 } 713 } 714 715 return 0; 716 } 717 718 static int netlink_connect(struct socket *sock, struct sockaddr *addr, 719 int alen, int flags) 720 { 721 int err = 0; 722 struct sock *sk = sock->sk; 723 struct netlink_sock *nlk = nlk_sk(sk); 724 struct sockaddr_nl *nladdr = (struct sockaddr_nl *)addr; 725 726 if (alen < sizeof(addr->sa_family)) 727 return -EINVAL; 728 729 if (addr->sa_family == AF_UNSPEC) { 730 sk->sk_state = NETLINK_UNCONNECTED; 731 nlk->dst_portid = 0; 732 nlk->dst_group = 0; 733 return 0; 734 } 735 if (addr->sa_family != AF_NETLINK) 736 return -EINVAL; 737 738 /* Only superuser is allowed to send multicasts */ 739 if (nladdr->nl_groups && !netlink_capable(sock, NL_CFG_F_NONROOT_SEND)) 740 return -EPERM; 741 742 if (!nlk->portid) 743 err = netlink_autobind(sock); 744 745 if (err == 0) { 746 sk->sk_state = NETLINK_CONNECTED; 747 nlk->dst_portid = nladdr->nl_pid; 748 nlk->dst_group = ffs(nladdr->nl_groups); 749 } 750 751 return err; 752 } 753 754 static int netlink_getname(struct socket *sock, struct sockaddr *addr, 755 int *addr_len, int peer) 756 { 757 struct sock *sk = sock->sk; 758 struct netlink_sock *nlk = nlk_sk(sk); 759 DECLARE_SOCKADDR(struct sockaddr_nl *, nladdr, addr); 760 761 nladdr->nl_family = AF_NETLINK; 762 nladdr->nl_pad = 0; 763 *addr_len = sizeof(*nladdr); 764 765 if (peer) { 766 nladdr->nl_pid = nlk->dst_portid; 767 nladdr->nl_groups = netlink_group_mask(nlk->dst_group); 768 } else { 769 nladdr->nl_pid = nlk->portid; 770 nladdr->nl_groups = nlk->groups ? nlk->groups[0] : 0; 771 } 772 return 0; 773 } 774 775 static void netlink_overrun(struct sock *sk) 776 { 777 struct netlink_sock *nlk = nlk_sk(sk); 778 779 if (!(nlk->flags & NETLINK_RECV_NO_ENOBUFS)) { 780 if (!test_and_set_bit(0, &nlk_sk(sk)->state)) { 781 sk->sk_err = ENOBUFS; 782 sk->sk_error_report(sk); 783 } 784 } 785 atomic_inc(&sk->sk_drops); 786 } 787 788 static struct sock *netlink_getsockbyportid(struct sock *ssk, u32 portid) 789 { 790 struct sock *sock; 791 struct netlink_sock *nlk; 792 793 sock = netlink_lookup(sock_net(ssk), ssk->sk_protocol, portid); 794 if (!sock) 795 return ERR_PTR(-ECONNREFUSED); 796 797 /* Don't bother queuing skb if kernel socket has no input function */ 798 nlk = nlk_sk(sock); 799 if (sock->sk_state == NETLINK_CONNECTED && 800 nlk->dst_portid != nlk_sk(ssk)->portid) { 801 sock_put(sock); 802 return ERR_PTR(-ECONNREFUSED); 803 } 804 return sock; 805 } 806 807 struct sock *netlink_getsockbyfilp(struct file *filp) 808 { 809 struct inode *inode = filp->f_path.dentry->d_inode; 810 struct sock *sock; 811 812 if (!S_ISSOCK(inode->i_mode)) 813 return ERR_PTR(-ENOTSOCK); 814 815 sock = SOCKET_I(inode)->sk; 816 if (sock->sk_family != AF_NETLINK) 817 return ERR_PTR(-EINVAL); 818 819 sock_hold(sock); 820 return sock; 821 } 822 823 /* 824 * Attach a skb to a netlink socket. 825 * The caller must hold a reference to the destination socket. On error, the 826 * reference is dropped. The skb is not send to the destination, just all 827 * all error checks are performed and memory in the queue is reserved. 828 * Return values: 829 * < 0: error. skb freed, reference to sock dropped. 830 * 0: continue 831 * 1: repeat lookup - reference dropped while waiting for socket memory. 832 */ 833 int netlink_attachskb(struct sock *sk, struct sk_buff *skb, 834 long *timeo, struct sock *ssk) 835 { 836 struct netlink_sock *nlk; 837 838 nlk = nlk_sk(sk); 839 840 if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf || 841 test_bit(0, &nlk->state)) { 842 DECLARE_WAITQUEUE(wait, current); 843 if (!*timeo) { 844 if (!ssk || netlink_is_kernel(ssk)) 845 netlink_overrun(sk); 846 sock_put(sk); 847 kfree_skb(skb); 848 return -EAGAIN; 849 } 850 851 __set_current_state(TASK_INTERRUPTIBLE); 852 add_wait_queue(&nlk->wait, &wait); 853 854 if ((atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf || 855 test_bit(0, &nlk->state)) && 856 !sock_flag(sk, SOCK_DEAD)) 857 *timeo = schedule_timeout(*timeo); 858 859 __set_current_state(TASK_RUNNING); 860 remove_wait_queue(&nlk->wait, &wait); 861 sock_put(sk); 862 863 if (signal_pending(current)) { 864 kfree_skb(skb); 865 return sock_intr_errno(*timeo); 866 } 867 return 1; 868 } 869 skb_set_owner_r(skb, sk); 870 return 0; 871 } 872 873 static int __netlink_sendskb(struct sock *sk, struct sk_buff *skb) 874 { 875 int len = skb->len; 876 877 skb_queue_tail(&sk->sk_receive_queue, skb); 878 sk->sk_data_ready(sk, len); 879 return len; 880 } 881 882 int netlink_sendskb(struct sock *sk, struct sk_buff *skb) 883 { 884 int len = __netlink_sendskb(sk, skb); 885 886 sock_put(sk); 887 return len; 888 } 889 890 void netlink_detachskb(struct sock *sk, struct sk_buff *skb) 891 { 892 kfree_skb(skb); 893 sock_put(sk); 894 } 895 896 static struct sk_buff *netlink_trim(struct sk_buff *skb, gfp_t allocation) 897 { 898 int delta; 899 900 skb_orphan(skb); 901 902 delta = skb->end - skb->tail; 903 if (delta * 2 < skb->truesize) 904 return skb; 905 906 if (skb_shared(skb)) { 907 struct sk_buff *nskb = skb_clone(skb, allocation); 908 if (!nskb) 909 return skb; 910 consume_skb(skb); 911 skb = nskb; 912 } 913 914 if (!pskb_expand_head(skb, 0, -delta, allocation)) 915 skb->truesize -= delta; 916 917 return skb; 918 } 919 920 static void netlink_rcv_wake(struct sock *sk) 921 { 922 struct netlink_sock *nlk = nlk_sk(sk); 923 924 if (skb_queue_empty(&sk->sk_receive_queue)) 925 clear_bit(0, &nlk->state); 926 if (!test_bit(0, &nlk->state)) 927 wake_up_interruptible(&nlk->wait); 928 } 929 930 static int netlink_unicast_kernel(struct sock *sk, struct sk_buff *skb, 931 struct sock *ssk) 932 { 933 int ret; 934 struct netlink_sock *nlk = nlk_sk(sk); 935 936 ret = -ECONNREFUSED; 937 if (nlk->netlink_rcv != NULL) { 938 ret = skb->len; 939 skb_set_owner_r(skb, sk); 940 NETLINK_CB(skb).ssk = ssk; 941 nlk->netlink_rcv(skb); 942 consume_skb(skb); 943 } else { 944 kfree_skb(skb); 945 } 946 sock_put(sk); 947 return ret; 948 } 949 950 int netlink_unicast(struct sock *ssk, struct sk_buff *skb, 951 u32 portid, int nonblock) 952 { 953 struct sock *sk; 954 int err; 955 long timeo; 956 957 skb = netlink_trim(skb, gfp_any()); 958 959 timeo = sock_sndtimeo(ssk, nonblock); 960 retry: 961 sk = netlink_getsockbyportid(ssk, portid); 962 if (IS_ERR(sk)) { 963 kfree_skb(skb); 964 return PTR_ERR(sk); 965 } 966 if (netlink_is_kernel(sk)) 967 return netlink_unicast_kernel(sk, skb, ssk); 968 969 if (sk_filter(sk, skb)) { 970 err = skb->len; 971 kfree_skb(skb); 972 sock_put(sk); 973 return err; 974 } 975 976 err = netlink_attachskb(sk, skb, &timeo, ssk); 977 if (err == 1) 978 goto retry; 979 if (err) 980 return err; 981 982 return netlink_sendskb(sk, skb); 983 } 984 EXPORT_SYMBOL(netlink_unicast); 985 986 int netlink_has_listeners(struct sock *sk, unsigned int group) 987 { 988 int res = 0; 989 struct listeners *listeners; 990 991 BUG_ON(!netlink_is_kernel(sk)); 992 993 rcu_read_lock(); 994 listeners = rcu_dereference(nl_table[sk->sk_protocol].listeners); 995 996 if (listeners && group - 1 < nl_table[sk->sk_protocol].groups) 997 res = test_bit(group - 1, listeners->masks); 998 999 rcu_read_unlock(); 1000 1001 return res; 1002 } 1003 EXPORT_SYMBOL_GPL(netlink_has_listeners); 1004 1005 static int netlink_broadcast_deliver(struct sock *sk, struct sk_buff *skb) 1006 { 1007 struct netlink_sock *nlk = nlk_sk(sk); 1008 1009 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf && 1010 !test_bit(0, &nlk->state)) { 1011 skb_set_owner_r(skb, sk); 1012 __netlink_sendskb(sk, skb); 1013 return atomic_read(&sk->sk_rmem_alloc) > (sk->sk_rcvbuf >> 1); 1014 } 1015 return -1; 1016 } 1017 1018 struct netlink_broadcast_data { 1019 struct sock *exclude_sk; 1020 struct net *net; 1021 u32 portid; 1022 u32 group; 1023 int failure; 1024 int delivery_failure; 1025 int congested; 1026 int delivered; 1027 gfp_t allocation; 1028 struct sk_buff *skb, *skb2; 1029 int (*tx_filter)(struct sock *dsk, struct sk_buff *skb, void *data); 1030 void *tx_data; 1031 }; 1032 1033 static int do_one_broadcast(struct sock *sk, 1034 struct netlink_broadcast_data *p) 1035 { 1036 struct netlink_sock *nlk = nlk_sk(sk); 1037 int val; 1038 1039 if (p->exclude_sk == sk) 1040 goto out; 1041 1042 if (nlk->portid == p->portid || p->group - 1 >= nlk->ngroups || 1043 !test_bit(p->group - 1, nlk->groups)) 1044 goto out; 1045 1046 if (!net_eq(sock_net(sk), p->net)) 1047 goto out; 1048 1049 if (p->failure) { 1050 netlink_overrun(sk); 1051 goto out; 1052 } 1053 1054 sock_hold(sk); 1055 if (p->skb2 == NULL) { 1056 if (skb_shared(p->skb)) { 1057 p->skb2 = skb_clone(p->skb, p->allocation); 1058 } else { 1059 p->skb2 = skb_get(p->skb); 1060 /* 1061 * skb ownership may have been set when 1062 * delivered to a previous socket. 1063 */ 1064 skb_orphan(p->skb2); 1065 } 1066 } 1067 if (p->skb2 == NULL) { 1068 netlink_overrun(sk); 1069 /* Clone failed. Notify ALL listeners. */ 1070 p->failure = 1; 1071 if (nlk->flags & NETLINK_BROADCAST_SEND_ERROR) 1072 p->delivery_failure = 1; 1073 } else if (p->tx_filter && p->tx_filter(sk, p->skb2, p->tx_data)) { 1074 kfree_skb(p->skb2); 1075 p->skb2 = NULL; 1076 } else if (sk_filter(sk, p->skb2)) { 1077 kfree_skb(p->skb2); 1078 p->skb2 = NULL; 1079 } else if ((val = netlink_broadcast_deliver(sk, p->skb2)) < 0) { 1080 netlink_overrun(sk); 1081 if (nlk->flags & NETLINK_BROADCAST_SEND_ERROR) 1082 p->delivery_failure = 1; 1083 } else { 1084 p->congested |= val; 1085 p->delivered = 1; 1086 p->skb2 = NULL; 1087 } 1088 sock_put(sk); 1089 1090 out: 1091 return 0; 1092 } 1093 1094 int netlink_broadcast_filtered(struct sock *ssk, struct sk_buff *skb, u32 portid, 1095 u32 group, gfp_t allocation, 1096 int (*filter)(struct sock *dsk, struct sk_buff *skb, void *data), 1097 void *filter_data) 1098 { 1099 struct net *net = sock_net(ssk); 1100 struct netlink_broadcast_data info; 1101 struct hlist_node *node; 1102 struct sock *sk; 1103 1104 skb = netlink_trim(skb, allocation); 1105 1106 info.exclude_sk = ssk; 1107 info.net = net; 1108 info.portid = portid; 1109 info.group = group; 1110 info.failure = 0; 1111 info.delivery_failure = 0; 1112 info.congested = 0; 1113 info.delivered = 0; 1114 info.allocation = allocation; 1115 info.skb = skb; 1116 info.skb2 = NULL; 1117 info.tx_filter = filter; 1118 info.tx_data = filter_data; 1119 1120 /* While we sleep in clone, do not allow to change socket list */ 1121 1122 netlink_lock_table(); 1123 1124 sk_for_each_bound(sk, node, &nl_table[ssk->sk_protocol].mc_list) 1125 do_one_broadcast(sk, &info); 1126 1127 consume_skb(skb); 1128 1129 netlink_unlock_table(); 1130 1131 if (info.delivery_failure) { 1132 kfree_skb(info.skb2); 1133 return -ENOBUFS; 1134 } 1135 consume_skb(info.skb2); 1136 1137 if (info.delivered) { 1138 if (info.congested && (allocation & __GFP_WAIT)) 1139 yield(); 1140 return 0; 1141 } 1142 return -ESRCH; 1143 } 1144 EXPORT_SYMBOL(netlink_broadcast_filtered); 1145 1146 int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, u32 portid, 1147 u32 group, gfp_t allocation) 1148 { 1149 return netlink_broadcast_filtered(ssk, skb, portid, group, allocation, 1150 NULL, NULL); 1151 } 1152 EXPORT_SYMBOL(netlink_broadcast); 1153 1154 struct netlink_set_err_data { 1155 struct sock *exclude_sk; 1156 u32 portid; 1157 u32 group; 1158 int code; 1159 }; 1160 1161 static int do_one_set_err(struct sock *sk, struct netlink_set_err_data *p) 1162 { 1163 struct netlink_sock *nlk = nlk_sk(sk); 1164 int ret = 0; 1165 1166 if (sk == p->exclude_sk) 1167 goto out; 1168 1169 if (!net_eq(sock_net(sk), sock_net(p->exclude_sk))) 1170 goto out; 1171 1172 if (nlk->portid == p->portid || p->group - 1 >= nlk->ngroups || 1173 !test_bit(p->group - 1, nlk->groups)) 1174 goto out; 1175 1176 if (p->code == ENOBUFS && nlk->flags & NETLINK_RECV_NO_ENOBUFS) { 1177 ret = 1; 1178 goto out; 1179 } 1180 1181 sk->sk_err = p->code; 1182 sk->sk_error_report(sk); 1183 out: 1184 return ret; 1185 } 1186 1187 /** 1188 * netlink_set_err - report error to broadcast listeners 1189 * @ssk: the kernel netlink socket, as returned by netlink_kernel_create() 1190 * @portid: the PORTID of a process that we want to skip (if any) 1191 * @groups: the broadcast group that will notice the error 1192 * @code: error code, must be negative (as usual in kernelspace) 1193 * 1194 * This function returns the number of broadcast listeners that have set the 1195 * NETLINK_RECV_NO_ENOBUFS socket option. 1196 */ 1197 int netlink_set_err(struct sock *ssk, u32 portid, u32 group, int code) 1198 { 1199 struct netlink_set_err_data info; 1200 struct hlist_node *node; 1201 struct sock *sk; 1202 int ret = 0; 1203 1204 info.exclude_sk = ssk; 1205 info.portid = portid; 1206 info.group = group; 1207 /* sk->sk_err wants a positive error value */ 1208 info.code = -code; 1209 1210 read_lock(&nl_table_lock); 1211 1212 sk_for_each_bound(sk, node, &nl_table[ssk->sk_protocol].mc_list) 1213 ret += do_one_set_err(sk, &info); 1214 1215 read_unlock(&nl_table_lock); 1216 return ret; 1217 } 1218 EXPORT_SYMBOL(netlink_set_err); 1219 1220 /* must be called with netlink table grabbed */ 1221 static void netlink_update_socket_mc(struct netlink_sock *nlk, 1222 unsigned int group, 1223 int is_new) 1224 { 1225 int old, new = !!is_new, subscriptions; 1226 1227 old = test_bit(group - 1, nlk->groups); 1228 subscriptions = nlk->subscriptions - old + new; 1229 if (new) 1230 __set_bit(group - 1, nlk->groups); 1231 else 1232 __clear_bit(group - 1, nlk->groups); 1233 netlink_update_subscriptions(&nlk->sk, subscriptions); 1234 netlink_update_listeners(&nlk->sk); 1235 } 1236 1237 static int netlink_setsockopt(struct socket *sock, int level, int optname, 1238 char __user *optval, unsigned int optlen) 1239 { 1240 struct sock *sk = sock->sk; 1241 struct netlink_sock *nlk = nlk_sk(sk); 1242 unsigned int val = 0; 1243 int err; 1244 1245 if (level != SOL_NETLINK) 1246 return -ENOPROTOOPT; 1247 1248 if (optlen >= sizeof(int) && 1249 get_user(val, (unsigned int __user *)optval)) 1250 return -EFAULT; 1251 1252 switch (optname) { 1253 case NETLINK_PKTINFO: 1254 if (val) 1255 nlk->flags |= NETLINK_RECV_PKTINFO; 1256 else 1257 nlk->flags &= ~NETLINK_RECV_PKTINFO; 1258 err = 0; 1259 break; 1260 case NETLINK_ADD_MEMBERSHIP: 1261 case NETLINK_DROP_MEMBERSHIP: { 1262 if (!netlink_capable(sock, NL_CFG_F_NONROOT_RECV)) 1263 return -EPERM; 1264 err = netlink_realloc_groups(sk); 1265 if (err) 1266 return err; 1267 if (!val || val - 1 >= nlk->ngroups) 1268 return -EINVAL; 1269 netlink_table_grab(); 1270 netlink_update_socket_mc(nlk, val, 1271 optname == NETLINK_ADD_MEMBERSHIP); 1272 netlink_table_ungrab(); 1273 1274 if (nlk->netlink_bind) 1275 nlk->netlink_bind(val); 1276 1277 err = 0; 1278 break; 1279 } 1280 case NETLINK_BROADCAST_ERROR: 1281 if (val) 1282 nlk->flags |= NETLINK_BROADCAST_SEND_ERROR; 1283 else 1284 nlk->flags &= ~NETLINK_BROADCAST_SEND_ERROR; 1285 err = 0; 1286 break; 1287 case NETLINK_NO_ENOBUFS: 1288 if (val) { 1289 nlk->flags |= NETLINK_RECV_NO_ENOBUFS; 1290 clear_bit(0, &nlk->state); 1291 wake_up_interruptible(&nlk->wait); 1292 } else { 1293 nlk->flags &= ~NETLINK_RECV_NO_ENOBUFS; 1294 } 1295 err = 0; 1296 break; 1297 default: 1298 err = -ENOPROTOOPT; 1299 } 1300 return err; 1301 } 1302 1303 static int netlink_getsockopt(struct socket *sock, int level, int optname, 1304 char __user *optval, int __user *optlen) 1305 { 1306 struct sock *sk = sock->sk; 1307 struct netlink_sock *nlk = nlk_sk(sk); 1308 int len, val, err; 1309 1310 if (level != SOL_NETLINK) 1311 return -ENOPROTOOPT; 1312 1313 if (get_user(len, optlen)) 1314 return -EFAULT; 1315 if (len < 0) 1316 return -EINVAL; 1317 1318 switch (optname) { 1319 case NETLINK_PKTINFO: 1320 if (len < sizeof(int)) 1321 return -EINVAL; 1322 len = sizeof(int); 1323 val = nlk->flags & NETLINK_RECV_PKTINFO ? 1 : 0; 1324 if (put_user(len, optlen) || 1325 put_user(val, optval)) 1326 return -EFAULT; 1327 err = 0; 1328 break; 1329 case NETLINK_BROADCAST_ERROR: 1330 if (len < sizeof(int)) 1331 return -EINVAL; 1332 len = sizeof(int); 1333 val = nlk->flags & NETLINK_BROADCAST_SEND_ERROR ? 1 : 0; 1334 if (put_user(len, optlen) || 1335 put_user(val, optval)) 1336 return -EFAULT; 1337 err = 0; 1338 break; 1339 case NETLINK_NO_ENOBUFS: 1340 if (len < sizeof(int)) 1341 return -EINVAL; 1342 len = sizeof(int); 1343 val = nlk->flags & NETLINK_RECV_NO_ENOBUFS ? 1 : 0; 1344 if (put_user(len, optlen) || 1345 put_user(val, optval)) 1346 return -EFAULT; 1347 err = 0; 1348 break; 1349 default: 1350 err = -ENOPROTOOPT; 1351 } 1352 return err; 1353 } 1354 1355 static void netlink_cmsg_recv_pktinfo(struct msghdr *msg, struct sk_buff *skb) 1356 { 1357 struct nl_pktinfo info; 1358 1359 info.group = NETLINK_CB(skb).dst_group; 1360 put_cmsg(msg, SOL_NETLINK, NETLINK_PKTINFO, sizeof(info), &info); 1361 } 1362 1363 static int netlink_sendmsg(struct kiocb *kiocb, struct socket *sock, 1364 struct msghdr *msg, size_t len) 1365 { 1366 struct sock_iocb *siocb = kiocb_to_siocb(kiocb); 1367 struct sock *sk = sock->sk; 1368 struct netlink_sock *nlk = nlk_sk(sk); 1369 struct sockaddr_nl *addr = msg->msg_name; 1370 u32 dst_portid; 1371 u32 dst_group; 1372 struct sk_buff *skb; 1373 int err; 1374 struct scm_cookie scm; 1375 1376 if (msg->msg_flags&MSG_OOB) 1377 return -EOPNOTSUPP; 1378 1379 if (NULL == siocb->scm) 1380 siocb->scm = &scm; 1381 1382 err = scm_send(sock, msg, siocb->scm, true); 1383 if (err < 0) 1384 return err; 1385 1386 if (msg->msg_namelen) { 1387 err = -EINVAL; 1388 if (addr->nl_family != AF_NETLINK) 1389 goto out; 1390 dst_portid = addr->nl_pid; 1391 dst_group = ffs(addr->nl_groups); 1392 err = -EPERM; 1393 if ((dst_group || dst_portid) && 1394 !netlink_capable(sock, NL_CFG_F_NONROOT_SEND)) 1395 goto out; 1396 } else { 1397 dst_portid = nlk->dst_portid; 1398 dst_group = nlk->dst_group; 1399 } 1400 1401 if (!nlk->portid) { 1402 err = netlink_autobind(sock); 1403 if (err) 1404 goto out; 1405 } 1406 1407 err = -EMSGSIZE; 1408 if (len > sk->sk_sndbuf - 32) 1409 goto out; 1410 err = -ENOBUFS; 1411 skb = alloc_skb(len, GFP_KERNEL); 1412 if (skb == NULL) 1413 goto out; 1414 1415 NETLINK_CB(skb).portid = nlk->portid; 1416 NETLINK_CB(skb).dst_group = dst_group; 1417 NETLINK_CB(skb).creds = siocb->scm->creds; 1418 1419 err = -EFAULT; 1420 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) { 1421 kfree_skb(skb); 1422 goto out; 1423 } 1424 1425 err = security_netlink_send(sk, skb); 1426 if (err) { 1427 kfree_skb(skb); 1428 goto out; 1429 } 1430 1431 if (dst_group) { 1432 atomic_inc(&skb->users); 1433 netlink_broadcast(sk, skb, dst_portid, dst_group, GFP_KERNEL); 1434 } 1435 err = netlink_unicast(sk, skb, dst_portid, msg->msg_flags&MSG_DONTWAIT); 1436 1437 out: 1438 scm_destroy(siocb->scm); 1439 return err; 1440 } 1441 1442 static int netlink_recvmsg(struct kiocb *kiocb, struct socket *sock, 1443 struct msghdr *msg, size_t len, 1444 int flags) 1445 { 1446 struct sock_iocb *siocb = kiocb_to_siocb(kiocb); 1447 struct scm_cookie scm; 1448 struct sock *sk = sock->sk; 1449 struct netlink_sock *nlk = nlk_sk(sk); 1450 int noblock = flags&MSG_DONTWAIT; 1451 size_t copied; 1452 struct sk_buff *skb, *data_skb; 1453 int err, ret; 1454 1455 if (flags&MSG_OOB) 1456 return -EOPNOTSUPP; 1457 1458 copied = 0; 1459 1460 skb = skb_recv_datagram(sk, flags, noblock, &err); 1461 if (skb == NULL) 1462 goto out; 1463 1464 data_skb = skb; 1465 1466 #ifdef CONFIG_COMPAT_NETLINK_MESSAGES 1467 if (unlikely(skb_shinfo(skb)->frag_list)) { 1468 /* 1469 * If this skb has a frag_list, then here that means that we 1470 * will have to use the frag_list skb's data for compat tasks 1471 * and the regular skb's data for normal (non-compat) tasks. 1472 * 1473 * If we need to send the compat skb, assign it to the 1474 * 'data_skb' variable so that it will be used below for data 1475 * copying. We keep 'skb' for everything else, including 1476 * freeing both later. 1477 */ 1478 if (flags & MSG_CMSG_COMPAT) 1479 data_skb = skb_shinfo(skb)->frag_list; 1480 } 1481 #endif 1482 1483 msg->msg_namelen = 0; 1484 1485 copied = data_skb->len; 1486 if (len < copied) { 1487 msg->msg_flags |= MSG_TRUNC; 1488 copied = len; 1489 } 1490 1491 skb_reset_transport_header(data_skb); 1492 err = skb_copy_datagram_iovec(data_skb, 0, msg->msg_iov, copied); 1493 1494 if (msg->msg_name) { 1495 struct sockaddr_nl *addr = (struct sockaddr_nl *)msg->msg_name; 1496 addr->nl_family = AF_NETLINK; 1497 addr->nl_pad = 0; 1498 addr->nl_pid = NETLINK_CB(skb).portid; 1499 addr->nl_groups = netlink_group_mask(NETLINK_CB(skb).dst_group); 1500 msg->msg_namelen = sizeof(*addr); 1501 } 1502 1503 if (nlk->flags & NETLINK_RECV_PKTINFO) 1504 netlink_cmsg_recv_pktinfo(msg, skb); 1505 1506 if (NULL == siocb->scm) { 1507 memset(&scm, 0, sizeof(scm)); 1508 siocb->scm = &scm; 1509 } 1510 siocb->scm->creds = *NETLINK_CREDS(skb); 1511 if (flags & MSG_TRUNC) 1512 copied = data_skb->len; 1513 1514 skb_free_datagram(sk, skb); 1515 1516 if (nlk->cb && atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf / 2) { 1517 ret = netlink_dump(sk); 1518 if (ret) { 1519 sk->sk_err = ret; 1520 sk->sk_error_report(sk); 1521 } 1522 } 1523 1524 scm_recv(sock, msg, siocb->scm, flags); 1525 out: 1526 netlink_rcv_wake(sk); 1527 return err ? : copied; 1528 } 1529 1530 static void netlink_data_ready(struct sock *sk, int len) 1531 { 1532 BUG(); 1533 } 1534 1535 /* 1536 * We export these functions to other modules. They provide a 1537 * complete set of kernel non-blocking support for message 1538 * queueing. 1539 */ 1540 1541 struct sock * 1542 __netlink_kernel_create(struct net *net, int unit, struct module *module, 1543 struct netlink_kernel_cfg *cfg) 1544 { 1545 struct socket *sock; 1546 struct sock *sk; 1547 struct netlink_sock *nlk; 1548 struct listeners *listeners = NULL; 1549 struct mutex *cb_mutex = cfg ? cfg->cb_mutex : NULL; 1550 unsigned int groups; 1551 1552 BUG_ON(!nl_table); 1553 1554 if (unit < 0 || unit >= MAX_LINKS) 1555 return NULL; 1556 1557 if (sock_create_lite(PF_NETLINK, SOCK_DGRAM, unit, &sock)) 1558 return NULL; 1559 1560 /* 1561 * We have to just have a reference on the net from sk, but don't 1562 * get_net it. Besides, we cannot get and then put the net here. 1563 * So we create one inside init_net and the move it to net. 1564 */ 1565 1566 if (__netlink_create(&init_net, sock, cb_mutex, unit) < 0) 1567 goto out_sock_release_nosk; 1568 1569 sk = sock->sk; 1570 sk_change_net(sk, net); 1571 1572 if (!cfg || cfg->groups < 32) 1573 groups = 32; 1574 else 1575 groups = cfg->groups; 1576 1577 listeners = kzalloc(sizeof(*listeners) + NLGRPSZ(groups), GFP_KERNEL); 1578 if (!listeners) 1579 goto out_sock_release; 1580 1581 sk->sk_data_ready = netlink_data_ready; 1582 if (cfg && cfg->input) 1583 nlk_sk(sk)->netlink_rcv = cfg->input; 1584 1585 if (netlink_insert(sk, net, 0)) 1586 goto out_sock_release; 1587 1588 nlk = nlk_sk(sk); 1589 nlk->flags |= NETLINK_KERNEL_SOCKET; 1590 1591 netlink_table_grab(); 1592 if (!nl_table[unit].registered) { 1593 nl_table[unit].groups = groups; 1594 rcu_assign_pointer(nl_table[unit].listeners, listeners); 1595 nl_table[unit].cb_mutex = cb_mutex; 1596 nl_table[unit].module = module; 1597 if (cfg) { 1598 nl_table[unit].bind = cfg->bind; 1599 nl_table[unit].flags = cfg->flags; 1600 } 1601 nl_table[unit].registered = 1; 1602 } else { 1603 kfree(listeners); 1604 nl_table[unit].registered++; 1605 } 1606 netlink_table_ungrab(); 1607 return sk; 1608 1609 out_sock_release: 1610 kfree(listeners); 1611 netlink_kernel_release(sk); 1612 return NULL; 1613 1614 out_sock_release_nosk: 1615 sock_release(sock); 1616 return NULL; 1617 } 1618 EXPORT_SYMBOL(__netlink_kernel_create); 1619 1620 void 1621 netlink_kernel_release(struct sock *sk) 1622 { 1623 sk_release_kernel(sk); 1624 } 1625 EXPORT_SYMBOL(netlink_kernel_release); 1626 1627 int __netlink_change_ngroups(struct sock *sk, unsigned int groups) 1628 { 1629 struct listeners *new, *old; 1630 struct netlink_table *tbl = &nl_table[sk->sk_protocol]; 1631 1632 if (groups < 32) 1633 groups = 32; 1634 1635 if (NLGRPSZ(tbl->groups) < NLGRPSZ(groups)) { 1636 new = kzalloc(sizeof(*new) + NLGRPSZ(groups), GFP_ATOMIC); 1637 if (!new) 1638 return -ENOMEM; 1639 old = nl_deref_protected(tbl->listeners); 1640 memcpy(new->masks, old->masks, NLGRPSZ(tbl->groups)); 1641 rcu_assign_pointer(tbl->listeners, new); 1642 1643 kfree_rcu(old, rcu); 1644 } 1645 tbl->groups = groups; 1646 1647 return 0; 1648 } 1649 1650 /** 1651 * netlink_change_ngroups - change number of multicast groups 1652 * 1653 * This changes the number of multicast groups that are available 1654 * on a certain netlink family. Note that it is not possible to 1655 * change the number of groups to below 32. Also note that it does 1656 * not implicitly call netlink_clear_multicast_users() when the 1657 * number of groups is reduced. 1658 * 1659 * @sk: The kernel netlink socket, as returned by netlink_kernel_create(). 1660 * @groups: The new number of groups. 1661 */ 1662 int netlink_change_ngroups(struct sock *sk, unsigned int groups) 1663 { 1664 int err; 1665 1666 netlink_table_grab(); 1667 err = __netlink_change_ngroups(sk, groups); 1668 netlink_table_ungrab(); 1669 1670 return err; 1671 } 1672 1673 void __netlink_clear_multicast_users(struct sock *ksk, unsigned int group) 1674 { 1675 struct sock *sk; 1676 struct hlist_node *node; 1677 struct netlink_table *tbl = &nl_table[ksk->sk_protocol]; 1678 1679 sk_for_each_bound(sk, node, &tbl->mc_list) 1680 netlink_update_socket_mc(nlk_sk(sk), group, 0); 1681 } 1682 1683 /** 1684 * netlink_clear_multicast_users - kick off multicast listeners 1685 * 1686 * This function removes all listeners from the given group. 1687 * @ksk: The kernel netlink socket, as returned by 1688 * netlink_kernel_create(). 1689 * @group: The multicast group to clear. 1690 */ 1691 void netlink_clear_multicast_users(struct sock *ksk, unsigned int group) 1692 { 1693 netlink_table_grab(); 1694 __netlink_clear_multicast_users(ksk, group); 1695 netlink_table_ungrab(); 1696 } 1697 1698 struct nlmsghdr * 1699 __nlmsg_put(struct sk_buff *skb, u32 portid, u32 seq, int type, int len, int flags) 1700 { 1701 struct nlmsghdr *nlh; 1702 int size = NLMSG_LENGTH(len); 1703 1704 nlh = (struct nlmsghdr*)skb_put(skb, NLMSG_ALIGN(size)); 1705 nlh->nlmsg_type = type; 1706 nlh->nlmsg_len = size; 1707 nlh->nlmsg_flags = flags; 1708 nlh->nlmsg_pid = portid; 1709 nlh->nlmsg_seq = seq; 1710 if (!__builtin_constant_p(size) || NLMSG_ALIGN(size) - size != 0) 1711 memset(NLMSG_DATA(nlh) + len, 0, NLMSG_ALIGN(size) - size); 1712 return nlh; 1713 } 1714 EXPORT_SYMBOL(__nlmsg_put); 1715 1716 /* 1717 * It looks a bit ugly. 1718 * It would be better to create kernel thread. 1719 */ 1720 1721 static int netlink_dump(struct sock *sk) 1722 { 1723 struct netlink_sock *nlk = nlk_sk(sk); 1724 struct netlink_callback *cb; 1725 struct sk_buff *skb = NULL; 1726 struct nlmsghdr *nlh; 1727 int len, err = -ENOBUFS; 1728 int alloc_size; 1729 1730 mutex_lock(nlk->cb_mutex); 1731 1732 cb = nlk->cb; 1733 if (cb == NULL) { 1734 err = -EINVAL; 1735 goto errout_skb; 1736 } 1737 1738 alloc_size = max_t(int, cb->min_dump_alloc, NLMSG_GOODSIZE); 1739 1740 skb = sock_rmalloc(sk, alloc_size, 0, GFP_KERNEL); 1741 if (!skb) 1742 goto errout_skb; 1743 1744 len = cb->dump(skb, cb); 1745 1746 if (len > 0) { 1747 mutex_unlock(nlk->cb_mutex); 1748 1749 if (sk_filter(sk, skb)) 1750 kfree_skb(skb); 1751 else 1752 __netlink_sendskb(sk, skb); 1753 return 0; 1754 } 1755 1756 nlh = nlmsg_put_answer(skb, cb, NLMSG_DONE, sizeof(len), NLM_F_MULTI); 1757 if (!nlh) 1758 goto errout_skb; 1759 1760 nl_dump_check_consistent(cb, nlh); 1761 1762 memcpy(nlmsg_data(nlh), &len, sizeof(len)); 1763 1764 if (sk_filter(sk, skb)) 1765 kfree_skb(skb); 1766 else 1767 __netlink_sendskb(sk, skb); 1768 1769 if (cb->done) 1770 cb->done(cb); 1771 nlk->cb = NULL; 1772 mutex_unlock(nlk->cb_mutex); 1773 1774 module_put(cb->module); 1775 netlink_consume_callback(cb); 1776 return 0; 1777 1778 errout_skb: 1779 mutex_unlock(nlk->cb_mutex); 1780 kfree_skb(skb); 1781 return err; 1782 } 1783 1784 int __netlink_dump_start(struct sock *ssk, struct sk_buff *skb, 1785 const struct nlmsghdr *nlh, 1786 struct netlink_dump_control *control) 1787 { 1788 struct netlink_callback *cb; 1789 struct sock *sk; 1790 struct netlink_sock *nlk; 1791 int ret; 1792 1793 cb = kzalloc(sizeof(*cb), GFP_KERNEL); 1794 if (cb == NULL) 1795 return -ENOBUFS; 1796 1797 cb->dump = control->dump; 1798 cb->done = control->done; 1799 cb->nlh = nlh; 1800 cb->data = control->data; 1801 cb->module = control->module; 1802 cb->min_dump_alloc = control->min_dump_alloc; 1803 atomic_inc(&skb->users); 1804 cb->skb = skb; 1805 1806 sk = netlink_lookup(sock_net(ssk), ssk->sk_protocol, NETLINK_CB(skb).portid); 1807 if (sk == NULL) { 1808 netlink_destroy_callback(cb); 1809 return -ECONNREFUSED; 1810 } 1811 nlk = nlk_sk(sk); 1812 1813 mutex_lock(nlk->cb_mutex); 1814 /* A dump is in progress... */ 1815 if (nlk->cb) { 1816 mutex_unlock(nlk->cb_mutex); 1817 netlink_destroy_callback(cb); 1818 ret = -EBUSY; 1819 goto out; 1820 } 1821 /* add reference of module which cb->dump belongs to */ 1822 if (!try_module_get(cb->module)) { 1823 mutex_unlock(nlk->cb_mutex); 1824 netlink_destroy_callback(cb); 1825 ret = -EPROTONOSUPPORT; 1826 goto out; 1827 } 1828 1829 nlk->cb = cb; 1830 mutex_unlock(nlk->cb_mutex); 1831 1832 ret = netlink_dump(sk); 1833 out: 1834 sock_put(sk); 1835 1836 if (ret) 1837 return ret; 1838 1839 /* We successfully started a dump, by returning -EINTR we 1840 * signal not to send ACK even if it was requested. 1841 */ 1842 return -EINTR; 1843 } 1844 EXPORT_SYMBOL(__netlink_dump_start); 1845 1846 void netlink_ack(struct sk_buff *in_skb, struct nlmsghdr *nlh, int err) 1847 { 1848 struct sk_buff *skb; 1849 struct nlmsghdr *rep; 1850 struct nlmsgerr *errmsg; 1851 size_t payload = sizeof(*errmsg); 1852 1853 /* error messages get the original request appened */ 1854 if (err) 1855 payload += nlmsg_len(nlh); 1856 1857 skb = nlmsg_new(payload, GFP_KERNEL); 1858 if (!skb) { 1859 struct sock *sk; 1860 1861 sk = netlink_lookup(sock_net(in_skb->sk), 1862 in_skb->sk->sk_protocol, 1863 NETLINK_CB(in_skb).portid); 1864 if (sk) { 1865 sk->sk_err = ENOBUFS; 1866 sk->sk_error_report(sk); 1867 sock_put(sk); 1868 } 1869 return; 1870 } 1871 1872 rep = __nlmsg_put(skb, NETLINK_CB(in_skb).portid, nlh->nlmsg_seq, 1873 NLMSG_ERROR, payload, 0); 1874 errmsg = nlmsg_data(rep); 1875 errmsg->error = err; 1876 memcpy(&errmsg->msg, nlh, err ? nlh->nlmsg_len : sizeof(*nlh)); 1877 netlink_unicast(in_skb->sk, skb, NETLINK_CB(in_skb).portid, MSG_DONTWAIT); 1878 } 1879 EXPORT_SYMBOL(netlink_ack); 1880 1881 int netlink_rcv_skb(struct sk_buff *skb, int (*cb)(struct sk_buff *, 1882 struct nlmsghdr *)) 1883 { 1884 struct nlmsghdr *nlh; 1885 int err; 1886 1887 while (skb->len >= nlmsg_total_size(0)) { 1888 int msglen; 1889 1890 nlh = nlmsg_hdr(skb); 1891 err = 0; 1892 1893 if (nlh->nlmsg_len < NLMSG_HDRLEN || skb->len < nlh->nlmsg_len) 1894 return 0; 1895 1896 /* Only requests are handled by the kernel */ 1897 if (!(nlh->nlmsg_flags & NLM_F_REQUEST)) 1898 goto ack; 1899 1900 /* Skip control messages */ 1901 if (nlh->nlmsg_type < NLMSG_MIN_TYPE) 1902 goto ack; 1903 1904 err = cb(skb, nlh); 1905 if (err == -EINTR) 1906 goto skip; 1907 1908 ack: 1909 if (nlh->nlmsg_flags & NLM_F_ACK || err) 1910 netlink_ack(skb, nlh, err); 1911 1912 skip: 1913 msglen = NLMSG_ALIGN(nlh->nlmsg_len); 1914 if (msglen > skb->len) 1915 msglen = skb->len; 1916 skb_pull(skb, msglen); 1917 } 1918 1919 return 0; 1920 } 1921 EXPORT_SYMBOL(netlink_rcv_skb); 1922 1923 /** 1924 * nlmsg_notify - send a notification netlink message 1925 * @sk: netlink socket to use 1926 * @skb: notification message 1927 * @portid: destination netlink portid for reports or 0 1928 * @group: destination multicast group or 0 1929 * @report: 1 to report back, 0 to disable 1930 * @flags: allocation flags 1931 */ 1932 int nlmsg_notify(struct sock *sk, struct sk_buff *skb, u32 portid, 1933 unsigned int group, int report, gfp_t flags) 1934 { 1935 int err = 0; 1936 1937 if (group) { 1938 int exclude_portid = 0; 1939 1940 if (report) { 1941 atomic_inc(&skb->users); 1942 exclude_portid = portid; 1943 } 1944 1945 /* errors reported via destination sk->sk_err, but propagate 1946 * delivery errors if NETLINK_BROADCAST_ERROR flag is set */ 1947 err = nlmsg_multicast(sk, skb, exclude_portid, group, flags); 1948 } 1949 1950 if (report) { 1951 int err2; 1952 1953 err2 = nlmsg_unicast(sk, skb, portid); 1954 if (!err || err == -ESRCH) 1955 err = err2; 1956 } 1957 1958 return err; 1959 } 1960 EXPORT_SYMBOL(nlmsg_notify); 1961 1962 #ifdef CONFIG_PROC_FS 1963 struct nl_seq_iter { 1964 struct seq_net_private p; 1965 int link; 1966 int hash_idx; 1967 }; 1968 1969 static struct sock *netlink_seq_socket_idx(struct seq_file *seq, loff_t pos) 1970 { 1971 struct nl_seq_iter *iter = seq->private; 1972 int i, j; 1973 struct sock *s; 1974 struct hlist_node *node; 1975 loff_t off = 0; 1976 1977 for (i = 0; i < MAX_LINKS; i++) { 1978 struct nl_portid_hash *hash = &nl_table[i].hash; 1979 1980 for (j = 0; j <= hash->mask; j++) { 1981 sk_for_each(s, node, &hash->table[j]) { 1982 if (sock_net(s) != seq_file_net(seq)) 1983 continue; 1984 if (off == pos) { 1985 iter->link = i; 1986 iter->hash_idx = j; 1987 return s; 1988 } 1989 ++off; 1990 } 1991 } 1992 } 1993 return NULL; 1994 } 1995 1996 static void *netlink_seq_start(struct seq_file *seq, loff_t *pos) 1997 __acquires(nl_table_lock) 1998 { 1999 read_lock(&nl_table_lock); 2000 return *pos ? netlink_seq_socket_idx(seq, *pos - 1) : SEQ_START_TOKEN; 2001 } 2002 2003 static void *netlink_seq_next(struct seq_file *seq, void *v, loff_t *pos) 2004 { 2005 struct sock *s; 2006 struct nl_seq_iter *iter; 2007 int i, j; 2008 2009 ++*pos; 2010 2011 if (v == SEQ_START_TOKEN) 2012 return netlink_seq_socket_idx(seq, 0); 2013 2014 iter = seq->private; 2015 s = v; 2016 do { 2017 s = sk_next(s); 2018 } while (s && sock_net(s) != seq_file_net(seq)); 2019 if (s) 2020 return s; 2021 2022 i = iter->link; 2023 j = iter->hash_idx + 1; 2024 2025 do { 2026 struct nl_portid_hash *hash = &nl_table[i].hash; 2027 2028 for (; j <= hash->mask; j++) { 2029 s = sk_head(&hash->table[j]); 2030 while (s && sock_net(s) != seq_file_net(seq)) 2031 s = sk_next(s); 2032 if (s) { 2033 iter->link = i; 2034 iter->hash_idx = j; 2035 return s; 2036 } 2037 } 2038 2039 j = 0; 2040 } while (++i < MAX_LINKS); 2041 2042 return NULL; 2043 } 2044 2045 static void netlink_seq_stop(struct seq_file *seq, void *v) 2046 __releases(nl_table_lock) 2047 { 2048 read_unlock(&nl_table_lock); 2049 } 2050 2051 2052 static int netlink_seq_show(struct seq_file *seq, void *v) 2053 { 2054 if (v == SEQ_START_TOKEN) { 2055 seq_puts(seq, 2056 "sk Eth Pid Groups " 2057 "Rmem Wmem Dump Locks Drops Inode\n"); 2058 } else { 2059 struct sock *s = v; 2060 struct netlink_sock *nlk = nlk_sk(s); 2061 2062 seq_printf(seq, "%pK %-3d %-6d %08x %-8d %-8d %pK %-8d %-8d %-8lu\n", 2063 s, 2064 s->sk_protocol, 2065 nlk->portid, 2066 nlk->groups ? (u32)nlk->groups[0] : 0, 2067 sk_rmem_alloc_get(s), 2068 sk_wmem_alloc_get(s), 2069 nlk->cb, 2070 atomic_read(&s->sk_refcnt), 2071 atomic_read(&s->sk_drops), 2072 sock_i_ino(s) 2073 ); 2074 2075 } 2076 return 0; 2077 } 2078 2079 static const struct seq_operations netlink_seq_ops = { 2080 .start = netlink_seq_start, 2081 .next = netlink_seq_next, 2082 .stop = netlink_seq_stop, 2083 .show = netlink_seq_show, 2084 }; 2085 2086 2087 static int netlink_seq_open(struct inode *inode, struct file *file) 2088 { 2089 return seq_open_net(inode, file, &netlink_seq_ops, 2090 sizeof(struct nl_seq_iter)); 2091 } 2092 2093 static const struct file_operations netlink_seq_fops = { 2094 .owner = THIS_MODULE, 2095 .open = netlink_seq_open, 2096 .read = seq_read, 2097 .llseek = seq_lseek, 2098 .release = seq_release_net, 2099 }; 2100 2101 #endif 2102 2103 int netlink_register_notifier(struct notifier_block *nb) 2104 { 2105 return atomic_notifier_chain_register(&netlink_chain, nb); 2106 } 2107 EXPORT_SYMBOL(netlink_register_notifier); 2108 2109 int netlink_unregister_notifier(struct notifier_block *nb) 2110 { 2111 return atomic_notifier_chain_unregister(&netlink_chain, nb); 2112 } 2113 EXPORT_SYMBOL(netlink_unregister_notifier); 2114 2115 static const struct proto_ops netlink_ops = { 2116 .family = PF_NETLINK, 2117 .owner = THIS_MODULE, 2118 .release = netlink_release, 2119 .bind = netlink_bind, 2120 .connect = netlink_connect, 2121 .socketpair = sock_no_socketpair, 2122 .accept = sock_no_accept, 2123 .getname = netlink_getname, 2124 .poll = datagram_poll, 2125 .ioctl = sock_no_ioctl, 2126 .listen = sock_no_listen, 2127 .shutdown = sock_no_shutdown, 2128 .setsockopt = netlink_setsockopt, 2129 .getsockopt = netlink_getsockopt, 2130 .sendmsg = netlink_sendmsg, 2131 .recvmsg = netlink_recvmsg, 2132 .mmap = sock_no_mmap, 2133 .sendpage = sock_no_sendpage, 2134 }; 2135 2136 static const struct net_proto_family netlink_family_ops = { 2137 .family = PF_NETLINK, 2138 .create = netlink_create, 2139 .owner = THIS_MODULE, /* for consistency 8) */ 2140 }; 2141 2142 static int __net_init netlink_net_init(struct net *net) 2143 { 2144 #ifdef CONFIG_PROC_FS 2145 if (!proc_net_fops_create(net, "netlink", 0, &netlink_seq_fops)) 2146 return -ENOMEM; 2147 #endif 2148 return 0; 2149 } 2150 2151 static void __net_exit netlink_net_exit(struct net *net) 2152 { 2153 #ifdef CONFIG_PROC_FS 2154 proc_net_remove(net, "netlink"); 2155 #endif 2156 } 2157 2158 static void __init netlink_add_usersock_entry(void) 2159 { 2160 struct listeners *listeners; 2161 int groups = 32; 2162 2163 listeners = kzalloc(sizeof(*listeners) + NLGRPSZ(groups), GFP_KERNEL); 2164 if (!listeners) 2165 panic("netlink_add_usersock_entry: Cannot allocate listeners\n"); 2166 2167 netlink_table_grab(); 2168 2169 nl_table[NETLINK_USERSOCK].groups = groups; 2170 rcu_assign_pointer(nl_table[NETLINK_USERSOCK].listeners, listeners); 2171 nl_table[NETLINK_USERSOCK].module = THIS_MODULE; 2172 nl_table[NETLINK_USERSOCK].registered = 1; 2173 nl_table[NETLINK_USERSOCK].flags = NL_CFG_F_NONROOT_SEND; 2174 2175 netlink_table_ungrab(); 2176 } 2177 2178 static struct pernet_operations __net_initdata netlink_net_ops = { 2179 .init = netlink_net_init, 2180 .exit = netlink_net_exit, 2181 }; 2182 2183 static int __init netlink_proto_init(void) 2184 { 2185 struct sk_buff *dummy_skb; 2186 int i; 2187 unsigned long limit; 2188 unsigned int order; 2189 int err = proto_register(&netlink_proto, 0); 2190 2191 if (err != 0) 2192 goto out; 2193 2194 BUILD_BUG_ON(sizeof(struct netlink_skb_parms) > sizeof(dummy_skb->cb)); 2195 2196 nl_table = kcalloc(MAX_LINKS, sizeof(*nl_table), GFP_KERNEL); 2197 if (!nl_table) 2198 goto panic; 2199 2200 if (totalram_pages >= (128 * 1024)) 2201 limit = totalram_pages >> (21 - PAGE_SHIFT); 2202 else 2203 limit = totalram_pages >> (23 - PAGE_SHIFT); 2204 2205 order = get_bitmask_order(limit) - 1 + PAGE_SHIFT; 2206 limit = (1UL << order) / sizeof(struct hlist_head); 2207 order = get_bitmask_order(min(limit, (unsigned long)UINT_MAX)) - 1; 2208 2209 for (i = 0; i < MAX_LINKS; i++) { 2210 struct nl_portid_hash *hash = &nl_table[i].hash; 2211 2212 hash->table = nl_portid_hash_zalloc(1 * sizeof(*hash->table)); 2213 if (!hash->table) { 2214 while (i-- > 0) 2215 nl_portid_hash_free(nl_table[i].hash.table, 2216 1 * sizeof(*hash->table)); 2217 kfree(nl_table); 2218 goto panic; 2219 } 2220 hash->max_shift = order; 2221 hash->shift = 0; 2222 hash->mask = 0; 2223 hash->rehash_time = jiffies; 2224 } 2225 2226 netlink_add_usersock_entry(); 2227 2228 sock_register(&netlink_family_ops); 2229 register_pernet_subsys(&netlink_net_ops); 2230 /* The netlink device handler may be needed early. */ 2231 rtnetlink_init(); 2232 out: 2233 return err; 2234 panic: 2235 panic("netlink_init: Cannot allocate nl_table\n"); 2236 } 2237 2238 core_initcall(netlink_proto_init); 2239