net/phonet/socket.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * File: socket.c
   4  *
   5  * Phonet sockets
   6  *
   7  * Copyright (C) 2008 Nokia Corporation.
   8  *
   9  * Authors: Sakari Ailus <sakari.ailus@nokia.com>
  10  *          Rémi Denis-Courmont
  11  */
  12
  13 #include <linux/gfp.h>
  14 #include <linux/kernel.h>
  15 #include <linux/net.h>
  16 #include <linux/poll.h>
  17 #include <linux/sched/signal.h>
  18
  19 #include <net/sock.h>
  20 #include <net/tcp_states.h>
  21
  22 #include <linux/phonet.h>
  23 #include <linux/export.h>
  24 #include <net/phonet/phonet.h>
  25 #include <net/phonet/pep.h>
  26 #include <net/phonet/pn_dev.h>
  27
  28 static int pn_socket_release(struct socket *sock)
  29 {
  30         struct sock *sk = sock->sk;
  31
  32         if (sk) {
  33                 sock->sk = NULL;
  34                 sk->sk_prot->close(sk, 0);
  35         }
  36         return 0;
  37 }
  38
  39 #define PN_HASHSIZE     16
  40 #define PN_HASHMASK     (PN_HASHSIZE-1)
  41
  42
  43 static struct  {
  44         struct hlist_head hlist[PN_HASHSIZE];
  45         struct mutex lock;
  46 } pnsocks;
  47
  48 void __init pn_sock_init(void)
  49 {
  50         unsigned int i;
  51
  52         for (i = 0; i < PN_HASHSIZE; i++)
  53                 INIT_HLIST_HEAD(pnsocks.hlist + i);
  54         mutex_init(&pnsocks.lock);
  55 }
  56
  57 static struct hlist_head *pn_hash_list(u16 obj)
  58 {
  59         return pnsocks.hlist + (obj & PN_HASHMASK);
  60 }
  61
  62 /*
  63  * Find address based on socket address, match only certain fields.
  64  * Also grab sock if it was found. Remember to sock_put it later.
  65  */
  66 struct sock *pn_find_sock_by_sa(struct net *net, const struct sockaddr_pn *spn)
  67 {
  68         struct sock *sknode;
  69         struct sock *rval = NULL;
  70         u16 obj = pn_sockaddr_get_object(spn);
  71         u8 res = spn->spn_resource;
  72         struct hlist_head *hlist = pn_hash_list(obj);
  73
  74         rcu_read_lock();
  75         sk_for_each_rcu(sknode, hlist) {
  76                 struct pn_sock *pn = pn_sk(sknode);
  77                 BUG_ON(!pn->sobject); /* unbound socket */
  78
  79                 if (!net_eq(sock_net(sknode), net))
  80                         continue;
  81                 if (pn_port(obj)) {
  82                         /* Look up socket by port */
  83                         if (pn_port(pn->sobject) != pn_port(obj))
  84                                 continue;
  85                 } else {
  86                         /* If port is zero, look up by resource */
  87                         if (pn->resource != res)
  88                                 continue;
  89                 }
  90                 if (pn_addr(pn->sobject) &&
  91                     pn_addr(pn->sobject) != pn_addr(obj))
  92                         continue;
  93
  94                 rval = sknode;
  95                 sock_hold(sknode);
  96                 break;
  97         }
  98         rcu_read_unlock();
  99
 100         return rval;
 101 }
 102
 103 /* Deliver a broadcast packet (only in bottom-half) */
 104 void pn_deliver_sock_broadcast(struct net *net, struct sk_buff *skb)
 105 {
 106         struct hlist_head *hlist = pnsocks.hlist;
 107         unsigned int h;
 108
 109         rcu_read_lock();
 110         for (h = 0; h < PN_HASHSIZE; h++) {
 111                 struct sock *sknode;
 112
 113                 sk_for_each(sknode, hlist) {
 114                         struct sk_buff *clone;
 115
 116                         if (!net_eq(sock_net(sknode), net))
 117                                 continue;
 118                         if (!sock_flag(sknode, SOCK_BROADCAST))
 119                                 continue;
 120
 121                         clone = skb_clone(skb, GFP_ATOMIC);
 122                         if (clone) {
 123                                 sock_hold(sknode);
 124                                 sk_receive_skb(sknode, clone, 0);
 125                         }
 126                 }
 127                 hlist++;
 128         }
 129         rcu_read_unlock();
 130 }
 131
 132 int pn_sock_hash(struct sock *sk)
 133 {
 134         struct hlist_head *hlist = pn_hash_list(pn_sk(sk)->sobject);
 135
 136         mutex_lock(&pnsocks.lock);
 137         sk_add_node_rcu(sk, hlist);
 138         mutex_unlock(&pnsocks.lock);
 139
 140         return 0;
 141 }
 142 EXPORT_SYMBOL(pn_sock_hash);
 143
 144 void pn_sock_unhash(struct sock *sk)
 145 {
 146         mutex_lock(&pnsocks.lock);
 147         sk_del_node_init_rcu(sk);
 148         mutex_unlock(&pnsocks.lock);
 149         pn_sock_unbind_all_res(sk);
 150         synchronize_rcu();
 151 }
 152 EXPORT_SYMBOL(pn_sock_unhash);
 153
 154 static DEFINE_MUTEX(port_mutex);
 155
 156 static int pn_socket_bind(struct socket *sock, struct sockaddr *addr, int len)
 157 {
 158         struct sock *sk = sock->sk;
 159         struct pn_sock *pn = pn_sk(sk);
 160         struct sockaddr_pn *spn = (struct sockaddr_pn *)addr;
 161         int err;
 162         u16 handle;
 163         u8 saddr;
 164
 165         if (sk->sk_prot->bind)
 166                 return sk->sk_prot->bind(sk, addr, len);
 167
 168         if (len < sizeof(struct sockaddr_pn))
 169                 return -EINVAL;
 170         if (spn->spn_family != AF_PHONET)
 171                 return -EAFNOSUPPORT;
 172
 173         handle = pn_sockaddr_get_object((struct sockaddr_pn *)addr);
 174         saddr = pn_addr(handle);
 175         if (saddr && phonet_address_lookup(sock_net(sk), saddr))
 176                 return -EADDRNOTAVAIL;
 177
 178         lock_sock(sk);
 179         if (sk->sk_state != TCP_CLOSE || pn_port(pn->sobject)) {
 180                 err = -EINVAL; /* attempt to rebind */
 181                 goto out;
 182         }
 183         WARN_ON(sk_hashed(sk));
 184         mutex_lock(&port_mutex);
 185         err = sk->sk_prot->get_port(sk, pn_port(handle));
 186         if (err)
 187                 goto out_port;
 188
 189         /* get_port() sets the port, bind() sets the address if applicable */
 190         pn->sobject = pn_object(saddr, pn_port(pn->sobject));
 191         pn->resource = spn->spn_resource;
 192
 193         /* Enable RX on the socket */
 194         err = sk->sk_prot->hash(sk);
 195 out_port:
 196         mutex_unlock(&port_mutex);
 197 out:
 198         release_sock(sk);
 199         return err;
 200 }
 201
 202 static int pn_socket_autobind(struct socket *sock)
 203 {
 204         struct sockaddr_pn sa;
 205         int err;
 206
 207         memset(&sa, 0, sizeof(sa));
 208         sa.spn_family = AF_PHONET;
 209         err = pn_socket_bind(sock, (struct sockaddr *)&sa,
 210                                 sizeof(struct sockaddr_pn));
 211         if (err != -EINVAL)
 212                 return err;
 213         BUG_ON(!pn_port(pn_sk(sock->sk)->sobject));
 214         return 0; /* socket was already bound */
 215 }
 216
 217 static int pn_socket_connect(struct socket *sock, struct sockaddr *addr,
 218                 int len, int flags)
 219 {
 220         struct sock *sk = sock->sk;
 221         struct pn_sock *pn = pn_sk(sk);
 222         struct sockaddr_pn *spn = (struct sockaddr_pn *)addr;
 223         struct task_struct *tsk = current;
 224         long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 225         int err;
 226
 227         if (pn_socket_autobind(sock))
 228                 return -ENOBUFS;
 229         if (len < sizeof(struct sockaddr_pn))
 230                 return -EINVAL;
 231         if (spn->spn_family != AF_PHONET)
 232                 return -EAFNOSUPPORT;
 233
 234         lock_sock(sk);
 235
 236         switch (sock->state) {
 237         case SS_UNCONNECTED:
 238                 if (sk->sk_state != TCP_CLOSE) {
 239                         err = -EISCONN;
 240                         goto out;
 241                 }
 242                 break;
 243         case SS_CONNECTING:
 244                 err = -EALREADY;
 245                 goto out;
 246         default:
 247                 err = -EISCONN;
 248                 goto out;
 249         }
 250
 251         pn->dobject = pn_sockaddr_get_object(spn);
 252         pn->resource = pn_sockaddr_get_resource(spn);
 253         sock->state = SS_CONNECTING;
 254
 255         err = sk->sk_prot->connect(sk, addr, len);
 256         if (err) {
 257                 sock->state = SS_UNCONNECTED;
 258                 pn->dobject = 0;
 259                 goto out;
 260         }
 261
 262         while (sk->sk_state == TCP_SYN_SENT) {
 263                 DEFINE_WAIT(wait);
 264
 265                 if (!timeo) {
 266                         err = -EINPROGRESS;
 267                         goto out;
 268                 }
 269                 if (signal_pending(tsk)) {
 270                         err = sock_intr_errno(timeo);
 271                         goto out;
 272                 }
 273
 274                 prepare_to_wait_exclusive(sk_sleep(sk), &wait,
 275                                                 TASK_INTERRUPTIBLE);
 276                 release_sock(sk);
 277                 timeo = schedule_timeout(timeo);
 278                 lock_sock(sk);
 279                 finish_wait(sk_sleep(sk), &wait);
 280         }
 281
 282         if ((1 << sk->sk_state) & (TCPF_SYN_RECV|TCPF_ESTABLISHED))
 283                 err = 0;
 284         else if (sk->sk_state == TCP_CLOSE_WAIT)
 285                 err = -ECONNRESET;
 286         else
 287                 err = -ECONNREFUSED;
 288         sock->state = err ? SS_UNCONNECTED : SS_CONNECTED;
 289 out:
 290         release_sock(sk);
 291         return err;
 292 }
 293
 294 static int pn_socket_accept(struct socket *sock, struct socket *newsock,
 295                             int flags, bool kern)
 296 {
 297         struct sock *sk = sock->sk;
 298         struct sock *newsk;
 299         int err;
 300
 301         if (unlikely(sk->sk_state != TCP_LISTEN))
 302                 return -EINVAL;
 303
 304         newsk = sk->sk_prot->accept(sk, flags, &err, kern);
 305         if (!newsk)
 306                 return err;
 307
 308         lock_sock(newsk);
 309         sock_graft(newsk, newsock);
 310         newsock->state = SS_CONNECTED;
 311         release_sock(newsk);
 312         return 0;
 313 }
 314
 315 static int pn_socket_getname(struct socket *sock, struct sockaddr *addr,
 316                                 int peer)
 317 {
 318         struct sock *sk = sock->sk;
 319         struct pn_sock *pn = pn_sk(sk);
 320
 321         memset(addr, 0, sizeof(struct sockaddr_pn));
 322         addr->sa_family = AF_PHONET;
 323         if (!peer) /* Race with bind() here is userland's problem. */
 324                 pn_sockaddr_set_object((struct sockaddr_pn *)addr,
 325                                         pn->sobject);
 326
 327         return sizeof(struct sockaddr_pn);
 328 }
 329
 330 static __poll_t pn_socket_poll(struct file *file, struct socket *sock,
 331                                         poll_table *wait)
 332 {
 333         struct sock *sk = sock->sk;
 334         struct pep_sock *pn = pep_sk(sk);
 335         __poll_t mask = 0;
 336
 337         poll_wait(file, sk_sleep(sk), wait);
 338
 339         if (sk->sk_state == TCP_CLOSE)
 340                 return EPOLLERR;
 341         if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
 342                 mask |= EPOLLIN | EPOLLRDNORM;
 343         if (!skb_queue_empty_lockless(&pn->ctrlreq_queue))
 344                 mask |= EPOLLPRI;
 345         if (!mask && sk->sk_state == TCP_CLOSE_WAIT)
 346                 return EPOLLHUP;
 347
 348         if (sk->sk_state == TCP_ESTABLISHED &&
 349                 refcount_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf &&
 350                 atomic_read(&pn->tx_credits))
 351                 mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
 352
 353         return mask;
 354 }
 355
 356 static int pn_socket_ioctl(struct socket *sock, unsigned int cmd,
 357                                 unsigned long arg)
 358 {
 359         struct sock *sk = sock->sk;
 360         struct pn_sock *pn = pn_sk(sk);
 361
 362         if (cmd == SIOCPNGETOBJECT) {
 363                 struct net_device *dev;
 364                 u16 handle;
 365                 u8 saddr;
 366
 367                 if (get_user(handle, (__u16 __user *)arg))
 368                         return -EFAULT;
 369
 370                 lock_sock(sk);
 371                 if (sk->sk_bound_dev_if)
 372                         dev = dev_get_by_index(sock_net(sk),
 373                                                 sk->sk_bound_dev_if);
 374                 else
 375                         dev = phonet_device_get(sock_net(sk));
 376                 if (dev && (dev->flags & IFF_UP))
 377                         saddr = phonet_address_get(dev, pn_addr(handle));
 378                 else
 379                         saddr = PN_NO_ADDR;
 380                 release_sock(sk);
 381
 382                 if (dev)
 383                         dev_put(dev);
 384                 if (saddr == PN_NO_ADDR)
 385                         return -EHOSTUNREACH;
 386
 387                 handle = pn_object(saddr, pn_port(pn->sobject));
 388                 return put_user(handle, (__u16 __user *)arg);
 389         }
 390
 391         return sk->sk_prot->ioctl(sk, cmd, arg);
 392 }
 393
 394 static int pn_socket_listen(struct socket *sock, int backlog)
 395 {
 396         struct sock *sk = sock->sk;
 397         int err = 0;
 398
 399         if (pn_socket_autobind(sock))
 400                 return -ENOBUFS;
 401
 402         lock_sock(sk);
 403         if (sock->state != SS_UNCONNECTED) {
 404                 err = -EINVAL;
 405                 goto out;
 406         }
 407
 408         if (sk->sk_state != TCP_LISTEN) {
 409                 sk->sk_state = TCP_LISTEN;
 410                 sk->sk_ack_backlog = 0;
 411         }
 412         sk->sk_max_ack_backlog = backlog;
 413 out:
 414         release_sock(sk);
 415         return err;
 416 }
 417
 418 static int pn_socket_sendmsg(struct socket *sock, struct msghdr *m,
 419                              size_t total_len)
 420 {
 421         struct sock *sk = sock->sk;
 422
 423         if (pn_socket_autobind(sock))
 424                 return -EAGAIN;
 425
 426         return sk->sk_prot->sendmsg(sk, m, total_len);
 427 }
 428
 429 const struct proto_ops phonet_dgram_ops = {
 430         .family         = AF_PHONET,
 431         .owner          = THIS_MODULE,
 432         .release        = pn_socket_release,
 433         .bind           = pn_socket_bind,
 434         .connect        = sock_no_connect,
 435         .socketpair     = sock_no_socketpair,
 436         .accept         = sock_no_accept,
 437         .getname        = pn_socket_getname,
 438         .poll           = datagram_poll,
 439         .ioctl          = pn_socket_ioctl,
 440         .listen         = sock_no_listen,
 441         .shutdown       = sock_no_shutdown,
 442         .setsockopt     = sock_no_setsockopt,
 443         .getsockopt     = sock_no_getsockopt,
 444 #ifdef CONFIG_COMPAT
 445         .compat_setsockopt = sock_no_setsockopt,
 446         .compat_getsockopt = sock_no_getsockopt,
 447 #endif
 448         .sendmsg        = pn_socket_sendmsg,
 449         .recvmsg        = sock_common_recvmsg,
 450         .mmap           = sock_no_mmap,
 451         .sendpage       = sock_no_sendpage,
 452 };
 453
 454 const struct proto_ops phonet_stream_ops = {
 455         .family         = AF_PHONET,
 456         .owner          = THIS_MODULE,
 457         .release        = pn_socket_release,
 458         .bind           = pn_socket_bind,
 459         .connect        = pn_socket_connect,
 460         .socketpair     = sock_no_socketpair,
 461         .accept         = pn_socket_accept,
 462         .getname        = pn_socket_getname,
 463         .poll           = pn_socket_poll,
 464         .ioctl          = pn_socket_ioctl,
 465         .listen         = pn_socket_listen,
 466         .shutdown       = sock_no_shutdown,
 467         .setsockopt     = sock_common_setsockopt,
 468         .getsockopt     = sock_common_getsockopt,
 469 #ifdef CONFIG_COMPAT
 470         .compat_setsockopt = compat_sock_common_setsockopt,
 471         .compat_getsockopt = compat_sock_common_getsockopt,
 472 #endif
 473         .sendmsg        = pn_socket_sendmsg,
 474         .recvmsg        = sock_common_recvmsg,
 475         .mmap           = sock_no_mmap,
 476         .sendpage       = sock_no_sendpage,
 477 };
 478 EXPORT_SYMBOL(phonet_stream_ops);
 479
 480 /* allocate port for a socket */
 481 int pn_sock_get_port(struct sock *sk, unsigned short sport)
 482 {
 483         static int port_cur;
 484         struct net *net = sock_net(sk);
 485         struct pn_sock *pn = pn_sk(sk);
 486         struct sockaddr_pn try_sa;
 487         struct sock *tmpsk;
 488
 489         memset(&try_sa, 0, sizeof(struct sockaddr_pn));
 490         try_sa.spn_family = AF_PHONET;
 491         WARN_ON(!mutex_is_locked(&port_mutex));
 492         if (!sport) {
 493                 /* search free port */
 494                 int port, pmin, pmax;
 495
 496                 phonet_get_local_port_range(&pmin, &pmax);
 497                 for (port = pmin; port <= pmax; port++) {
 498                         port_cur++;
 499                         if (port_cur < pmin || port_cur > pmax)
 500                                 port_cur = pmin;
 501
 502                         pn_sockaddr_set_port(&try_sa, port_cur);
 503                         tmpsk = pn_find_sock_by_sa(net, &try_sa);
 504                         if (tmpsk == NULL) {
 505                                 sport = port_cur;
 506                                 goto found;
 507                         } else
 508                                 sock_put(tmpsk);
 509                 }
 510         } else {
 511                 /* try to find specific port */
 512                 pn_sockaddr_set_port(&try_sa, sport);
 513                 tmpsk = pn_find_sock_by_sa(net, &try_sa);
 514                 if (tmpsk == NULL)
 515                         /* No sock there! We can use that port... */
 516                         goto found;
 517                 else
 518                         sock_put(tmpsk);
 519         }
 520         /* the port must be in use already */
 521         return -EADDRINUSE;
 522
 523 found:
 524         pn->sobject = pn_object(pn_addr(pn->sobject), sport);
 525         return 0;
 526 }
 527 EXPORT_SYMBOL(pn_sock_get_port);
 528
 529 #ifdef CONFIG_PROC_FS
 530 static struct sock *pn_sock_get_idx(struct seq_file *seq, loff_t pos)
 531 {
 532         struct net *net = seq_file_net(seq);
 533         struct hlist_head *hlist = pnsocks.hlist;
 534         struct sock *sknode;
 535         unsigned int h;
 536
 537         for (h = 0; h < PN_HASHSIZE; h++) {
 538                 sk_for_each_rcu(sknode, hlist) {
 539                         if (!net_eq(net, sock_net(sknode)))
 540                                 continue;
 541                         if (!pos)
 542                                 return sknode;
 543                         pos--;
 544                 }
 545                 hlist++;
 546         }
 547         return NULL;
 548 }
 549
 550 static struct sock *pn_sock_get_next(struct seq_file *seq, struct sock *sk)
 551 {
 552         struct net *net = seq_file_net(seq);
 553
 554         do
 555                 sk = sk_next(sk);
 556         while (sk && !net_eq(net, sock_net(sk)));
 557
 558         return sk;
 559 }
 560
 561 static void *pn_sock_seq_start(struct seq_file *seq, loff_t *pos)
 562         __acquires(rcu)
 563 {
 564         rcu_read_lock();
 565         return *pos ? pn_sock_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
 566 }
 567
 568 static void *pn_sock_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 569 {
 570         struct sock *sk;
 571
 572         if (v == SEQ_START_TOKEN)
 573                 sk = pn_sock_get_idx(seq, 0);
 574         else
 575                 sk = pn_sock_get_next(seq, v);
 576         (*pos)++;
 577         return sk;
 578 }
 579
 580 static void pn_sock_seq_stop(struct seq_file *seq, void *v)
 581         __releases(rcu)
 582 {
 583         rcu_read_unlock();
 584 }
 585
 586 static int pn_sock_seq_show(struct seq_file *seq, void *v)
 587 {
 588         seq_setwidth(seq, 127);
 589         if (v == SEQ_START_TOKEN)
 590                 seq_puts(seq, "pt  loc  rem rs st tx_queue rx_queue "
 591                         "  uid inode ref pointer drops");
 592         else {
 593                 struct sock *sk = v;
 594                 struct pn_sock *pn = pn_sk(sk);
 595
 596                 seq_printf(seq, "%2d %04X:%04X:%02X %02X %08X:%08X %5d %lu "
 597                         "%d %pK %u",
 598                         sk->sk_protocol, pn->sobject, pn->dobject,
 599                         pn->resource, sk->sk_state,
 600                         sk_wmem_alloc_get(sk), sk_rmem_alloc_get(sk),
 601                         from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
 602                         sock_i_ino(sk),
 603                         refcount_read(&sk->sk_refcnt), sk,
 604                         atomic_read(&sk->sk_drops));
 605         }
 606         seq_pad(seq, '\n');
 607         return 0;
 608 }
 609
 610 const struct seq_operations pn_sock_seq_ops = {
 611         .start = pn_sock_seq_start,
 612         .next = pn_sock_seq_next,
 613         .stop = pn_sock_seq_stop,
 614         .show = pn_sock_seq_show,
 615 };
 616 #endif
 617
 618 static struct  {
 619         struct sock *sk[256];
 620 } pnres;
 621
 622 /*
 623  * Find and hold socket based on resource.
 624  */
 625 struct sock *pn_find_sock_by_res(struct net *net, u8 res)
 626 {
 627         struct sock *sk;
 628
 629         if (!net_eq(net, &init_net))
 630                 return NULL;
 631
 632         rcu_read_lock();
 633         sk = rcu_dereference(pnres.sk[res]);
 634         if (sk)
 635                 sock_hold(sk);
 636         rcu_read_unlock();
 637         return sk;
 638 }
 639
 640 static DEFINE_MUTEX(resource_mutex);
 641
 642 int pn_sock_bind_res(struct sock *sk, u8 res)
 643 {
 644         int ret = -EADDRINUSE;
 645
 646         if (!net_eq(sock_net(sk), &init_net))
 647                 return -ENOIOCTLCMD;
 648         if (!capable(CAP_SYS_ADMIN))
 649                 return -EPERM;
 650         if (pn_socket_autobind(sk->sk_socket))
 651                 return -EAGAIN;
 652
 653         mutex_lock(&resource_mutex);
 654         if (pnres.sk[res] == NULL) {
 655                 sock_hold(sk);
 656                 rcu_assign_pointer(pnres.sk[res], sk);
 657                 ret = 0;
 658         }
 659         mutex_unlock(&resource_mutex);
 660         return ret;
 661 }
 662
 663 int pn_sock_unbind_res(struct sock *sk, u8 res)
 664 {
 665         int ret = -ENOENT;
 666
 667         if (!capable(CAP_SYS_ADMIN))
 668                 return -EPERM;
 669
 670         mutex_lock(&resource_mutex);
 671         if (pnres.sk[res] == sk) {
 672                 RCU_INIT_POINTER(pnres.sk[res], NULL);
 673                 ret = 0;
 674         }
 675         mutex_unlock(&resource_mutex);
 676
 677         if (ret == 0) {
 678                 synchronize_rcu();
 679                 sock_put(sk);
 680         }
 681         return ret;
 682 }
 683
 684 void pn_sock_unbind_all_res(struct sock *sk)
 685 {
 686         unsigned int res, match = 0;
 687
 688         mutex_lock(&resource_mutex);
 689         for (res = 0; res < 256; res++) {
 690                 if (pnres.sk[res] == sk) {
 691                         RCU_INIT_POINTER(pnres.sk[res], NULL);
 692                         match++;
 693                 }
 694         }
 695         mutex_unlock(&resource_mutex);
 696
 697         while (match > 0) {
 698                 __sock_put(sk);
 699                 match--;
 700         }
 701         /* Caller is responsible for RCU sync before final sock_put() */
 702 }
 703
 704 #ifdef CONFIG_PROC_FS
 705 static struct sock **pn_res_get_idx(struct seq_file *seq, loff_t pos)
 706 {
 707         struct net *net = seq_file_net(seq);
 708         unsigned int i;
 709
 710         if (!net_eq(net, &init_net))
 711                 return NULL;
 712
 713         for (i = 0; i < 256; i++) {
 714                 if (pnres.sk[i] == NULL)
 715                         continue;
 716                 if (!pos)
 717                         return pnres.sk + i;
 718                 pos--;
 719         }
 720         return NULL;
 721 }
 722
 723 static struct sock **pn_res_get_next(struct seq_file *seq, struct sock **sk)
 724 {
 725         struct net *net = seq_file_net(seq);
 726         unsigned int i;
 727
 728         BUG_ON(!net_eq(net, &init_net));
 729
 730         for (i = (sk - pnres.sk) + 1; i < 256; i++)
 731                 if (pnres.sk[i])
 732                         return pnres.sk + i;
 733         return NULL;
 734 }
 735
 736 static void *pn_res_seq_start(struct seq_file *seq, loff_t *pos)
 737         __acquires(resource_mutex)
 738 {
 739         mutex_lock(&resource_mutex);
 740         return *pos ? pn_res_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
 741 }
 742
 743 static void *pn_res_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 744 {
 745         struct sock **sk;
 746
 747         if (v == SEQ_START_TOKEN)
 748                 sk = pn_res_get_idx(seq, 0);
 749         else
 750                 sk = pn_res_get_next(seq, v);
 751         (*pos)++;
 752         return sk;
 753 }
 754
 755 static void pn_res_seq_stop(struct seq_file *seq, void *v)
 756         __releases(resource_mutex)
 757 {
 758         mutex_unlock(&resource_mutex);
 759 }
 760
 761 static int pn_res_seq_show(struct seq_file *seq, void *v)
 762 {
 763         seq_setwidth(seq, 63);
 764         if (v == SEQ_START_TOKEN)
 765                 seq_puts(seq, "rs   uid inode");
 766         else {
 767                 struct sock **psk = v;
 768                 struct sock *sk = *psk;
 769
 770                 seq_printf(seq, "%02X %5u %lu",
 771                            (int) (psk - pnres.sk),
 772                            from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
 773                            sock_i_ino(sk));
 774         }
 775         seq_pad(seq, '\n');
 776         return 0;
 777 }
 778
 779 const struct seq_operations pn_res_seq_ops = {
 780         .start = pn_res_seq_start,
 781         .next = pn_res_seq_next,
 782         .stop = pn_res_seq_stop,
 783         .show = pn_res_seq_show,
 784 };
 785 #endif