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 <asm/ioctls.h>
32 #include <net/bluetooth/bluetooth.h>
33 #include <linux/proc_fs.h>
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);
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",
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",
67 void bt_sock_reclassify_lock(struct sock *sk, int proto)
70 BUG_ON(!sock_allow_reclassification(sk));
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]);
76 EXPORT_SYMBOL(bt_sock_reclassify_lock);
78 int bt_sock_register(int proto, const struct net_proto_family *ops)
82 if (proto < 0 || proto >= BT_MAX_PROTO)
85 write_lock(&bt_proto_lock);
90 bt_proto[proto] = ops;
92 write_unlock(&bt_proto_lock);
96 EXPORT_SYMBOL(bt_sock_register);
98 void bt_sock_unregister(int proto)
100 if (proto < 0 || proto >= BT_MAX_PROTO)
103 write_lock(&bt_proto_lock);
104 bt_proto[proto] = NULL;
105 write_unlock(&bt_proto_lock);
107 EXPORT_SYMBOL(bt_sock_unregister);
109 static int bt_sock_create(struct net *net, struct socket *sock, int proto,
114 if (net != &init_net)
115 return -EAFNOSUPPORT;
117 if (proto < 0 || proto >= BT_MAX_PROTO)
120 if (!bt_proto[proto])
121 request_module("bt-proto-%d", proto);
123 err = -EPROTONOSUPPORT;
125 read_lock(&bt_proto_lock);
127 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
128 err = bt_proto[proto]->create(net, sock, proto, kern);
130 bt_sock_reclassify_lock(sock->sk, proto);
131 module_put(bt_proto[proto]->owner);
134 read_unlock(&bt_proto_lock);
139 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
141 write_lock(&l->lock);
142 sk_add_node(sk, &l->head);
143 write_unlock(&l->lock);
145 EXPORT_SYMBOL(bt_sock_link);
147 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
149 write_lock(&l->lock);
150 sk_del_node_init(sk);
151 write_unlock(&l->lock);
153 EXPORT_SYMBOL(bt_sock_unlink);
155 void bt_accept_enqueue(struct sock *parent, struct sock *sk)
157 BT_DBG("parent %p, sk %p", parent, 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++;
164 EXPORT_SYMBOL(bt_accept_enqueue);
166 /* Calling function must hold the sk lock.
167 * bt_sk(sk)->parent must be non-NULL meaning sk is in the parent list.
169 void bt_accept_unlink(struct sock *sk)
171 BT_DBG("sk %p state %d", sk, sk->sk_state);
173 list_del_init(&bt_sk(sk)->accept_q);
174 bt_sk(sk)->parent->sk_ack_backlog--;
175 bt_sk(sk)->parent = NULL;
178 EXPORT_SYMBOL(bt_accept_unlink);
180 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
182 struct bt_sock *s, *n;
185 BT_DBG("parent %p", parent);
188 list_for_each_entry_safe(s, n, &bt_sk(parent)->accept_q, accept_q) {
189 sk = (struct sock *)s;
191 /* Prevent early freeing of sk due to unlink and sock_kill */
195 /* Check sk has not already been unlinked via
196 * bt_accept_unlink() due to serialisation caused by sk locking
198 if (!bt_sk(sk)->parent) {
199 BT_DBG("sk %p, already unlinked", sk);
203 /* Restart the loop as sk is no longer in the list
204 * and also avoid a potential infinite loop because
205 * list_for_each_entry_safe() is not thread safe.
210 /* sk is safely in the parent list so reduce reference count */
213 /* FIXME: Is this check still needed */
214 if (sk->sk_state == BT_CLOSED) {
215 bt_accept_unlink(sk);
220 if (sk->sk_state == BT_CONNECTED || !newsock ||
221 test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
222 bt_accept_unlink(sk);
224 sock_graft(sk, newsock);
235 EXPORT_SYMBOL(bt_accept_dequeue);
237 int bt_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
240 int noblock = flags & MSG_DONTWAIT;
241 struct sock *sk = sock->sk;
247 BT_DBG("sock %p sk %p len %zu", sock, sk, len);
252 skb = skb_recv_datagram(sk, flags, noblock, &err);
254 if (sk->sk_shutdown & RCV_SHUTDOWN)
263 msg->msg_flags |= MSG_TRUNC;
267 skb_reset_transport_header(skb);
268 err = skb_copy_datagram_msg(skb, 0, msg, copied);
270 sock_recv_ts_and_drops(msg, sk, skb);
272 if (bt_sk(sk)->skb_msg_name)
273 bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
277 skb_free_datagram(sk, skb);
279 if (flags & MSG_TRUNC)
282 return err ? : copied;
284 EXPORT_SYMBOL(bt_sock_recvmsg);
286 static long bt_sock_data_wait(struct sock *sk, long timeo)
288 DECLARE_WAITQUEUE(wait, current);
290 add_wait_queue(sk_sleep(sk), &wait);
292 set_current_state(TASK_INTERRUPTIBLE);
294 if (!skb_queue_empty(&sk->sk_receive_queue))
297 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
300 if (signal_pending(current) || !timeo)
303 sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
305 timeo = schedule_timeout(timeo);
307 sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
310 __set_current_state(TASK_RUNNING);
311 remove_wait_queue(sk_sleep(sk), &wait);
315 int bt_sock_stream_recvmsg(struct socket *sock, struct msghdr *msg,
316 size_t size, int flags)
318 struct sock *sk = sock->sk;
320 size_t target, copied = 0;
326 BT_DBG("sk %p size %zu", sk, size);
330 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
331 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
337 skb = skb_dequeue(&sk->sk_receive_queue);
339 if (copied >= target)
342 err = sock_error(sk);
345 if (sk->sk_shutdown & RCV_SHUTDOWN)
352 timeo = bt_sock_data_wait(sk, timeo);
354 if (signal_pending(current)) {
355 err = sock_intr_errno(timeo);
361 chunk = min_t(unsigned int, skb->len, size);
362 if (skb_copy_datagram_msg(skb, 0, msg, chunk)) {
363 skb_queue_head(&sk->sk_receive_queue, skb);
371 sock_recv_ts_and_drops(msg, sk, skb);
373 if (!(flags & MSG_PEEK)) {
374 int skb_len = skb_headlen(skb);
376 if (chunk <= skb_len) {
377 __skb_pull(skb, chunk);
379 struct sk_buff *frag;
381 __skb_pull(skb, skb_len);
384 skb_walk_frags(skb, frag) {
385 if (chunk <= frag->len) {
386 /* Pulling partial data */
388 skb->data_len -= chunk;
389 __skb_pull(frag, chunk);
391 } else if (frag->len) {
392 /* Pulling all frag data */
394 skb->len -= frag->len;
395 skb->data_len -= frag->len;
396 __skb_pull(frag, frag->len);
402 skb_queue_head(&sk->sk_receive_queue, skb);
408 /* put message back and return */
409 skb_queue_head(&sk->sk_receive_queue, skb);
416 return copied ? : err;
418 EXPORT_SYMBOL(bt_sock_stream_recvmsg);
420 static inline unsigned int bt_accept_poll(struct sock *parent)
422 struct bt_sock *s, *n;
425 list_for_each_entry_safe(s, n, &bt_sk(parent)->accept_q, accept_q) {
426 sk = (struct sock *)s;
427 if (sk->sk_state == BT_CONNECTED ||
428 (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
429 sk->sk_state == BT_CONNECT2))
430 return POLLIN | POLLRDNORM;
436 unsigned int bt_sock_poll(struct file *file, struct socket *sock,
439 struct sock *sk = sock->sk;
440 unsigned int mask = 0;
442 BT_DBG("sock %p, sk %p", sock, sk);
444 poll_wait(file, sk_sleep(sk), wait);
446 if (sk->sk_state == BT_LISTEN)
447 return bt_accept_poll(sk);
449 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
451 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
453 if (sk->sk_shutdown & RCV_SHUTDOWN)
454 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
456 if (sk->sk_shutdown == SHUTDOWN_MASK)
459 if (!skb_queue_empty(&sk->sk_receive_queue))
460 mask |= POLLIN | POLLRDNORM;
462 if (sk->sk_state == BT_CLOSED)
465 if (sk->sk_state == BT_CONNECT ||
466 sk->sk_state == BT_CONNECT2 ||
467 sk->sk_state == BT_CONFIG)
470 if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
471 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
473 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
477 EXPORT_SYMBOL(bt_sock_poll);
479 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
481 struct sock *sk = sock->sk;
486 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
490 if (sk->sk_state == BT_LISTEN)
493 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
496 err = put_user(amount, (int __user *) arg);
500 if (sk->sk_state == BT_LISTEN)
504 skb = skb_peek(&sk->sk_receive_queue);
505 amount = skb ? skb->len : 0;
507 err = put_user(amount, (int __user *) arg);
511 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
515 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
525 EXPORT_SYMBOL(bt_sock_ioctl);
527 /* This function expects the sk lock to be held when called */
528 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
530 DECLARE_WAITQUEUE(wait, current);
535 add_wait_queue(sk_sleep(sk), &wait);
536 set_current_state(TASK_INTERRUPTIBLE);
537 while (sk->sk_state != state) {
543 if (signal_pending(current)) {
544 err = sock_intr_errno(timeo);
549 timeo = schedule_timeout(timeo);
551 set_current_state(TASK_INTERRUPTIBLE);
553 err = sock_error(sk);
557 __set_current_state(TASK_RUNNING);
558 remove_wait_queue(sk_sleep(sk), &wait);
561 EXPORT_SYMBOL(bt_sock_wait_state);
563 /* This function expects the sk lock to be held when called */
564 int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
566 DECLARE_WAITQUEUE(wait, current);
572 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
574 add_wait_queue(sk_sleep(sk), &wait);
575 set_current_state(TASK_INTERRUPTIBLE);
576 while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
582 if (signal_pending(current)) {
583 err = sock_intr_errno(timeo);
588 timeo = schedule_timeout(timeo);
590 set_current_state(TASK_INTERRUPTIBLE);
592 err = sock_error(sk);
596 __set_current_state(TASK_RUNNING);
597 remove_wait_queue(sk_sleep(sk), &wait);
601 EXPORT_SYMBOL(bt_sock_wait_ready);
603 #ifdef CONFIG_PROC_FS
604 struct bt_seq_state {
605 struct bt_sock_list *l;
608 static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
609 __acquires(seq->private->l->lock)
611 struct bt_seq_state *s = seq->private;
612 struct bt_sock_list *l = s->l;
615 return seq_hlist_start_head(&l->head, *pos);
618 static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
620 struct bt_seq_state *s = seq->private;
621 struct bt_sock_list *l = s->l;
623 return seq_hlist_next(v, &l->head, pos);
626 static void bt_seq_stop(struct seq_file *seq, void *v)
627 __releases(seq->private->l->lock)
629 struct bt_seq_state *s = seq->private;
630 struct bt_sock_list *l = s->l;
632 read_unlock(&l->lock);
635 static int bt_seq_show(struct seq_file *seq, void *v)
637 struct bt_seq_state *s = seq->private;
638 struct bt_sock_list *l = s->l;
640 if (v == SEQ_START_TOKEN) {
641 seq_puts(seq ,"sk RefCnt Rmem Wmem User Inode Parent");
643 if (l->custom_seq_show) {
645 l->custom_seq_show(seq, v);
650 struct sock *sk = sk_entry(v);
651 struct bt_sock *bt = bt_sk(sk);
654 "%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
656 atomic_read(&sk->sk_refcnt),
657 sk_rmem_alloc_get(sk),
658 sk_wmem_alloc_get(sk),
659 from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
661 bt->parent? sock_i_ino(bt->parent): 0LU);
663 if (l->custom_seq_show) {
665 l->custom_seq_show(seq, v);
673 static const struct seq_operations bt_seq_ops = {
674 .start = bt_seq_start,
680 static int bt_seq_open(struct inode *inode, struct file *file)
682 struct bt_sock_list *sk_list;
683 struct bt_seq_state *s;
685 sk_list = PDE_DATA(inode);
686 s = __seq_open_private(file, &bt_seq_ops,
687 sizeof(struct bt_seq_state));
695 static const struct file_operations bt_fops = {
699 .release = seq_release_private
702 int bt_procfs_init(struct net *net, const char *name,
703 struct bt_sock_list *sk_list,
704 int (* seq_show)(struct seq_file *, void *))
706 sk_list->custom_seq_show = seq_show;
708 if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
713 void bt_procfs_cleanup(struct net *net, const char *name)
715 remove_proc_entry(name, net->proc_net);
718 int bt_procfs_init(struct net *net, const char *name,
719 struct bt_sock_list *sk_list,
720 int (* seq_show)(struct seq_file *, void *))
725 void bt_procfs_cleanup(struct net *net, const char *name)
729 EXPORT_SYMBOL(bt_procfs_init);
730 EXPORT_SYMBOL(bt_procfs_cleanup);
732 static struct net_proto_family bt_sock_family_ops = {
733 .owner = THIS_MODULE,
734 .family = PF_BLUETOOTH,
735 .create = bt_sock_create,
738 struct dentry *bt_debugfs;
739 EXPORT_SYMBOL_GPL(bt_debugfs);
741 #define VERSION __stringify(BT_SUBSYS_VERSION) "." \
742 __stringify(BT_SUBSYS_REVISION)
744 static int __init bt_init(void)
748 sock_skb_cb_check_size(sizeof(struct bt_skb_cb));
750 BT_INFO("Core ver %s", VERSION);
756 bt_debugfs = debugfs_create_dir("bluetooth", NULL);
760 err = bt_sysfs_init();
764 err = sock_register(&bt_sock_family_ops);
770 BT_INFO("HCI device and connection manager initialized");
772 err = hci_sock_init();
799 sock_unregister(PF_BLUETOOTH);
805 static void __exit bt_exit(void)
815 sock_unregister(PF_BLUETOOTH);
821 debugfs_remove_recursive(bt_debugfs);
824 subsys_initcall(bt_init);
825 module_exit(bt_exit);
827 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
828 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
829 MODULE_VERSION(VERSION);
830 MODULE_LICENSE("GPL");
831 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);