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_unsized *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_unsized *)&sa, 210 sizeof(struct sockaddr_pn)); 211 /* 212 * pn_socket_bind() also returns -EINVAL when sk_state != TCP_CLOSE 213 * without a prior bind, so -EINVAL alone is not sufficient to infer 214 * that the socket was already bound. Only treat it as "already 215 * bound" when the port is non-zero; otherwise propagate the error 216 * instead of crashing the kernel. 217 */ 218 if (err != -EINVAL || unlikely(!pn_port(pn_sk(sock->sk)->sobject))) 219 return err; 220 return 0; /* socket was already bound */ 221 } 222 223 static int pn_socket_connect(struct socket *sock, struct sockaddr_unsized *addr, 224 int len, int flags) 225 { 226 struct sock *sk = sock->sk; 227 struct pn_sock *pn = pn_sk(sk); 228 struct sockaddr_pn *spn = (struct sockaddr_pn *)addr; 229 struct task_struct *tsk = current; 230 long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK); 231 int err; 232 233 if (pn_socket_autobind(sock)) 234 return -ENOBUFS; 235 if (len < sizeof(struct sockaddr_pn)) 236 return -EINVAL; 237 if (spn->spn_family != AF_PHONET) 238 return -EAFNOSUPPORT; 239 240 lock_sock(sk); 241 242 switch (sock->state) { 243 case SS_UNCONNECTED: 244 if (sk->sk_state != TCP_CLOSE) { 245 err = -EISCONN; 246 goto out; 247 } 248 break; 249 case SS_CONNECTING: 250 err = -EALREADY; 251 goto out; 252 default: 253 err = -EISCONN; 254 goto out; 255 } 256 257 pn->dobject = pn_sockaddr_get_object(spn); 258 pn->resource = pn_sockaddr_get_resource(spn); 259 sock->state = SS_CONNECTING; 260 261 err = sk->sk_prot->connect(sk, addr, len); 262 if (err) { 263 sock->state = SS_UNCONNECTED; 264 pn->dobject = 0; 265 goto out; 266 } 267 268 while (sk->sk_state == TCP_SYN_SENT) { 269 DEFINE_WAIT(wait); 270 271 if (!timeo) { 272 err = -EINPROGRESS; 273 goto out; 274 } 275 if (signal_pending(tsk)) { 276 err = sock_intr_errno(timeo); 277 goto out; 278 } 279 280 prepare_to_wait_exclusive(sk_sleep(sk), &wait, 281 TASK_INTERRUPTIBLE); 282 release_sock(sk); 283 timeo = schedule_timeout(timeo); 284 lock_sock(sk); 285 finish_wait(sk_sleep(sk), &wait); 286 } 287 288 if ((1 << sk->sk_state) & (TCPF_SYN_RECV|TCPF_ESTABLISHED)) 289 err = 0; 290 else if (sk->sk_state == TCP_CLOSE_WAIT) 291 err = -ECONNRESET; 292 else 293 err = -ECONNREFUSED; 294 sock->state = err ? SS_UNCONNECTED : SS_CONNECTED; 295 out: 296 release_sock(sk); 297 return err; 298 } 299 300 static int pn_socket_accept(struct socket *sock, struct socket *newsock, 301 struct proto_accept_arg *arg) 302 { 303 struct sock *sk = sock->sk; 304 struct sock *newsk; 305 306 if (unlikely(sk->sk_state != TCP_LISTEN)) 307 return -EINVAL; 308 309 newsk = sk->sk_prot->accept(sk, arg); 310 if (!newsk) 311 return arg->err; 312 313 lock_sock(newsk); 314 sock_graft(newsk, newsock); 315 newsock->state = SS_CONNECTED; 316 release_sock(newsk); 317 return 0; 318 } 319 320 static int pn_socket_getname(struct socket *sock, struct sockaddr *addr, 321 int peer) 322 { 323 struct sock *sk = sock->sk; 324 struct pn_sock *pn = pn_sk(sk); 325 326 memset(addr, 0, sizeof(struct sockaddr_pn)); 327 addr->sa_family = AF_PHONET; 328 if (!peer) /* Race with bind() here is userland's problem. */ 329 pn_sockaddr_set_object((struct sockaddr_pn *)addr, 330 pn->sobject); 331 332 return sizeof(struct sockaddr_pn); 333 } 334 335 static __poll_t pn_socket_poll(struct file *file, struct socket *sock, 336 poll_table *wait) 337 { 338 struct sock *sk = sock->sk; 339 struct pep_sock *pn = pep_sk(sk); 340 __poll_t mask = 0; 341 342 poll_wait(file, sk_sleep(sk), wait); 343 344 if (sk->sk_state == TCP_CLOSE) 345 return EPOLLERR; 346 if (!skb_queue_empty_lockless(&sk->sk_receive_queue)) 347 mask |= EPOLLIN | EPOLLRDNORM; 348 if (!skb_queue_empty_lockless(&pn->ctrlreq_queue)) 349 mask |= EPOLLPRI; 350 if (!mask && sk->sk_state == TCP_CLOSE_WAIT) 351 return EPOLLHUP; 352 353 if (sk->sk_state == TCP_ESTABLISHED && 354 refcount_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf && 355 atomic_read(&pn->tx_credits)) 356 mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND; 357 358 return mask; 359 } 360 361 static int pn_socket_ioctl(struct socket *sock, unsigned int cmd, 362 unsigned long arg) 363 { 364 struct sock *sk = sock->sk; 365 struct pn_sock *pn = pn_sk(sk); 366 367 if (cmd == SIOCPNGETOBJECT) { 368 struct net_device *dev; 369 u16 handle; 370 u8 saddr; 371 372 if (get_user(handle, (__u16 __user *)arg)) 373 return -EFAULT; 374 375 lock_sock(sk); 376 if (sk->sk_bound_dev_if) 377 dev = dev_get_by_index(sock_net(sk), 378 sk->sk_bound_dev_if); 379 else 380 dev = phonet_device_get(sock_net(sk)); 381 if (dev && (dev->flags & IFF_UP)) 382 saddr = phonet_address_get(dev, pn_addr(handle)); 383 else 384 saddr = PN_NO_ADDR; 385 release_sock(sk); 386 387 dev_put(dev); 388 if (saddr == PN_NO_ADDR) 389 return -EHOSTUNREACH; 390 391 handle = pn_object(saddr, pn_port(pn->sobject)); 392 return put_user(handle, (__u16 __user *)arg); 393 } 394 395 return sk_ioctl(sk, cmd, (void __user *)arg); 396 } 397 398 static int pn_socket_listen(struct socket *sock, int backlog) 399 { 400 struct sock *sk = sock->sk; 401 int err = 0; 402 403 if (pn_socket_autobind(sock)) 404 return -ENOBUFS; 405 406 lock_sock(sk); 407 if (sock->state != SS_UNCONNECTED) { 408 err = -EINVAL; 409 goto out; 410 } 411 412 if (sk->sk_state != TCP_LISTEN) { 413 sk->sk_state = TCP_LISTEN; 414 sk->sk_ack_backlog = 0; 415 } 416 sk->sk_max_ack_backlog = backlog; 417 out: 418 release_sock(sk); 419 return err; 420 } 421 422 static int pn_socket_sendmsg(struct socket *sock, struct msghdr *m, 423 size_t total_len) 424 { 425 struct sock *sk = sock->sk; 426 427 if (pn_socket_autobind(sock)) 428 return -EAGAIN; 429 430 return sk->sk_prot->sendmsg(sk, m, total_len); 431 } 432 433 const struct proto_ops phonet_dgram_ops = { 434 .family = AF_PHONET, 435 .owner = THIS_MODULE, 436 .release = pn_socket_release, 437 .bind = pn_socket_bind, 438 .connect = sock_no_connect, 439 .socketpair = sock_no_socketpair, 440 .accept = sock_no_accept, 441 .getname = pn_socket_getname, 442 .poll = datagram_poll, 443 .ioctl = pn_socket_ioctl, 444 .listen = sock_no_listen, 445 .shutdown = sock_no_shutdown, 446 .sendmsg = pn_socket_sendmsg, 447 .recvmsg = sock_common_recvmsg, 448 .mmap = sock_no_mmap, 449 }; 450 451 const struct proto_ops phonet_stream_ops = { 452 .family = AF_PHONET, 453 .owner = THIS_MODULE, 454 .release = pn_socket_release, 455 .bind = pn_socket_bind, 456 .connect = pn_socket_connect, 457 .socketpair = sock_no_socketpair, 458 .accept = pn_socket_accept, 459 .getname = pn_socket_getname, 460 .poll = pn_socket_poll, 461 .ioctl = pn_socket_ioctl, 462 .listen = pn_socket_listen, 463 .shutdown = sock_no_shutdown, 464 .setsockopt = sock_common_setsockopt, 465 .getsockopt = sock_common_getsockopt, 466 .sendmsg = pn_socket_sendmsg, 467 .recvmsg = sock_common_recvmsg, 468 .mmap = sock_no_mmap, 469 }; 470 EXPORT_SYMBOL(phonet_stream_ops); 471 472 /* allocate port for a socket */ 473 int pn_sock_get_port(struct sock *sk, unsigned short sport) 474 { 475 static int port_cur; 476 struct net *net = sock_net(sk); 477 struct pn_sock *pn = pn_sk(sk); 478 struct sockaddr_pn try_sa; 479 struct sock *tmpsk; 480 481 memset(&try_sa, 0, sizeof(struct sockaddr_pn)); 482 try_sa.spn_family = AF_PHONET; 483 WARN_ON(!mutex_is_locked(&port_mutex)); 484 if (!sport) { 485 /* search free port */ 486 int port, pmin, pmax; 487 488 phonet_get_local_port_range(&pmin, &pmax); 489 for (port = pmin; port <= pmax; port++) { 490 port_cur++; 491 if (port_cur < pmin || port_cur > pmax) 492 port_cur = pmin; 493 494 pn_sockaddr_set_port(&try_sa, port_cur); 495 tmpsk = pn_find_sock_by_sa(net, &try_sa); 496 if (tmpsk == NULL) { 497 sport = port_cur; 498 goto found; 499 } else 500 sock_put(tmpsk); 501 } 502 } else { 503 /* try to find specific port */ 504 pn_sockaddr_set_port(&try_sa, sport); 505 tmpsk = pn_find_sock_by_sa(net, &try_sa); 506 if (tmpsk == NULL) 507 /* No sock there! We can use that port... */ 508 goto found; 509 else 510 sock_put(tmpsk); 511 } 512 /* the port must be in use already */ 513 return -EADDRINUSE; 514 515 found: 516 pn->sobject = pn_object(pn_addr(pn->sobject), sport); 517 return 0; 518 } 519 EXPORT_SYMBOL(pn_sock_get_port); 520 521 #ifdef CONFIG_PROC_FS 522 static struct sock *pn_sock_get_idx(struct seq_file *seq, loff_t pos) 523 { 524 struct net *net = seq_file_net(seq); 525 struct hlist_head *hlist = pnsocks.hlist; 526 struct sock *sknode; 527 unsigned int h; 528 529 for (h = 0; h < PN_HASHSIZE; h++) { 530 sk_for_each_rcu(sknode, hlist) { 531 if (!net_eq(net, sock_net(sknode))) 532 continue; 533 if (!pos) 534 return sknode; 535 pos--; 536 } 537 hlist++; 538 } 539 return NULL; 540 } 541 542 static struct sock *pn_sock_get_next(struct seq_file *seq, struct sock *sk) 543 { 544 struct net *net = seq_file_net(seq); 545 546 do 547 sk = sk_next(sk); 548 while (sk && !net_eq(net, sock_net(sk))); 549 550 return sk; 551 } 552 553 static void *pn_sock_seq_start(struct seq_file *seq, loff_t *pos) 554 __acquires(rcu) 555 { 556 rcu_read_lock(); 557 return *pos ? pn_sock_get_idx(seq, *pos - 1) : SEQ_START_TOKEN; 558 } 559 560 static void *pn_sock_seq_next(struct seq_file *seq, void *v, loff_t *pos) 561 { 562 struct sock *sk; 563 564 if (v == SEQ_START_TOKEN) 565 sk = pn_sock_get_idx(seq, 0); 566 else 567 sk = pn_sock_get_next(seq, v); 568 (*pos)++; 569 return sk; 570 } 571 572 static void pn_sock_seq_stop(struct seq_file *seq, void *v) 573 __releases(rcu) 574 { 575 rcu_read_unlock(); 576 } 577 578 static int pn_sock_seq_show(struct seq_file *seq, void *v) 579 { 580 seq_setwidth(seq, 127); 581 if (v == SEQ_START_TOKEN) 582 seq_puts(seq, "pt loc rem rs st tx_queue rx_queue " 583 " uid inode ref pointer drops"); 584 else { 585 struct sock *sk = v; 586 struct pn_sock *pn = pn_sk(sk); 587 588 seq_printf(seq, "%2d %04X:%04X:%02X %02X %08X:%08X %5d %llu " 589 "%d %pK %u", 590 sk->sk_protocol, pn->sobject, pn->dobject, 591 pn->resource, sk->sk_state, 592 sk_wmem_alloc_get(sk), sk_rmem_alloc_get(sk), 593 from_kuid_munged(seq_user_ns(seq), sk_uid(sk)), 594 sock_i_ino(sk), 595 refcount_read(&sk->sk_refcnt), sk, 596 sk_drops_read(sk)); 597 } 598 seq_pad(seq, '\n'); 599 return 0; 600 } 601 602 const struct seq_operations pn_sock_seq_ops = { 603 .start = pn_sock_seq_start, 604 .next = pn_sock_seq_next, 605 .stop = pn_sock_seq_stop, 606 .show = pn_sock_seq_show, 607 }; 608 #endif 609 610 static struct { 611 struct sock __rcu *sk[256]; 612 } pnres; 613 614 /* 615 * Find and hold socket based on resource. 616 */ 617 struct sock *pn_find_sock_by_res(struct net *net, u8 res) 618 { 619 struct sock *sk; 620 621 if (!net_eq(net, &init_net)) 622 return NULL; 623 624 rcu_read_lock(); 625 sk = rcu_dereference(pnres.sk[res]); 626 if (sk) 627 sock_hold(sk); 628 rcu_read_unlock(); 629 return sk; 630 } 631 632 static DEFINE_MUTEX(resource_mutex); 633 634 int pn_sock_bind_res(struct sock *sk, u8 res) 635 { 636 int ret = -EADDRINUSE; 637 638 if (!net_eq(sock_net(sk), &init_net)) 639 return -ENOIOCTLCMD; 640 if (!capable(CAP_SYS_ADMIN)) 641 return -EPERM; 642 if (pn_socket_autobind(sk->sk_socket)) 643 return -EAGAIN; 644 645 mutex_lock(&resource_mutex); 646 if (pnres.sk[res] == NULL) { 647 sock_hold(sk); 648 rcu_assign_pointer(pnres.sk[res], sk); 649 ret = 0; 650 } 651 mutex_unlock(&resource_mutex); 652 return ret; 653 } 654 655 int pn_sock_unbind_res(struct sock *sk, u8 res) 656 { 657 int ret = -ENOENT; 658 659 if (!capable(CAP_SYS_ADMIN)) 660 return -EPERM; 661 662 mutex_lock(&resource_mutex); 663 if (rcu_access_pointer(pnres.sk[res]) == sk) { 664 RCU_INIT_POINTER(pnres.sk[res], NULL); 665 ret = 0; 666 } 667 mutex_unlock(&resource_mutex); 668 669 if (ret == 0) { 670 synchronize_rcu(); 671 sock_put(sk); 672 } 673 return ret; 674 } 675 676 void pn_sock_unbind_all_res(struct sock *sk) 677 { 678 unsigned int res, match = 0; 679 680 mutex_lock(&resource_mutex); 681 for (res = 0; res < 256; res++) { 682 if (rcu_access_pointer(pnres.sk[res]) == sk) { 683 RCU_INIT_POINTER(pnres.sk[res], NULL); 684 match++; 685 } 686 } 687 mutex_unlock(&resource_mutex); 688 689 while (match > 0) { 690 __sock_put(sk); 691 match--; 692 } 693 /* Caller is responsible for RCU sync before final sock_put() */ 694 } 695 696 #ifdef CONFIG_PROC_FS 697 static struct sock __rcu **pn_res_get_idx(struct seq_file *seq, loff_t pos) 698 { 699 struct net *net = seq_file_net(seq); 700 unsigned int i; 701 702 if (!net_eq(net, &init_net)) 703 return NULL; 704 705 for (i = 0; i < 256; i++) { 706 if (rcu_access_pointer(pnres.sk[i]) == NULL) 707 continue; 708 if (!pos) 709 return pnres.sk + i; 710 pos--; 711 } 712 return NULL; 713 } 714 715 static struct sock __rcu **pn_res_get_next(struct seq_file *seq, struct sock __rcu **sk) 716 { 717 struct net *net = seq_file_net(seq); 718 unsigned int i; 719 720 BUG_ON(!net_eq(net, &init_net)); 721 722 for (i = (sk - pnres.sk) + 1; i < 256; i++) 723 if (pnres.sk[i]) 724 return pnres.sk + i; 725 return NULL; 726 } 727 728 static void *pn_res_seq_start(struct seq_file *seq, loff_t *pos) 729 __acquires(resource_mutex) 730 { 731 mutex_lock(&resource_mutex); 732 return *pos ? pn_res_get_idx(seq, *pos - 1) : SEQ_START_TOKEN; 733 } 734 735 static void *pn_res_seq_next(struct seq_file *seq, void *v, loff_t *pos) 736 { 737 struct sock __rcu **sk; 738 739 if (v == SEQ_START_TOKEN) 740 sk = pn_res_get_idx(seq, 0); 741 else 742 sk = pn_res_get_next(seq, v); 743 (*pos)++; 744 return sk; 745 } 746 747 static void pn_res_seq_stop(struct seq_file *seq, void *v) 748 __releases(resource_mutex) 749 { 750 mutex_unlock(&resource_mutex); 751 } 752 753 static int pn_res_seq_show(struct seq_file *seq, void *v) 754 { 755 seq_setwidth(seq, 63); 756 if (v == SEQ_START_TOKEN) { 757 seq_puts(seq, "rs uid inode"); 758 } else { 759 struct sock __rcu **psk = v; 760 struct sock *sk = rcu_dereference_protected(*psk, 761 lockdep_is_held(&resource_mutex)); 762 763 seq_printf(seq, "%02X %5u %llu", 764 (int) (psk - pnres.sk), 765 from_kuid_munged(seq_user_ns(seq), sk_uid(sk)), 766 sock_i_ino(sk)); 767 } 768 seq_pad(seq, '\n'); 769 return 0; 770 } 771 772 const struct seq_operations pn_res_seq_ops = { 773 .start = pn_res_seq_start, 774 .next = pn_res_seq_next, 775 .stop = pn_res_seq_stop, 776 .show = pn_res_seq_show, 777 }; 778 #endif 779