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