~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/phonet/socket.c

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.12 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.55 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.136 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.191 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.232 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.232 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 <net/sock.h>
 31 #include <net/tcp_states.h>
 32 
 33 #include <linux/phonet.h>
 34 #include <linux/export.h>
 35 #include <net/phonet/phonet.h>
 36 #include <net/phonet/pep.h>
 37 #include <net/phonet/pn_dev.h>
 38 
 39 static int pn_socket_release(struct socket *sock)
 40 {
 41         struct sock *sk = sock->sk;
 42 
 43         if (sk) {
 44                 sock->sk = NULL;
 45                 sk->sk_prot->close(sk, 0);
 46         }
 47         return 0;
 48 }
 49 
 50 #define PN_HASHSIZE     16
 51 #define PN_HASHMASK     (PN_HASHSIZE-1)
 52 
 53 
 54 static struct  {
 55         struct hlist_head hlist[PN_HASHSIZE];
 56         struct mutex lock;
 57 } pnsocks;
 58 
 59 void __init pn_sock_init(void)
 60 {
 61         unsigned int i;
 62 
 63         for (i = 0; i < PN_HASHSIZE; i++)
 64                 INIT_HLIST_HEAD(pnsocks.hlist + i);
 65         mutex_init(&pnsocks.lock);
 66 }
 67 
 68 static struct hlist_head *pn_hash_list(u16 obj)
 69 {
 70         return pnsocks.hlist + (obj & PN_HASHMASK);
 71 }
 72 
 73 /*
 74  * Find address based on socket address, match only certain fields.
 75  * Also grab sock if it was found. Remember to sock_put it later.
 76  */
 77 struct sock *pn_find_sock_by_sa(struct net *net, const struct sockaddr_pn *spn)
 78 {
 79         struct sock *sknode;
 80         struct sock *rval = NULL;
 81         u16 obj = pn_sockaddr_get_object(spn);
 82         u8 res = spn->spn_resource;
 83         struct hlist_head *hlist = pn_hash_list(obj);
 84 
 85         rcu_read_lock();
 86         sk_for_each_rcu(sknode, hlist) {
 87                 struct pn_sock *pn = pn_sk(sknode);
 88                 BUG_ON(!pn->sobject); /* unbound socket */
 89 
 90                 if (!net_eq(sock_net(sknode), net))
 91                         continue;
 92                 if (pn_port(obj)) {
 93                         /* Look up socket by port */
 94                         if (pn_port(pn->sobject) != pn_port(obj))
 95                                 continue;
 96                 } else {
 97                         /* If port is zero, look up by resource */
 98                         if (pn->resource != res)
 99                                 continue;
100                 }
101                 if (pn_addr(pn->sobject) &&
102                     pn_addr(pn->sobject) != pn_addr(obj))
103                         continue;
104 
105                 rval = sknode;
106                 sock_hold(sknode);
107                 break;
108         }
109         rcu_read_unlock();
110 
111         return rval;
112 }
113 
114 /* Deliver a broadcast packet (only in bottom-half) */
115 void pn_deliver_sock_broadcast(struct net *net, struct sk_buff *skb)
116 {
117         struct hlist_head *hlist = pnsocks.hlist;
118         unsigned int h;
119 
120         rcu_read_lock();
121         for (h = 0; h < PN_HASHSIZE; h++) {
122                 struct sock *sknode;
123 
124                 sk_for_each(sknode, hlist) {
125                         struct sk_buff *clone;
126 
127                         if (!net_eq(sock_net(sknode), net))
128                                 continue;
129                         if (!sock_flag(sknode, SOCK_BROADCAST))
130                                 continue;
131 
132                         clone = skb_clone(skb, GFP_ATOMIC);
133                         if (clone) {
134                                 sock_hold(sknode);
135                                 sk_receive_skb(sknode, clone, 0);
136                         }
137                 }
138                 hlist++;
139         }
140         rcu_read_unlock();
141 }
142 
143 void pn_sock_hash(struct sock *sk)
144 {
145         struct hlist_head *hlist = pn_hash_list(pn_sk(sk)->sobject);
146 
147         mutex_lock(&pnsocks.lock);
148         sk_add_node_rcu(sk, hlist);
149         mutex_unlock(&pnsocks.lock);
150 }
151 EXPORT_SYMBOL(pn_sock_hash);
152 
153 void pn_sock_unhash(struct sock *sk)
154 {
155         mutex_lock(&pnsocks.lock);
156         sk_del_node_init_rcu(sk);
157         mutex_unlock(&pnsocks.lock);
158         pn_sock_unbind_all_res(sk);
159         synchronize_rcu();
160 }
161 EXPORT_SYMBOL(pn_sock_unhash);
162 
163 static DEFINE_MUTEX(port_mutex);
164 
165 static int pn_socket_bind(struct socket *sock, struct sockaddr *addr, int len)
166 {
167         struct sock *sk = sock->sk;
168         struct pn_sock *pn = pn_sk(sk);
169         struct sockaddr_pn *spn = (struct sockaddr_pn *)addr;
170         int err;
171         u16 handle;
172         u8 saddr;
173 
174         if (sk->sk_prot->bind)
175                 return sk->sk_prot->bind(sk, addr, len);
176 
177         if (len < sizeof(struct sockaddr_pn))
178                 return -EINVAL;
179         if (spn->spn_family != AF_PHONET)
180                 return -EAFNOSUPPORT;
181 
182         handle = pn_sockaddr_get_object((struct sockaddr_pn *)addr);
183         saddr = pn_addr(handle);
184         if (saddr && phonet_address_lookup(sock_net(sk), saddr))
185                 return -EADDRNOTAVAIL;
186 
187         lock_sock(sk);
188         if (sk->sk_state != TCP_CLOSE || pn_port(pn->sobject)) {
189                 err = -EINVAL; /* attempt to rebind */
190                 goto out;
191         }
192         WARN_ON(sk_hashed(sk));
193         mutex_lock(&port_mutex);
194         err = sk->sk_prot->get_port(sk, pn_port(handle));
195         if (err)
196                 goto out_port;
197 
198         /* get_port() sets the port, bind() sets the address if applicable */
199         pn->sobject = pn_object(saddr, pn_port(pn->sobject));
200         pn->resource = spn->spn_resource;
201 
202         /* Enable RX on the socket */
203         sk->sk_prot->hash(sk);
204 out_port:
205         mutex_unlock(&port_mutex);
206 out:
207         release_sock(sk);
208         return err;
209 }
210 
211 static int pn_socket_autobind(struct socket *sock)
212 {
213         struct sockaddr_pn sa;
214         int err;
215 
216         memset(&sa, 0, sizeof(sa));
217         sa.spn_family = AF_PHONET;
218         err = pn_socket_bind(sock, (struct sockaddr *)&sa,
219                                 sizeof(struct sockaddr_pn));
220         if (err != -EINVAL)
221                 return err;
222         BUG_ON(!pn_port(pn_sk(sock->sk)->sobject));
223         return 0; /* socket was already bound */
224 }
225 
226 static int pn_socket_connect(struct socket *sock, struct sockaddr *addr,
227                 int len, int flags)
228 {
229         struct sock *sk = sock->sk;
230         struct pn_sock *pn = pn_sk(sk);
231         struct sockaddr_pn *spn = (struct sockaddr_pn *)addr;
232         struct task_struct *tsk = current;
233         long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
234         int err;
235 
236         if (pn_socket_autobind(sock))
237                 return -ENOBUFS;
238         if (len < sizeof(struct sockaddr_pn))
239                 return -EINVAL;
240         if (spn->spn_family != AF_PHONET)
241                 return -EAFNOSUPPORT;
242 
243         lock_sock(sk);
244 
245         switch (sock->state) {
246         case SS_UNCONNECTED:
247                 if (sk->sk_state != TCP_CLOSE) {
248                         err = -EISCONN;
249                         goto out;
250                 }
251                 break;
252         case SS_CONNECTING:
253                 err = -EALREADY;
254                 goto out;
255         default:
256                 err = -EISCONN;
257                 goto out;
258         }
259 
260         pn->dobject = pn_sockaddr_get_object(spn);
261         pn->resource = pn_sockaddr_get_resource(spn);
262         sock->state = SS_CONNECTING;
263 
264         err = sk->sk_prot->connect(sk, addr, len);
265         if (err) {
266                 sock->state = SS_UNCONNECTED;
267                 pn->dobject = 0;
268                 goto out;
269         }
270 
271         while (sk->sk_state == TCP_SYN_SENT) {
272                 DEFINE_WAIT(wait);
273 
274                 if (!timeo) {
275                         err = -EINPROGRESS;
276                         goto out;
277                 }
278                 if (signal_pending(tsk)) {
279                         err = sock_intr_errno(timeo);
280                         goto out;
281                 }
282 
283                 prepare_to_wait_exclusive(sk_sleep(sk), &wait,
284                                                 TASK_INTERRUPTIBLE);
285                 release_sock(sk);
286                 timeo = schedule_timeout(timeo);
287                 lock_sock(sk);
288                 finish_wait(sk_sleep(sk), &wait);
289         }
290 
291         if ((1 << sk->sk_state) & (TCPF_SYN_RECV|TCPF_ESTABLISHED))
292                 err = 0;
293         else if (sk->sk_state == TCP_CLOSE_WAIT)
294                 err = -ECONNRESET;
295         else
296                 err = -ECONNREFUSED;
297         sock->state = err ? SS_UNCONNECTED : SS_CONNECTED;
298 out:
299         release_sock(sk);
300         return err;
301 }
302 
303 static int pn_socket_accept(struct socket *sock, struct socket *newsock,
304                                 int flags)
305 {
306         struct sock *sk = sock->sk;
307         struct sock *newsk;
308         int err;
309 
310         if (unlikely(sk->sk_state != TCP_LISTEN))
311                 return -EINVAL;
312 
313         newsk = sk->sk_prot->accept(sk, flags, &err);
314         if (!newsk)
315                 return err;
316 
317         lock_sock(newsk);
318         sock_graft(newsk, newsock);
319         newsock->state = SS_CONNECTED;
320         release_sock(newsk);
321         return 0;
322 }
323 
324 static int pn_socket_getname(struct socket *sock, struct sockaddr *addr,
325                                 int *sockaddr_len, int peer)
326 {
327         struct sock *sk = sock->sk;
328         struct pn_sock *pn = pn_sk(sk);
329 
330         memset(addr, 0, sizeof(struct sockaddr_pn));
331         addr->sa_family = AF_PHONET;
332         if (!peer) /* Race with bind() here is userland's problem. */
333                 pn_sockaddr_set_object((struct sockaddr_pn *)addr,
334                                         pn->sobject);
335 
336         *sockaddr_len = sizeof(struct sockaddr_pn);
337         return 0;
338 }
339 
340 static unsigned int pn_socket_poll(struct file *file, struct socket *sock,
341                                         poll_table *wait)
342 {
343         struct sock *sk = sock->sk;
344         struct pep_sock *pn = pep_sk(sk);
345         unsigned int mask = 0;
346 
347         poll_wait(file, sk_sleep(sk), wait);
348 
349         if (sk->sk_state == TCP_CLOSE)
350                 return POLLERR;
351         if (!skb_queue_empty(&sk->sk_receive_queue))
352                 mask |= POLLIN | POLLRDNORM;
353         if (!skb_queue_empty(&pn->ctrlreq_queue))
354                 mask |= POLLPRI;
355         if (!mask && sk->sk_state == TCP_CLOSE_WAIT)
356                 return POLLHUP;
357 
358         if (sk->sk_state == TCP_ESTABLISHED &&
359                 atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf &&
360                 atomic_read(&pn->tx_credits))
361                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
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 kiocb *iocb, struct socket *sock,
429                                 struct msghdr *m, 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(iocb, 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           = datagram_poll,
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           = pn_socket_poll,
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                         atomic_read(&sk->sk_refcnt), sk,
614                         atomic_read(&sk->sk_drops));
615         }
616         seq_pad(seq, '\n');
617         return 0;
618 }
619 
620 static 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 
627 static int pn_sock_open(struct inode *inode, struct file *file)
628 {
629         return seq_open_net(inode, file, &pn_sock_seq_ops,
630                                 sizeof(struct seq_net_private));
631 }
632 
633 const struct file_operations pn_sock_seq_fops = {
634         .owner = THIS_MODULE,
635         .open = pn_sock_open,
636         .read = seq_read,
637         .llseek = seq_lseek,
638         .release = seq_release_net,
639 };
640 #endif
641 
642 static struct  {
643         struct sock *sk[256];
644 } pnres;
645 
646 /*
647  * Find and hold socket based on resource.
648  */
649 struct sock *pn_find_sock_by_res(struct net *net, u8 res)
650 {
651         struct sock *sk;
652 
653         if (!net_eq(net, &init_net))
654                 return NULL;
655 
656         rcu_read_lock();
657         sk = rcu_dereference(pnres.sk[res]);
658         if (sk)
659                 sock_hold(sk);
660         rcu_read_unlock();
661         return sk;
662 }
663 
664 static DEFINE_MUTEX(resource_mutex);
665 
666 int pn_sock_bind_res(struct sock *sk, u8 res)
667 {
668         int ret = -EADDRINUSE;
669 
670         if (!net_eq(sock_net(sk), &init_net))
671                 return -ENOIOCTLCMD;
672         if (!capable(CAP_SYS_ADMIN))
673                 return -EPERM;
674         if (pn_socket_autobind(sk->sk_socket))
675                 return -EAGAIN;
676 
677         mutex_lock(&resource_mutex);
678         if (pnres.sk[res] == NULL) {
679                 sock_hold(sk);
680                 rcu_assign_pointer(pnres.sk[res], sk);
681                 ret = 0;
682         }
683         mutex_unlock(&resource_mutex);
684         return ret;
685 }
686 
687 int pn_sock_unbind_res(struct sock *sk, u8 res)
688 {
689         int ret = -ENOENT;
690 
691         if (!capable(CAP_SYS_ADMIN))
692                 return -EPERM;
693 
694         mutex_lock(&resource_mutex);
695         if (pnres.sk[res] == sk) {
696                 RCU_INIT_POINTER(pnres.sk[res], NULL);
697                 ret = 0;
698         }
699         mutex_unlock(&resource_mutex);
700 
701         if (ret == 0) {
702                 synchronize_rcu();
703                 sock_put(sk);
704         }
705         return ret;
706 }
707 
708 void pn_sock_unbind_all_res(struct sock *sk)
709 {
710         unsigned int res, match = 0;
711 
712         mutex_lock(&resource_mutex);
713         for (res = 0; res < 256; res++) {
714                 if (pnres.sk[res] == sk) {
715                         RCU_INIT_POINTER(pnres.sk[res], NULL);
716                         match++;
717                 }
718         }
719         mutex_unlock(&resource_mutex);
720 
721         while (match > 0) {
722                 __sock_put(sk);
723                 match--;
724         }
725         /* Caller is responsible for RCU sync before final sock_put() */
726 }
727 
728 #ifdef CONFIG_PROC_FS
729 static struct sock **pn_res_get_idx(struct seq_file *seq, loff_t pos)
730 {
731         struct net *net = seq_file_net(seq);
732         unsigned int i;
733 
734         if (!net_eq(net, &init_net))
735                 return NULL;
736 
737         for (i = 0; i < 256; i++) {
738                 if (pnres.sk[i] == NULL)
739                         continue;
740                 if (!pos)
741                         return pnres.sk + i;
742                 pos--;
743         }
744         return NULL;
745 }
746 
747 static struct sock **pn_res_get_next(struct seq_file *seq, struct sock **sk)
748 {
749         struct net *net = seq_file_net(seq);
750         unsigned int i;
751 
752         BUG_ON(!net_eq(net, &init_net));
753 
754         for (i = (sk - pnres.sk) + 1; i < 256; i++)
755                 if (pnres.sk[i])
756                         return pnres.sk + i;
757         return NULL;
758 }
759 
760 static void *pn_res_seq_start(struct seq_file *seq, loff_t *pos)
761         __acquires(resource_mutex)
762 {
763         mutex_lock(&resource_mutex);
764         return *pos ? pn_res_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
765 }
766 
767 static void *pn_res_seq_next(struct seq_file *seq, void *v, loff_t *pos)
768 {
769         struct sock **sk;
770 
771         if (v == SEQ_START_TOKEN)
772                 sk = pn_res_get_idx(seq, 0);
773         else
774                 sk = pn_res_get_next(seq, v);
775         (*pos)++;
776         return sk;
777 }
778 
779 static void pn_res_seq_stop(struct seq_file *seq, void *v)
780         __releases(resource_mutex)
781 {
782         mutex_unlock(&resource_mutex);
783 }
784 
785 static int pn_res_seq_show(struct seq_file *seq, void *v)
786 {
787         seq_setwidth(seq, 63);
788         if (v == SEQ_START_TOKEN)
789                 seq_puts(seq, "rs   uid inode");
790         else {
791                 struct sock **psk = v;
792                 struct sock *sk = *psk;
793 
794                 seq_printf(seq, "%02X %5u %lu",
795                            (int) (psk - pnres.sk),
796                            from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
797                            sock_i_ino(sk));
798         }
799         seq_pad(seq, '\n');
800         return 0;
801 }
802 
803 static const struct seq_operations pn_res_seq_ops = {
804         .start = pn_res_seq_start,
805         .next = pn_res_seq_next,
806         .stop = pn_res_seq_stop,
807         .show = pn_res_seq_show,
808 };
809 
810 static int pn_res_open(struct inode *inode, struct file *file)
811 {
812         return seq_open_net(inode, file, &pn_res_seq_ops,
813                                 sizeof(struct seq_net_private));
814 }
815 
816 const struct file_operations pn_res_seq_fops = {
817         .owner = THIS_MODULE,
818         .open = pn_res_open,
819         .read = seq_read,
820         .llseek = seq_lseek,
821         .release = seq_release_net,
822 };
823 #endif
824 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp