kernel/net/netlink/af_netlink.c

   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  *                              Patrick McHardy <kaber@trash.net>
   7  *
   8  *              This program is free software; you can redistribute it and/or
   9  *              modify it under the terms of the GNU General Public License
  10  *              as published by the Free Software Foundation; either version
  11  *              2 of the License, or (at your option) any later version.
  12  *
  13  * Tue Jun 26 14:36:48 MEST 2001 Herbert "herp" Rosmanith
  14  *                               added netlink_proto_exit
  15  * Tue Jan 22 18:32:44 BRST 2002 Arnaldo C. de Melo <acme@conectiva.com.br>
  16  *                               use nlk_sk, as sk->protinfo is on a diet 8)
  17  * Fri Jul 22 19:51:12 MEST 2005 Harald Welte <laforge@gnumonks.org>
  18  *                               - inc module use count of module that owns
  19  *                                 the kernel socket in case userspace opens
  20  *                                 socket of same protocol
  21  *                               - remove all module support, since netlink is
  22  *                                 mandatory if CONFIG_NET=y these days
  23  */
  24
  25 #include <linux/module.h>
  26
  27 #include <linux/capability.h>
  28 #include <linux/kernel.h>
  29 #include <linux/init.h>
  30 #include <linux/signal.h>
  31 #include <linux/sched.h>
  32 #include <linux/errno.h>
  33 #include <linux/string.h>
  34 #include <linux/stat.h>
  35 #include <linux/socket.h>
  36 #include <linux/un.h>
  37 #include <linux/fcntl.h>
  38 #include <linux/termios.h>
  39 #include <linux/sockios.h>
  40 #include <linux/net.h>
  41 #include <linux/fs.h>
  42 #include <linux/slab.h>
  43 #include <asm/uaccess.h>
  44 #include <linux/skbuff.h>
  45 #include <linux/netdevice.h>
  46 #include <linux/rtnetlink.h>
  47 #include <linux/proc_fs.h>
  48 #include <linux/seq_file.h>
  49 #include <linux/notifier.h>
  50 #include <linux/security.h>
  51 #include <linux/jhash.h>
  52 #include <linux/jiffies.h>
  53 #include <linux/random.h>
  54 #include <linux/bitops.h>
  55 #include <linux/mm.h>
  56 #include <linux/types.h>
  57 #include <linux/audit.h>
  58 #include <linux/mutex.h>
  59 #include <linux/vmalloc.h>
  60 #include <linux/if_arp.h>
  61 #include <linux/rhashtable.h>
  62 #include <asm/cacheflush.h>
  63 #include <linux/hash.h>
  64 #include <linux/genetlink.h>
  65
  66 #include <net/net_namespace.h>
  67 #include <net/sock.h>
  68 #include <net/scm.h>
  69 #include <net/netlink.h>
  70
  71 #include "af_netlink.h"
  72
  73 struct listeners {
  74         struct rcu_head         rcu;
  75         unsigned long           masks[0];
  76 };
  77
  78 /* state bits */
  79 #define NETLINK_CONGESTED       0x0
  80
  81 /* flags */
  82 #define NETLINK_KERNEL_SOCKET   0x1
  83 #define NETLINK_RECV_PKTINFO    0x2
  84 #define NETLINK_BROADCAST_SEND_ERROR    0x4
  85 #define NETLINK_RECV_NO_ENOBUFS 0x8
  86
  87 static inline int netlink_is_kernel(struct sock *sk)
  88 {
  89         return nlk_sk(sk)->flags & NETLINK_KERNEL_SOCKET;
  90 }
  91
  92 struct netlink_table *nl_table __read_mostly;
  93 EXPORT_SYMBOL_GPL(nl_table);
  94
  95 static DECLARE_WAIT_QUEUE_HEAD(nl_table_wait);
  96
  97 static int netlink_dump(struct sock *sk);
  98 static void netlink_skb_destructor(struct sk_buff *skb);
  99
 100 /* nl_table locking explained:
 101  * Lookup and traversal are protected with an RCU read-side lock. Insertion
 102  * and removal are protected with per bucket lock while using RCU list
 103  * modification primitives and may run in parallel to RCU protected lookups.
 104  * Destruction of the Netlink socket may only occur *after* nl_table_lock has
 105  * been acquired * either during or after the socket has been removed from
 106  * the list and after an RCU grace period.
 107  */
 108 DEFINE_RWLOCK(nl_table_lock);
 109 EXPORT_SYMBOL_GPL(nl_table_lock);
 110 static atomic_t nl_table_users = ATOMIC_INIT(0);
 111
 112 #define nl_deref_protected(X) rcu_dereference_protected(X, lockdep_is_held(&nl_table_lock));
 113
 114 static ATOMIC_NOTIFIER_HEAD(netlink_chain);
 115
 116 static DEFINE_SPINLOCK(netlink_tap_lock);
 117 static struct list_head netlink_tap_all __read_mostly;
 118
 119 static const struct rhashtable_params netlink_rhashtable_params;
 120
 121 static inline u32 netlink_group_mask(u32 group)
 122 {
 123         return group ? 1 << (group - 1) : 0;
 124 }
 125
 126 int netlink_add_tap(struct netlink_tap *nt)
 127 {
 128         if (unlikely(nt->dev->type != ARPHRD_NETLINK))
 129                 return -EINVAL;
 130
 131         spin_lock(&netlink_tap_lock);
 132         list_add_rcu(&nt->list, &netlink_tap_all);
 133         spin_unlock(&netlink_tap_lock);
 134
 135         __module_get(nt->module);
 136
 137         return 0;
 138 }
 139 EXPORT_SYMBOL_GPL(netlink_add_tap);
 140
 141 static int __netlink_remove_tap(struct netlink_tap *nt)
 142 {
 143         bool found = false;
 144         struct netlink_tap *tmp;
 145
 146         spin_lock(&netlink_tap_lock);
 147
 148         list_for_each_entry(tmp, &netlink_tap_all, list) {
 149                 if (nt == tmp) {
 150                         list_del_rcu(&nt->list);
 151                         found = true;
 152                         goto out;
 153                 }
 154         }
 155
 156         pr_warn("__netlink_remove_tap: %p not found\n", nt);
 157 out:
 158         spin_unlock(&netlink_tap_lock);
 159
 160         if (found && nt->module)
 161                 module_put(nt->module);
 162
 163         return found ? 0 : -ENODEV;
 164 }
 165
 166 int netlink_remove_tap(struct netlink_tap *nt)
 167 {
 168         int ret;
 169
 170         ret = __netlink_remove_tap(nt);
 171         synchronize_net();
 172
 173         return ret;
 174 }
 175 EXPORT_SYMBOL_GPL(netlink_remove_tap);
 176
 177 static bool netlink_filter_tap(const struct sk_buff *skb)
 178 {
 179         struct sock *sk = skb->sk;
 180
 181         /* We take the more conservative approach and
 182          * whitelist socket protocols that may pass.
 183          */
 184         switch (sk->sk_protocol) {
 185         case NETLINK_ROUTE:
 186         case NETLINK_USERSOCK:
 187         case NETLINK_SOCK_DIAG:
 188         case NETLINK_NFLOG:
 189         case NETLINK_XFRM:
 190         case NETLINK_FIB_LOOKUP:
 191         case NETLINK_NETFILTER:
 192         case NETLINK_GENERIC:
 193                 return true;
 194         }
 195
 196         return false;
 197 }
 198
 199 static int __netlink_deliver_tap_skb(struct sk_buff *skb,
 200                                      struct net_device *dev)
 201 {
 202         struct sk_buff *nskb;
 203         struct sock *sk = skb->sk;
 204         int ret = -ENOMEM;
 205
 206         dev_hold(dev);
 207         nskb = skb_clone(skb, GFP_ATOMIC);
 208         if (nskb) {
 209                 nskb->dev = dev;
 210                 nskb->protocol = htons((u16) sk->sk_protocol);
 211                 nskb->pkt_type = netlink_is_kernel(sk) ?
 212                                  PACKET_KERNEL : PACKET_USER;
 213                 skb_reset_network_header(nskb);
 214                 ret = dev_queue_xmit(nskb);
 215                 if (unlikely(ret > 0))
 216                         ret = net_xmit_errno(ret);
 217         }
 218
 219         dev_put(dev);
 220         return ret;
 221 }
 222
 223 static void __netlink_deliver_tap(struct sk_buff *skb)
 224 {
 225         int ret;
 226         struct netlink_tap *tmp;
 227
 228         if (!netlink_filter_tap(skb))
 229                 return;
 230
 231         list_for_each_entry_rcu(tmp, &netlink_tap_all, list) {
 232                 ret = __netlink_deliver_tap_skb(skb, tmp->dev);
 233                 if (unlikely(ret))
 234                         break;
 235         }
 236 }
 237
 238 static void netlink_deliver_tap(struct sk_buff *skb)
 239 {
 240         rcu_read_lock();
 241
 242         if (unlikely(!list_empty(&netlink_tap_all)))
 243                 __netlink_deliver_tap(skb);
 244
 245         rcu_read_unlock();
 246 }
 247
 248 static void netlink_deliver_tap_kernel(struct sock *dst, struct sock *src,
 249                                        struct sk_buff *skb)
 250 {
 251         if (!(netlink_is_kernel(dst) && netlink_is_kernel(src)))
 252                 netlink_deliver_tap(skb);
 253 }
 254
 255 static void netlink_overrun(struct sock *sk)
 256 {
 257         struct netlink_sock *nlk = nlk_sk(sk);
 258
 259         if (!(nlk->flags & NETLINK_RECV_NO_ENOBUFS)) {
 260                 if (!test_and_set_bit(NETLINK_CONGESTED, &nlk_sk(sk)->state)) {
 261                         sk->sk_err = ENOBUFS;
 262                         sk->sk_error_report(sk);
 263                 }
 264         }
 265         atomic_inc(&sk->sk_drops);
 266 }
 267
 268 static void netlink_rcv_wake(struct sock *sk)
 269 {
 270         struct netlink_sock *nlk = nlk_sk(sk);
 271
 272         if (skb_queue_empty(&sk->sk_receive_queue))
 273                 clear_bit(NETLINK_CONGESTED, &nlk->state);
 274         if (!test_bit(NETLINK_CONGESTED, &nlk->state))
 275                 wake_up_interruptible(&nlk->wait);
 276 }
 277
 278 #ifdef CONFIG_NETLINK_MMAP
 279 static bool netlink_skb_is_mmaped(const struct sk_buff *skb)
 280 {
 281         return NETLINK_CB(skb).flags & NETLINK_SKB_MMAPED;
 282 }
 283
 284 static bool netlink_rx_is_mmaped(struct sock *sk)
 285 {
 286         return nlk_sk(sk)->rx_ring.pg_vec != NULL;
 287 }
 288
 289 static bool netlink_tx_is_mmaped(struct sock *sk)
 290 {
 291         return nlk_sk(sk)->tx_ring.pg_vec != NULL;
 292 }
 293
 294 static __pure struct page *pgvec_to_page(const void *addr)
 295 {
 296         if (is_vmalloc_addr(addr))
 297                 return vmalloc_to_page(addr);
 298         else
 299                 return virt_to_page(addr);
 300 }
 301
 302 static void free_pg_vec(void **pg_vec, unsigned int order, unsigned int len)
 303 {
 304         unsigned int i;
 305
 306         for (i = 0; i < len; i++) {
 307                 if (pg_vec[i] != NULL) {
 308                         if (is_vmalloc_addr(pg_vec[i]))
 309                                 vfree(pg_vec[i]);
 310                         else
 311                                 free_pages((unsigned long)pg_vec[i], order);
 312                 }
 313         }
 314         kfree(pg_vec);
 315 }
 316
 317 static void *alloc_one_pg_vec_page(unsigned long order)
 318 {
 319         void *buffer;
 320         gfp_t gfp_flags = GFP_KERNEL | __GFP_COMP | __GFP_ZERO |
 321                           __GFP_NOWARN | __GFP_NORETRY;
 322
 323         buffer = (void *)__get_free_pages(gfp_flags, order);
 324         if (buffer != NULL)
 325                 return buffer;
 326
 327         buffer = vzalloc((1 << order) * PAGE_SIZE);
 328         if (buffer != NULL)
 329                 return buffer;
 330
 331         gfp_flags &= ~__GFP_NORETRY;
 332         return (void *)__get_free_pages(gfp_flags, order);
 333 }
 334
 335 static void **alloc_pg_vec(struct netlink_sock *nlk,
 336                            struct nl_mmap_req *req, unsigned int order)
 337 {
 338         unsigned int block_nr = req->nm_block_nr;
 339         unsigned int i;
 340         void **pg_vec;
 341
 342         pg_vec = kcalloc(block_nr, sizeof(void *), GFP_KERNEL);
 343         if (pg_vec == NULL)
 344                 return NULL;
 345
 346         for (i = 0; i < block_nr; i++) {
 347                 pg_vec[i] = alloc_one_pg_vec_page(order);
 348                 if (pg_vec[i] == NULL)
 349                         goto err1;
 350         }
 351
 352         return pg_vec;
 353 err1:
 354         free_pg_vec(pg_vec, order, block_nr);
 355         return NULL;
 356 }
 357
 358 static int netlink_set_ring(struct sock *sk, struct nl_mmap_req *req,
 359                             bool closing, bool tx_ring)
 360 {
 361         struct netlink_sock *nlk = nlk_sk(sk);
 362         struct netlink_ring *ring;
 363         struct sk_buff_head *queue;
 364         void **pg_vec = NULL;
 365         unsigned int order = 0;
 366         int err;
 367
 368         ring  = tx_ring ? &nlk->tx_ring : &nlk->rx_ring;
 369         queue = tx_ring ? &sk->sk_write_queue : &sk->sk_receive_queue;
 370
 371         if (!closing) {
 372                 if (atomic_read(&nlk->mapped))
 373                         return -EBUSY;
 374                 if (atomic_read(&ring->pending))
 375                         return -EBUSY;
 376         }
 377
 378         if (req->nm_block_nr) {
 379                 if (ring->pg_vec != NULL)
 380                         return -EBUSY;
 381
 382                 if ((int)req->nm_block_size <= 0)
 383                         return -EINVAL;
 384                 if (!PAGE_ALIGNED(req->nm_block_size))
 385                         return -EINVAL;
 386                 if (req->nm_frame_size < NL_MMAP_HDRLEN)
 387                         return -EINVAL;
 388                 if (!IS_ALIGNED(req->nm_frame_size, NL_MMAP_MSG_ALIGNMENT))
 389                         return -EINVAL;
 390
 391                 ring->frames_per_block = req->nm_block_size /
 392                                          req->nm_frame_size;
 393                 if (ring->frames_per_block == 0)
 394                         return -EINVAL;
 395                 if (ring->frames_per_block * req->nm_block_nr !=
 396                     req->nm_frame_nr)
 397                         return -EINVAL;
 398
 399                 order = get_order(req->nm_block_size);
 400                 pg_vec = alloc_pg_vec(nlk, req, order);
 401                 if (pg_vec == NULL)
 402                         return -ENOMEM;
 403         } else {
 404                 if (req->nm_frame_nr)
 405                         return -EINVAL;
 406         }
 407
 408         err = -EBUSY;
 409         mutex_lock(&nlk->pg_vec_lock);
 410         if (closing || atomic_read(&nlk->mapped) == 0) {
 411                 err = 0;
 412                 spin_lock_bh(&queue->lock);
 413
 414                 ring->frame_max         = req->nm_frame_nr - 1;
 415                 ring->head              = 0;
 416                 ring->frame_size        = req->nm_frame_size;
 417                 ring->pg_vec_pages      = req->nm_block_size / PAGE_SIZE;
 418
 419                 swap(ring->pg_vec_len, req->nm_block_nr);
 420                 swap(ring->pg_vec_order, order);
 421                 swap(ring->pg_vec, pg_vec);
 422
 423                 __skb_queue_purge(queue);
 424                 spin_unlock_bh(&queue->lock);
 425
 426                 WARN_ON(atomic_read(&nlk->mapped));
 427         }
 428         mutex_unlock(&nlk->pg_vec_lock);
 429
 430         if (pg_vec)
 431                 free_pg_vec(pg_vec, order, req->nm_block_nr);
 432         return err;
 433 }
 434
 435 static void netlink_mm_open(struct vm_area_struct *vma)
 436 {
 437         struct file *file = vma->vm_file;
 438         struct socket *sock = file->private_data;
 439         struct sock *sk = sock->sk;
 440
 441         if (sk)
 442                 atomic_inc(&nlk_sk(sk)->mapped);
 443 }
 444
 445 static void netlink_mm_close(struct vm_area_struct *vma)
 446 {
 447         struct file *file = vma->vm_file;
 448         struct socket *sock = file->private_data;
 449         struct sock *sk = sock->sk;
 450
 451         if (sk)
 452                 atomic_dec(&nlk_sk(sk)->mapped);
 453 }
 454
 455 static const struct vm_operations_struct netlink_mmap_ops = {
 456         .open   = netlink_mm_open,
 457         .close  = netlink_mm_close,
 458 };
 459
 460 static int netlink_mmap(struct file *file, struct socket *sock,
 461                         struct vm_area_struct *vma)
 462 {
 463         struct sock *sk = sock->sk;
 464         struct netlink_sock *nlk = nlk_sk(sk);
 465         struct netlink_ring *ring;
 466         unsigned long start, size, expected;
 467         unsigned int i;
 468         int err = -EINVAL;
 469
 470         if (vma->vm_pgoff)
 471                 return -EINVAL;
 472
 473         mutex_lock(&nlk->pg_vec_lock);
 474
 475         expected = 0;
 476         for (ring = &nlk->rx_ring; ring <= &nlk->tx_ring; ring++) {
 477                 if (ring->pg_vec == NULL)
 478                         continue;
 479                 expected += ring->pg_vec_len * ring->pg_vec_pages * PAGE_SIZE;
 480         }
 481
 482         if (expected == 0)
 483                 goto out;
 484
 485         size = vma->vm_end - vma->vm_start;
 486         if (size != expected)
 487                 goto out;
 488
 489         start = vma->vm_start;
 490         for (ring = &nlk->rx_ring; ring <= &nlk->tx_ring; ring++) {
 491                 if (ring->pg_vec == NULL)
 492                         continue;
 493
 494                 for (i = 0; i < ring->pg_vec_len; i++) {
 495                         struct page *page;
 496                         void *kaddr = ring->pg_vec[i];
 497                         unsigned int pg_num;
 498
 499                         for (pg_num = 0; pg_num < ring->pg_vec_pages; pg_num++) {
 500                                 page = pgvec_to_page(kaddr);
 501                                 err = vm_insert_page(vma, start, page);
 502                                 if (err < 0)
 503                                         goto out;
 504                                 start += PAGE_SIZE;
 505                                 kaddr += PAGE_SIZE;
 506                         }
 507                 }
 508         }
 509
 510         atomic_inc(&nlk->mapped);
 511         vma->vm_ops = &netlink_mmap_ops;
 512         err = 0;
 513 out:
 514         mutex_unlock(&nlk->pg_vec_lock);
 515         return err;
 516 }
 517
 518 static void netlink_frame_flush_dcache(const struct nl_mmap_hdr *hdr, unsigned int nm_len)
 519 {
 520 #if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE == 1
 521         struct page *p_start, *p_end;
 522
 523         /* First page is flushed through netlink_{get,set}_status */
 524         p_start = pgvec_to_page(hdr + PAGE_SIZE);
 525         p_end   = pgvec_to_page((void *)hdr + NL_MMAP_HDRLEN + nm_len - 1);
 526         while (p_start <= p_end) {
 527                 flush_dcache_page(p_start);
 528                 p_start++;
 529         }
 530 #endif
 531 }
 532
 533 static enum nl_mmap_status netlink_get_status(const struct nl_mmap_hdr *hdr)
 534 {
 535         smp_rmb();
 536         flush_dcache_page(pgvec_to_page(hdr));
 537         return hdr->nm_status;
 538 }
 539
 540 static void netlink_set_status(struct nl_mmap_hdr *hdr,
 541                                enum nl_mmap_status status)
 542 {
 543         smp_mb();
 544         hdr->nm_status = status;
 545         flush_dcache_page(pgvec_to_page(hdr));
 546 }
 547
 548 static struct nl_mmap_hdr *
 549 __netlink_lookup_frame(const struct netlink_ring *ring, unsigned int pos)
 550 {
 551         unsigned int pg_vec_pos, frame_off;
 552
 553         pg_vec_pos = pos / ring->frames_per_block;
 554         frame_off  = pos % ring->frames_per_block;
 555
 556         return ring->pg_vec[pg_vec_pos] + (frame_off * ring->frame_size);
 557 }
 558
 559 static struct nl_mmap_hdr *
 560 netlink_lookup_frame(const struct netlink_ring *ring, unsigned int pos,
 561                      enum nl_mmap_status status)
 562 {
 563         struct nl_mmap_hdr *hdr;
 564
 565         hdr = __netlink_lookup_frame(ring, pos);
 566         if (netlink_get_status(hdr) != status)
 567                 return NULL;
 568
 569         return hdr;
 570 }
 571
 572 static struct nl_mmap_hdr *
 573 netlink_current_frame(const struct netlink_ring *ring,
 574                       enum nl_mmap_status status)
 575 {
 576         return netlink_lookup_frame(ring, ring->head, status);
 577 }
 578
 579 static struct nl_mmap_hdr *
 580 netlink_previous_frame(const struct netlink_ring *ring,
 581                        enum nl_mmap_status status)
 582 {
 583         unsigned int prev;
 584
 585         prev = ring->head ? ring->head - 1 : ring->frame_max;
 586         return netlink_lookup_frame(ring, prev, status);
 587 }
 588
 589 static void netlink_increment_head(struct netlink_ring *ring)
 590 {
 591         ring->head = ring->head != ring->frame_max ? ring->head + 1 : 0;
 592 }
 593
 594 static void netlink_forward_ring(struct netlink_ring *ring)
 595 {
 596         unsigned int head = ring->head, pos = head;
 597         const struct nl_mmap_hdr *hdr;
 598
 599         do {
 600                 hdr = __netlink_lookup_frame(ring, pos);
 601                 if (hdr->nm_status == NL_MMAP_STATUS_UNUSED)
 602                         break;
 603                 if (hdr->nm_status != NL_MMAP_STATUS_SKIP)
 604                         break;
 605                 netlink_increment_head(ring);
 606         } while (ring->head != head);
 607 }
 608
 609 static bool netlink_dump_space(struct netlink_sock *nlk)
 610 {
 611         struct netlink_ring *ring = &nlk->rx_ring;
 612         struct nl_mmap_hdr *hdr;
 613         unsigned int n;
 614
 615         hdr = netlink_current_frame(ring, NL_MMAP_STATUS_UNUSED);
 616         if (hdr == NULL)
 617                 return false;
 618
 619         n = ring->head + ring->frame_max / 2;
 620         if (n > ring->frame_max)
 621                 n -= ring->frame_max;
 622
 623         hdr = __netlink_lookup_frame(ring, n);
 624
 625         return hdr->nm_status == NL_MMAP_STATUS_UNUSED;
 626 }
 627
 628 static unsigned int netlink_poll(struct file *file, struct socket *sock,
 629                                  poll_table *wait)
 630 {
 631         struct sock *sk = sock->sk;
 632         struct netlink_sock *nlk = nlk_sk(sk);
 633         unsigned int mask;
 634         int err;
 635
 636         if (nlk->rx_ring.pg_vec != NULL) {
 637                 /* Memory mapped sockets don't call recvmsg(), so flow control
 638                  * for dumps is performed here. A dump is allowed to continue
 639                  * if at least half the ring is unused.
 640                  */
 641                 while (nlk->cb_running && netlink_dump_space(nlk)) {
 642                         err = netlink_dump(sk);
 643                         if (err < 0) {
 644                                 sk->sk_err = -err;
 645                                 sk->sk_error_report(sk);
 646                                 break;
 647                         }
 648                 }
 649                 netlink_rcv_wake(sk);
 650         }
 651
 652         mask = datagram_poll(file, sock, wait);
 653
 654         spin_lock_bh(&sk->sk_receive_queue.lock);
 655         if (nlk->rx_ring.pg_vec) {
 656                 netlink_forward_ring(&nlk->rx_ring);
 657                 if (!netlink_previous_frame(&nlk->rx_ring, NL_MMAP_STATUS_UNUSED))
 658                         mask |= POLLIN | POLLRDNORM;
 659         }
 660         spin_unlock_bh(&sk->sk_receive_queue.lock);
 661
 662         spin_lock_bh(&sk->sk_write_queue.lock);
 663         if (nlk->tx_ring.pg_vec) {
 664                 if (netlink_current_frame(&nlk->tx_ring, NL_MMAP_STATUS_UNUSED))
 665                         mask |= POLLOUT | POLLWRNORM;
 666         }
 667         spin_unlock_bh(&sk->sk_write_queue.lock);
 668
 669         return mask;
 670 }
 671
 672 static struct nl_mmap_hdr *netlink_mmap_hdr(struct sk_buff *skb)
 673 {
 674         return (struct nl_mmap_hdr *)(skb->head - NL_MMAP_HDRLEN);
 675 }
 676
 677 static void netlink_ring_setup_skb(struct sk_buff *skb, struct sock *sk,
 678                                    struct netlink_ring *ring,
 679                                    struct nl_mmap_hdr *hdr)
 680 {
 681         unsigned int size;
 682         void *data;
 683
 684         size = ring->frame_size - NL_MMAP_HDRLEN;
 685         data = (void *)hdr + NL_MMAP_HDRLEN;
 686
 687         skb->head       = data;
 688         skb->data       = data;
 689         skb_reset_tail_pointer(skb);
 690         skb->end        = skb->tail + size;
 691         skb->len        = 0;
 692
 693         skb->destructor = netlink_skb_destructor;
 694         NETLINK_CB(skb).flags |= NETLINK_SKB_MMAPED;
 695         NETLINK_CB(skb).sk = sk;
 696 }
 697
 698 static int netlink_mmap_sendmsg(struct sock *sk, struct msghdr *msg,
 699                                 u32 dst_portid, u32 dst_group,
 700                                 struct scm_cookie *scm)
 701 {
 702         struct netlink_sock *nlk = nlk_sk(sk);
 703         struct netlink_ring *ring;
 704         struct nl_mmap_hdr *hdr;
 705         struct sk_buff *skb;
 706         unsigned int maxlen;
 707         int err = 0, len = 0;
 708
 709         mutex_lock(&nlk->pg_vec_lock);
 710
 711         ring   = &nlk->tx_ring;
 712         maxlen = ring->frame_size - NL_MMAP_HDRLEN;
 713
 714         do {
 715                 unsigned int nm_len;
 716
 717                 hdr = netlink_current_frame(ring, NL_MMAP_STATUS_VALID);
 718                 if (hdr == NULL) {
 719                         if (!(msg->msg_flags & MSG_DONTWAIT) &&
 720                             atomic_read(&nlk->tx_ring.pending))
 721                                 schedule();
 722                         continue;
 723                 }
 724
 725                 nm_len = ACCESS_ONCE(hdr->nm_len);
 726                 if (nm_len > maxlen) {
 727                         err = -EINVAL;
 728                         goto out;
 729                 }
 730
 731                 netlink_frame_flush_dcache(hdr, nm_len);
 732
 733                 skb = alloc_skb(nm_len, GFP_KERNEL);
 734                 if (skb == NULL) {
 735                         err = -ENOBUFS;
 736                         goto out;
 737                 }
 738                 __skb_put(skb, nm_len);
 739                 memcpy(skb->data, (void *)hdr + NL_MMAP_HDRLEN, nm_len);
 740                 netlink_set_status(hdr, NL_MMAP_STATUS_UNUSED);
 741
 742                 netlink_increment_head(ring);
 743
 744                 NETLINK_CB(skb).portid    = nlk->portid;
 745                 NETLINK_CB(skb).dst_group = dst_group;
 746                 NETLINK_CB(skb).creds     = scm->creds;
 747
 748                 err = security_netlink_send(sk, skb);
 749                 if (err) {
 750                         kfree_skb(skb);
 751                         goto out;
 752                 }
 753
 754                 if (unlikely(dst_group)) {
 755                         atomic_inc(&skb->users);
 756                         netlink_broadcast(sk, skb, dst_portid, dst_group,
 757                                           GFP_KERNEL);
 758                 }
 759                 err = netlink_unicast(sk, skb, dst_portid,
 760                                       msg->msg_flags & MSG_DONTWAIT);
 761                 if (err < 0)
 762                         goto out;
 763                 len += err;
 764
 765         } while (hdr != NULL ||
 766                  (!(msg->msg_flags & MSG_DONTWAIT) &&
 767                   atomic_read(&nlk->tx_ring.pending)));
 768
 769         if (len > 0)
 770                 err = len;
 771 out:
 772         mutex_unlock(&nlk->pg_vec_lock);
 773         return err;
 774 }
 775
 776 static void netlink_queue_mmaped_skb(struct sock *sk, struct sk_buff *skb)
 777 {
 778         struct nl_mmap_hdr *hdr;
 779
 780         hdr = netlink_mmap_hdr(skb);
 781         hdr->nm_len     = skb->len;
 782         hdr->nm_group   = NETLINK_CB(skb).dst_group;
 783         hdr->nm_pid     = NETLINK_CB(skb).creds.pid;
 784         hdr->nm_uid     = from_kuid(sk_user_ns(sk), NETLINK_CB(skb).creds.uid);
 785         hdr->nm_gid     = from_kgid(sk_user_ns(sk), NETLINK_CB(skb).creds.gid);
 786         netlink_frame_flush_dcache(hdr, hdr->nm_len);
 787         netlink_set_status(hdr, NL_MMAP_STATUS_VALID);
 788
 789         NETLINK_CB(skb).flags |= NETLINK_SKB_DELIVERED;
 790         kfree_skb(skb);
 791 }
 792
 793 static void netlink_ring_set_copied(struct sock *sk, struct sk_buff *skb)
 794 {
 795         struct netlink_sock *nlk = nlk_sk(sk);
 796         struct netlink_ring *ring = &nlk->rx_ring;
 797         struct nl_mmap_hdr *hdr;
 798
 799         spin_lock_bh(&sk->sk_receive_queue.lock);
 800         hdr = netlink_current_frame(ring, NL_MMAP_STATUS_UNUSED);
 801         if (hdr == NULL) {
 802                 spin_unlock_bh(&sk->sk_receive_queue.lock);
 803                 kfree_skb(skb);
 804                 netlink_overrun(sk);
 805                 return;
 806         }
 807         netlink_increment_head(ring);
 808         __skb_queue_tail(&sk->sk_receive_queue, skb);
 809         spin_unlock_bh(&sk->sk_receive_queue.lock);
 810
 811         hdr->nm_len     = skb->len;
 812         hdr->nm_group   = NETLINK_CB(skb).dst_group;
 813         hdr->nm_pid     = NETLINK_CB(skb).creds.pid;
 814         hdr->nm_uid     = from_kuid(sk_user_ns(sk), NETLINK_CB(skb).creds.uid);
 815         hdr->nm_gid     = from_kgid(sk_user_ns(sk), NETLINK_CB(skb).creds.gid);
 816         netlink_set_status(hdr, NL_MMAP_STATUS_COPY);
 817 }
 818
 819 #else /* CONFIG_NETLINK_MMAP */
 820 #define netlink_skb_is_mmaped(skb)      false
 821 #define netlink_rx_is_mmaped(sk)        false
 822 #define netlink_tx_is_mmaped(sk)        false
 823 #define netlink_mmap                    sock_no_mmap
 824 #define netlink_poll                    datagram_poll
 825 #define netlink_mmap_sendmsg(sk, msg, dst_portid, dst_group, scm)       0
 826 #endif /* CONFIG_NETLINK_MMAP */
 827
 828 static void netlink_skb_destructor(struct sk_buff *skb)
 829 {
 830 #ifdef CONFIG_NETLINK_MMAP
 831         struct nl_mmap_hdr *hdr;
 832         struct netlink_ring *ring;
 833         struct sock *sk;
 834
 835         /* If a packet from the kernel to userspace was freed because of an
 836          * error without being delivered to userspace, the kernel must reset
 837          * the status. In the direction userspace to kernel, the status is
 838          * always reset here after the packet was processed and freed.
 839          */
 840         if (netlink_skb_is_mmaped(skb)) {
 841                 hdr = netlink_mmap_hdr(skb);
 842                 sk = NETLINK_CB(skb).sk;
 843
 844                 if (NETLINK_CB(skb).flags & NETLINK_SKB_TX) {
 845                         netlink_set_status(hdr, NL_MMAP_STATUS_UNUSED);
 846                         ring = &nlk_sk(sk)->tx_ring;
 847                 } else {
 848                         if (!(NETLINK_CB(skb).flags & NETLINK_SKB_DELIVERED)) {
 849                                 hdr->nm_len = 0;
 850                                 netlink_set_status(hdr, NL_MMAP_STATUS_VALID);
 851                         }
 852                         ring = &nlk_sk(sk)->rx_ring;
 853                 }
 854
 855                 WARN_ON(atomic_read(&ring->pending) == 0);
 856                 atomic_dec(&ring->pending);
 857                 sock_put(sk);
 858
 859                 skb->head = NULL;
 860         }
 861 #endif
 862         if (is_vmalloc_addr(skb->head)) {
 863                 if (!skb->cloned ||
 864                     !atomic_dec_return(&(skb_shinfo(skb)->dataref)))
 865                         vfree(skb->head);
 866
 867                 skb->head = NULL;
 868         }
 869         if (skb->sk != NULL)
 870                 sock_rfree(skb);
 871 }
 872
 873 static void netlink_skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
 874 {
 875         WARN_ON(skb->sk != NULL);
 876         skb->sk = sk;
 877         skb->destructor = netlink_skb_destructor;
 878         atomic_add(skb->truesize, &sk->sk_rmem_alloc);
 879         sk_mem_charge(sk, skb->truesize);
 880 }
 881
 882 static void netlink_sock_destruct(struct sock *sk)
 883 {
 884         struct netlink_sock *nlk = nlk_sk(sk);
 885
 886         if (nlk->cb_running) {
 887                 if (nlk->cb.done)
 888                         nlk->cb.done(&nlk->cb);
 889
 890                 module_put(nlk->cb.module);
 891                 kfree_skb(nlk->cb.skb);
 892         }
 893
 894         skb_queue_purge(&sk->sk_receive_queue);
 895 #ifdef CONFIG_NETLINK_MMAP
 896         if (1) {
 897                 struct nl_mmap_req req;
 898
 899                 memset(&req, 0, sizeof(req));
 900                 if (nlk->rx_ring.pg_vec)
 901                         netlink_set_ring(sk, &req, true, false);
 902                 memset(&req, 0, sizeof(req));
 903                 if (nlk->tx_ring.pg_vec)
 904                         netlink_set_ring(sk, &req, true, true);
 905         }
 906 #endif /* CONFIG_NETLINK_MMAP */
 907
 908         if (!sock_flag(sk, SOCK_DEAD)) {
 909                 printk(KERN_ERR "Freeing alive netlink socket %p\n", sk);
 910                 return;
 911         }
 912
 913         WARN_ON(atomic_read(&sk->sk_rmem_alloc));
 914         WARN_ON(atomic_read(&sk->sk_wmem_alloc));
 915         WARN_ON(nlk_sk(sk)->groups);
 916 }
 917
 918 /* This lock without WQ_FLAG_EXCLUSIVE is good on UP and it is _very_ bad on
 919  * SMP. Look, when several writers sleep and reader wakes them up, all but one
 920  * immediately hit write lock and grab all the cpus. Exclusive sleep solves
 921  * this, _but_ remember, it adds useless work on UP machines.
 922  */
 923
 924 void netlink_table_grab(void)
 925         __acquires(nl_table_lock)
 926 {
 927         might_sleep();
 928
 929         write_lock_irq(&nl_table_lock);
 930
 931         if (atomic_read(&nl_table_users)) {
 932                 DECLARE_WAITQUEUE(wait, current);
 933
 934                 add_wait_queue_exclusive(&nl_table_wait, &wait);
 935                 for (;;) {
 936                         set_current_state(TASK_UNINTERRUPTIBLE);
 937                         if (atomic_read(&nl_table_users) == 0)
 938                                 break;
 939                         write_unlock_irq(&nl_table_lock);
 940                         schedule();
 941                         write_lock_irq(&nl_table_lock);
 942                 }
 943
 944                 __set_current_state(TASK_RUNNING);
 945                 remove_wait_queue(&nl_table_wait, &wait);
 946         }
 947 }
 948
 949 void netlink_table_ungrab(void)
 950         __releases(nl_table_lock)
 951 {
 952         write_unlock_irq(&nl_table_lock);
 953         wake_up(&nl_table_wait);
 954 }
 955
 956 static inline void
 957 netlink_lock_table(void)
 958 {
 959         /* read_lock() synchronizes us to netlink_table_grab */
 960
 961         read_lock(&nl_table_lock);
 962         atomic_inc(&nl_table_users);
 963         read_unlock(&nl_table_lock);
 964 }
 965
 966 static inline void
 967 netlink_unlock_table(void)
 968 {
 969         if (atomic_dec_and_test(&nl_table_users))
 970                 wake_up(&nl_table_wait);
 971 }
 972
 973 struct netlink_compare_arg
 974 {
 975         possible_net_t pnet;
 976         u32 portid;
 977 };
 978
 979 /* Doing sizeof directly may yield 4 extra bytes on 64-bit. */
 980 #define netlink_compare_arg_len \
 981         (offsetof(struct netlink_compare_arg, portid) + sizeof(u32))
 982
 983 static inline int netlink_compare(struct rhashtable_compare_arg *arg,
 984                                   const void *ptr)
 985 {
 986         const struct netlink_compare_arg *x = arg->key;
 987         const struct netlink_sock *nlk = ptr;
 988
 989         return nlk->portid != x->portid ||
 990                !net_eq(sock_net(&nlk->sk), read_pnet(&x->pnet));
 991 }
 992
 993 static void netlink_compare_arg_init(struct netlink_compare_arg *arg,
 994                                      struct net *net, u32 portid)
 995 {
 996         memset(arg, 0, sizeof(*arg));
 997         write_pnet(&arg->pnet, net);
 998         arg->portid = portid;
 999 }
1000
1001 static struct sock *__netlink_lookup(struct netlink_table *table, u32 portid,
1002                                      struct net *net)
1003 {
1004         struct netlink_compare_arg arg;
1005
1006         netlink_compare_arg_init(&arg, net, portid);
1007         return rhashtable_lookup_fast(&table->hash, &arg,
1008                                       netlink_rhashtable_params);
1009 }
1010
1011 static int __netlink_insert(struct netlink_table *table, struct sock *sk)
1012 {
1013         struct netlink_compare_arg arg;
1014
1015         netlink_compare_arg_init(&arg, sock_net(sk), nlk_sk(sk)->portid);
1016         return rhashtable_lookup_insert_key(&table->hash, &arg,
1017                                             &nlk_sk(sk)->node,
1018                                             netlink_rhashtable_params);
1019 }
1020
1021 static struct sock *netlink_lookup(struct net *net, int protocol, u32 portid)
1022 {
1023         struct netlink_table *table = &nl_table[protocol];
1024         struct sock *sk;
1025
1026         rcu_read_lock();
1027         sk = __netlink_lookup(table, portid, net);
1028         if (sk)
1029                 sock_hold(sk);
1030         rcu_read_unlock();
1031
1032         return sk;
1033 }
1034
1035 static const struct proto_ops netlink_ops;
1036
1037 static void
1038 netlink_update_listeners(struct sock *sk)
1039 {
1040         struct netlink_table *tbl = &nl_table[sk->sk_protocol];
1041         unsigned long mask;
1042         unsigned int i;
1043         struct listeners *listeners;
1044
1045         listeners = nl_deref_protected(tbl->listeners);
1046         if (!listeners)
1047                 return;
1048
1049         for (i = 0; i < NLGRPLONGS(tbl->groups); i++) {
1050                 mask = 0;
1051                 sk_for_each_bound(sk, &tbl->mc_list) {
1052                         if (i < NLGRPLONGS(nlk_sk(sk)->ngroups))
1053                                 mask |= nlk_sk(sk)->groups[i];
1054                 }
1055                 listeners->masks[i] = mask;
1056         }
1057         /* this function is only called with the netlink table "grabbed", which
1058          * makes sure updates are visible before bind or setsockopt return. */
1059 }
1060
1061 static int netlink_insert(struct sock *sk, u32 portid)
1062 {
1063         struct netlink_table *table = &nl_table[sk->sk_protocol];
1064         int err;
1065
1066         lock_sock(sk);
1067
1068         err = -EBUSY;
1069         if (nlk_sk(sk)->portid)
1070                 goto err;
1071
1072         err = -ENOMEM;
1073         if (BITS_PER_LONG > 32 &&
1074             unlikely(atomic_read(&table->hash.nelems) >= UINT_MAX))
1075                 goto err;
1076
1077         nlk_sk(sk)->portid = portid;
1078         sock_hold(sk);
1079
1080         err = __netlink_insert(table, sk);
1081         if (err) {
1082                 if (err == -EEXIST)
1083                         err = -EADDRINUSE;
1084                 nlk_sk(sk)->portid = 0;
1085                 sock_put(sk);
1086         }
1087
1088 err:
1089         release_sock(sk);
1090         return err;
1091 }
1092
1093 static void netlink_remove(struct sock *sk)
1094 {
1095         struct netlink_table *table;
1096
1097         table = &nl_table[sk->sk_protocol];
1098         if (!rhashtable_remove_fast(&table->hash, &nlk_sk(sk)->node,
1099                                     netlink_rhashtable_params)) {
1100                 WARN_ON(atomic_read(&sk->sk_refcnt) == 1);
1101                 __sock_put(sk);
1102         }
1103
1104         netlink_table_grab();
1105         if (nlk_sk(sk)->subscriptions) {
1106                 __sk_del_bind_node(sk);
1107                 netlink_update_listeners(sk);
1108         }
1109         if (sk->sk_protocol == NETLINK_GENERIC)
1110                 atomic_inc(&genl_sk_destructing_cnt);
1111         netlink_table_ungrab();
1112 }
1113
1114 static struct proto netlink_proto = {
1115         .name     = "NETLINK",
1116         .owner    = THIS_MODULE,
1117         .obj_size = sizeof(struct netlink_sock),
1118 };
1119
1120 static int __netlink_create(struct net *net, struct socket *sock,
1121                             struct mutex *cb_mutex, int protocol)
1122 {
1123         struct sock *sk;
1124         struct netlink_sock *nlk;
1125
1126         sock->ops = &netlink_ops;
1127
1128         sk = sk_alloc(net, PF_NETLINK, GFP_KERNEL, &netlink_proto);
1129         if (!sk)
1130                 return -ENOMEM;
1131
1132         sock_init_data(sock, sk);
1133
1134         nlk = nlk_sk(sk);
1135         if (cb_mutex) {
1136                 nlk->cb_mutex = cb_mutex;
1137         } else {
1138                 nlk->cb_mutex = &nlk->cb_def_mutex;
1139                 mutex_init(nlk->cb_mutex);
1140         }
1141         init_waitqueue_head(&nlk->wait);
1142 #ifdef CONFIG_NETLINK_MMAP
1143         mutex_init(&nlk->pg_vec_lock);
1144 #endif
1145
1146         sk->sk_destruct = netlink_sock_destruct;
1147         sk->sk_protocol = protocol;
1148         return 0;
1149 }
1150
1151 static int netlink_create(struct net *net, struct socket *sock, int protocol,
1152                           int kern)
1153 {
1154         struct module *module = NULL;
1155         struct mutex *cb_mutex;
1156         struct netlink_sock *nlk;
1157         int (*bind)(struct net *net, int group);
1158         void (*unbind)(struct net *net, int group);
1159         int err = 0;
1160
1161         sock->state = SS_UNCONNECTED;
1162
1163         if (sock->type != SOCK_RAW && sock->type != SOCK_DGRAM)
1164                 return -ESOCKTNOSUPPORT;
1165
1166         if (protocol < 0 || protocol >= MAX_LINKS)
1167                 return -EPROTONOSUPPORT;
1168
1169         netlink_lock_table();
1170 #ifdef CONFIG_MODULES
1171         if (!nl_table[protocol].registered) {
1172                 netlink_unlock_table();
1173                 request_module("net-pf-%d-proto-%d", PF_NETLINK, protocol);
1174                 netlink_lock_table();
1175         }
1176 #endif
1177         if (nl_table[protocol].registered &&
1178             try_module_get(nl_table[protocol].module))
1179                 module = nl_table[protocol].module;
1180         else
1181                 err = -EPROTONOSUPPORT;
1182         cb_mutex = nl_table[protocol].cb_mutex;
1183         bind = nl_table[protocol].bind;
1184         unbind = nl_table[protocol].unbind;
1185         netlink_unlock_table();
1186
1187         if (err < 0)
1188                 goto out;
1189
1190         err = __netlink_create(net, sock, cb_mutex, protocol);
1191         if (err < 0)
1192                 goto out_module;
1193
1194         local_bh_disable();
1195         sock_prot_inuse_add(net, &netlink_proto, 1);
1196         local_bh_enable();
1197
1198         nlk = nlk_sk(sock->sk);
1199         nlk->module = module;
1200         nlk->netlink_bind = bind;
1201         nlk->netlink_unbind = unbind;
1202 out:
1203         return err;
1204
1205 out_module:
1206         module_put(module);
1207         goto out;
1208 }
1209
1210 static void deferred_put_nlk_sk(struct rcu_head *head)
1211 {
1212         struct netlink_sock *nlk = container_of(head, struct netlink_sock, rcu);
1213
1214         sock_put(&nlk->sk);
1215 }
1216
1217 static int netlink_release(struct socket *sock)
1218 {
1219         struct sock *sk = sock->sk;
1220         struct netlink_sock *nlk;
1221
1222         if (!sk)
1223                 return 0;
1224
1225         netlink_remove(sk);
1226         sock_orphan(sk);
1227         nlk = nlk_sk(sk);
1228
1229         /*
1230          * OK. Socket is unlinked, any packets that arrive now
1231          * will be purged.
1232          */
1233
1234         /* must not acquire netlink_table_lock in any way again before unbind
1235          * and notifying genetlink is done as otherwise it might deadlock
1236          */
1237         if (nlk->netlink_unbind) {
1238                 int i;
1239
1240                 for (i = 0; i < nlk->ngroups; i++)
1241                         if (test_bit(i, nlk->groups))
1242                                 nlk->netlink_unbind(sock_net(sk), i + 1);
1243         }
1244         if (sk->sk_protocol == NETLINK_GENERIC &&
1245             atomic_dec_return(&genl_sk_destructing_cnt) == 0)
1246                 wake_up(&genl_sk_destructing_waitq);
1247
1248         sock->sk = NULL;
1249         wake_up_interruptible_all(&nlk->wait);
1250
1251         skb_queue_purge(&sk->sk_write_queue);
1252
1253         if (nlk->portid) {
1254                 struct netlink_notify n = {
1255                                                 .net = sock_net(sk),
1256                                                 .protocol = sk->sk_protocol,
1257                                                 .portid = nlk->portid,
1258                                           };
1259                 atomic_notifier_call_chain(&netlink_chain,
1260                                 NETLINK_URELEASE, &n);
1261         }
1262
1263         module_put(nlk->module);
1264
1265         if (netlink_is_kernel(sk)) {
1266                 netlink_table_grab();
1267                 BUG_ON(nl_table[sk->sk_protocol].registered == 0);
1268                 if (--nl_table[sk->sk_protocol].registered == 0) {
1269                         struct listeners *old;
1270
1271                         old = nl_deref_protected(nl_table[sk->sk_protocol].listeners);
1272                         RCU_INIT_POINTER(nl_table[sk->sk_protocol].listeners, NULL);
1273                         kfree_rcu(old, rcu);
1274                         nl_table[sk->sk_protocol].module = NULL;
1275                         nl_table[sk->sk_protocol].bind = NULL;
1276                         nl_table[sk->sk_protocol].unbind = NULL;
1277                         nl_table[sk->sk_protocol].flags = 0;
1278                         nl_table[sk->sk_protocol].registered = 0;
1279                 }
1280                 netlink_table_ungrab();
1281         }
1282
1283         kfree(nlk->groups);
1284         nlk->groups = NULL;
1285
1286         local_bh_disable();
1287         sock_prot_inuse_add(sock_net(sk), &netlink_proto, -1);
1288         local_bh_enable();
1289         call_rcu(&nlk->rcu, deferred_put_nlk_sk);
1290         return 0;
1291 }
1292
1293 static int netlink_autobind(struct socket *sock)
1294 {
1295         struct sock *sk = sock->sk;
1296         struct net *net = sock_net(sk);
1297         struct netlink_table *table = &nl_table[sk->sk_protocol];
1298         s32 portid = task_tgid_vnr(current);
1299         int err;
1300         static s32 rover = -4097;
1301
1302 retry:
1303         cond_resched();
1304         rcu_read_lock();
1305         if (__netlink_lookup(table, portid, net)) {
1306                 /* Bind collision, search negative portid values. */
1307                 portid = rover--;
1308                 if (rover > -4097)
1309                         rover = -4097;
1310                 rcu_read_unlock();
1311                 goto retry;
1312         }
1313         rcu_read_unlock();
1314
1315         err = netlink_insert(sk, portid);
1316         if (err == -EADDRINUSE)
1317                 goto retry;
1318
1319         /* If 2 threads race to autobind, that is fine.  */
1320         if (err == -EBUSY)
1321                 err = 0;
1322
1323         return err;
1324 }
1325
1326 /**
1327  * __netlink_ns_capable - General netlink message capability test
1328  * @nsp: NETLINK_CB of the socket buffer holding a netlink command from userspace.
1329  * @user_ns: The user namespace of the capability to use
1330  * @cap: The capability to use
1331  *
1332  * Test to see if the opener of the socket we received the message
1333  * from had when the netlink socket was created and the sender of the
1334  * message has has the capability @cap in the user namespace @user_ns.
1335  */
1336 bool __netlink_ns_capable(const struct netlink_skb_parms *nsp,
1337                         struct user_namespace *user_ns, int cap)
1338 {
1339         return ((nsp->flags & NETLINK_SKB_DST) ||
1340                 file_ns_capable(nsp->sk->sk_socket->file, user_ns, cap)) &&
1341                 ns_capable(user_ns, cap);
1342 }
1343 EXPORT_SYMBOL(__netlink_ns_capable);
1344
1345 /**
1346  * netlink_ns_capable - General netlink message capability test
1347  * @skb: socket buffer holding a netlink command from userspace
1348  * @user_ns: The user namespace of the capability to use
1349  * @cap: The capability to use
1350  *
1351  * Test to see if the opener of the socket we received the message
1352  * from had when the netlink socket was created and the sender of the
1353  * message has has the capability @cap in the user namespace @user_ns.
1354  */
1355 bool netlink_ns_capable(const struct sk_buff *skb,
1356                         struct user_namespace *user_ns, int cap)
1357 {
1358         return __netlink_ns_capable(&NETLINK_CB(skb), user_ns, cap);
1359 }
1360 EXPORT_SYMBOL(netlink_ns_capable);
1361
1362 /**
1363  * netlink_capable - Netlink global message capability test
1364  * @skb: socket buffer holding a netlink command from userspace
1365  * @cap: The capability to use
1366  *
1367  * Test to see if the opener of the socket we received the message
1368  * from had when the netlink socket was created and the sender of the
1369  * message has has the capability @cap in all user namespaces.
1370  */
1371 bool netlink_capable(const struct sk_buff *skb, int cap)
1372 {
1373         return netlink_ns_capable(skb, &init_user_ns, cap);
1374 }
1375 EXPORT_SYMBOL(netlink_capable);
1376
1377 /**
1378  * netlink_net_capable - Netlink network namespace message capability test
1379  * @skb: socket buffer holding a netlink command from userspace
1380  * @cap: The capability to use
1381  *
1382  * Test to see if the opener of the socket we received the message
1383  * from had when the netlink socket was created and the sender of the
1384  * message has has the capability @cap over the network namespace of
1385  * the socket we received the message from.
1386  */
1387 bool netlink_net_capable(const struct sk_buff *skb, int cap)
1388 {
1389         return netlink_ns_capable(skb, sock_net(skb->sk)->user_ns, cap);
1390 }
1391 EXPORT_SYMBOL(netlink_net_capable);
1392
1393 static inline int netlink_allowed(const struct socket *sock, unsigned int flag)
1394 {
1395         return (nl_table[sock->sk->sk_protocol].flags & flag) ||
1396                 ns_capable(sock_net(sock->sk)->user_ns, CAP_NET_ADMIN);
1397 }
1398
1399 static void
1400 netlink_update_subscriptions(struct sock *sk, unsigned int subscriptions)
1401 {
1402         struct netlink_sock *nlk = nlk_sk(sk);
1403
1404         if (nlk->subscriptions && !subscriptions)
1405                 __sk_del_bind_node(sk);
1406         else if (!nlk->subscriptions && subscriptions)
1407                 sk_add_bind_node(sk, &nl_table[sk->sk_protocol].mc_list);
1408         nlk->subscriptions = subscriptions;
1409 }
1410
1411 static int netlink_realloc_groups(struct sock *sk)
1412 {
1413         struct netlink_sock *nlk = nlk_sk(sk);
1414         unsigned int groups;
1415         unsigned long *new_groups;
1416         int err = 0;
1417
1418         netlink_table_grab();
1419
1420         groups = nl_table[sk->sk_protocol].groups;
1421         if (!nl_table[sk->sk_protocol].registered) {
1422                 err = -ENOENT;
1423                 goto out_unlock;
1424         }
1425
1426         if (nlk->ngroups >= groups)
1427                 goto out_unlock;
1428
1429         new_groups = krealloc(nlk->groups, NLGRPSZ(groups), GFP_ATOMIC);
1430         if (new_groups == NULL) {
1431                 err = -ENOMEM;
1432                 goto out_unlock;
1433         }
1434         memset((char *)new_groups + NLGRPSZ(nlk->ngroups), 0,
1435                NLGRPSZ(groups) - NLGRPSZ(nlk->ngroups));
1436
1437         nlk->groups = new_groups;
1438         nlk->ngroups = groups;
1439  out_unlock:
1440         netlink_table_ungrab();
1441         return err;
1442 }
1443
1444 static void netlink_undo_bind(int group, long unsigned int groups,
1445                               struct sock *sk)
1446 {
1447         struct netlink_sock *nlk = nlk_sk(sk);
1448         int undo;
1449
1450         if (!nlk->netlink_unbind)
1451                 return;
1452
1453         for (undo = 0; undo < group; undo++)
1454                 if (test_bit(undo, &groups))
1455                         nlk->netlink_unbind(sock_net(sk), undo + 1);
1456 }
1457
1458 static int netlink_bind(struct socket *sock, struct sockaddr *addr,
1459                         int addr_len)
1460 {
1461         struct sock *sk = sock->sk;
1462         struct net *net = sock_net(sk);
1463         struct netlink_sock *nlk = nlk_sk(sk);
1464         struct sockaddr_nl *nladdr = (struct sockaddr_nl *)addr;
1465         int err;
1466         long unsigned int groups = nladdr->nl_groups;
1467
1468         if (addr_len < sizeof(struct sockaddr_nl))
1469                 return -EINVAL;
1470
1471         if (nladdr->nl_family != AF_NETLINK)
1472                 return -EINVAL;
1473
1474         /* Only superuser is allowed to listen multicasts */
1475         if (groups) {
1476                 if (!netlink_allowed(sock, NL_CFG_F_NONROOT_RECV))
1477                         return -EPERM;
1478                 err = netlink_realloc_groups(sk);
1479                 if (err)
1480                         return err;
1481         }
1482
1483         if (nlk->portid)
1484                 if (nladdr->nl_pid != nlk->portid)
1485                         return -EINVAL;
1486
1487         if (nlk->netlink_bind && groups) {
1488                 int group;
1489
1490                 for (group = 0; group < nlk->ngroups; group++) {
1491                         if (!test_bit(group, &groups))
1492                                 continue;
1493                         err = nlk->netlink_bind(net, group + 1);
1494                         if (!err)
1495                                 continue;
1496                         netlink_undo_bind(group, groups, sk);
1497                         return err;
1498                 }
1499         }
1500
1501         if (!nlk->portid) {
1502                 err = nladdr->nl_pid ?
1503                         netlink_insert(sk, nladdr->nl_pid) :
1504                         netlink_autobind(sock);
1505                 if (err) {
1506                         netlink_undo_bind(nlk->ngroups, groups, sk);
1507                         return err;
1508                 }
1509         }
1510
1511         if (!groups && (nlk->groups == NULL || !(u32)nlk->groups[0]))
1512                 return 0;
1513
1514         netlink_table_grab();
1515         netlink_update_subscriptions(sk, nlk->subscriptions +
1516                                          hweight32(groups) -
1517                                          hweight32(nlk->groups[0]));
1518         nlk->groups[0] = (nlk->groups[0] & ~0xffffffffUL) | groups;
1519         netlink_update_listeners(sk);
1520         netlink_table_ungrab();
1521
1522         return 0;
1523 }
1524
1525 static int netlink_connect(struct socket *sock, struct sockaddr *addr,
1526                            int alen, int flags)
1527 {
1528         int err = 0;
1529         struct sock *sk = sock->sk;
1530         struct netlink_sock *nlk = nlk_sk(sk);
1531         struct sockaddr_nl *nladdr = (struct sockaddr_nl *)addr;
1532
1533         if (alen < sizeof(addr->sa_family))
1534                 return -EINVAL;
1535
1536         if (addr->sa_family == AF_UNSPEC) {
1537                 sk->sk_state    = NETLINK_UNCONNECTED;
1538                 nlk->dst_portid = 0;
1539                 nlk->dst_group  = 0;
1540                 return 0;
1541         }
1542         if (addr->sa_family != AF_NETLINK)
1543                 return -EINVAL;
1544
1545         if ((nladdr->nl_groups || nladdr->nl_pid) &&
1546             !netlink_allowed(sock, NL_CFG_F_NONROOT_SEND))
1547                 return -EPERM;
1548
1549         if (!nlk->portid)
1550                 err = netlink_autobind(sock);
1551
1552         if (err == 0) {
1553                 sk->sk_state    = NETLINK_CONNECTED;
1554                 nlk->dst_portid = nladdr->nl_pid;
1555                 nlk->dst_group  = ffs(nladdr->nl_groups);
1556         }
1557
1558         return err;
1559 }
1560
1561 static int netlink_getname(struct socket *sock, struct sockaddr *addr,
1562                            int *addr_len, int peer)
1563 {
1564         struct sock *sk = sock->sk;
1565         struct netlink_sock *nlk = nlk_sk(sk);
1566         DECLARE_SOCKADDR(struct sockaddr_nl *, nladdr, addr);
1567
1568         nladdr->nl_family = AF_NETLINK;
1569         nladdr->nl_pad = 0;
1570         *addr_len = sizeof(*nladdr);
1571
1572         if (peer) {
1573                 nladdr->nl_pid = nlk->dst_portid;
1574                 nladdr->nl_groups = netlink_group_mask(nlk->dst_group);
1575         } else {
1576                 nladdr->nl_pid = nlk->portid;
1577                 nladdr->nl_groups = nlk->groups ? nlk->groups[0] : 0;
1578         }
1579         return 0;
1580 }
1581
1582 static struct sock *netlink_getsockbyportid(struct sock *ssk, u32 portid)
1583 {
1584         struct sock *sock;
1585         struct netlink_sock *nlk;
1586
1587         sock = netlink_lookup(sock_net(ssk), ssk->sk_protocol, portid);
1588         if (!sock)
1589                 return ERR_PTR(-ECONNREFUSED);
1590
1591         /* Don't bother queuing skb if kernel socket has no input function */
1592         nlk = nlk_sk(sock);
1593         if (sock->sk_state == NETLINK_CONNECTED &&
1594             nlk->dst_portid != nlk_sk(ssk)->portid) {
1595                 sock_put(sock);
1596                 return ERR_PTR(-ECONNREFUSED);
1597         }
1598         return sock;
1599 }
1600
1601 struct sock *netlink_getsockbyfilp(struct file *filp)
1602 {
1603         struct inode *inode = file_inode(filp);
1604         struct sock *sock;
1605
1606         if (!S_ISSOCK(inode->i_mode))
1607                 return ERR_PTR(-ENOTSOCK);
1608
1609         sock = SOCKET_I(inode)->sk;
1610         if (sock->sk_family != AF_NETLINK)
1611                 return ERR_PTR(-EINVAL);
1612
1613         sock_hold(sock);
1614         return sock;
1615 }
1616
1617 static struct sk_buff *netlink_alloc_large_skb(unsigned int size,
1618                                                int broadcast)
1619 {
1620         struct sk_buff *skb;
1621         void *data;
1622
1623         if (size <= NLMSG_GOODSIZE || broadcast)
1624                 return alloc_skb(size, GFP_KERNEL);
1625
1626         size = SKB_DATA_ALIGN(size) +
1627                SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
1628
1629         data = vmalloc(size);
1630         if (data == NULL)
1631                 return NULL;
1632
1633         skb = __build_skb(data, size);
1634         if (skb == NULL)
1635                 vfree(data);
1636         else
1637                 skb->destructor = netlink_skb_destructor;
1638
1639         return skb;
1640 }
1641
1642 /*
1643  * Attach a skb to a netlink socket.
1644  * The caller must hold a reference to the destination socket. On error, the
1645  * reference is dropped. The skb is not send to the destination, just all
1646  * all error checks are performed and memory in the queue is reserved.
1647  * Return values:
1648  * < 0: error. skb freed, reference to sock dropped.
1649  * 0: continue
1650  * 1: repeat lookup - reference dropped while waiting for socket memory.
1651  */
1652 int netlink_attachskb(struct sock *sk, struct sk_buff *skb,
1653                       long *timeo, struct sock *ssk)
1654 {
1655         struct netlink_sock *nlk;
1656
1657         nlk = nlk_sk(sk);
1658
1659         if ((atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
1660              test_bit(NETLINK_CONGESTED, &nlk->state)) &&
1661             !netlink_skb_is_mmaped(skb)) {
1662                 DECLARE_WAITQUEUE(wait, current);
1663                 if (!*timeo) {
1664                         if (!ssk || netlink_is_kernel(ssk))
1665                                 netlink_overrun(sk);
1666                         sock_put(sk);
1667                         kfree_skb(skb);
1668                         return -EAGAIN;
1669                 }
1670
1671                 __set_current_state(TASK_INTERRUPTIBLE);
1672                 add_wait_queue(&nlk->wait, &wait);
1673
1674                 if ((atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
1675                      test_bit(NETLINK_CONGESTED, &nlk->state)) &&
1676                     !sock_flag(sk, SOCK_DEAD))
1677                         *timeo = schedule_timeout(*timeo);
1678
1679                 __set_current_state(TASK_RUNNING);
1680                 remove_wait_queue(&nlk->wait, &wait);
1681                 sock_put(sk);
1682
1683                 if (signal_pending(current)) {
1684                         kfree_skb(skb);
1685                         return sock_intr_errno(*timeo);
1686                 }
1687                 return 1;
1688         }
1689         netlink_skb_set_owner_r(skb, sk);
1690         return 0;
1691 }
1692
1693 static int __netlink_sendskb(struct sock *sk, struct sk_buff *skb)
1694 {
1695         int len = skb->len;
1696
1697         netlink_deliver_tap(skb);
1698
1699 #ifdef CONFIG_NETLINK_MMAP
1700         if (netlink_skb_is_mmaped(skb))
1701                 netlink_queue_mmaped_skb(sk, skb);
1702         else if (netlink_rx_is_mmaped(sk))
1703                 netlink_ring_set_copied(sk, skb);
1704         else
1705 #endif /* CONFIG_NETLINK_MMAP */
1706                 skb_queue_tail(&sk->sk_receive_queue, skb);
1707         sk->sk_data_ready(sk);
1708         return len;
1709 }
1710
1711 int netlink_sendskb(struct sock *sk, struct sk_buff *skb)
1712 {
1713         int len = __netlink_sendskb(sk, skb);
1714
1715         sock_put(sk);
1716         return len;
1717 }
1718
1719 void netlink_detachskb(struct sock *sk, struct sk_buff *skb)
1720 {
1721         kfree_skb(skb);
1722         sock_put(sk);
1723 }
1724
1725 static struct sk_buff *netlink_trim(struct sk_buff *skb, gfp_t allocation)
1726 {
1727         int delta;
1728
1729         WARN_ON(skb->sk != NULL);
1730         if (netlink_skb_is_mmaped(skb))
1731                 return skb;
1732
1733         delta = skb->end - skb->tail;
1734         if (is_vmalloc_addr(skb->head) || delta * 2 < skb->truesize)
1735                 return skb;
1736
1737         if (skb_shared(skb)) {
1738                 struct sk_buff *nskb = skb_clone(skb, allocation);
1739                 if (!nskb)
1740                         return skb;
1741                 consume_skb(skb);
1742                 skb = nskb;
1743         }
1744
1745         if (!pskb_expand_head(skb, 0, -delta, allocation))
1746                 skb->truesize -= delta;
1747
1748         return skb;
1749 }
1750
1751 static int netlink_unicast_kernel(struct sock *sk, struct sk_buff *skb,
1752                                   struct sock *ssk)
1753 {
1754         int ret;
1755         struct netlink_sock *nlk = nlk_sk(sk);
1756
1757         ret = -ECONNREFUSED;
1758         if (nlk->netlink_rcv != NULL) {
1759                 ret = skb->len;
1760                 netlink_skb_set_owner_r(skb, sk);
1761                 NETLINK_CB(skb).sk = ssk;
1762                 netlink_deliver_tap_kernel(sk, ssk, skb);
1763                 nlk->netlink_rcv(skb);
1764                 consume_skb(skb);
1765         } else {
1766                 kfree_skb(skb);
1767         }
1768         sock_put(sk);
1769         return ret;
1770 }
1771
1772 int netlink_unicast(struct sock *ssk, struct sk_buff *skb,
1773                     u32 portid, int nonblock)
1774 {
1775         struct sock *sk;
1776         int err;
1777         long timeo;
1778
1779         skb = netlink_trim(skb, gfp_any());
1780
1781         timeo = sock_sndtimeo(ssk, nonblock);
1782 retry:
1783         sk = netlink_getsockbyportid(ssk, portid);
1784         if (IS_ERR(sk)) {
1785                 kfree_skb(skb);
1786                 return PTR_ERR(sk);
1787         }
1788         if (netlink_is_kernel(sk))
1789                 return netlink_unicast_kernel(sk, skb, ssk);
1790
1791         if (sk_filter(sk, skb)) {
1792                 err = skb->len;
1793                 kfree_skb(skb);
1794                 sock_put(sk);
1795                 return err;
1796         }
1797
1798         err = netlink_attachskb(sk, skb, &timeo, ssk);
1799         if (err == 1)
1800                 goto retry;
1801         if (err)
1802                 return err;
1803
1804         return netlink_sendskb(sk, skb);
1805 }
1806 EXPORT_SYMBOL(netlink_unicast);
1807
1808 struct sk_buff *netlink_alloc_skb(struct sock *ssk, unsigned int size,
1809                                   u32 dst_portid, gfp_t gfp_mask)
1810 {
1811 #ifdef CONFIG_NETLINK_MMAP
1812         struct sock *sk = NULL;
1813         struct sk_buff *skb;
1814         struct netlink_ring *ring;
1815         struct nl_mmap_hdr *hdr;
1816         unsigned int maxlen;
1817
1818         sk = netlink_getsockbyportid(ssk, dst_portid);
1819         if (IS_ERR(sk))
1820                 goto out;
1821
1822         ring = &nlk_sk(sk)->rx_ring;
1823         /* fast-path without atomic ops for common case: non-mmaped receiver */
1824         if (ring->pg_vec == NULL)
1825                 goto out_put;
1826
1827         if (ring->frame_size - NL_MMAP_HDRLEN < size)
1828                 goto out_put;
1829
1830         skb = alloc_skb_head(gfp_mask);
1831         if (skb == NULL)
1832                 goto err1;
1833
1834         spin_lock_bh(&sk->sk_receive_queue.lock);
1835         /* check again under lock */
1836         if (ring->pg_vec == NULL)
1837                 goto out_free;
1838
1839         /* check again under lock */
1840         maxlen = ring->frame_size - NL_MMAP_HDRLEN;
1841         if (maxlen < size)
1842                 goto out_free;
1843
1844         netlink_forward_ring(ring);
1845         hdr = netlink_current_frame(ring, NL_MMAP_STATUS_UNUSED);
1846         if (hdr == NULL)
1847                 goto err2;
1848         netlink_ring_setup_skb(skb, sk, ring, hdr);
1849         netlink_set_status(hdr, NL_MMAP_STATUS_RESERVED);
1850         atomic_inc(&ring->pending);
1851         netlink_increment_head(ring);
1852
1853         spin_unlock_bh(&sk->sk_receive_queue.lock);
1854         return skb;
1855
1856 err2:
1857         kfree_skb(skb);
1858         spin_unlock_bh(&sk->sk_receive_queue.lock);
1859         netlink_overrun(sk);
1860 err1:
1861         sock_put(sk);
1862         return NULL;
1863
1864 out_free:
1865         kfree_skb(skb);
1866         spin_unlock_bh(&sk->sk_receive_queue.lock);
1867 out_put:
1868         sock_put(sk);
1869 out:
1870 #endif
1871         return alloc_skb(size, gfp_mask);
1872 }
1873 EXPORT_SYMBOL_GPL(netlink_alloc_skb);
1874
1875 int netlink_has_listeners(struct sock *sk, unsigned int group)
1876 {
1877         int res = 0;
1878         struct listeners *listeners;
1879
1880         BUG_ON(!netlink_is_kernel(sk));
1881
1882         rcu_read_lock();
1883         listeners = rcu_dereference(nl_table[sk->sk_protocol].listeners);
1884
1885         if (listeners && group - 1 < nl_table[sk->sk_protocol].groups)
1886                 res = test_bit(group - 1, listeners->masks);
1887
1888         rcu_read_unlock();
1889
1890         return res;
1891 }
1892 EXPORT_SYMBOL_GPL(netlink_has_listeners);
1893
1894 static int netlink_broadcast_deliver(struct sock *sk, struct sk_buff *skb)
1895 {
1896         struct netlink_sock *nlk = nlk_sk(sk);
1897
1898         if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf &&
1899             !test_bit(NETLINK_CONGESTED, &nlk->state)) {
1900                 netlink_skb_set_owner_r(skb, sk);
1901                 __netlink_sendskb(sk, skb);
1902                 return atomic_read(&sk->sk_rmem_alloc) > (sk->sk_rcvbuf >> 1);
1903         }
1904         return -1;
1905 }
1906
1907 struct netlink_broadcast_data {
1908         struct sock *exclude_sk;
1909         struct net *net;
1910         u32 portid;
1911         u32 group;
1912         int failure;
1913         int delivery_failure;
1914         int congested;
1915         int delivered;
1916         gfp_t allocation;
1917         struct sk_buff *skb, *skb2;
1918         int (*tx_filter)(struct sock *dsk, struct sk_buff *skb, void *data);
1919         void *tx_data;
1920 };
1921
1922 static void do_one_broadcast(struct sock *sk,
1923                                     struct netlink_broadcast_data *p)
1924 {
1925         struct netlink_sock *nlk = nlk_sk(sk);
1926         int val;
1927
1928         if (p->exclude_sk == sk)
1929                 return;
1930
1931         if (nlk->portid == p->portid || p->group - 1 >= nlk->ngroups ||
1932             !test_bit(p->group - 1, nlk->groups))
1933                 return;
1934
1935         if (!net_eq(sock_net(sk), p->net))
1936                 return;
1937
1938         if (p->failure) {
1939                 netlink_overrun(sk);
1940                 return;
1941         }
1942
1943         sock_hold(sk);
1944         if (p->skb2 == NULL) {
1945                 if (skb_shared(p->skb)) {
1946                         p->skb2 = skb_clone(p->skb, p->allocation);
1947                 } else {
1948                         p->skb2 = skb_get(p->skb);
1949                         /*
1950                          * skb ownership may have been set when
1951                          * delivered to a previous socket.
1952                          */
1953                         skb_orphan(p->skb2);
1954                 }
1955         }
1956         if (p->skb2 == NULL) {
1957                 netlink_overrun(sk);
1958                 /* Clone failed. Notify ALL listeners. */
1959                 p->failure = 1;
1960                 if (nlk->flags & NETLINK_BROADCAST_SEND_ERROR)
1961                         p->delivery_failure = 1;
1962         } else if (p->tx_filter && p->tx_filter(sk, p->skb2, p->tx_data)) {
1963                 kfree_skb(p->skb2);
1964                 p->skb2 = NULL;
1965         } else if (sk_filter(sk, p->skb2)) {
1966                 kfree_skb(p->skb2);
1967                 p->skb2 = NULL;
1968         } else if ((val = netlink_broadcast_deliver(sk, p->skb2)) < 0) {
1969                 netlink_overrun(sk);
1970                 if (nlk->flags & NETLINK_BROADCAST_SEND_ERROR)
1971                         p->delivery_failure = 1;
1972         } else {
1973                 p->congested |= val;
1974                 p->delivered = 1;
1975                 p->skb2 = NULL;
1976         }
1977         sock_put(sk);
1978 }
1979
1980 int netlink_broadcast_filtered(struct sock *ssk, struct sk_buff *skb, u32 portid,
1981         u32 group, gfp_t allocation,
1982         int (*filter)(struct sock *dsk, struct sk_buff *skb, void *data),
1983         void *filter_data)
1984 {
1985         struct net *net = sock_net(ssk);
1986         struct netlink_broadcast_data info;
1987         struct sock *sk;
1988
1989         skb = netlink_trim(skb, allocation);
1990
1991         info.exclude_sk = ssk;
1992         info.net = net;
1993         info.portid = portid;
1994         info.group = group;
1995         info.failure = 0;
1996         info.delivery_failure = 0;
1997         info.congested = 0;
1998         info.delivered = 0;
1999         info.allocation = allocation;
2000         info.skb = skb;
2001         info.skb2 = NULL;
2002         info.tx_filter = filter;
2003         info.tx_data = filter_data;
2004
2005         /* While we sleep in clone, do not allow to change socket list */
2006
2007         netlink_lock_table();
2008
2009         sk_for_each_bound(sk, &nl_table[ssk->sk_protocol].mc_list)
2010                 do_one_broadcast(sk, &info);
2011
2012         consume_skb(skb);
2013
2014         netlink_unlock_table();
2015
2016         if (info.delivery_failure) {
2017                 kfree_skb(info.skb2);
2018                 return -ENOBUFS;
2019         }
2020         consume_skb(info.skb2);
2021
2022         if (info.delivered) {
2023                 if (info.congested && (allocation & __GFP_WAIT))
2024                         yield();
2025                 return 0;
2026         }
2027         return -ESRCH;
2028 }
2029 EXPORT_SYMBOL(netlink_broadcast_filtered);
2030
2031 int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, u32 portid,
2032                       u32 group, gfp_t allocation)
2033 {
2034         return netlink_broadcast_filtered(ssk, skb, portid, group, allocation,
2035                 NULL, NULL);
2036 }
2037 EXPORT_SYMBOL(netlink_broadcast);
2038
2039 struct netlink_set_err_data {
2040         struct sock *exclude_sk;
2041         u32 portid;
2042         u32 group;
2043         int code;
2044 };
2045
2046 static int do_one_set_err(struct sock *sk, struct netlink_set_err_data *p)
2047 {
2048         struct netlink_sock *nlk = nlk_sk(sk);
2049         int ret = 0;
2050
2051         if (sk == p->exclude_sk)
2052                 goto out;
2053
2054         if (!net_eq(sock_net(sk), sock_net(p->exclude_sk)))
2055                 goto out;
2056
2057         if (nlk->portid == p->portid || p->group - 1 >= nlk->ngroups ||
2058             !test_bit(p->group - 1, nlk->groups))
2059                 goto out;
2060
2061         if (p->code == ENOBUFS && nlk->flags & NETLINK_RECV_NO_ENOBUFS) {
2062                 ret = 1;
2063                 goto out;
2064         }
2065
2066         sk->sk_err = p->code;
2067         sk->sk_error_report(sk);
2068 out:
2069         return ret;
2070 }
2071
2072 /**
2073  * netlink_set_err - report error to broadcast listeners
2074  * @ssk: the kernel netlink socket, as returned by netlink_kernel_create()
2075  * @portid: the PORTID of a process that we want to skip (if any)
2076  * @group: the broadcast group that will notice the error
2077  * @code: error code, must be negative (as usual in kernelspace)
2078  *
2079  * This function returns the number of broadcast listeners that have set the
2080  * NETLINK_RECV_NO_ENOBUFS socket option.
2081  */
2082 int netlink_set_err(struct sock *ssk, u32 portid, u32 group, int code)
2083 {
2084         struct netlink_set_err_data info;
2085         struct sock *sk;
2086         int ret = 0;
2087
2088         info.exclude_sk = ssk;
2089         info.portid = portid;
2090         info.group = group;
2091         /* sk->sk_err wants a positive error value */
2092         info.code = -code;
2093
2094         read_lock(&nl_table_lock);
2095
2096         sk_for_each_bound(sk, &nl_table[ssk->sk_protocol].mc_list)
2097                 ret += do_one_set_err(sk, &info);
2098
2099         read_unlock(&nl_table_lock);
2100         return ret;
2101 }
2102 EXPORT_SYMBOL(netlink_set_err);
2103
2104 /* must be called with netlink table grabbed */
2105 static void netlink_update_socket_mc(struct netlink_sock *nlk,
2106                                      unsigned int group,
2107                                      int is_new)
2108 {
2109         int old, new = !!is_new, subscriptions;
2110
2111         old = test_bit(group - 1, nlk->groups);
2112         subscriptions = nlk->subscriptions - old + new;
2113         if (new)
2114                 __set_bit(group - 1, nlk->groups);
2115         else
2116                 __clear_bit(group - 1, nlk->groups);
2117         netlink_update_subscriptions(&nlk->sk, subscriptions);
2118         netlink_update_listeners(&nlk->sk);
2119 }
2120
2121 static int netlink_setsockopt(struct socket *sock, int level, int optname,
2122                               char __user *optval, unsigned int optlen)
2123 {
2124         struct sock *sk = sock->sk;
2125         struct netlink_sock *nlk = nlk_sk(sk);
2126         unsigned int val = 0;
2127         int err;
2128
2129         if (level != SOL_NETLINK)
2130                 return -ENOPROTOOPT;
2131
2132         if (optname != NETLINK_RX_RING && optname != NETLINK_TX_RING &&
2133             optlen >= sizeof(int) &&
2134             get_user(val, (unsigned int __user *)optval))
2135                 return -EFAULT;
2136
2137         switch (optname) {
2138         case NETLINK_PKTINFO:
2139                 if (val)
2140                         nlk->flags |= NETLINK_RECV_PKTINFO;
2141                 else
2142                         nlk->flags &= ~NETLINK_RECV_PKTINFO;
2143                 err = 0;
2144                 break;
2145         case NETLINK_ADD_MEMBERSHIP:
2146         case NETLINK_DROP_MEMBERSHIP: {
2147                 if (!netlink_allowed(sock, NL_CFG_F_NONROOT_RECV))
2148                         return -EPERM;
2149                 err = netlink_realloc_groups(sk);
2150                 if (err)
2151                         return err;
2152                 if (!val || val - 1 >= nlk->ngroups)
2153                         return -EINVAL;
2154                 if (optname == NETLINK_ADD_MEMBERSHIP && nlk->netlink_bind) {
2155                         err = nlk->netlink_bind(sock_net(sk), val);
2156                         if (err)
2157                                 return err;
2158                 }
2159                 netlink_table_grab();
2160                 netlink_update_socket_mc(nlk, val,
2161                                          optname == NETLINK_ADD_MEMBERSHIP);
2162                 netlink_table_ungrab();
2163                 if (optname == NETLINK_DROP_MEMBERSHIP && nlk->netlink_unbind)
2164                         nlk->netlink_unbind(sock_net(sk), val);
2165
2166                 err = 0;
2167                 break;
2168         }
2169         case NETLINK_BROADCAST_ERROR:
2170                 if (val)
2171                         nlk->flags |= NETLINK_BROADCAST_SEND_ERROR;
2172                 else
2173                         nlk->flags &= ~NETLINK_BROADCAST_SEND_ERROR;
2174                 err = 0;
2175                 break;
2176         case NETLINK_NO_ENOBUFS:
2177                 if (val) {
2178                         nlk->flags |= NETLINK_RECV_NO_ENOBUFS;
2179                         clear_bit(NETLINK_CONGESTED, &nlk->state);
2180                         wake_up_interruptible(&nlk->wait);
2181                 } else {
2182                         nlk->flags &= ~NETLINK_RECV_NO_ENOBUFS;
2183                 }
2184                 err = 0;
2185                 break;
2186 #ifdef CONFIG_NETLINK_MMAP
2187         case NETLINK_RX_RING:
2188         case NETLINK_TX_RING: {
2189                 struct nl_mmap_req req;
2190
2191                 /* Rings might consume more memory than queue limits, require
2192                  * CAP_NET_ADMIN.
2193                  */
2194                 if (!capable(CAP_NET_ADMIN))
2195                         return -EPERM;
2196                 if (optlen < sizeof(req))
2197                         return -EINVAL;
2198                 if (copy_from_user(&req, optval, sizeof(req)))
2199                         return -EFAULT;
2200                 err = netlink_set_ring(sk, &req, false,
2201                                        optname == NETLINK_TX_RING);
2202                 break;
2203         }
2204 #endif /* CONFIG_NETLINK_MMAP */
2205         default:
2206                 err = -ENOPROTOOPT;
2207         }
2208         return err;
2209 }
2210
2211 static int netlink_getsockopt(struct socket *sock, int level, int optname,
2212                               char __user *optval, int __user *optlen)
2213 {
2214         struct sock *sk = sock->sk;
2215         struct netlink_sock *nlk = nlk_sk(sk);
2216         int len, val, err;
2217
2218         if (level != SOL_NETLINK)
2219                 return -ENOPROTOOPT;
2220
2221         if (get_user(len, optlen))
2222                 return -EFAULT;
2223         if (len < 0)
2224                 return -EINVAL;
2225
2226         switch (optname) {
2227         case NETLINK_PKTINFO:
2228                 if (len < sizeof(int))
2229                         return -EINVAL;
2230                 len = sizeof(int);
2231                 val = nlk->flags & NETLINK_RECV_PKTINFO ? 1 : 0;
2232                 if (put_user(len, optlen) ||
2233                     put_user(val, optval))
2234                         return -EFAULT;
2235                 err = 0;
2236                 break;
2237         case NETLINK_BROADCAST_ERROR:
2238                 if (len < sizeof(int))
2239                         return -EINVAL;
2240                 len = sizeof(int);
2241                 val = nlk->flags & NETLINK_BROADCAST_SEND_ERROR ? 1 : 0;
2242                 if (put_user(len, optlen) ||
2243                     put_user(val, optval))
2244                         return -EFAULT;
2245                 err = 0;
2246                 break;
2247         case NETLINK_NO_ENOBUFS:
2248                 if (len < sizeof(int))
2249                         return -EINVAL;
2250                 len = sizeof(int);
2251                 val = nlk->flags & NETLINK_RECV_NO_ENOBUFS ? 1 : 0;
2252                 if (put_user(len, optlen) ||
2253                     put_user(val, optval))
2254                         return -EFAULT;
2255                 err = 0;
2256                 break;
2257         default:
2258                 err = -ENOPROTOOPT;
2259         }
2260         return err;
2261 }
2262
2263 static void netlink_cmsg_recv_pktinfo(struct msghdr *msg, struct sk_buff *skb)
2264 {
2265         struct nl_pktinfo info;
2266
2267         info.group = NETLINK_CB(skb).dst_group;
2268         put_cmsg(msg, SOL_NETLINK, NETLINK_PKTINFO, sizeof(info), &info);
2269 }
2270
2271 static int netlink_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
2272 {
2273         struct sock *sk = sock->sk;
2274         struct netlink_sock *nlk = nlk_sk(sk);
2275         DECLARE_SOCKADDR(struct sockaddr_nl *, addr, msg->msg_name);
2276         u32 dst_portid;
2277         u32 dst_group;
2278         struct sk_buff *skb;
2279         int err;
2280         struct scm_cookie scm;
2281         u32 netlink_skb_flags = 0;
2282
2283         if (msg->msg_flags&MSG_OOB)
2284                 return -EOPNOTSUPP;
2285
2286         err = scm_send(sock, msg, &scm, true);
2287         if (err < 0)
2288                 return err;
2289
2290         if (msg->msg_namelen) {
2291                 err = -EINVAL;
2292                 if (addr->nl_family != AF_NETLINK)
2293                         goto out;
2294                 dst_portid = addr->nl_pid;
2295                 dst_group = ffs(addr->nl_groups);
2296                 err =  -EPERM;
2297                 if ((dst_group || dst_portid) &&
2298                     !netlink_allowed(sock, NL_CFG_F_NONROOT_SEND))
2299                         goto out;
2300                 netlink_skb_flags |= NETLINK_SKB_DST;
2301         } else {
2302                 dst_portid = nlk->dst_portid;
2303                 dst_group = nlk->dst_group;
2304         }
2305
2306         if (!nlk->portid) {
2307                 err = netlink_autobind(sock);
2308                 if (err)
2309                         goto out;
2310         }
2311
2312         /* It's a really convoluted way for userland to ask for mmaped
2313          * sendmsg(), but that's what we've got...
2314          */
2315         if (netlink_tx_is_mmaped(sk) &&
2316             msg->msg_iter.type == ITER_IOVEC &&
2317             msg->msg_iter.nr_segs == 1 &&
2318             msg->msg_iter.iov->iov_base == NULL) {
2319                 err = netlink_mmap_sendmsg(sk, msg, dst_portid, dst_group,
2320                                            &scm);
2321                 goto out;
2322         }
2323
2324         err = -EMSGSIZE;
2325         if (len > sk->sk_sndbuf - 32)
2326                 goto out;
2327         err = -ENOBUFS;
2328         skb = netlink_alloc_large_skb(len, dst_group);
2329         if (skb == NULL)
2330                 goto out;
2331
2332         NETLINK_CB(skb).portid  = nlk->portid;
2333         NETLINK_CB(skb).dst_group = dst_group;
2334         NETLINK_CB(skb).creds   = scm.creds;
2335         NETLINK_CB(skb).flags   = netlink_skb_flags;
2336
2337         err = -EFAULT;
2338         if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
2339                 kfree_skb(skb);
2340                 goto out;
2341         }
2342
2343         err = security_netlink_send(sk, skb);
2344         if (err) {
2345                 kfree_skb(skb);
2346                 goto out;
2347         }
2348
2349         if (dst_group) {
2350                 atomic_inc(&skb->users);
2351                 netlink_broadcast(sk, skb, dst_portid, dst_group, GFP_KERNEL);
2352         }
2353         err = netlink_unicast(sk, skb, dst_portid, msg->msg_flags&MSG_DONTWAIT);
2354
2355 out:
2356         scm_destroy(&scm);
2357         return err;
2358 }
2359
2360 static int netlink_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
2361                            int flags)
2362 {
2363         struct scm_cookie scm;
2364         struct sock *sk = sock->sk;
2365         struct netlink_sock *nlk = nlk_sk(sk);
2366         int noblock = flags&MSG_DONTWAIT;
2367         size_t copied;
2368         struct sk_buff *skb, *data_skb;
2369         int err, ret;
2370
2371         if (flags&MSG_OOB)
2372                 return -EOPNOTSUPP;
2373
2374         copied = 0;
2375
2376         skb = skb_recv_datagram(sk, flags, noblock, &err);
2377         if (skb == NULL)
2378                 goto out;
2379
2380         data_skb = skb;
2381
2382 #ifdef CONFIG_COMPAT_NETLINK_MESSAGES
2383         if (unlikely(skb_shinfo(skb)->frag_list)) {
2384                 /*
2385                  * If this skb has a frag_list, then here that means that we
2386                  * will have to use the frag_list skb's data for compat tasks
2387                  * and the regular skb's data for normal (non-compat) tasks.
2388                  *
2389                  * If we need to send the compat skb, assign it to the
2390                  * 'data_skb' variable so that it will be used below for data
2391                  * copying. We keep 'skb' for everything else, including
2392                  * freeing both later.
2393                  */
2394                 if (flags & MSG_CMSG_COMPAT)
2395                         data_skb = skb_shinfo(skb)->frag_list;
2396         }
2397 #endif
2398
2399         /* Record the max length of recvmsg() calls for future allocations */
2400         nlk->max_recvmsg_len = max(nlk->max_recvmsg_len, len);
2401         nlk->max_recvmsg_len = min_t(size_t, nlk->max_recvmsg_len,
2402                                      16384);
2403
2404         copied = data_skb->len;
2405         if (len < copied) {
2406                 msg->msg_flags |= MSG_TRUNC;
2407                 copied = len;
2408         }
2409
2410         skb_reset_transport_header(data_skb);
2411         err = skb_copy_datagram_msg(data_skb, 0, msg, copied);
2412
2413         if (msg->msg_name) {
2414                 DECLARE_SOCKADDR(struct sockaddr_nl *, addr, msg->msg_name);
2415                 addr->nl_family = AF_NETLINK;
2416                 addr->nl_pad    = 0;
2417                 addr->nl_pid    = NETLINK_CB(skb).portid;
2418                 addr->nl_groups = netlink_group_mask(NETLINK_CB(skb).dst_group);
2419                 msg->msg_namelen = sizeof(*addr);
2420         }
2421
2422         if (nlk->flags & NETLINK_RECV_PKTINFO)
2423                 netlink_cmsg_recv_pktinfo(msg, skb);
2424
2425         memset(&scm, 0, sizeof(scm));
2426         scm.creds = *NETLINK_CREDS(skb);
2427         if (flags & MSG_TRUNC)
2428                 copied = data_skb->len;
2429
2430         skb_free_datagram(sk, skb);
2431
2432         if (nlk->cb_running &&
2433             atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf / 2) {
2434                 ret = netlink_dump(sk);
2435                 if (ret) {
2436                         sk->sk_err = -ret;
2437                         sk->sk_error_report(sk);
2438                 }
2439         }
2440
2441         scm_recv(sock, msg, &scm, flags);
2442 out:
2443         netlink_rcv_wake(sk);
2444         return err ? : copied;
2445 }
2446
2447 static void netlink_data_ready(struct sock *sk)
2448 {
2449         BUG();
2450 }
2451
2452 /*
2453  *      We export these functions to other modules. They provide a
2454  *      complete set of kernel non-blocking support for message
2455  *      queueing.
2456  */
2457
2458 struct sock *
2459 __netlink_kernel_create(struct net *net, int unit, struct module *module,
2460                         struct netlink_kernel_cfg *cfg)
2461 {
2462         struct socket *sock;
2463         struct sock *sk;
2464         struct netlink_sock *nlk;
2465         struct listeners *listeners = NULL;
2466         struct mutex *cb_mutex = cfg ? cfg->cb_mutex : NULL;
2467         unsigned int groups;
2468
2469         BUG_ON(!nl_table);
2470
2471         if (unit < 0 || unit >= MAX_LINKS)
2472                 return NULL;
2473
2474         if (sock_create_lite(PF_NETLINK, SOCK_DGRAM, unit, &sock))
2475                 return NULL;
2476
2477         /*
2478          * We have to just have a reference on the net from sk, but don't
2479          * get_net it. Besides, we cannot get and then put the net here.
2480          * So we create one inside init_net and the move it to net.
2481          */
2482
2483         if (__netlink_create(&init_net, sock, cb_mutex, unit) < 0)
2484                 goto out_sock_release_nosk;
2485
2486         sk = sock->sk;
2487         sk_change_net(sk, net);
2488
2489         if (!cfg || cfg->groups < 32)
2490                 groups = 32;
2491         else
2492                 groups = cfg->groups;
2493
2494         listeners = kzalloc(sizeof(*listeners) + NLGRPSZ(groups), GFP_KERNEL);
2495         if (!listeners)
2496                 goto out_sock_release;
2497
2498         sk->sk_data_ready = netlink_data_ready;
2499         if (cfg && cfg->input)
2500                 nlk_sk(sk)->netlink_rcv = cfg->input;
2501
2502         if (netlink_insert(sk, 0))
2503                 goto out_sock_release;
2504
2505         nlk = nlk_sk(sk);
2506         nlk->flags |= NETLINK_KERNEL_SOCKET;
2507
2508         netlink_table_grab();
2509         if (!nl_table[unit].registered) {
2510                 nl_table[unit].groups = groups;
2511                 rcu_assign_pointer(nl_table[unit].listeners, listeners);
2512                 nl_table[unit].cb_mutex = cb_mutex;
2513                 nl_table[unit].module = module;
2514                 if (cfg) {
2515                         nl_table[unit].bind = cfg->bind;
2516                         nl_table[unit].unbind = cfg->unbind;
2517                         nl_table[unit].flags = cfg->flags;
2518                         if (cfg->compare)
2519                                 nl_table[unit].compare = cfg->compare;
2520                 }
2521                 nl_table[unit].registered = 1;
2522         } else {
2523                 kfree(listeners);
2524                 nl_table[unit].registered++;
2525         }
2526         netlink_table_ungrab();
2527         return sk;
2528
2529 out_sock_release:
2530         kfree(listeners);
2531         netlink_kernel_release(sk);
2532         return NULL;
2533
2534 out_sock_release_nosk:
2535         sock_release(sock);
2536         return NULL;
2537 }
2538 EXPORT_SYMBOL(__netlink_kernel_create);
2539
2540 void
2541 netlink_kernel_release(struct sock *sk)
2542 {
2543         sk_release_kernel(sk);
2544 }
2545 EXPORT_SYMBOL(netlink_kernel_release);
2546
2547 int __netlink_change_ngroups(struct sock *sk, unsigned int groups)
2548 {
2549         struct listeners *new, *old;
2550         struct netlink_table *tbl = &nl_table[sk->sk_protocol];
2551
2552         if (groups < 32)
2553                 groups = 32;
2554
2555         if (NLGRPSZ(tbl->groups) < NLGRPSZ(groups)) {
2556                 new = kzalloc(sizeof(*new) + NLGRPSZ(groups), GFP_ATOMIC);
2557                 if (!new)
2558                         return -ENOMEM;
2559                 old = nl_deref_protected(tbl->listeners);
2560                 memcpy(new->masks, old->masks, NLGRPSZ(tbl->groups));
2561                 rcu_assign_pointer(tbl->listeners, new);
2562
2563                 kfree_rcu(old, rcu);
2564         }
2565         tbl->groups = groups;
2566
2567         return 0;
2568 }
2569
2570 /**
2571  * netlink_change_ngroups - change number of multicast groups
2572  *
2573  * This changes the number of multicast groups that are available
2574  * on a certain netlink family. Note that it is not possible to
2575  * change the number of groups to below 32. Also note that it does
2576  * not implicitly call netlink_clear_multicast_users() when the
2577  * number of groups is reduced.
2578  *
2579  * @sk: The kernel netlink socket, as returned by netlink_kernel_create().
2580  * @groups: The new number of groups.
2581  */
2582 int netlink_change_ngroups(struct sock *sk, unsigned int groups)
2583 {
2584         int err;
2585
2586         netlink_table_grab();
2587         err = __netlink_change_ngroups(sk, groups);
2588         netlink_table_ungrab();
2589
2590         return err;
2591 }
2592
2593 void __netlink_clear_multicast_users(struct sock *ksk, unsigned int group)
2594 {
2595         struct sock *sk;
2596         struct netlink_table *tbl = &nl_table[ksk->sk_protocol];
2597
2598         sk_for_each_bound(sk, &tbl->mc_list)
2599                 netlink_update_socket_mc(nlk_sk(sk), group, 0);
2600 }
2601
2602 struct nlmsghdr *
2603 __nlmsg_put(struct sk_buff *skb, u32 portid, u32 seq, int type, int len, int flags)
2604 {
2605         struct nlmsghdr *nlh;
2606         int size = nlmsg_msg_size(len);
2607
2608         nlh = (struct nlmsghdr *)skb_put(skb, NLMSG_ALIGN(size));
2609         nlh->nlmsg_type = type;
2610         nlh->nlmsg_len = size;
2611         nlh->nlmsg_flags = flags;
2612         nlh->nlmsg_pid = portid;
2613         nlh->nlmsg_seq = seq;
2614         if (!__builtin_constant_p(size) || NLMSG_ALIGN(size) - size != 0)
2615                 memset(nlmsg_data(nlh) + len, 0, NLMSG_ALIGN(size) - size);
2616         return nlh;
2617 }
2618 EXPORT_SYMBOL(__nlmsg_put);
2619
2620 /*
2621  * It looks a bit ugly.
2622  * It would be better to create kernel thread.
2623  */
2624
2625 static int netlink_dump(struct sock *sk)
2626 {
2627         struct netlink_sock *nlk = nlk_sk(sk);
2628         struct netlink_callback *cb;
2629         struct sk_buff *skb = NULL;
2630         struct nlmsghdr *nlh;
2631         int len, err = -ENOBUFS;
2632         int alloc_size;
2633
2634         mutex_lock(nlk->cb_mutex);
2635         if (!nlk->cb_running) {
2636                 err = -EINVAL;
2637                 goto errout_skb;
2638         }
2639
2640         cb = &nlk->cb;
2641         alloc_size = max_t(int, cb->min_dump_alloc, NLMSG_GOODSIZE);
2642
2643         if (!netlink_rx_is_mmaped(sk) &&
2644             atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
2645                 goto errout_skb;
2646
2647         /* NLMSG_GOODSIZE is small to avoid high order allocations being
2648          * required, but it makes sense to _attempt_ a 16K bytes allocation
2649          * to reduce number of system calls on dump operations, if user
2650          * ever provided a big enough buffer.
2651          */
2652         if (alloc_size < nlk->max_recvmsg_len) {
2653                 skb = netlink_alloc_skb(sk,
2654                                         nlk->max_recvmsg_len,
2655                                         nlk->portid,
2656                                         GFP_KERNEL |
2657                                         __GFP_NOWARN |
2658                                         __GFP_NORETRY);
2659                 /* available room should be exact amount to avoid MSG_TRUNC */
2660                 if (skb)
2661                         skb_reserve(skb, skb_tailroom(skb) -
2662                                          nlk->max_recvmsg_len);
2663         }
2664         if (!skb)
2665                 skb = netlink_alloc_skb(sk, alloc_size, nlk->portid,
2666                                         GFP_KERNEL);
2667         if (!skb)
2668                 goto errout_skb;
2669         netlink_skb_set_owner_r(skb, sk);
2670
2671         len = cb->dump(skb, cb);
2672
2673         if (len > 0) {
2674                 mutex_unlock(nlk->cb_mutex);
2675
2676                 if (sk_filter(sk, skb))
2677                         kfree_skb(skb);
2678                 else
2679                         __netlink_sendskb(sk, skb);
2680                 return 0;
2681         }
2682
2683         nlh = nlmsg_put_answer(skb, cb, NLMSG_DONE, sizeof(len), NLM_F_MULTI);
2684         if (!nlh)
2685                 goto errout_skb;
2686
2687         nl_dump_check_consistent(cb, nlh);
2688
2689         memcpy(nlmsg_data(nlh), &len, sizeof(len));
2690
2691         if (sk_filter(sk, skb))
2692                 kfree_skb(skb);
2693         else
2694                 __netlink_sendskb(sk, skb);
2695
2696         if (cb->done)
2697                 cb->done(cb);
2698
2699         nlk->cb_running = false;
2700         mutex_unlock(nlk->cb_mutex);
2701         module_put(cb->module);
2702         consume_skb(cb->skb);
2703         return 0;
2704
2705 errout_skb:
2706         mutex_unlock(nlk->cb_mutex);
2707         kfree_skb(skb);
2708         return err;
2709 }
2710
2711 int __netlink_dump_start(struct sock *ssk, struct sk_buff *skb,
2712                          const struct nlmsghdr *nlh,
2713                          struct netlink_dump_control *control)
2714 {
2715         struct netlink_callback *cb;
2716         struct sock *sk;
2717         struct netlink_sock *nlk;
2718         int ret;
2719
2720         /* Memory mapped dump requests need to be copied to avoid looping
2721          * on the pending state in netlink_mmap_sendmsg() while the CB hold
2722          * a reference to the skb.
2723          */
2724         if (netlink_skb_is_mmaped(skb)) {
2725                 skb = skb_copy(skb, GFP_KERNEL);
2726                 if (skb == NULL)
2727                         return -ENOBUFS;
2728         } else
2729                 atomic_inc(&skb->users);
2730
2731         sk = netlink_lookup(sock_net(ssk), ssk->sk_protocol, NETLINK_CB(skb).portid);
2732         if (sk == NULL) {
2733                 ret = -ECONNREFUSED;
2734                 goto error_free;
2735         }
2736
2737         nlk = nlk_sk(sk);
2738         mutex_lock(nlk->cb_mutex);
2739         /* A dump is in progress... */
2740         if (nlk->cb_running) {
2741                 ret = -EBUSY;
2742                 goto error_unlock;
2743         }
2744         /* add reference of module which cb->dump belongs to */
2745         if (!try_module_get(control->module)) {
2746                 ret = -EPROTONOSUPPORT;
2747                 goto error_unlock;
2748         }
2749
2750         cb = &nlk->cb;
2751         memset(cb, 0, sizeof(*cb));
2752         cb->dump = control->dump;
2753         cb->done = control->done;
2754         cb->nlh = nlh;
2755         cb->data = control->data;
2756         cb->module = control->module;
2757         cb->min_dump_alloc = control->min_dump_alloc;
2758         cb->skb = skb;
2759
2760         nlk->cb_running = true;
2761
2762         mutex_unlock(nlk->cb_mutex);
2763
2764         ret = netlink_dump(sk);
2765         sock_put(sk);
2766
2767         if (ret)
2768                 return ret;
2769
2770         /* We successfully started a dump, by returning -EINTR we
2771          * signal not to send ACK even if it was requested.
2772          */
2773         return -EINTR;
2774
2775 error_unlock:
2776         sock_put(sk);
2777         mutex_unlock(nlk->cb_mutex);
2778 error_free:
2779         kfree_skb(skb);
2780         return ret;
2781 }
2782 EXPORT_SYMBOL(__netlink_dump_start);
2783
2784 void netlink_ack(struct sk_buff *in_skb, struct nlmsghdr *nlh, int err)
2785 {
2786         struct sk_buff *skb;
2787         struct nlmsghdr *rep;
2788         struct nlmsgerr *errmsg;
2789         size_t payload = sizeof(*errmsg);
2790
2791         /* error messages get the original request appened */
2792         if (err)
2793                 payload += nlmsg_len(nlh);
2794
2795         skb = netlink_alloc_skb(in_skb->sk, nlmsg_total_size(payload),
2796                                 NETLINK_CB(in_skb).portid, GFP_KERNEL);
2797         if (!skb) {
2798                 struct sock *sk;
2799
2800                 sk = netlink_lookup(sock_net(in_skb->sk),
2801                                     in_skb->sk->sk_protocol,
2802                                     NETLINK_CB(in_skb).portid);
2803                 if (sk) {
2804                         sk->sk_err = ENOBUFS;
2805                         sk->sk_error_report(sk);
2806                         sock_put(sk);
2807                 }
2808                 return;
2809         }
2810
2811         rep = __nlmsg_put(skb, NETLINK_CB(in_skb).portid, nlh->nlmsg_seq,
2812                           NLMSG_ERROR, payload, 0);
2813         errmsg = nlmsg_data(rep);
2814         errmsg->error = err;
2815         memcpy(&errmsg->msg, nlh, err ? nlh->nlmsg_len : sizeof(*nlh));
2816         netlink_unicast(in_skb->sk, skb, NETLINK_CB(in_skb).portid, MSG_DONTWAIT);
2817 }
2818 EXPORT_SYMBOL(netlink_ack);
2819
2820 int netlink_rcv_skb(struct sk_buff *skb, int (*cb)(struct sk_buff *,
2821                                                      struct nlmsghdr *))
2822 {
2823         struct nlmsghdr *nlh;
2824         int err;
2825
2826         while (skb->len >= nlmsg_total_size(0)) {
2827                 int msglen;
2828
2829                 nlh = nlmsg_hdr(skb);
2830                 err = 0;
2831
2832                 if (nlh->nlmsg_len < NLMSG_HDRLEN || skb->len < nlh->nlmsg_len)
2833                         return 0;
2834
2835                 /* Only requests are handled by the kernel */
2836                 if (!(nlh->nlmsg_flags & NLM_F_REQUEST))
2837                         goto ack;
2838
2839                 /* Skip control messages */
2840                 if (nlh->nlmsg_type < NLMSG_MIN_TYPE)
2841                         goto ack;
2842
2843                 err = cb(skb, nlh);
2844                 if (err == -EINTR)
2845                         goto skip;
2846
2847 ack:
2848                 if (nlh->nlmsg_flags & NLM_F_ACK || err)
2849                         netlink_ack(skb, nlh, err);
2850
2851 skip:
2852                 msglen = NLMSG_ALIGN(nlh->nlmsg_len);
2853                 if (msglen > skb->len)
2854                         msglen = skb->len;
2855                 skb_pull(skb, msglen);
2856         }
2857
2858         return 0;
2859 }
2860 EXPORT_SYMBOL(netlink_rcv_skb);
2861
2862 /**
2863  * nlmsg_notify - send a notification netlink message
2864  * @sk: netlink socket to use
2865  * @skb: notification message
2866  * @portid: destination netlink portid for reports or 0
2867  * @group: destination multicast group or 0
2868  * @report: 1 to report back, 0 to disable
2869  * @flags: allocation flags
2870  */
2871 int nlmsg_notify(struct sock *sk, struct sk_buff *skb, u32 portid,
2872                  unsigned int group, int report, gfp_t flags)
2873 {
2874         int err = 0;
2875
2876         if (group) {
2877                 int exclude_portid = 0;
2878
2879                 if (report) {
2880                         atomic_inc(&skb->users);
2881                         exclude_portid = portid;
2882                 }
2883
2884                 /* errors reported via destination sk->sk_err, but propagate
2885                  * delivery errors if NETLINK_BROADCAST_ERROR flag is set */
2886                 err = nlmsg_multicast(sk, skb, exclude_portid, group, flags);
2887         }
2888
2889         if (report) {
2890                 int err2;
2891
2892                 err2 = nlmsg_unicast(sk, skb, portid);
2893                 if (!err || err == -ESRCH)
2894                         err = err2;
2895         }
2896
2897         return err;
2898 }
2899 EXPORT_SYMBOL(nlmsg_notify);
2900
2901 #ifdef CONFIG_PROC_FS
2902 struct nl_seq_iter {
2903         struct seq_net_private p;
2904         struct rhashtable_iter hti;
2905         int link;
2906 };
2907
2908 static int netlink_walk_start(struct nl_seq_iter *iter)
2909 {
2910         int err;
2911
2912         err = rhashtable_walk_init(&nl_table[iter->link].hash, &iter->hti);
2913         if (err) {
2914                 iter->link = MAX_LINKS;
2915                 return err;
2916         }
2917
2918         err = rhashtable_walk_start(&iter->hti);
2919         return err == -EAGAIN ? 0 : err;
2920 }
2921
2922 static void netlink_walk_stop(struct nl_seq_iter *iter)
2923 {
2924         rhashtable_walk_stop(&iter->hti);
2925         rhashtable_walk_exit(&iter->hti);
2926 }
2927
2928 static void *__netlink_seq_next(struct seq_file *seq)
2929 {
2930         struct nl_seq_iter *iter = seq->private;
2931         struct netlink_sock *nlk;
2932
2933         do {
2934                 for (;;) {
2935                         int err;
2936
2937                         nlk = rhashtable_walk_next(&iter->hti);
2938
2939                         if (IS_ERR(nlk)) {
2940                                 if (PTR_ERR(nlk) == -EAGAIN)
2941                                         continue;
2942
2943                                 return nlk;
2944                         }
2945
2946                         if (nlk)
2947                                 break;
2948
2949                         netlink_walk_stop(iter);
2950                         if (++iter->link >= MAX_LINKS)
2951                                 return NULL;
2952
2953                         err = netlink_walk_start(iter);
2954                         if (err)
2955                                 return ERR_PTR(err);
2956                 }
2957         } while (sock_net(&nlk->sk) != seq_file_net(seq));
2958
2959         return nlk;
2960 }
2961
2962 static void *netlink_seq_start(struct seq_file *seq, loff_t *posp)
2963 {
2964         struct nl_seq_iter *iter = seq->private;
2965         void *obj = SEQ_START_TOKEN;
2966         loff_t pos;
2967         int err;
2968
2969         iter->link = 0;
2970
2971         err = netlink_walk_start(iter);
2972         if (err)
2973                 return ERR_PTR(err);
2974
2975         for (pos = *posp; pos && obj && !IS_ERR(obj); pos--)
2976                 obj = __netlink_seq_next(seq);
2977
2978         return obj;
2979 }
2980
2981 static void *netlink_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2982 {
2983         ++*pos;
2984         return __netlink_seq_next(seq);
2985 }
2986
2987 static void netlink_seq_stop(struct seq_file *seq, void *v)
2988 {
2989         struct nl_seq_iter *iter = seq->private;
2990
2991         if (iter->link >= MAX_LINKS)
2992                 return;
2993
2994         netlink_walk_stop(iter);
2995 }
2996
2997
2998 static int netlink_seq_show(struct seq_file *seq, void *v)
2999 {
3000         if (v == SEQ_START_TOKEN) {
3001                 seq_puts(seq,
3002                          "sk       Eth Pid    Groups   "
3003                          "Rmem     Wmem     Dump     Locks     Drops     Inode\n");
3004         } else {
3005                 struct sock *s = v;
3006                 struct netlink_sock *nlk = nlk_sk(s);
3007
3008                 seq_printf(seq, "%pK %-3d %-6u %08x %-8d %-8d %d %-8d %-8d %-8lu\n",
3009                            s,
3010                            s->sk_protocol,
3011                            nlk->portid,
3012                            nlk->groups ? (u32)nlk->groups[0] : 0,
3013                            sk_rmem_alloc_get(s),
3014                            sk_wmem_alloc_get(s),
3015                            nlk->cb_running,
3016                            atomic_read(&s->sk_refcnt),
3017                            atomic_read(&s->sk_drops),
3018                            sock_i_ino(s)
3019                         );
3020
3021         }
3022         return 0;
3023 }
3024
3025 static const struct seq_operations netlink_seq_ops = {
3026         .start  = netlink_seq_start,
3027         .next   = netlink_seq_next,
3028         .stop   = netlink_seq_stop,
3029         .show   = netlink_seq_show,
3030 };
3031
3032
3033 static int netlink_seq_open(struct inode *inode, struct file *file)
3034 {
3035         return seq_open_net(inode, file, &netlink_seq_ops,
3036                                 sizeof(struct nl_seq_iter));
3037 }
3038
3039 static const struct file_operations netlink_seq_fops = {
3040         .owner          = THIS_MODULE,
3041         .open           = netlink_seq_open,
3042         .read           = seq_read,
3043         .llseek         = seq_lseek,
3044         .release        = seq_release_net,
3045 };
3046
3047 #endif
3048
3049 int netlink_register_notifier(struct notifier_block *nb)
3050 {
3051         return atomic_notifier_chain_register(&netlink_chain, nb);
3052 }
3053 EXPORT_SYMBOL(netlink_register_notifier);
3054
3055 int netlink_unregister_notifier(struct notifier_block *nb)
3056 {
3057         return atomic_notifier_chain_unregister(&netlink_chain, nb);
3058 }
3059 EXPORT_SYMBOL(netlink_unregister_notifier);
3060
3061 static const struct proto_ops netlink_ops = {
3062         .family =       PF_NETLINK,
3063         .owner =        THIS_MODULE,
3064         .release =      netlink_release,
3065         .bind =         netlink_bind,
3066         .connect =      netlink_connect,
3067         .socketpair =   sock_no_socketpair,
3068         .accept =       sock_no_accept,
3069         .getname =      netlink_getname,
3070         .poll =         netlink_poll,
3071         .ioctl =        sock_no_ioctl,
3072         .listen =       sock_no_listen,
3073         .shutdown =     sock_no_shutdown,
3074         .setsockopt =   netlink_setsockopt,
3075         .getsockopt =   netlink_getsockopt,
3076         .sendmsg =      netlink_sendmsg,
3077         .recvmsg =      netlink_recvmsg,
3078         .mmap =         netlink_mmap,
3079         .sendpage =     sock_no_sendpage,
3080 };
3081
3082 static const struct net_proto_family netlink_family_ops = {
3083         .family = PF_NETLINK,
3084         .create = netlink_create,
3085         .owner  = THIS_MODULE,  /* for consistency 8) */
3086 };
3087
3088 static int __net_init netlink_net_init(struct net *net)
3089 {
3090 #ifdef CONFIG_PROC_FS
3091         if (!proc_create("netlink", 0, net->proc_net, &netlink_seq_fops))
3092                 return -ENOMEM;
3093 #endif
3094         return 0;
3095 }
3096
3097 static void __net_exit netlink_net_exit(struct net *net)
3098 {
3099 #ifdef CONFIG_PROC_FS
3100         remove_proc_entry("netlink", net->proc_net);
3101 #endif
3102 }
3103
3104 static void __init netlink_add_usersock_entry(void)
3105 {
3106         struct listeners *listeners;
3107         int groups = 32;
3108
3109         listeners = kzalloc(sizeof(*listeners) + NLGRPSZ(groups), GFP_KERNEL);
3110         if (!listeners)
3111                 panic("netlink_add_usersock_entry: Cannot allocate listeners\n");
3112
3113         netlink_table_grab();
3114
3115         nl_table[NETLINK_USERSOCK].groups = groups;
3116         rcu_assign_pointer(nl_table[NETLINK_USERSOCK].listeners, listeners);
3117         nl_table[NETLINK_USERSOCK].module = THIS_MODULE;
3118         nl_table[NETLINK_USERSOCK].registered = 1;
3119         nl_table[NETLINK_USERSOCK].flags = NL_CFG_F_NONROOT_SEND;
3120
3121         netlink_table_ungrab();
3122 }
3123
3124 static struct pernet_operations __net_initdata netlink_net_ops = {
3125         .init = netlink_net_init,
3126         .exit = netlink_net_exit,
3127 };
3128
3129 static inline u32 netlink_hash(const void *data, u32 len, u32 seed)
3130 {
3131         const struct netlink_sock *nlk = data;
3132         struct netlink_compare_arg arg;
3133
3134         netlink_compare_arg_init(&arg, sock_net(&nlk->sk), nlk->portid);
3135         return jhash2((u32 *)&arg, netlink_compare_arg_len / sizeof(u32), seed);
3136 }
3137
3138 static const struct rhashtable_params netlink_rhashtable_params = {
3139         .head_offset = offsetof(struct netlink_sock, node),
3140         .key_len = netlink_compare_arg_len,
3141         .obj_hashfn = netlink_hash,
3142         .obj_cmpfn = netlink_compare,
3143         .automatic_shrinking = true,
3144 };
3145
3146 static int __init netlink_proto_init(void)
3147 {
3148         int i;
3149         int err = proto_register(&netlink_proto, 0);
3150
3151         if (err != 0)
3152                 goto out;
3153
3154         BUILD_BUG_ON(sizeof(struct netlink_skb_parms) > FIELD_SIZEOF(struct sk_buff, cb));
3155
3156         nl_table = kcalloc(MAX_LINKS, sizeof(*nl_table), GFP_KERNEL);
3157         if (!nl_table)
3158                 goto panic;
3159
3160         for (i = 0; i < MAX_LINKS; i++) {
3161                 if (rhashtable_init(&nl_table[i].hash,
3162                                     &netlink_rhashtable_params) < 0) {
3163                         while (--i > 0)
3164                                 rhashtable_destroy(&nl_table[i].hash);
3165                         kfree(nl_table);
3166                         goto panic;
3167                 }
3168         }
3169
3170         INIT_LIST_HEAD(&netlink_tap_all);
3171
3172         netlink_add_usersock_entry();
3173
3174         sock_register(&netlink_family_ops);
3175         register_pernet_subsys(&netlink_net_ops);
3176         /* The netlink device handler may be needed early. */
3177         rtnetlink_init();
3178 out:
3179         return err;
3180 panic:
3181         panic("netlink_init: Cannot allocate nl_table\n");
3182 }
3183
3184 core_initcall(netlink_proto_init);