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 <linux/stringify.h>
30 #include <linux/sched/signal.h>
31
32 #include <asm/ioctls.h>
33
34 #include <net/bluetooth/bluetooth.h>
35 #include <linux/proc_fs.h>
36
37 #include "leds.h"
38 #include "selftest.h"
39
40 /* Bluetooth sockets */
41 #define BT_MAX_PROTO 8
42 static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
43 static DEFINE_RWLOCK(bt_proto_lock);
44
45 static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
46 static const char *const bt_key_strings[BT_MAX_PROTO] = {
47 "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
48 "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
49 "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
50 "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
51 "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
52 "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
53 "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
54 "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
55 };
56
57 static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
58 static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
59 "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
60 "slock-AF_BLUETOOTH-BTPROTO_HCI",
61 "slock-AF_BLUETOOTH-BTPROTO_SCO",
62 "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
63 "slock-AF_BLUETOOTH-BTPROTO_BNEP",
64 "slock-AF_BLUETOOTH-BTPROTO_CMTP",
65 "slock-AF_BLUETOOTH-BTPROTO_HIDP",
66 "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
67 };
68
bt_sock_reclassify_lock(struct sock * sk,int proto)69 void bt_sock_reclassify_lock(struct sock *sk, int proto)
70 {
71 BUG_ON(!sk);
72 BUG_ON(!sock_allow_reclassification(sk));
73
74 sock_lock_init_class_and_name(sk,
75 bt_slock_key_strings[proto], &bt_slock_key[proto],
76 bt_key_strings[proto], &bt_lock_key[proto]);
77 }
78 EXPORT_SYMBOL(bt_sock_reclassify_lock);
79
bt_sock_register(int proto,const struct net_proto_family * ops)80 int bt_sock_register(int proto, const struct net_proto_family *ops)
81 {
82 int err = 0;
83
84 if (proto < 0 || proto >= BT_MAX_PROTO)
85 return -EINVAL;
86
87 write_lock(&bt_proto_lock);
88
89 if (bt_proto[proto])
90 err = -EEXIST;
91 else
92 bt_proto[proto] = ops;
93
94 write_unlock(&bt_proto_lock);
95
96 return err;
97 }
98 EXPORT_SYMBOL(bt_sock_register);
99
bt_sock_unregister(int proto)100 void bt_sock_unregister(int proto)
101 {
102 if (proto < 0 || proto >= BT_MAX_PROTO)
103 return;
104
105 write_lock(&bt_proto_lock);
106 bt_proto[proto] = NULL;
107 write_unlock(&bt_proto_lock);
108 }
109 EXPORT_SYMBOL(bt_sock_unregister);
110
111 #ifdef CONFIG_PARANOID_NETWORK
current_has_bt_admin(void)112 static inline int current_has_bt_admin(void)
113 {
114 return !current_euid();
115 }
116
current_has_bt(void)117 static inline int current_has_bt(void)
118 {
119 return current_has_bt_admin();
120 }
121 # else
current_has_bt_admin(void)122 static inline int current_has_bt_admin(void)
123 {
124 return 1;
125 }
126
current_has_bt(void)127 static inline int current_has_bt(void)
128 {
129 return 1;
130 }
131 #endif
132
bt_sock_create(struct net * net,struct socket * sock,int proto,int kern)133 static int bt_sock_create(struct net *net, struct socket *sock, int proto,
134 int kern)
135 {
136 int err;
137
138 if (proto == BTPROTO_RFCOMM || proto == BTPROTO_SCO ||
139 proto == BTPROTO_L2CAP) {
140 if (!current_has_bt())
141 return -EPERM;
142 } else if (!current_has_bt_admin())
143 return -EPERM;
144
145 if (net != &init_net)
146 return -EAFNOSUPPORT;
147
148 if (proto < 0 || proto >= BT_MAX_PROTO)
149 return -EINVAL;
150
151 if (!bt_proto[proto])
152 request_module("bt-proto-%d", proto);
153
154 err = -EPROTONOSUPPORT;
155
156 read_lock(&bt_proto_lock);
157
158 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
159 err = bt_proto[proto]->create(net, sock, proto, kern);
160 if (!err)
161 bt_sock_reclassify_lock(sock->sk, proto);
162 module_put(bt_proto[proto]->owner);
163 }
164
165 read_unlock(&bt_proto_lock);
166
167 return err;
168 }
169
bt_sock_link(struct bt_sock_list * l,struct sock * sk)170 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
171 {
172 write_lock(&l->lock);
173 sk_add_node(sk, &l->head);
174 write_unlock(&l->lock);
175 }
176 EXPORT_SYMBOL(bt_sock_link);
177
bt_sock_unlink(struct bt_sock_list * l,struct sock * sk)178 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
179 {
180 write_lock(&l->lock);
181 sk_del_node_init(sk);
182 write_unlock(&l->lock);
183 }
184 EXPORT_SYMBOL(bt_sock_unlink);
185
bt_accept_enqueue(struct sock * parent,struct sock * sk,bool bh)186 void bt_accept_enqueue(struct sock *parent, struct sock *sk, bool bh)
187 {
188 BT_DBG("parent %p, sk %p", parent, sk);
189
190 sock_hold(sk);
191
192 if (bh)
193 bh_lock_sock_nested(sk);
194 else
195 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
196
197 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
198 bt_sk(sk)->parent = parent;
199
200 if (bh)
201 bh_unlock_sock(sk);
202 else
203 release_sock(sk);
204
205 parent->sk_ack_backlog++;
206 }
207 EXPORT_SYMBOL(bt_accept_enqueue);
208
209 /* Calling function must hold the sk lock.
210 * bt_sk(sk)->parent must be non-NULL meaning sk is in the parent list.
211 */
bt_accept_unlink(struct sock * sk)212 void bt_accept_unlink(struct sock *sk)
213 {
214 BT_DBG("sk %p state %d", sk, sk->sk_state);
215
216 list_del_init(&bt_sk(sk)->accept_q);
217 bt_sk(sk)->parent->sk_ack_backlog--;
218 bt_sk(sk)->parent = NULL;
219 sock_put(sk);
220 }
221 EXPORT_SYMBOL(bt_accept_unlink);
222
bt_accept_dequeue(struct sock * parent,struct socket * newsock)223 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
224 {
225 struct bt_sock *s, *n;
226 struct sock *sk;
227
228 BT_DBG("parent %p", parent);
229
230 restart:
231 list_for_each_entry_safe(s, n, &bt_sk(parent)->accept_q, accept_q) {
232 sk = (struct sock *)s;
233
234 /* Prevent early freeing of sk due to unlink and sock_kill */
235 sock_hold(sk);
236 lock_sock(sk);
237
238 /* Check sk has not already been unlinked via
239 * bt_accept_unlink() due to serialisation caused by sk locking
240 */
241 if (!bt_sk(sk)->parent) {
242 BT_DBG("sk %p, already unlinked", sk);
243 release_sock(sk);
244 sock_put(sk);
245
246 /* Restart the loop as sk is no longer in the list
247 * and also avoid a potential infinite loop because
248 * list_for_each_entry_safe() is not thread safe.
249 */
250 goto restart;
251 }
252
253 /* sk is safely in the parent list so reduce reference count */
254 sock_put(sk);
255
256 /* FIXME: Is this check still needed */
257 if (sk->sk_state == BT_CLOSED) {
258 bt_accept_unlink(sk);
259 release_sock(sk);
260 continue;
261 }
262
263 if (sk->sk_state == BT_CONNECTED || !newsock ||
264 test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
265 bt_accept_unlink(sk);
266 if (newsock)
267 sock_graft(sk, newsock);
268
269 release_sock(sk);
270 return sk;
271 }
272
273 release_sock(sk);
274 }
275
276 return NULL;
277 }
278 EXPORT_SYMBOL(bt_accept_dequeue);
279
bt_sock_recvmsg(struct socket * sock,struct msghdr * msg,size_t len,int flags)280 int bt_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
281 int flags)
282 {
283 int noblock = flags & MSG_DONTWAIT;
284 struct sock *sk = sock->sk;
285 struct sk_buff *skb;
286 size_t copied;
287 size_t skblen;
288 int err;
289
290 BT_DBG("sock %p sk %p len %zu", sock, sk, len);
291
292 if (flags & MSG_OOB)
293 return -EOPNOTSUPP;
294
295 skb = skb_recv_datagram(sk, flags, noblock, &err);
296 if (!skb) {
297 if (sk->sk_shutdown & RCV_SHUTDOWN)
298 return 0;
299
300 return err;
301 }
302
303 skblen = skb->len;
304 copied = skb->len;
305 if (len < copied) {
306 msg->msg_flags |= MSG_TRUNC;
307 copied = len;
308 }
309
310 skb_reset_transport_header(skb);
311 err = skb_copy_datagram_msg(skb, 0, msg, copied);
312 if (err == 0) {
313 sock_recv_ts_and_drops(msg, sk, skb);
314
315 if (msg->msg_name && bt_sk(sk)->skb_msg_name)
316 bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
317 &msg->msg_namelen);
318 }
319
320 skb_free_datagram(sk, skb);
321
322 if (flags & MSG_TRUNC)
323 copied = skblen;
324
325 return err ? : copied;
326 }
327 EXPORT_SYMBOL(bt_sock_recvmsg);
328
bt_sock_data_wait(struct sock * sk,long timeo)329 static long bt_sock_data_wait(struct sock *sk, long timeo)
330 {
331 DECLARE_WAITQUEUE(wait, current);
332
333 add_wait_queue(sk_sleep(sk), &wait);
334 for (;;) {
335 set_current_state(TASK_INTERRUPTIBLE);
336
337 if (!skb_queue_empty(&sk->sk_receive_queue))
338 break;
339
340 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
341 break;
342
343 if (signal_pending(current) || !timeo)
344 break;
345
346 sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
347 release_sock(sk);
348 timeo = schedule_timeout(timeo);
349 lock_sock(sk);
350 sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
351 }
352
353 __set_current_state(TASK_RUNNING);
354 remove_wait_queue(sk_sleep(sk), &wait);
355 return timeo;
356 }
357
bt_sock_stream_recvmsg(struct socket * sock,struct msghdr * msg,size_t size,int flags)358 int bt_sock_stream_recvmsg(struct socket *sock, struct msghdr *msg,
359 size_t size, int flags)
360 {
361 struct sock *sk = sock->sk;
362 int err = 0;
363 size_t target, copied = 0;
364 long timeo;
365
366 if (flags & MSG_OOB)
367 return -EOPNOTSUPP;
368
369 BT_DBG("sk %p size %zu", sk, size);
370
371 lock_sock(sk);
372
373 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
374 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
375
376 do {
377 struct sk_buff *skb;
378 int chunk;
379
380 skb = skb_dequeue(&sk->sk_receive_queue);
381 if (!skb) {
382 if (copied >= target)
383 break;
384
385 err = sock_error(sk);
386 if (err)
387 break;
388 if (sk->sk_shutdown & RCV_SHUTDOWN)
389 break;
390
391 err = -EAGAIN;
392 if (!timeo)
393 break;
394
395 timeo = bt_sock_data_wait(sk, timeo);
396
397 if (signal_pending(current)) {
398 err = sock_intr_errno(timeo);
399 goto out;
400 }
401 continue;
402 }
403
404 chunk = min_t(unsigned int, skb->len, size);
405 if (skb_copy_datagram_msg(skb, 0, msg, chunk)) {
406 skb_queue_head(&sk->sk_receive_queue, skb);
407 if (!copied)
408 copied = -EFAULT;
409 break;
410 }
411 copied += chunk;
412 size -= chunk;
413
414 sock_recv_ts_and_drops(msg, sk, skb);
415
416 if (!(flags & MSG_PEEK)) {
417 int skb_len = skb_headlen(skb);
418
419 if (chunk <= skb_len) {
420 __skb_pull(skb, chunk);
421 } else {
422 struct sk_buff *frag;
423
424 __skb_pull(skb, skb_len);
425 chunk -= skb_len;
426
427 skb_walk_frags(skb, frag) {
428 if (chunk <= frag->len) {
429 /* Pulling partial data */
430 skb->len -= chunk;
431 skb->data_len -= chunk;
432 __skb_pull(frag, chunk);
433 break;
434 } else if (frag->len) {
435 /* Pulling all frag data */
436 chunk -= frag->len;
437 skb->len -= frag->len;
438 skb->data_len -= frag->len;
439 __skb_pull(frag, frag->len);
440 }
441 }
442 }
443
444 if (skb->len) {
445 skb_queue_head(&sk->sk_receive_queue, skb);
446 break;
447 }
448 kfree_skb(skb);
449
450 } else {
451 /* put message back and return */
452 skb_queue_head(&sk->sk_receive_queue, skb);
453 break;
454 }
455 } while (size);
456
457 out:
458 release_sock(sk);
459 return copied ? : err;
460 }
461 EXPORT_SYMBOL(bt_sock_stream_recvmsg);
462
bt_accept_poll(struct sock * parent)463 static inline unsigned int bt_accept_poll(struct sock *parent)
464 {
465 struct bt_sock *s, *n;
466 struct sock *sk;
467
468 list_for_each_entry_safe(s, n, &bt_sk(parent)->accept_q, accept_q) {
469 sk = (struct sock *)s;
470 if (sk->sk_state == BT_CONNECTED ||
471 (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
472 sk->sk_state == BT_CONNECT2))
473 return POLLIN | POLLRDNORM;
474 }
475
476 return 0;
477 }
478
bt_sock_poll(struct file * file,struct socket * sock,poll_table * wait)479 unsigned int bt_sock_poll(struct file *file, struct socket *sock,
480 poll_table *wait)
481 {
482 struct sock *sk = sock->sk;
483 unsigned int mask = 0;
484
485 BT_DBG("sock %p, sk %p", sock, sk);
486
487 poll_wait(file, sk_sleep(sk), wait);
488
489 if (sk->sk_state == BT_LISTEN)
490 return bt_accept_poll(sk);
491
492 if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue))
493 mask |= POLLERR |
494 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
495
496 if (sk->sk_shutdown & RCV_SHUTDOWN)
497 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
498
499 if (sk->sk_shutdown == SHUTDOWN_MASK)
500 mask |= POLLHUP;
501
502 if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
503 mask |= POLLIN | POLLRDNORM;
504
505 if (sk->sk_state == BT_CLOSED)
506 mask |= POLLHUP;
507
508 if (sk->sk_state == BT_CONNECT ||
509 sk->sk_state == BT_CONNECT2 ||
510 sk->sk_state == BT_CONFIG)
511 return mask;
512
513 if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
514 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
515 else
516 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
517
518 return mask;
519 }
520 EXPORT_SYMBOL(bt_sock_poll);
521
bt_sock_ioctl(struct socket * sock,unsigned int cmd,unsigned long arg)522 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
523 {
524 struct sock *sk = sock->sk;
525 struct sk_buff *skb;
526 long amount;
527 int err;
528
529 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
530
531 switch (cmd) {
532 case TIOCOUTQ:
533 if (sk->sk_state == BT_LISTEN)
534 return -EINVAL;
535
536 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
537 if (amount < 0)
538 amount = 0;
539 err = put_user(amount, (int __user *) arg);
540 break;
541
542 case TIOCINQ:
543 if (sk->sk_state == BT_LISTEN)
544 return -EINVAL;
545
546 lock_sock(sk);
547 skb = skb_peek(&sk->sk_receive_queue);
548 amount = skb ? skb->len : 0;
549 release_sock(sk);
550 err = put_user(amount, (int __user *) arg);
551 break;
552
553 case SIOCGSTAMP:
554 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
555 break;
556
557 case SIOCGSTAMPNS:
558 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
559 break;
560
561 default:
562 err = -ENOIOCTLCMD;
563 break;
564 }
565
566 return err;
567 }
568 EXPORT_SYMBOL(bt_sock_ioctl);
569
570 /* This function expects the sk lock to be held when called */
bt_sock_wait_state(struct sock * sk,int state,unsigned long timeo)571 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
572 {
573 DECLARE_WAITQUEUE(wait, current);
574 int err = 0;
575
576 BT_DBG("sk %p", sk);
577
578 add_wait_queue(sk_sleep(sk), &wait);
579 set_current_state(TASK_INTERRUPTIBLE);
580 while (sk->sk_state != state) {
581 if (!timeo) {
582 err = -EINPROGRESS;
583 break;
584 }
585
586 if (signal_pending(current)) {
587 err = sock_intr_errno(timeo);
588 break;
589 }
590
591 release_sock(sk);
592 timeo = schedule_timeout(timeo);
593 lock_sock(sk);
594 set_current_state(TASK_INTERRUPTIBLE);
595
596 err = sock_error(sk);
597 if (err)
598 break;
599 }
600 __set_current_state(TASK_RUNNING);
601 remove_wait_queue(sk_sleep(sk), &wait);
602 return err;
603 }
604 EXPORT_SYMBOL(bt_sock_wait_state);
605
606 /* This function expects the sk lock to be held when called */
bt_sock_wait_ready(struct sock * sk,unsigned long flags)607 int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
608 {
609 DECLARE_WAITQUEUE(wait, current);
610 unsigned long timeo;
611 int err = 0;
612
613 BT_DBG("sk %p", sk);
614
615 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
616
617 add_wait_queue(sk_sleep(sk), &wait);
618 set_current_state(TASK_INTERRUPTIBLE);
619 while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
620 if (!timeo) {
621 err = -EAGAIN;
622 break;
623 }
624
625 if (signal_pending(current)) {
626 err = sock_intr_errno(timeo);
627 break;
628 }
629
630 release_sock(sk);
631 timeo = schedule_timeout(timeo);
632 lock_sock(sk);
633 set_current_state(TASK_INTERRUPTIBLE);
634
635 err = sock_error(sk);
636 if (err)
637 break;
638 }
639 __set_current_state(TASK_RUNNING);
640 remove_wait_queue(sk_sleep(sk), &wait);
641
642 return err;
643 }
644 EXPORT_SYMBOL(bt_sock_wait_ready);
645
646 #ifdef CONFIG_PROC_FS
647 struct bt_seq_state {
648 struct bt_sock_list *l;
649 };
650
bt_seq_start(struct seq_file * seq,loff_t * pos)651 static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
652 __acquires(seq->private->l->lock)
653 {
654 struct bt_seq_state *s = seq->private;
655 struct bt_sock_list *l = s->l;
656
657 read_lock(&l->lock);
658 return seq_hlist_start_head(&l->head, *pos);
659 }
660
bt_seq_next(struct seq_file * seq,void * v,loff_t * pos)661 static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
662 {
663 struct bt_seq_state *s = seq->private;
664 struct bt_sock_list *l = s->l;
665
666 return seq_hlist_next(v, &l->head, pos);
667 }
668
bt_seq_stop(struct seq_file * seq,void * v)669 static void bt_seq_stop(struct seq_file *seq, void *v)
670 __releases(seq->private->l->lock)
671 {
672 struct bt_seq_state *s = seq->private;
673 struct bt_sock_list *l = s->l;
674
675 read_unlock(&l->lock);
676 }
677
bt_seq_show(struct seq_file * seq,void * v)678 static int bt_seq_show(struct seq_file *seq, void *v)
679 {
680 struct bt_seq_state *s = seq->private;
681 struct bt_sock_list *l = s->l;
682
683 if (v == SEQ_START_TOKEN) {
684 seq_puts(seq ,"sk RefCnt Rmem Wmem User Inode Parent");
685
686 if (l->custom_seq_show) {
687 seq_putc(seq, ' ');
688 l->custom_seq_show(seq, v);
689 }
690
691 seq_putc(seq, '\n');
692 } else {
693 struct sock *sk = sk_entry(v);
694 struct bt_sock *bt = bt_sk(sk);
695
696 seq_printf(seq,
697 "%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
698 sk,
699 refcount_read(&sk->sk_refcnt),
700 sk_rmem_alloc_get(sk),
701 sk_wmem_alloc_get(sk),
702 from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
703 sock_i_ino(sk),
704 bt->parent? sock_i_ino(bt->parent): 0LU);
705
706 if (l->custom_seq_show) {
707 seq_putc(seq, ' ');
708 l->custom_seq_show(seq, v);
709 }
710
711 seq_putc(seq, '\n');
712 }
713 return 0;
714 }
715
716 static const struct seq_operations bt_seq_ops = {
717 .start = bt_seq_start,
718 .next = bt_seq_next,
719 .stop = bt_seq_stop,
720 .show = bt_seq_show,
721 };
722
bt_seq_open(struct inode * inode,struct file * file)723 static int bt_seq_open(struct inode *inode, struct file *file)
724 {
725 struct bt_sock_list *sk_list;
726 struct bt_seq_state *s;
727
728 sk_list = PDE_DATA(inode);
729 s = __seq_open_private(file, &bt_seq_ops,
730 sizeof(struct bt_seq_state));
731 if (!s)
732 return -ENOMEM;
733
734 s->l = sk_list;
735 return 0;
736 }
737
738 static const struct file_operations bt_fops = {
739 .open = bt_seq_open,
740 .read = seq_read,
741 .llseek = seq_lseek,
742 .release = seq_release_private
743 };
744
bt_procfs_init(struct net * net,const char * name,struct bt_sock_list * sk_list,int (* seq_show)(struct seq_file *,void *))745 int bt_procfs_init(struct net *net, const char *name,
746 struct bt_sock_list *sk_list,
747 int (* seq_show)(struct seq_file *, void *))
748 {
749 sk_list->custom_seq_show = seq_show;
750
751 if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
752 return -ENOMEM;
753 return 0;
754 }
755
bt_procfs_cleanup(struct net * net,const char * name)756 void bt_procfs_cleanup(struct net *net, const char *name)
757 {
758 remove_proc_entry(name, net->proc_net);
759 }
760 #else
bt_procfs_init(struct net * net,const char * name,struct bt_sock_list * sk_list,int (* seq_show)(struct seq_file *,void *))761 int bt_procfs_init(struct net *net, const char *name,
762 struct bt_sock_list *sk_list,
763 int (* seq_show)(struct seq_file *, void *))
764 {
765 return 0;
766 }
767
bt_procfs_cleanup(struct net * net,const char * name)768 void bt_procfs_cleanup(struct net *net, const char *name)
769 {
770 }
771 #endif
772 EXPORT_SYMBOL(bt_procfs_init);
773 EXPORT_SYMBOL(bt_procfs_cleanup);
774
775 static const struct net_proto_family bt_sock_family_ops = {
776 .owner = THIS_MODULE,
777 .family = PF_BLUETOOTH,
778 .create = bt_sock_create,
779 };
780
781 struct dentry *bt_debugfs;
782 EXPORT_SYMBOL_GPL(bt_debugfs);
783
784 #define VERSION __stringify(BT_SUBSYS_VERSION) "." \
785 __stringify(BT_SUBSYS_REVISION)
786
bt_init(void)787 static int __init bt_init(void)
788 {
789 int err;
790
791 sock_skb_cb_check_size(sizeof(struct bt_skb_cb));
792
793 BT_INFO("Core ver %s", VERSION);
794
795 err = bt_selftest();
796 if (err < 0)
797 return err;
798
799 bt_debugfs = debugfs_create_dir("bluetooth", NULL);
800
801 bt_leds_init();
802
803 err = bt_sysfs_init();
804 if (err < 0)
805 return err;
806
807 err = sock_register(&bt_sock_family_ops);
808 if (err < 0) {
809 bt_sysfs_cleanup();
810 return err;
811 }
812
813 BT_INFO("HCI device and connection manager initialized");
814
815 err = hci_sock_init();
816 if (err < 0)
817 goto error;
818
819 err = l2cap_init();
820 if (err < 0)
821 goto sock_err;
822
823 err = sco_init();
824 if (err < 0) {
825 l2cap_exit();
826 goto sock_err;
827 }
828
829 err = mgmt_init();
830 if (err < 0) {
831 sco_exit();
832 l2cap_exit();
833 goto sock_err;
834 }
835
836 return 0;
837
838 sock_err:
839 hci_sock_cleanup();
840
841 error:
842 sock_unregister(PF_BLUETOOTH);
843 bt_sysfs_cleanup();
844
845 return err;
846 }
847
bt_exit(void)848 static void __exit bt_exit(void)
849 {
850 mgmt_exit();
851
852 sco_exit();
853
854 l2cap_exit();
855
856 hci_sock_cleanup();
857
858 sock_unregister(PF_BLUETOOTH);
859
860 bt_sysfs_cleanup();
861
862 bt_leds_cleanup();
863
864 debugfs_remove_recursive(bt_debugfs);
865 }
866
867 subsys_initcall(bt_init);
868 module_exit(bt_exit);
869
870 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
871 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
872 MODULE_VERSION(VERSION);
873 MODULE_LICENSE("GPL");
874 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);
875