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