projects/linux·blob master · refs

1018 lines · 21.7 KiB

1// SPDX-License-Identifier: GPL-2.0
2/*
3 BlueZ - Bluetooth protocol stack for Linux
4 Copyright (C) 2000-2001 Qualcomm Incorporated
5
6 Written 2000,2001 by Maxim Krasnyansky <[email protected]>
7
8 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
9 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
10 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
11 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
12 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
13 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16
17 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
18 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
19 SOFTWARE IS DISCLAIMED.
20*/
21
22/* Bluetooth address family and sockets. */
23
24#include <linux/module.h>
25#include <linux/debugfs.h>
26#include <linux/stringify.h>
27#include <linux/sched/signal.h>
28
29#include <asm/ioctls.h>
30
31#include <net/bluetooth/bluetooth.h>
32#include <linux/proc_fs.h>
33
34#include <linux/ethtool.h>
35#include <linux/sockios.h>
36
37#include "leds.h"
38#include "selftest.h"
39
40/* Bluetooth sockets */
41#define BT_MAX_PROTO (BTPROTO_LAST + 1)
42static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
43static DEFINE_RWLOCK(bt_proto_lock);
44
45static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
46static 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 "sk_lock-AF_BLUETOOTH-BTPROTO_ISO",
56};
57
58static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
59static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
60 "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
61 "slock-AF_BLUETOOTH-BTPROTO_HCI",
62 "slock-AF_BLUETOOTH-BTPROTO_SCO",
63 "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
64 "slock-AF_BLUETOOTH-BTPROTO_BNEP",
65 "slock-AF_BLUETOOTH-BTPROTO_CMTP",
66 "slock-AF_BLUETOOTH-BTPROTO_HIDP",
67 "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
68 "slock-AF_BLUETOOTH-BTPROTO_ISO",
69};
70
71void bt_sock_reclassify_lock(struct sock *sk, int proto)
72{
73 BUG_ON(!sk);
74 BUG_ON(!sock_allow_reclassification(sk));
75
76 sock_lock_init_class_and_name(sk,
77 bt_slock_key_strings[proto], &bt_slock_key[proto],
78 bt_key_strings[proto], &bt_lock_key[proto]);
79}
80EXPORT_SYMBOL(bt_sock_reclassify_lock);
81
82int bt_sock_register(int proto, const struct net_proto_family *ops)
83{
84 int err = 0;
85
86 if (proto < 0 || proto >= BT_MAX_PROTO)
87 return -EINVAL;
88
89 write_lock(&bt_proto_lock);
90
91 if (bt_proto[proto])
92 err = -EEXIST;
93 else
94 bt_proto[proto] = ops;
95
96 write_unlock(&bt_proto_lock);
97
98 return err;
99}
100EXPORT_SYMBOL(bt_sock_register);
101
102void bt_sock_unregister(int proto)
103{
104 if (proto < 0 || proto >= BT_MAX_PROTO)
105 return;
106
107 write_lock(&bt_proto_lock);
108 bt_proto[proto] = NULL;
109 write_unlock(&bt_proto_lock);
110}
111EXPORT_SYMBOL(bt_sock_unregister);
112
113static int bt_sock_create(struct net *net, struct socket *sock, int proto,
114 int kern)
115{
116 int err;
117
118 if (net != &init_net)
119 return -EAFNOSUPPORT;
120
121 if (proto < 0 || proto >= BT_MAX_PROTO)
122 return -EINVAL;
123
124 if (!bt_proto[proto])
125 request_module("bt-proto-%d", proto);
126
127 err = -EPROTONOSUPPORT;
128
129 read_lock(&bt_proto_lock);
130
131 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
132 err = bt_proto[proto]->create(net, sock, proto, kern);
133 if (!err)
134 bt_sock_reclassify_lock(sock->sk, proto);
135 module_put(bt_proto[proto]->owner);
136 }
137
138 read_unlock(&bt_proto_lock);
139
140 return err;
141}
142
143struct sock *bt_sock_alloc(struct net *net, struct socket *sock,
144 struct proto *prot, int proto, gfp_t prio, int kern)
145{
146 struct sock *sk;
147
148 sk = sk_alloc(net, PF_BLUETOOTH, prio, prot, kern);
149 if (!sk)
150 return NULL;
151
152 sock_init_data(sock, sk);
153 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
154 spin_lock_init(&bt_sk(sk)->accept_q_lock);
155
156 sock_reset_flag(sk, SOCK_ZAPPED);
157
158 sk->sk_protocol = proto;
159 sk->sk_state = BT_OPEN;
160
161 /* Init peer information so it can be properly monitored */
162 if (!kern) {
163 spin_lock(&sk->sk_peer_lock);
164 sk->sk_peer_pid[PIDTYPE_TGID] = get_pid(task_tgid(current));
165 sk->sk_peer_cred = get_current_cred();
166 spin_unlock(&sk->sk_peer_lock);
167 }
168
169 return sk;
170}
171EXPORT_SYMBOL(bt_sock_alloc);
172
173void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
174{
175 write_lock(&l->lock);
176 sk_add_node(sk, &l->head);
177 write_unlock(&l->lock);
178}
179EXPORT_SYMBOL(bt_sock_link);
180
181void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
182{
183 write_lock(&l->lock);
184 sk_del_node_init(sk);
185 write_unlock(&l->lock);
186}
187EXPORT_SYMBOL(bt_sock_unlink);
188
189bool bt_sock_linked(struct bt_sock_list *l, struct sock *s)
190{
191 struct sock *sk;
192
193 if (!l || !s)
194 return false;
195
196 read_lock(&l->lock);
197
198 sk_for_each(sk, &l->head) {
199 if (s == sk) {
200 read_unlock(&l->lock);
201 return true;
202 }
203 }
204
205 read_unlock(&l->lock);
206
207 return false;
208}
209EXPORT_SYMBOL(bt_sock_linked);
210
211void bt_accept_enqueue(struct sock *parent, struct sock *sk, bool bh)
212 __context_unsafe(/* conditional locking */)
213{
214 const struct cred *old_cred;
215 struct pid *old_pid;
216 struct bt_sock *par = bt_sk(parent);
217
218 BT_DBG("parent %p, sk %p", parent, sk);
219
220 sock_hold(sk);
221
222 if (bh)
223 bh_lock_sock_nested(sk);
224 else
225 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
226
227 bt_sk(sk)->parent = parent;
228
229 spin_lock_bh(&par->accept_q_lock);
230 list_add_tail(&bt_sk(sk)->accept_q, &par->accept_q);
231 sk_acceptq_added(parent);
232 spin_unlock_bh(&par->accept_q_lock);
233
234 /* Copy credentials from parent since for incoming connections the
235 * socket is allocated by the kernel.
236 */
237 spin_lock(&sk->sk_peer_lock);
238 old_pid = sk->sk_peer_pid[PIDTYPE_TGID];
239 old_cred = sk->sk_peer_cred;
240 sk->sk_peer_pid[PIDTYPE_TGID] = get_pid(parent->sk_peer_pid[PIDTYPE_TGID]);
241 sk->sk_peer_cred = get_cred(parent->sk_peer_cred);
242 spin_unlock(&sk->sk_peer_lock);
243
244 put_pid(old_pid);
245 put_cred(old_cred);
246
247 if (bh)
248 bh_unlock_sock(sk);
249 else
250 release_sock(sk);
251}
252EXPORT_SYMBOL(bt_accept_enqueue);
253
254/* Calling function must hold the sk lock.
255 * bt_sk(sk)->parent must be non-NULL meaning sk is in the parent list.
256 */
257void bt_accept_unlink(struct sock *sk)
258{
259 struct sock *parent = bt_sk(sk)->parent;
260
261 BT_DBG("sk %p state %d", sk, sk->sk_state);
262
263 spin_lock_bh(&bt_sk(parent)->accept_q_lock);
264 list_del_init(&bt_sk(sk)->accept_q);
265 sk_acceptq_removed(parent);
266 spin_unlock_bh(&bt_sk(parent)->accept_q_lock);
267 bt_sk(sk)->parent = NULL;
268 sock_put(sk);
269}
270EXPORT_SYMBOL(bt_accept_unlink);
271
272static struct sock *bt_accept_get(struct sock *parent, struct sock *sk)
273{
274 struct bt_sock *bt = bt_sk(parent);
275 struct sock *next = NULL;
276
277 /* accept_q is modified from child teardown paths too, so take a
278 * temporary reference before dropping the queue lock.
279 */
280 spin_lock_bh(&bt->accept_q_lock);
281
282 if (sk) {
283 if (bt_sk(sk)->parent != parent)
284 goto out;
285
286 if (!list_is_last(&bt_sk(sk)->accept_q, &bt->accept_q)) {
287 next = &list_next_entry(bt_sk(sk), accept_q)->sk;
288 sock_hold(next);
289 }
290 } else if (!list_empty(&bt->accept_q)) {
291 next = &list_first_entry(&bt->accept_q,
292 struct bt_sock, accept_q)->sk;
293 sock_hold(next);
294 }
295
296out:
297 spin_unlock_bh(&bt->accept_q_lock);
298 return next;
299}
300
301struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
302{
303 struct sock *sk, *next;
304
305 BT_DBG("parent %p", parent);
306
307restart:
308 for (sk = bt_accept_get(parent, NULL); sk; sk = next) {
309 /* The reference from bt_accept_get() keeps sk alive. */
310 lock_sock(sk);
311
312 /* Check sk has not already been unlinked via
313 * bt_accept_unlink() due to serialisation caused by sk locking
314 */
315 if (bt_sk(sk)->parent != parent) {
316 BT_DBG("sk %p, already unlinked", sk);
317 release_sock(sk);
318 sock_put(sk);
319
320 goto restart;
321 }
322
323 next = bt_accept_get(parent, sk);
324
325 /* FIXME: Is this check still needed */
326 if (sk->sk_state == BT_CLOSED) {
327 bt_accept_unlink(sk);
328 release_sock(sk);
329 sock_put(sk);
330 continue;
331 }
332
333 if (sk->sk_state == BT_CONNECTED || !newsock ||
334 test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
335 bt_accept_unlink(sk);
336 if (newsock)
337 sock_graft(sk, newsock);
338
339 release_sock(sk);
340 if (next)
341 sock_put(next);
342 return sk;
343 }
344
345 release_sock(sk);
346 sock_put(sk);
347 }
348
349 return NULL;
350}
351EXPORT_SYMBOL(bt_accept_dequeue);
352
353int bt_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
354 int flags)
355{
356 struct sock *sk = sock->sk;
357 struct sk_buff *skb;
358 size_t copied;
359 size_t skblen;
360 int err;
361
362 BT_DBG("sock %p sk %p len %zu", sock, sk, len);
363
364 if (flags & MSG_OOB)
365 return -EOPNOTSUPP;
366
367 skb = skb_recv_datagram(sk, flags, &err);
368 if (!skb) {
369 if (sk->sk_shutdown & RCV_SHUTDOWN)
370 err = 0;
371
372 return err;
373 }
374
375 skblen = skb->len;
376 copied = skb->len;
377 if (len < copied) {
378 msg->msg_flags |= MSG_TRUNC;
379 copied = len;
380 }
381
382 skb_reset_transport_header(skb);
383 err = skb_copy_datagram_msg(skb, 0, msg, copied);
384 if (err == 0) {
385 sock_recv_cmsgs(msg, sk, skb);
386
387 if (msg->msg_name && bt_sk(sk)->skb_msg_name)
388 bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
389 &msg->msg_namelen);
390
391 if (test_bit(BT_SK_PKT_STATUS, &bt_sk(sk)->flags)) {
392 u8 pkt_status = hci_skb_pkt_status(skb);
393
394 put_cmsg(msg, SOL_BLUETOOTH, BT_SCM_PKT_STATUS,
395 sizeof(pkt_status), &pkt_status);
396 }
397
398 if (test_bit(BT_SK_PKT_SEQNUM, &bt_sk(sk)->flags)) {
399 u16 pkt_seqnum = hci_skb_pkt_seqnum(skb);
400
401 put_cmsg(msg, SOL_BLUETOOTH, BT_SCM_PKT_SEQNUM,
402 sizeof(pkt_seqnum), &pkt_seqnum);
403 }
404 }
405
406 skb_free_datagram(sk, skb);
407
408 if (flags & MSG_TRUNC)
409 copied = skblen;
410
411 return err ? : copied;
412}
413EXPORT_SYMBOL(bt_sock_recvmsg);
414
415static long bt_sock_data_wait(struct sock *sk, long timeo)
416{
417 DECLARE_WAITQUEUE(wait, current);
418
419 add_wait_queue(sk_sleep(sk), &wait);
420 for (;;) {
421 set_current_state(TASK_INTERRUPTIBLE);
422
423 if (!skb_queue_empty(&sk->sk_receive_queue))
424 break;
425
426 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
427 break;
428
429 if (signal_pending(current) || !timeo)
430 break;
431
432 sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
433 release_sock(sk);
434 timeo = schedule_timeout(timeo);
435 lock_sock(sk);
436 sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
437 }
438
439 __set_current_state(TASK_RUNNING);
440 remove_wait_queue(sk_sleep(sk), &wait);
441 return timeo;
442}
443
444int bt_sock_stream_recvmsg(struct socket *sock, struct msghdr *msg,
445 size_t size, int flags)
446{
447 struct sock *sk = sock->sk;
448 int err = 0;
449 size_t target, copied = 0;
450 long timeo;
451
452 if (flags & MSG_OOB)
453 return -EOPNOTSUPP;
454
455 BT_DBG("sk %p size %zu", sk, size);
456
457 lock_sock(sk);
458
459 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
460 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
461
462 do {
463 struct sk_buff *skb;
464 int chunk;
465
466 skb = skb_dequeue(&sk->sk_receive_queue);
467 if (!skb) {
468 if (copied >= target)
469 break;
470
471 err = sock_error(sk);
472 if (err)
473 break;
474 if (sk->sk_shutdown & RCV_SHUTDOWN)
475 break;
476
477 err = -EAGAIN;
478 if (!timeo)
479 break;
480
481 timeo = bt_sock_data_wait(sk, timeo);
482
483 if (signal_pending(current)) {
484 err = sock_intr_errno(timeo);
485 goto out;
486 }
487 continue;
488 }
489
490 chunk = min_t(unsigned int, skb->len, size);
491 if (skb_copy_datagram_msg(skb, 0, msg, chunk)) {
492 skb_queue_head(&sk->sk_receive_queue, skb);
493 if (!copied)
494 copied = -EFAULT;
495 break;
496 }
497 copied += chunk;
498 size -= chunk;
499
500 sock_recv_cmsgs(msg, sk, skb);
501
502 if (!(flags & MSG_PEEK)) {
503 int skb_len = skb_headlen(skb);
504
505 if (chunk <= skb_len) {
506 __skb_pull(skb, chunk);
507 } else {
508 struct sk_buff *frag;
509
510 __skb_pull(skb, skb_len);
511 chunk -= skb_len;
512
513 skb_walk_frags(skb, frag) {
514 if (chunk <= frag->len) {
515 /* Pulling partial data */
516 skb->len -= chunk;
517 skb->data_len -= chunk;
518 __skb_pull(frag, chunk);
519 break;
520 } else if (frag->len) {
521 /* Pulling all frag data */
522 chunk -= frag->len;
523 skb->len -= frag->len;
524 skb->data_len -= frag->len;
525 __skb_pull(frag, frag->len);
526 }
527 }
528 }
529
530 if (skb->len) {
531 skb_queue_head(&sk->sk_receive_queue, skb);
532 break;
533 }
534 kfree_skb(skb);
535
536 } else {
537 /* put message back and return */
538 skb_queue_head(&sk->sk_receive_queue, skb);
539 break;
540 }
541 } while (size);
542
543out:
544 release_sock(sk);
545 return copied ? : err;
546}
547EXPORT_SYMBOL(bt_sock_stream_recvmsg);
548
549static inline __poll_t bt_accept_poll(struct sock *parent)
550{
551 struct bt_sock *bt = bt_sk(parent);
552 struct bt_sock *s;
553 struct sock *sk;
554 __poll_t mask = 0;
555
556 spin_lock_bh(&bt->accept_q_lock);
557 list_for_each_entry(s, &bt->accept_q, accept_q) {
558 int state;
559
560 sk = (struct sock *)s;
561 state = READ_ONCE(sk->sk_state);
562
563 if (state == BT_CONNECTED ||
564 (test_bit(BT_SK_DEFER_SETUP, &bt->flags) &&
565 state == BT_CONNECT2)) {
566 mask = EPOLLIN | EPOLLRDNORM;
567 break;
568 }
569 }
570 spin_unlock_bh(&bt->accept_q_lock);
571
572 return mask;
573}
574
575__poll_t bt_sock_poll(struct file *file, struct socket *sock,
576 poll_table *wait)
577{
578 struct sock *sk = sock->sk;
579 __poll_t mask = 0;
580
581 poll_wait(file, sk_sleep(sk), wait);
582
583 if (sk->sk_state == BT_LISTEN)
584 return bt_accept_poll(sk);
585
586 if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue))
587 mask |= EPOLLERR |
588 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
589
590 if (sk->sk_shutdown & RCV_SHUTDOWN)
591 mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
592
593 if (sk->sk_shutdown == SHUTDOWN_MASK)
594 mask |= EPOLLHUP;
595
596 if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
597 mask |= EPOLLIN | EPOLLRDNORM;
598
599 if (sk->sk_state == BT_CLOSED)
600 mask |= EPOLLHUP;
601
602 if (sk->sk_state == BT_CONNECT ||
603 sk->sk_state == BT_CONNECT2 ||
604 sk->sk_state == BT_CONFIG)
605 return mask;
606
607 if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
608 mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
609 else
610 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
611
612 return mask;
613}
614EXPORT_SYMBOL(bt_sock_poll);
615
616static int bt_ethtool_get_ts_info(struct sock *sk, unsigned int index,
617 void __user *useraddr)
618{
619 struct ethtool_ts_info info;
620 struct kernel_ethtool_ts_info ts_info = {};
621 int ret;
622
623 ret = hci_ethtool_ts_info(index, sk->sk_protocol, &ts_info);
624 if (ret == -ENODEV)
625 return ret;
626 else if (ret < 0)
627 return -EIO;
628
629 memset(&info, 0, sizeof(info));
630
631 info.cmd = ETHTOOL_GET_TS_INFO;
632 info.so_timestamping = ts_info.so_timestamping;
633 info.phc_index = ts_info.phc_index;
634 info.tx_types = ts_info.tx_types;
635 info.rx_filters = ts_info.rx_filters;
636
637 if (copy_to_user(useraddr, &info, sizeof(info)))
638 return -EFAULT;
639
640 return 0;
641}
642
643static int bt_ethtool(struct sock *sk, const struct ifreq *ifr,
644 void __user *useraddr)
645{
646 unsigned int index;
647 u32 ethcmd;
648 int n;
649
650 if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
651 return -EFAULT;
652
653 if (sscanf(ifr->ifr_name, "hci%u%n", &index, &n) != 1 ||
654 n != strlen(ifr->ifr_name))
655 return -ENODEV;
656
657 switch (ethcmd) {
658 case ETHTOOL_GET_TS_INFO:
659 return bt_ethtool_get_ts_info(sk, index, useraddr);
660 }
661
662 return -EOPNOTSUPP;
663}
664
665static int bt_dev_ioctl(struct socket *sock, unsigned int cmd, void __user *arg)
666{
667 struct sock *sk = sock->sk;
668 struct ifreq ifr = {};
669 void __user *data;
670 char *colon;
671 int ret = -ENOIOCTLCMD;
672
673 if (get_user_ifreq(&ifr, &data, arg))
674 return -EFAULT;
675
676 ifr.ifr_name[IFNAMSIZ - 1] = 0;
677 colon = strchr(ifr.ifr_name, ':');
678 if (colon)
679 *colon = 0;
680
681 switch (cmd) {
682 case SIOCETHTOOL:
683 ret = bt_ethtool(sk, &ifr, data);
684 break;
685 }
686
687 if (colon)
688 *colon = ':';
689
690 if (put_user_ifreq(&ifr, arg))
691 return -EFAULT;
692
693 return ret;
694}
695
696int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
697{
698 struct sock *sk = sock->sk;
699 struct sk_buff *skb;
700 long amount;
701 int err;
702
703 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
704
705 switch (cmd) {
706 case TIOCOUTQ:
707 if (sk->sk_state == BT_LISTEN)
708 return -EINVAL;
709
710 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
711 if (amount < 0)
712 amount = 0;
713 err = put_user(amount, (int __user *)arg);
714 break;
715
716 case TIOCINQ:
717 if (sk->sk_state == BT_LISTEN)
718 return -EINVAL;
719
720 spin_lock(&sk->sk_receive_queue.lock);
721 skb = skb_peek(&sk->sk_receive_queue);
722 amount = skb ? skb->len : 0;
723 spin_unlock(&sk->sk_receive_queue.lock);
724
725 err = put_user(amount, (int __user *)arg);
726 break;
727
728 case SIOCETHTOOL:
729 err = bt_dev_ioctl(sock, cmd, (void __user *)arg);
730 break;
731
732 default:
733 err = -ENOIOCTLCMD;
734 break;
735 }
736
737 return err;
738}
739EXPORT_SYMBOL(bt_sock_ioctl);
740
741/* This function expects the sk lock to be held when called */
742int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
743{
744 DECLARE_WAITQUEUE(wait, current);
745 int err = 0;
746
747 BT_DBG("sk %p", sk);
748
749 add_wait_queue(sk_sleep(sk), &wait);
750 set_current_state(TASK_INTERRUPTIBLE);
751 while (sk->sk_state != state) {
752 if (!timeo) {
753 err = -EINPROGRESS;
754 break;
755 }
756
757 if (signal_pending(current)) {
758 err = sock_intr_errno(timeo);
759 break;
760 }
761
762 release_sock(sk);
763 timeo = schedule_timeout(timeo);
764 lock_sock(sk);
765 set_current_state(TASK_INTERRUPTIBLE);
766
767 err = sock_error(sk);
768 if (err)
769 break;
770 }
771 __set_current_state(TASK_RUNNING);
772 remove_wait_queue(sk_sleep(sk), &wait);
773 return err;
774}
775EXPORT_SYMBOL(bt_sock_wait_state);
776
777/* This function expects the sk lock to be held when called */
778int bt_sock_wait_ready(struct sock *sk, unsigned int msg_flags)
779{
780 DECLARE_WAITQUEUE(wait, current);
781 unsigned long timeo;
782 int err = 0;
783
784 BT_DBG("sk %p", sk);
785
786 timeo = sock_sndtimeo(sk, !!(msg_flags & MSG_DONTWAIT));
787
788 add_wait_queue(sk_sleep(sk), &wait);
789 set_current_state(TASK_INTERRUPTIBLE);
790 while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
791 if (!timeo) {
792 err = -EAGAIN;
793 break;
794 }
795
796 if (signal_pending(current)) {
797 err = sock_intr_errno(timeo);
798 break;
799 }
800
801 release_sock(sk);
802 timeo = schedule_timeout(timeo);
803 lock_sock(sk);
804 set_current_state(TASK_INTERRUPTIBLE);
805
806 err = sock_error(sk);
807 if (err)
808 break;
809 }
810 __set_current_state(TASK_RUNNING);
811 remove_wait_queue(sk_sleep(sk), &wait);
812
813 return err;
814}
815EXPORT_SYMBOL(bt_sock_wait_ready);
816
817#ifdef CONFIG_PROC_FS
818static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
819 __acquires_shared(&((struct bt_sock_list *)
820 pde_data(file_inode(seq->file)))->lock)
821{
822 struct bt_sock_list *l = pde_data(file_inode(seq->file));
823
824 read_lock(&l->lock);
825 return seq_hlist_start_head(&l->head, *pos);
826}
827
828static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
829{
830 struct bt_sock_list *l = pde_data(file_inode(seq->file));
831
832 return seq_hlist_next(v, &l->head, pos);
833}
834
835static void bt_seq_stop(struct seq_file *seq, void *v)
836 __releases_shared(&((struct bt_sock_list *)
837 pde_data(file_inode(seq->file)))->lock)
838{
839 struct bt_sock_list *l = pde_data(file_inode(seq->file));
840
841 read_unlock(&l->lock);
842}
843
844static int bt_seq_show(struct seq_file *seq, void *v)
845{
846 struct bt_sock_list *l = pde_data(file_inode(seq->file));
847
848 if (v == SEQ_START_TOKEN) {
849 seq_puts(seq, "sk RefCnt Rmem Wmem User Inode Parent");
850
851 if (l->custom_seq_show) {
852 seq_putc(seq, ' ');
853 l->custom_seq_show(seq, v);
854 }
855
856 seq_putc(seq, '\n');
857 } else {
858 struct sock *sk = sk_entry(v);
859 struct bt_sock *bt = bt_sk(sk);
860
861 seq_printf(seq,
862 "%pK %-6d %-6u %-6u %-6u %-6llu %-6llu",
863 sk,
864 refcount_read(&sk->sk_refcnt),
865 sk_rmem_alloc_get(sk),
866 sk_wmem_alloc_get(sk),
867 from_kuid(seq_user_ns(seq), sk_uid(sk)),
868 sock_i_ino(sk),
869 bt->parent ? sock_i_ino(bt->parent) : 0ULL);
870
871 if (l->custom_seq_show) {
872 seq_putc(seq, ' ');
873 l->custom_seq_show(seq, v);
874 }
875
876 seq_putc(seq, '\n');
877 }
878 return 0;
879}
880
881static const struct seq_operations bt_seq_ops = {
882 .start = bt_seq_start,
883 .next = bt_seq_next,
884 .stop = bt_seq_stop,
885 .show = bt_seq_show,
886};
887
888int bt_procfs_init(struct net *net, const char *name,
889 struct bt_sock_list *sk_list,
890 int (*seq_show)(struct seq_file *, void *))
891{
892 sk_list->custom_seq_show = seq_show;
893
894 if (!proc_create_seq_data(name, 0, net->proc_net, &bt_seq_ops, sk_list))
895 return -ENOMEM;
896 return 0;
897}
898
899void bt_procfs_cleanup(struct net *net, const char *name)
900{
901 remove_proc_entry(name, net->proc_net);
902}
903#else
904int bt_procfs_init(struct net *net, const char *name,
905 struct bt_sock_list *sk_list,
906 int (*seq_show)(struct seq_file *, void *))
907{
908 return 0;
909}
910
911void bt_procfs_cleanup(struct net *net, const char *name)
912{
913}
914#endif
915EXPORT_SYMBOL(bt_procfs_init);
916EXPORT_SYMBOL(bt_procfs_cleanup);
917
918static const struct net_proto_family bt_sock_family_ops = {
919 .owner = THIS_MODULE,
920 .family = PF_BLUETOOTH,
921 .create = bt_sock_create,
922};
923
924struct dentry *bt_debugfs;
925EXPORT_SYMBOL_GPL(bt_debugfs);
926
927#define VERSION __stringify(BT_SUBSYS_VERSION) "." \
928 __stringify(BT_SUBSYS_REVISION)
929
930static int __init bt_init(void)
931{
932 int err;
933
934 sock_skb_cb_check_size(sizeof(struct bt_skb_cb));
935
936 BT_INFO("Core ver %s", VERSION);
937
938 err = bt_selftest();
939 if (err < 0)
940 return err;
941
942 bt_debugfs = debugfs_create_dir("bluetooth", NULL);
943
944 bt_leds_init();
945
946 err = bt_sysfs_init();
947 if (err < 0)
948 goto cleanup_led;
949
950 err = sock_register(&bt_sock_family_ops);
951 if (err)
952 goto cleanup_sysfs;
953
954 BT_INFO("HCI device and connection manager initialized");
955
956 err = hci_sock_init();
957 if (err)
958 goto unregister_socket;
959
960 err = l2cap_init();
961 if (err)
962 goto cleanup_socket;
963
964 err = sco_init();
965 if (err)
966 goto cleanup_cap;
967
968 err = mgmt_init();
969 if (err)
970 goto cleanup_sco;
971
972 return 0;
973
974cleanup_sco:
975 sco_exit();
976cleanup_cap:
977 l2cap_exit();
978cleanup_socket:
979 hci_sock_cleanup();
980unregister_socket:
981 sock_unregister(PF_BLUETOOTH);
982cleanup_sysfs:
983 bt_sysfs_cleanup();
984cleanup_led:
985 bt_leds_cleanup();
986 debugfs_remove_recursive(bt_debugfs);
987 return err;
988}
989
990static void __exit bt_exit(void)
991{
992 iso_exit();
993
994 mgmt_exit();
995
996 sco_exit();
997
998 l2cap_exit();
999
1000 hci_sock_cleanup();
1001
1002 sock_unregister(PF_BLUETOOTH);
1003
1004 bt_sysfs_cleanup();
1005
1006 bt_leds_cleanup();
1007
1008 debugfs_remove_recursive(bt_debugfs);
1009}
1010
1011subsys_initcall(bt_init);
1012module_exit(bt_exit);
1013
1014MODULE_AUTHOR("Marcel Holtmann <[email protected]>");
1015MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
1016MODULE_VERSION(VERSION);
1017MODULE_LICENSE("GPL");
1018MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);