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         .sendmsg        = pn_socket_sendmsg,
 443         .recvmsg        = sock_common_recvmsg,
 444         .mmap           = sock_no_mmap,
 445         .sendpage       = sock_no_sendpage,
 446 };
 447
 448 const struct proto_ops phonet_stream_ops = {
 449         .family         = AF_PHONET,
 450         .owner          = THIS_MODULE,
 451         .release        = pn_socket_release,
 452         .bind           = pn_socket_bind,
 453         .connect        = pn_socket_connect,
 454         .socketpair     = sock_no_socketpair,
 455         .accept         = pn_socket_accept,
 456         .getname        = pn_socket_getname,
 457         .poll           = pn_socket_poll,
 458         .ioctl          = pn_socket_ioctl,
 459         .listen         = pn_socket_listen,
 460         .shutdown       = sock_no_shutdown,
 461         .setsockopt     = sock_common_setsockopt,
 462         .getsockopt     = sock_common_getsockopt,
 463         .sendmsg        = pn_socket_sendmsg,
 464         .recvmsg        = sock_common_recvmsg,
 465         .mmap           = sock_no_mmap,
 466         .sendpage       = sock_no_sendpage,
 467 };
 468 EXPORT_SYMBOL(phonet_stream_ops);
 469
 470 /* allocate port for a socket */
 471 int pn_sock_get_port(struct sock *sk, unsigned short sport)
 472 {
 473         static int port_cur;
 474         struct net *net = sock_net(sk);
 475         struct pn_sock *pn = pn_sk(sk);
 476         struct sockaddr_pn try_sa;
 477         struct sock *tmpsk;
 478
 479         memset(&try_sa, 0, sizeof(struct sockaddr_pn));
 480         try_sa.spn_family = AF_PHONET;
 481         WARN_ON(!mutex_is_locked(&port_mutex));
 482         if (!sport) {
 483                 /* search free port */
 484                 int port, pmin, pmax;
 485
 486                 phonet_get_local_port_range(&pmin, &pmax);
 487                 for (port = pmin; port <= pmax; port++) {
 488                         port_cur++;
 489                         if (port_cur < pmin || port_cur > pmax)
 490                                 port_cur = pmin;
 491
 492                         pn_sockaddr_set_port(&try_sa, port_cur);
 493                         tmpsk = pn_find_sock_by_sa(net, &try_sa);
 494                         if (tmpsk == NULL) {
 495                                 sport = port_cur;
 496                                 goto found;
 497                         } else
 498                                 sock_put(tmpsk);
 499                 }
 500         } else {
 501                 /* try to find specific port */
 502                 pn_sockaddr_set_port(&try_sa, sport);
 503                 tmpsk = pn_find_sock_by_sa(net, &try_sa);
 504                 if (tmpsk == NULL)
 505                         /* No sock there! We can use that port... */
 506                         goto found;
 507                 else
 508                         sock_put(tmpsk);
 509         }
 510         /* the port must be in use already */
 511         return -EADDRINUSE;
 512
 513 found:
 514         pn->sobject = pn_object(pn_addr(pn->sobject), sport);
 515         return 0;
 516 }
 517 EXPORT_SYMBOL(pn_sock_get_port);
 518
 519 #ifdef CONFIG_PROC_FS
 520 static struct sock *pn_sock_get_idx(struct seq_file *seq, loff_t pos)
 521 {
 522         struct net *net = seq_file_net(seq);
 523         struct hlist_head *hlist = pnsocks.hlist;
 524         struct sock *sknode;
 525         unsigned int h;
 526
 527         for (h = 0; h < PN_HASHSIZE; h++) {
 528                 sk_for_each_rcu(sknode, hlist) {
 529                         if (!net_eq(net, sock_net(sknode)))
 530                                 continue;
 531                         if (!pos)
 532                                 return sknode;
 533                         pos--;
 534                 }
 535                 hlist++;
 536         }
 537         return NULL;
 538 }
 539
 540 static struct sock *pn_sock_get_next(struct seq_file *seq, struct sock *sk)
 541 {
 542         struct net *net = seq_file_net(seq);
 543
 544         do
 545                 sk = sk_next(sk);
 546         while (sk && !net_eq(net, sock_net(sk)));
 547
 548         return sk;
 549 }
 550
 551 static void *pn_sock_seq_start(struct seq_file *seq, loff_t *pos)
 552         __acquires(rcu)
 553 {
 554         rcu_read_lock();
 555         return *pos ? pn_sock_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
 556 }
 557
 558 static void *pn_sock_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 559 {
 560         struct sock *sk;
 561
 562         if (v == SEQ_START_TOKEN)
 563                 sk = pn_sock_get_idx(seq, 0);
 564         else
 565                 sk = pn_sock_get_next(seq, v);
 566         (*pos)++;
 567         return sk;
 568 }
 569
 570 static void pn_sock_seq_stop(struct seq_file *seq, void *v)
 571         __releases(rcu)
 572 {
 573         rcu_read_unlock();
 574 }
 575
 576 static int pn_sock_seq_show(struct seq_file *seq, void *v)
 577 {
 578         seq_setwidth(seq, 127);
 579         if (v == SEQ_START_TOKEN)
 580                 seq_puts(seq, "pt  loc  rem rs st tx_queue rx_queue "
 581                         "  uid inode ref pointer drops");
 582         else {
 583                 struct sock *sk = v;
 584                 struct pn_sock *pn = pn_sk(sk);
 585
 586                 seq_printf(seq, "%2d %04X:%04X:%02X %02X %08X:%08X %5d %lu "
 587                         "%d %pK %u",
 588                         sk->sk_protocol, pn->sobject, pn->dobject,
 589                         pn->resource, sk->sk_state,
 590                         sk_wmem_alloc_get(sk), sk_rmem_alloc_get(sk),
 591                         from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
 592                         sock_i_ino(sk),
 593                         refcount_read(&sk->sk_refcnt), sk,
 594                         atomic_read(&sk->sk_drops));
 595         }
 596         seq_pad(seq, '\n');
 597         return 0;
 598 }
 599
 600 const struct seq_operations pn_sock_seq_ops = {
 601         .start = pn_sock_seq_start,
 602         .next = pn_sock_seq_next,
 603         .stop = pn_sock_seq_stop,
 604         .show = pn_sock_seq_show,
 605 };
 606 #endif
 607
 608 static struct  {
 609         struct sock *sk[256];
 610 } pnres;
 611
 612 /*
 613  * Find and hold socket based on resource.
 614  */
 615 struct sock *pn_find_sock_by_res(struct net *net, u8 res)
 616 {
 617         struct sock *sk;
 618
 619         if (!net_eq(net, &init_net))
 620                 return NULL;
 621
 622         rcu_read_lock();
 623         sk = rcu_dereference(pnres.sk[res]);
 624         if (sk)
 625                 sock_hold(sk);
 626         rcu_read_unlock();
 627         return sk;
 628 }
 629
 630 static DEFINE_MUTEX(resource_mutex);
 631
 632 int pn_sock_bind_res(struct sock *sk, u8 res)
 633 {
 634         int ret = -EADDRINUSE;
 635
 636         if (!net_eq(sock_net(sk), &init_net))
 637                 return -ENOIOCTLCMD;
 638         if (!capable(CAP_SYS_ADMIN))
 639                 return -EPERM;
 640         if (pn_socket_autobind(sk->sk_socket))
 641                 return -EAGAIN;
 642
 643         mutex_lock(&resource_mutex);
 644         if (pnres.sk[res] == NULL) {
 645                 sock_hold(sk);
 646                 rcu_assign_pointer(pnres.sk[res], sk);
 647                 ret = 0;
 648         }
 649         mutex_unlock(&resource_mutex);
 650         return ret;
 651 }
 652
 653 int pn_sock_unbind_res(struct sock *sk, u8 res)
 654 {
 655         int ret = -ENOENT;
 656
 657         if (!capable(CAP_SYS_ADMIN))
 658                 return -EPERM;
 659
 660         mutex_lock(&resource_mutex);
 661         if (pnres.sk[res] == sk) {
 662                 RCU_INIT_POINTER(pnres.sk[res], NULL);
 663                 ret = 0;
 664         }
 665         mutex_unlock(&resource_mutex);
 666
 667         if (ret == 0) {
 668                 synchronize_rcu();
 669                 sock_put(sk);
 670         }
 671         return ret;
 672 }
 673
 674 void pn_sock_unbind_all_res(struct sock *sk)
 675 {
 676         unsigned int res, match = 0;
 677
 678         mutex_lock(&resource_mutex);
 679         for (res = 0; res < 256; res++) {
 680                 if (pnres.sk[res] == sk) {
 681                         RCU_INIT_POINTER(pnres.sk[res], NULL);
 682                         match++;
 683                 }
 684         }
 685         mutex_unlock(&resource_mutex);
 686
 687         while (match > 0) {
 688                 __sock_put(sk);
 689                 match--;
 690         }
 691         /* Caller is responsible for RCU sync before final sock_put() */
 692 }
 693
 694 #ifdef CONFIG_PROC_FS
 695 static struct sock **pn_res_get_idx(struct seq_file *seq, loff_t pos)
 696 {
 697         struct net *net = seq_file_net(seq);
 698         unsigned int i;
 699
 700         if (!net_eq(net, &init_net))
 701                 return NULL;
 702
 703         for (i = 0; i < 256; i++) {
 704                 if (pnres.sk[i] == NULL)
 705                         continue;
 706                 if (!pos)
 707                         return pnres.sk + i;
 708                 pos--;
 709         }
 710         return NULL;
 711 }
 712
 713 static struct sock **pn_res_get_next(struct seq_file *seq, struct sock **sk)
 714 {
 715         struct net *net = seq_file_net(seq);
 716         unsigned int i;
 717
 718         BUG_ON(!net_eq(net, &init_net));
 719
 720         for (i = (sk - pnres.sk) + 1; i < 256; i++)
 721                 if (pnres.sk[i])
 722                         return pnres.sk + i;
 723         return NULL;
 724 }
 725
 726 static void *pn_res_seq_start(struct seq_file *seq, loff_t *pos)
 727         __acquires(resource_mutex)
 728 {
 729         mutex_lock(&resource_mutex);
 730         return *pos ? pn_res_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
 731 }
 732
 733 static void *pn_res_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 734 {
 735         struct sock **sk;
 736
 737         if (v == SEQ_START_TOKEN)
 738                 sk = pn_res_get_idx(seq, 0);
 739         else
 740                 sk = pn_res_get_next(seq, v);
 741         (*pos)++;
 742         return sk;
 743 }
 744
 745 static void pn_res_seq_stop(struct seq_file *seq, void *v)
 746         __releases(resource_mutex)
 747 {
 748         mutex_unlock(&resource_mutex);
 749 }
 750
 751 static int pn_res_seq_show(struct seq_file *seq, void *v)
 752 {
 753         seq_setwidth(seq, 63);
 754         if (v == SEQ_START_TOKEN)
 755                 seq_puts(seq, "rs   uid inode");
 756         else {
 757                 struct sock **psk = v;
 758                 struct sock *sk = *psk;
 759
 760                 seq_printf(seq, "%02X %5u %lu",
 761                            (int) (psk - pnres.sk),
 762                            from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
 763                            sock_i_ino(sk));
 764         }
 765         seq_pad(seq, '\n');
 766         return 0;
 767 }
 768
 769 const struct seq_operations pn_res_seq_ops = {
 770         .start = pn_res_seq_start,
 771         .next = pn_res_seq_next,
 772         .stop = pn_res_seq_stop,
 773         .show = pn_res_seq_show,
 774 };
 775 #endif