2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
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;
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.
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.
25 /* Bluetooth address family and sockets. */
27 #include <linux/module.h>
28 #include <linux/debugfs.h>
29 #include <linux/stringify.h>
30 #include <linux/sched/signal.h>
32 #include <asm/ioctls.h>
34 #include <net/bluetooth/bluetooth.h>
35 #include <linux/proc_fs.h>
40 /* Bluetooth sockets */
41 #define BT_MAX_PROTO (BTPROTO_LAST + 1)
42 static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
43 static DEFINE_RWLOCK(bt_proto_lock);
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 "sk_lock-AF_BLUETOOTH-BTPROTO_ISO",
58 static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
59 static 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",
71 void bt_sock_reclassify_lock(struct sock *sk, int proto)
74 BUG_ON(!sock_allow_reclassification(sk));
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]);
80 EXPORT_SYMBOL(bt_sock_reclassify_lock);
82 int bt_sock_register(int proto, const struct net_proto_family *ops)
86 if (proto < 0 || proto >= BT_MAX_PROTO)
89 write_lock(&bt_proto_lock);
94 bt_proto[proto] = ops;
96 write_unlock(&bt_proto_lock);
100 EXPORT_SYMBOL(bt_sock_register);
102 void bt_sock_unregister(int proto)
104 if (proto < 0 || proto >= BT_MAX_PROTO)
107 write_lock(&bt_proto_lock);
108 bt_proto[proto] = NULL;
109 write_unlock(&bt_proto_lock);
111 EXPORT_SYMBOL(bt_sock_unregister);
113 static int bt_sock_create(struct net *net, struct socket *sock, int proto,
118 if (net != &init_net)
119 return -EAFNOSUPPORT;
121 if (proto < 0 || proto >= BT_MAX_PROTO)
124 if (!bt_proto[proto])
125 request_module("bt-proto-%d", proto);
127 err = -EPROTONOSUPPORT;
129 read_lock(&bt_proto_lock);
131 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
132 err = bt_proto[proto]->create(net, sock, proto, kern);
134 bt_sock_reclassify_lock(sock->sk, proto);
135 module_put(bt_proto[proto]->owner);
138 read_unlock(&bt_proto_lock);
143 struct sock *bt_sock_alloc(struct net *net, struct socket *sock,
144 struct proto *prot, int proto, gfp_t prio, int kern)
148 sk = sk_alloc(net, PF_BLUETOOTH, prio, prot, kern);
152 sock_init_data(sock, sk);
153 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
155 sock_reset_flag(sk, SOCK_ZAPPED);
157 sk->sk_protocol = proto;
158 sk->sk_state = BT_OPEN;
160 /* Init peer information so it can be properly monitored */
162 spin_lock(&sk->sk_peer_lock);
163 sk->sk_peer_pid = get_pid(task_tgid(current));
164 sk->sk_peer_cred = get_current_cred();
165 spin_unlock(&sk->sk_peer_lock);
170 EXPORT_SYMBOL(bt_sock_alloc);
172 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
174 write_lock(&l->lock);
175 sk_add_node(sk, &l->head);
176 write_unlock(&l->lock);
178 EXPORT_SYMBOL(bt_sock_link);
180 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
182 write_lock(&l->lock);
183 sk_del_node_init(sk);
184 write_unlock(&l->lock);
186 EXPORT_SYMBOL(bt_sock_unlink);
188 void bt_accept_enqueue(struct sock *parent, struct sock *sk, bool bh)
190 const struct cred *old_cred;
193 BT_DBG("parent %p, sk %p", parent, sk);
198 bh_lock_sock_nested(sk);
200 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
202 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
203 bt_sk(sk)->parent = parent;
205 /* Copy credentials from parent since for incoming connections the
206 * socket is allocated by the kernel.
208 spin_lock(&sk->sk_peer_lock);
209 old_pid = sk->sk_peer_pid;
210 old_cred = sk->sk_peer_cred;
211 sk->sk_peer_pid = get_pid(parent->sk_peer_pid);
212 sk->sk_peer_cred = get_cred(parent->sk_peer_cred);
213 spin_unlock(&sk->sk_peer_lock);
223 sk_acceptq_added(parent);
225 EXPORT_SYMBOL(bt_accept_enqueue);
227 /* Calling function must hold the sk lock.
228 * bt_sk(sk)->parent must be non-NULL meaning sk is in the parent list.
230 void bt_accept_unlink(struct sock *sk)
232 BT_DBG("sk %p state %d", sk, sk->sk_state);
234 list_del_init(&bt_sk(sk)->accept_q);
235 sk_acceptq_removed(bt_sk(sk)->parent);
236 bt_sk(sk)->parent = NULL;
239 EXPORT_SYMBOL(bt_accept_unlink);
241 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
243 struct bt_sock *s, *n;
246 BT_DBG("parent %p", parent);
249 list_for_each_entry_safe(s, n, &bt_sk(parent)->accept_q, accept_q) {
250 sk = (struct sock *)s;
252 /* Prevent early freeing of sk due to unlink and sock_kill */
256 /* Check sk has not already been unlinked via
257 * bt_accept_unlink() due to serialisation caused by sk locking
259 if (!bt_sk(sk)->parent) {
260 BT_DBG("sk %p, already unlinked", sk);
264 /* Restart the loop as sk is no longer in the list
265 * and also avoid a potential infinite loop because
266 * list_for_each_entry_safe() is not thread safe.
271 /* sk is safely in the parent list so reduce reference count */
274 /* FIXME: Is this check still needed */
275 if (sk->sk_state == BT_CLOSED) {
276 bt_accept_unlink(sk);
281 if (sk->sk_state == BT_CONNECTED || !newsock ||
282 test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
283 bt_accept_unlink(sk);
285 sock_graft(sk, newsock);
296 EXPORT_SYMBOL(bt_accept_dequeue);
298 int bt_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
301 struct sock *sk = sock->sk;
307 BT_DBG("sock %p sk %p len %zu", sock, sk, len);
314 skb = skb_recv_datagram(sk, flags, &err);
316 if (sk->sk_shutdown & RCV_SHUTDOWN)
326 msg->msg_flags |= MSG_TRUNC;
330 skb_reset_transport_header(skb);
331 err = skb_copy_datagram_msg(skb, 0, msg, copied);
333 sock_recv_cmsgs(msg, sk, skb);
335 if (msg->msg_name && bt_sk(sk)->skb_msg_name)
336 bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
339 if (test_bit(BT_SK_PKT_STATUS, &bt_sk(sk)->flags)) {
340 u8 pkt_status = hci_skb_pkt_status(skb);
342 put_cmsg(msg, SOL_BLUETOOTH, BT_SCM_PKT_STATUS,
343 sizeof(pkt_status), &pkt_status);
347 skb_free_datagram(sk, skb);
351 if (flags & MSG_TRUNC)
354 return err ? : copied;
356 EXPORT_SYMBOL(bt_sock_recvmsg);
358 static long bt_sock_data_wait(struct sock *sk, long timeo)
360 DECLARE_WAITQUEUE(wait, current);
362 add_wait_queue(sk_sleep(sk), &wait);
364 set_current_state(TASK_INTERRUPTIBLE);
366 if (!skb_queue_empty(&sk->sk_receive_queue))
369 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
372 if (signal_pending(current) || !timeo)
375 sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
377 timeo = schedule_timeout(timeo);
379 sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
382 __set_current_state(TASK_RUNNING);
383 remove_wait_queue(sk_sleep(sk), &wait);
387 int bt_sock_stream_recvmsg(struct socket *sock, struct msghdr *msg,
388 size_t size, int flags)
390 struct sock *sk = sock->sk;
392 size_t target, copied = 0;
398 BT_DBG("sk %p size %zu", sk, size);
402 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
403 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
409 skb = skb_dequeue(&sk->sk_receive_queue);
411 if (copied >= target)
414 err = sock_error(sk);
417 if (sk->sk_shutdown & RCV_SHUTDOWN)
424 timeo = bt_sock_data_wait(sk, timeo);
426 if (signal_pending(current)) {
427 err = sock_intr_errno(timeo);
433 chunk = min_t(unsigned int, skb->len, size);
434 if (skb_copy_datagram_msg(skb, 0, msg, chunk)) {
435 skb_queue_head(&sk->sk_receive_queue, skb);
443 sock_recv_cmsgs(msg, sk, skb);
445 if (!(flags & MSG_PEEK)) {
446 int skb_len = skb_headlen(skb);
448 if (chunk <= skb_len) {
449 __skb_pull(skb, chunk);
451 struct sk_buff *frag;
453 __skb_pull(skb, skb_len);
456 skb_walk_frags(skb, frag) {
457 if (chunk <= frag->len) {
458 /* Pulling partial data */
460 skb->data_len -= chunk;
461 __skb_pull(frag, chunk);
463 } else if (frag->len) {
464 /* Pulling all frag data */
466 skb->len -= frag->len;
467 skb->data_len -= frag->len;
468 __skb_pull(frag, frag->len);
474 skb_queue_head(&sk->sk_receive_queue, skb);
480 /* put message back and return */
481 skb_queue_head(&sk->sk_receive_queue, skb);
488 return copied ? : err;
490 EXPORT_SYMBOL(bt_sock_stream_recvmsg);
492 static inline __poll_t bt_accept_poll(struct sock *parent)
494 struct bt_sock *s, *n;
497 list_for_each_entry_safe(s, n, &bt_sk(parent)->accept_q, accept_q) {
498 sk = (struct sock *)s;
499 if (sk->sk_state == BT_CONNECTED ||
500 (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
501 sk->sk_state == BT_CONNECT2))
502 return EPOLLIN | EPOLLRDNORM;
508 __poll_t bt_sock_poll(struct file *file, struct socket *sock,
511 struct sock *sk = sock->sk;
514 poll_wait(file, sk_sleep(sk), wait);
516 if (sk->sk_state == BT_LISTEN)
517 return bt_accept_poll(sk);
519 if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue))
521 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
523 if (sk->sk_shutdown & RCV_SHUTDOWN)
524 mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
526 if (sk->sk_shutdown == SHUTDOWN_MASK)
529 if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
530 mask |= EPOLLIN | EPOLLRDNORM;
532 if (sk->sk_state == BT_CLOSED)
535 if (sk->sk_state == BT_CONNECT ||
536 sk->sk_state == BT_CONNECT2 ||
537 sk->sk_state == BT_CONFIG)
540 if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
541 mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
543 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
547 EXPORT_SYMBOL(bt_sock_poll);
549 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
551 struct sock *sk = sock->sk;
556 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
560 if (sk->sk_state == BT_LISTEN)
563 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
566 err = put_user(amount, (int __user *)arg);
570 if (sk->sk_state == BT_LISTEN)
574 skb = skb_peek(&sk->sk_receive_queue);
575 amount = skb ? skb->len : 0;
577 err = put_user(amount, (int __user *)arg);
587 EXPORT_SYMBOL(bt_sock_ioctl);
589 /* This function expects the sk lock to be held when called */
590 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
592 DECLARE_WAITQUEUE(wait, current);
597 add_wait_queue(sk_sleep(sk), &wait);
598 set_current_state(TASK_INTERRUPTIBLE);
599 while (sk->sk_state != state) {
605 if (signal_pending(current)) {
606 err = sock_intr_errno(timeo);
611 timeo = schedule_timeout(timeo);
613 set_current_state(TASK_INTERRUPTIBLE);
615 err = sock_error(sk);
619 __set_current_state(TASK_RUNNING);
620 remove_wait_queue(sk_sleep(sk), &wait);
623 EXPORT_SYMBOL(bt_sock_wait_state);
625 /* This function expects the sk lock to be held when called */
626 int bt_sock_wait_ready(struct sock *sk, unsigned int msg_flags)
628 DECLARE_WAITQUEUE(wait, current);
634 timeo = sock_sndtimeo(sk, !!(msg_flags & MSG_DONTWAIT));
636 add_wait_queue(sk_sleep(sk), &wait);
637 set_current_state(TASK_INTERRUPTIBLE);
638 while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
644 if (signal_pending(current)) {
645 err = sock_intr_errno(timeo);
650 timeo = schedule_timeout(timeo);
652 set_current_state(TASK_INTERRUPTIBLE);
654 err = sock_error(sk);
658 __set_current_state(TASK_RUNNING);
659 remove_wait_queue(sk_sleep(sk), &wait);
663 EXPORT_SYMBOL(bt_sock_wait_ready);
665 #ifdef CONFIG_PROC_FS
666 static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
667 __acquires(seq->private->l->lock)
669 struct bt_sock_list *l = pde_data(file_inode(seq->file));
672 return seq_hlist_start_head(&l->head, *pos);
675 static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
677 struct bt_sock_list *l = pde_data(file_inode(seq->file));
679 return seq_hlist_next(v, &l->head, pos);
682 static void bt_seq_stop(struct seq_file *seq, void *v)
683 __releases(seq->private->l->lock)
685 struct bt_sock_list *l = pde_data(file_inode(seq->file));
687 read_unlock(&l->lock);
690 static int bt_seq_show(struct seq_file *seq, void *v)
692 struct bt_sock_list *l = pde_data(file_inode(seq->file));
694 if (v == SEQ_START_TOKEN) {
695 seq_puts(seq, "sk RefCnt Rmem Wmem User Inode Parent");
697 if (l->custom_seq_show) {
699 l->custom_seq_show(seq, v);
704 struct sock *sk = sk_entry(v);
705 struct bt_sock *bt = bt_sk(sk);
708 "%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
710 refcount_read(&sk->sk_refcnt),
711 sk_rmem_alloc_get(sk),
712 sk_wmem_alloc_get(sk),
713 from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
715 bt->parent ? sock_i_ino(bt->parent) : 0LU);
717 if (l->custom_seq_show) {
719 l->custom_seq_show(seq, v);
727 static const struct seq_operations bt_seq_ops = {
728 .start = bt_seq_start,
734 int bt_procfs_init(struct net *net, const char *name,
735 struct bt_sock_list *sk_list,
736 int (*seq_show)(struct seq_file *, void *))
738 sk_list->custom_seq_show = seq_show;
740 if (!proc_create_seq_data(name, 0, net->proc_net, &bt_seq_ops, sk_list))
745 void bt_procfs_cleanup(struct net *net, const char *name)
747 remove_proc_entry(name, net->proc_net);
750 int bt_procfs_init(struct net *net, const char *name,
751 struct bt_sock_list *sk_list,
752 int (*seq_show)(struct seq_file *, void *))
757 void bt_procfs_cleanup(struct net *net, const char *name)
761 EXPORT_SYMBOL(bt_procfs_init);
762 EXPORT_SYMBOL(bt_procfs_cleanup);
764 static const struct net_proto_family bt_sock_family_ops = {
765 .owner = THIS_MODULE,
766 .family = PF_BLUETOOTH,
767 .create = bt_sock_create,
770 struct dentry *bt_debugfs;
771 EXPORT_SYMBOL_GPL(bt_debugfs);
773 #define VERSION __stringify(BT_SUBSYS_VERSION) "." \
774 __stringify(BT_SUBSYS_REVISION)
776 static int __init bt_init(void)
780 sock_skb_cb_check_size(sizeof(struct bt_skb_cb));
782 BT_INFO("Core ver %s", VERSION);
788 bt_debugfs = debugfs_create_dir("bluetooth", NULL);
792 err = bt_sysfs_init();
796 err = sock_register(&bt_sock_family_ops);
800 BT_INFO("HCI device and connection manager initialized");
802 err = hci_sock_init();
804 goto unregister_socket;
827 sock_unregister(PF_BLUETOOTH);
835 static void __exit bt_exit(void)
845 sock_unregister(PF_BLUETOOTH);
851 debugfs_remove_recursive(bt_debugfs);
854 subsys_initcall(bt_init);
855 module_exit(bt_exit);
857 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
858 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
859 MODULE_VERSION(VERSION);
860 MODULE_LICENSE("GPL");
861 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);