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