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

TOMOYO Linux Cross Reference
Linux/net/bluetooth/af_bluetooth.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ 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.75 ] ~ [ 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-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ 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    BlueZ - Bluetooth protocol stack for Linux
  3    Copyright (C) 2000-2001 Qualcomm Incorporated
  4 
  5    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
  6 
  7    This program is free software; you can redistribute it and/or modify
  8    it under the terms of the GNU General Public License version 2 as
  9    published by the Free Software Foundation;
 10 
 11    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 12    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 13    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
 14    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
 15    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
 16    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 17    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 18    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 19 
 20    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
 21    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
 22    SOFTWARE IS DISCLAIMED.
 23 */
 24 
 25 /* Bluetooth address family and sockets. */
 26 
 27 #include <linux/module.h>
 28 #include <linux/debugfs.h>
 29 #include <asm/ioctls.h>
 30 
 31 #include <net/bluetooth/bluetooth.h>
 32 #include <linux/proc_fs.h>
 33 
 34 #include "selftest.h"
 35 
 36 #define VERSION "2.20"
 37 
 38 /* Bluetooth sockets */
 39 #define BT_MAX_PROTO    8
 40 static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
 41 static DEFINE_RWLOCK(bt_proto_lock);
 42 
 43 static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
 44 static const char *const bt_key_strings[BT_MAX_PROTO] = {
 45         "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
 46         "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
 47         "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
 48         "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
 49         "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
 50         "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
 51         "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
 52         "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
 53 };
 54 
 55 static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
 56 static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
 57         "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
 58         "slock-AF_BLUETOOTH-BTPROTO_HCI",
 59         "slock-AF_BLUETOOTH-BTPROTO_SCO",
 60         "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
 61         "slock-AF_BLUETOOTH-BTPROTO_BNEP",
 62         "slock-AF_BLUETOOTH-BTPROTO_CMTP",
 63         "slock-AF_BLUETOOTH-BTPROTO_HIDP",
 64         "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
 65 };
 66 
 67 void bt_sock_reclassify_lock(struct sock *sk, int proto)
 68 {
 69         BUG_ON(!sk);
 70         BUG_ON(sock_owned_by_user(sk));
 71 
 72         sock_lock_init_class_and_name(sk,
 73                         bt_slock_key_strings[proto], &bt_slock_key[proto],
 74                                 bt_key_strings[proto], &bt_lock_key[proto]);
 75 }
 76 EXPORT_SYMBOL(bt_sock_reclassify_lock);
 77 
 78 int bt_sock_register(int proto, const struct net_proto_family *ops)
 79 {
 80         int err = 0;
 81 
 82         if (proto < 0 || proto >= BT_MAX_PROTO)
 83                 return -EINVAL;
 84 
 85         write_lock(&bt_proto_lock);
 86 
 87         if (bt_proto[proto])
 88                 err = -EEXIST;
 89         else
 90                 bt_proto[proto] = ops;
 91 
 92         write_unlock(&bt_proto_lock);
 93 
 94         return err;
 95 }
 96 EXPORT_SYMBOL(bt_sock_register);
 97 
 98 void bt_sock_unregister(int proto)
 99 {
100         if (proto < 0 || proto >= BT_MAX_PROTO)
101                 return;
102 
103         write_lock(&bt_proto_lock);
104         bt_proto[proto] = NULL;
105         write_unlock(&bt_proto_lock);
106 }
107 EXPORT_SYMBOL(bt_sock_unregister);
108 
109 static int bt_sock_create(struct net *net, struct socket *sock, int proto,
110                           int kern)
111 {
112         int err;
113 
114         if (net != &init_net)
115                 return -EAFNOSUPPORT;
116 
117         if (proto < 0 || proto >= BT_MAX_PROTO)
118                 return -EINVAL;
119 
120         if (!bt_proto[proto])
121                 request_module("bt-proto-%d", proto);
122 
123         err = -EPROTONOSUPPORT;
124 
125         read_lock(&bt_proto_lock);
126 
127         if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
128                 err = bt_proto[proto]->create(net, sock, proto, kern);
129                 if (!err)
130                         bt_sock_reclassify_lock(sock->sk, proto);
131                 module_put(bt_proto[proto]->owner);
132         }
133 
134         read_unlock(&bt_proto_lock);
135 
136         return err;
137 }
138 
139 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
140 {
141         write_lock(&l->lock);
142         sk_add_node(sk, &l->head);
143         write_unlock(&l->lock);
144 }
145 EXPORT_SYMBOL(bt_sock_link);
146 
147 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
148 {
149         write_lock(&l->lock);
150         sk_del_node_init(sk);
151         write_unlock(&l->lock);
152 }
153 EXPORT_SYMBOL(bt_sock_unlink);
154 
155 void bt_accept_enqueue(struct sock *parent, struct sock *sk)
156 {
157         BT_DBG("parent %p, sk %p", parent, sk);
158 
159         sock_hold(sk);
160         list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
161         bt_sk(sk)->parent = parent;
162         parent->sk_ack_backlog++;
163 }
164 EXPORT_SYMBOL(bt_accept_enqueue);
165 
166 void bt_accept_unlink(struct sock *sk)
167 {
168         BT_DBG("sk %p state %d", sk, sk->sk_state);
169 
170         list_del_init(&bt_sk(sk)->accept_q);
171         bt_sk(sk)->parent->sk_ack_backlog--;
172         bt_sk(sk)->parent = NULL;
173         sock_put(sk);
174 }
175 EXPORT_SYMBOL(bt_accept_unlink);
176 
177 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
178 {
179         struct list_head *p, *n;
180         struct sock *sk;
181 
182         BT_DBG("parent %p", parent);
183 
184         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
185                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
186 
187                 lock_sock(sk);
188 
189                 /* FIXME: Is this check still needed */
190                 if (sk->sk_state == BT_CLOSED) {
191                         release_sock(sk);
192                         bt_accept_unlink(sk);
193                         continue;
194                 }
195 
196                 if (sk->sk_state == BT_CONNECTED || !newsock ||
197                     test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
198                         bt_accept_unlink(sk);
199                         if (newsock)
200                                 sock_graft(sk, newsock);
201 
202                         release_sock(sk);
203                         return sk;
204                 }
205 
206                 release_sock(sk);
207         }
208 
209         return NULL;
210 }
211 EXPORT_SYMBOL(bt_accept_dequeue);
212 
213 int bt_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
214                     int flags)
215 {
216         int noblock = flags & MSG_DONTWAIT;
217         struct sock *sk = sock->sk;
218         struct sk_buff *skb;
219         size_t copied;
220         int err;
221 
222         BT_DBG("sock %p sk %p len %zu", sock, sk, len);
223 
224         if (flags & (MSG_OOB))
225                 return -EOPNOTSUPP;
226 
227         skb = skb_recv_datagram(sk, flags, noblock, &err);
228         if (!skb) {
229                 if (sk->sk_shutdown & RCV_SHUTDOWN)
230                         return 0;
231 
232                 return err;
233         }
234 
235         copied = skb->len;
236         if (len < copied) {
237                 msg->msg_flags |= MSG_TRUNC;
238                 copied = len;
239         }
240 
241         skb_reset_transport_header(skb);
242         err = skb_copy_datagram_msg(skb, 0, msg, copied);
243         if (err == 0) {
244                 sock_recv_ts_and_drops(msg, sk, skb);
245 
246                 if (bt_sk(sk)->skb_msg_name)
247                         bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
248                                                 &msg->msg_namelen);
249         }
250 
251         skb_free_datagram(sk, skb);
252 
253         return err ? : copied;
254 }
255 EXPORT_SYMBOL(bt_sock_recvmsg);
256 
257 static long bt_sock_data_wait(struct sock *sk, long timeo)
258 {
259         DECLARE_WAITQUEUE(wait, current);
260 
261         add_wait_queue(sk_sleep(sk), &wait);
262         for (;;) {
263                 set_current_state(TASK_INTERRUPTIBLE);
264 
265                 if (!skb_queue_empty(&sk->sk_receive_queue))
266                         break;
267 
268                 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
269                         break;
270 
271                 if (signal_pending(current) || !timeo)
272                         break;
273 
274                 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
275                 release_sock(sk);
276                 timeo = schedule_timeout(timeo);
277                 lock_sock(sk);
278                 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
279         }
280 
281         __set_current_state(TASK_RUNNING);
282         remove_wait_queue(sk_sleep(sk), &wait);
283         return timeo;
284 }
285 
286 int bt_sock_stream_recvmsg(struct socket *sock, struct msghdr *msg,
287                            size_t size, int flags)
288 {
289         struct sock *sk = sock->sk;
290         int err = 0;
291         size_t target, copied = 0;
292         long timeo;
293 
294         if (flags & MSG_OOB)
295                 return -EOPNOTSUPP;
296 
297         BT_DBG("sk %p size %zu", sk, size);
298 
299         lock_sock(sk);
300 
301         target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
302         timeo  = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
303 
304         do {
305                 struct sk_buff *skb;
306                 int chunk;
307 
308                 skb = skb_dequeue(&sk->sk_receive_queue);
309                 if (!skb) {
310                         if (copied >= target)
311                                 break;
312 
313                         err = sock_error(sk);
314                         if (err)
315                                 break;
316                         if (sk->sk_shutdown & RCV_SHUTDOWN)
317                                 break;
318 
319                         err = -EAGAIN;
320                         if (!timeo)
321                                 break;
322 
323                         timeo = bt_sock_data_wait(sk, timeo);
324 
325                         if (signal_pending(current)) {
326                                 err = sock_intr_errno(timeo);
327                                 goto out;
328                         }
329                         continue;
330                 }
331 
332                 chunk = min_t(unsigned int, skb->len, size);
333                 if (skb_copy_datagram_msg(skb, 0, msg, chunk)) {
334                         skb_queue_head(&sk->sk_receive_queue, skb);
335                         if (!copied)
336                                 copied = -EFAULT;
337                         break;
338                 }
339                 copied += chunk;
340                 size   -= chunk;
341 
342                 sock_recv_ts_and_drops(msg, sk, skb);
343 
344                 if (!(flags & MSG_PEEK)) {
345                         int skb_len = skb_headlen(skb);
346 
347                         if (chunk <= skb_len) {
348                                 __skb_pull(skb, chunk);
349                         } else {
350                                 struct sk_buff *frag;
351 
352                                 __skb_pull(skb, skb_len);
353                                 chunk -= skb_len;
354 
355                                 skb_walk_frags(skb, frag) {
356                                         if (chunk <= frag->len) {
357                                                 /* Pulling partial data */
358                                                 skb->len -= chunk;
359                                                 skb->data_len -= chunk;
360                                                 __skb_pull(frag, chunk);
361                                                 break;
362                                         } else if (frag->len) {
363                                                 /* Pulling all frag data */
364                                                 chunk -= frag->len;
365                                                 skb->len -= frag->len;
366                                                 skb->data_len -= frag->len;
367                                                 __skb_pull(frag, frag->len);
368                                         }
369                                 }
370                         }
371 
372                         if (skb->len) {
373                                 skb_queue_head(&sk->sk_receive_queue, skb);
374                                 break;
375                         }
376                         kfree_skb(skb);
377 
378                 } else {
379                         /* put message back and return */
380                         skb_queue_head(&sk->sk_receive_queue, skb);
381                         break;
382                 }
383         } while (size);
384 
385 out:
386         release_sock(sk);
387         return copied ? : err;
388 }
389 EXPORT_SYMBOL(bt_sock_stream_recvmsg);
390 
391 static inline unsigned int bt_accept_poll(struct sock *parent)
392 {
393         struct list_head *p, *n;
394         struct sock *sk;
395 
396         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
397                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
398                 if (sk->sk_state == BT_CONNECTED ||
399                     (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
400                      sk->sk_state == BT_CONNECT2))
401                         return POLLIN | POLLRDNORM;
402         }
403 
404         return 0;
405 }
406 
407 unsigned int bt_sock_poll(struct file *file, struct socket *sock,
408                           poll_table *wait)
409 {
410         struct sock *sk = sock->sk;
411         unsigned int mask = 0;
412 
413         BT_DBG("sock %p, sk %p", sock, sk);
414 
415         poll_wait(file, sk_sleep(sk), wait);
416 
417         if (sk->sk_state == BT_LISTEN)
418                 return bt_accept_poll(sk);
419 
420         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
421                 mask |= POLLERR |
422                         (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
423 
424         if (sk->sk_shutdown & RCV_SHUTDOWN)
425                 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
426 
427         if (sk->sk_shutdown == SHUTDOWN_MASK)
428                 mask |= POLLHUP;
429 
430         if (!skb_queue_empty(&sk->sk_receive_queue))
431                 mask |= POLLIN | POLLRDNORM;
432 
433         if (sk->sk_state == BT_CLOSED)
434                 mask |= POLLHUP;
435 
436         if (sk->sk_state == BT_CONNECT ||
437                         sk->sk_state == BT_CONNECT2 ||
438                         sk->sk_state == BT_CONFIG)
439                 return mask;
440 
441         if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
442                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
443         else
444                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
445 
446         return mask;
447 }
448 EXPORT_SYMBOL(bt_sock_poll);
449 
450 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
451 {
452         struct sock *sk = sock->sk;
453         struct sk_buff *skb;
454         long amount;
455         int err;
456 
457         BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
458 
459         switch (cmd) {
460         case TIOCOUTQ:
461                 if (sk->sk_state == BT_LISTEN)
462                         return -EINVAL;
463 
464                 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
465                 if (amount < 0)
466                         amount = 0;
467                 err = put_user(amount, (int __user *) arg);
468                 break;
469 
470         case TIOCINQ:
471                 if (sk->sk_state == BT_LISTEN)
472                         return -EINVAL;
473 
474                 lock_sock(sk);
475                 skb = skb_peek(&sk->sk_receive_queue);
476                 amount = skb ? skb->len : 0;
477                 release_sock(sk);
478                 err = put_user(amount, (int __user *) arg);
479                 break;
480 
481         case SIOCGSTAMP:
482                 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
483                 break;
484 
485         case SIOCGSTAMPNS:
486                 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
487                 break;
488 
489         default:
490                 err = -ENOIOCTLCMD;
491                 break;
492         }
493 
494         return err;
495 }
496 EXPORT_SYMBOL(bt_sock_ioctl);
497 
498 /* This function expects the sk lock to be held when called */
499 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
500 {
501         DECLARE_WAITQUEUE(wait, current);
502         int err = 0;
503 
504         BT_DBG("sk %p", sk);
505 
506         add_wait_queue(sk_sleep(sk), &wait);
507         set_current_state(TASK_INTERRUPTIBLE);
508         while (sk->sk_state != state) {
509                 if (!timeo) {
510                         err = -EINPROGRESS;
511                         break;
512                 }
513 
514                 if (signal_pending(current)) {
515                         err = sock_intr_errno(timeo);
516                         break;
517                 }
518 
519                 release_sock(sk);
520                 timeo = schedule_timeout(timeo);
521                 lock_sock(sk);
522                 set_current_state(TASK_INTERRUPTIBLE);
523 
524                 err = sock_error(sk);
525                 if (err)
526                         break;
527         }
528         __set_current_state(TASK_RUNNING);
529         remove_wait_queue(sk_sleep(sk), &wait);
530         return err;
531 }
532 EXPORT_SYMBOL(bt_sock_wait_state);
533 
534 /* This function expects the sk lock to be held when called */
535 int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
536 {
537         DECLARE_WAITQUEUE(wait, current);
538         unsigned long timeo;
539         int err = 0;
540 
541         BT_DBG("sk %p", sk);
542 
543         timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
544 
545         add_wait_queue(sk_sleep(sk), &wait);
546         set_current_state(TASK_INTERRUPTIBLE);
547         while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
548                 if (!timeo) {
549                         err = -EAGAIN;
550                         break;
551                 }
552 
553                 if (signal_pending(current)) {
554                         err = sock_intr_errno(timeo);
555                         break;
556                 }
557 
558                 release_sock(sk);
559                 timeo = schedule_timeout(timeo);
560                 lock_sock(sk);
561                 set_current_state(TASK_INTERRUPTIBLE);
562 
563                 err = sock_error(sk);
564                 if (err)
565                         break;
566         }
567         __set_current_state(TASK_RUNNING);
568         remove_wait_queue(sk_sleep(sk), &wait);
569 
570         return err;
571 }
572 EXPORT_SYMBOL(bt_sock_wait_ready);
573 
574 #ifdef CONFIG_PROC_FS
575 struct bt_seq_state {
576         struct bt_sock_list *l;
577 };
578 
579 static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
580         __acquires(seq->private->l->lock)
581 {
582         struct bt_seq_state *s = seq->private;
583         struct bt_sock_list *l = s->l;
584 
585         read_lock(&l->lock);
586         return seq_hlist_start_head(&l->head, *pos);
587 }
588 
589 static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
590 {
591         struct bt_seq_state *s = seq->private;
592         struct bt_sock_list *l = s->l;
593 
594         return seq_hlist_next(v, &l->head, pos);
595 }
596 
597 static void bt_seq_stop(struct seq_file *seq, void *v)
598         __releases(seq->private->l->lock)
599 {
600         struct bt_seq_state *s = seq->private;
601         struct bt_sock_list *l = s->l;
602 
603         read_unlock(&l->lock);
604 }
605 
606 static int bt_seq_show(struct seq_file *seq, void *v)
607 {
608         struct bt_seq_state *s = seq->private;
609         struct bt_sock_list *l = s->l;
610 
611         if (v == SEQ_START_TOKEN) {
612                 seq_puts(seq ,"sk               RefCnt Rmem   Wmem   User   Inode  Parent");
613 
614                 if (l->custom_seq_show) {
615                         seq_putc(seq, ' ');
616                         l->custom_seq_show(seq, v);
617                 }
618 
619                 seq_putc(seq, '\n');
620         } else {
621                 struct sock *sk = sk_entry(v);
622                 struct bt_sock *bt = bt_sk(sk);
623 
624                 seq_printf(seq,
625                            "%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
626                            sk,
627                            atomic_read(&sk->sk_refcnt),
628                            sk_rmem_alloc_get(sk),
629                            sk_wmem_alloc_get(sk),
630                            from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
631                            sock_i_ino(sk),
632                            bt->parent? sock_i_ino(bt->parent): 0LU);
633 
634                 if (l->custom_seq_show) {
635                         seq_putc(seq, ' ');
636                         l->custom_seq_show(seq, v);
637                 }
638 
639                 seq_putc(seq, '\n');
640         }
641         return 0;
642 }
643 
644 static const struct seq_operations bt_seq_ops = {
645         .start = bt_seq_start,
646         .next  = bt_seq_next,
647         .stop  = bt_seq_stop,
648         .show  = bt_seq_show,
649 };
650 
651 static int bt_seq_open(struct inode *inode, struct file *file)
652 {
653         struct bt_sock_list *sk_list;
654         struct bt_seq_state *s;
655 
656         sk_list = PDE_DATA(inode);
657         s = __seq_open_private(file, &bt_seq_ops,
658                                sizeof(struct bt_seq_state));
659         if (!s)
660                 return -ENOMEM;
661 
662         s->l = sk_list;
663         return 0;
664 }
665 
666 static const struct file_operations bt_fops = {
667         .open = bt_seq_open,
668         .read = seq_read,
669         .llseek = seq_lseek,
670         .release = seq_release_private
671 };
672 
673 int bt_procfs_init(struct net *net, const char *name,
674                    struct bt_sock_list* sk_list,
675                    int (* seq_show)(struct seq_file *, void *))
676 {
677         sk_list->custom_seq_show = seq_show;
678 
679         if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
680                 return -ENOMEM;
681         return 0;
682 }
683 
684 void bt_procfs_cleanup(struct net *net, const char *name)
685 {
686         remove_proc_entry(name, net->proc_net);
687 }
688 #else
689 int bt_procfs_init(struct net *net, const char *name,
690                    struct bt_sock_list* sk_list,
691                    int (* seq_show)(struct seq_file *, void *))
692 {
693         return 0;
694 }
695 
696 void bt_procfs_cleanup(struct net *net, const char *name)
697 {
698 }
699 #endif
700 EXPORT_SYMBOL(bt_procfs_init);
701 EXPORT_SYMBOL(bt_procfs_cleanup);
702 
703 static struct net_proto_family bt_sock_family_ops = {
704         .owner  = THIS_MODULE,
705         .family = PF_BLUETOOTH,
706         .create = bt_sock_create,
707 };
708 
709 struct dentry *bt_debugfs;
710 EXPORT_SYMBOL_GPL(bt_debugfs);
711 
712 static int __init bt_init(void)
713 {
714         int err;
715 
716         sock_skb_cb_check_size(sizeof(struct bt_skb_cb));
717 
718         BT_INFO("Core ver %s", VERSION);
719 
720         err = bt_selftest();
721         if (err < 0)
722                 return err;
723 
724         bt_debugfs = debugfs_create_dir("bluetooth", NULL);
725 
726         err = bt_sysfs_init();
727         if (err < 0)
728                 return err;
729 
730         err = sock_register(&bt_sock_family_ops);
731         if (err < 0) {
732                 bt_sysfs_cleanup();
733                 return err;
734         }
735 
736         BT_INFO("HCI device and connection manager initialized");
737 
738         err = hci_sock_init();
739         if (err < 0)
740                 goto error;
741 
742         err = l2cap_init();
743         if (err < 0)
744                 goto sock_err;
745 
746         err = sco_init();
747         if (err < 0) {
748                 l2cap_exit();
749                 goto sock_err;
750         }
751 
752         err = mgmt_init();
753         if (err < 0) {
754                 sco_exit();
755                 l2cap_exit();
756                 goto sock_err;
757         }
758 
759         return 0;
760 
761 sock_err:
762         hci_sock_cleanup();
763 
764 error:
765         sock_unregister(PF_BLUETOOTH);
766         bt_sysfs_cleanup();
767 
768         return err;
769 }
770 
771 static void __exit bt_exit(void)
772 {
773         mgmt_exit();
774 
775         sco_exit();
776 
777         l2cap_exit();
778 
779         hci_sock_cleanup();
780 
781         sock_unregister(PF_BLUETOOTH);
782 
783         bt_sysfs_cleanup();
784 
785         debugfs_remove_recursive(bt_debugfs);
786 }
787 
788 subsys_initcall(bt_init);
789 module_exit(bt_exit);
790 
791 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
792 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
793 MODULE_VERSION(VERSION);
794 MODULE_LICENSE("GPL");
795 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);
796 

~ [ 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