socket.c 16 KB

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