net/netlink/af_netlink.c

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