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 <asm/ioctls.h>
31 #include <net/bluetooth/bluetooth.h>
32 #include <linux/proc_fs.h>
36 #define VERSION "2.20"
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_owned_by_user(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 void bt_accept_unlink(struct sock *sk)
168 BT_DBG("sk %p state %d", sk, sk->sk_state);
170 list_del_init(&bt_sk(sk)->accept_q);
171 bt_sk(sk)->parent->sk_ack_backlog--;
172 bt_sk(sk)->parent = NULL;
175 EXPORT_SYMBOL(bt_accept_unlink);
177 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
179 struct list_head *p, *n;
182 BT_DBG("parent %p", parent);
184 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
185 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
189 /* FIXME: Is this check still needed */
190 if (sk->sk_state == BT_CLOSED) {
192 #ifdef CONFIG_TIZEN_WIP /* Fix kernel panic */
193 if (bt_sk(sk)->parent)
195 bt_accept_unlink(sk);
199 if (sk->sk_state == BT_CONNECTED || !newsock ||
200 test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
201 #ifdef CONFIG_TIZEN_WIP /* Fix kernel panic */
202 if (bt_sk(sk)->parent)
204 bt_accept_unlink(sk);
206 sock_graft(sk, newsock);
217 EXPORT_SYMBOL(bt_accept_dequeue);
219 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
220 struct msghdr *msg, size_t len, int flags)
222 int noblock = flags & MSG_DONTWAIT;
223 struct sock *sk = sock->sk;
228 BT_DBG("sock %p sk %p len %zu", sock, sk, len);
230 if (flags & (MSG_OOB))
233 skb = skb_recv_datagram(sk, flags, noblock, &err);
235 if (sk->sk_shutdown & RCV_SHUTDOWN)
243 msg->msg_flags |= MSG_TRUNC;
247 skb_reset_transport_header(skb);
248 #ifdef CONFIG_TIZEN_WIP
249 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
251 err = skb_copy_datagram_msg(skb, 0, msg, copied);
254 sock_recv_ts_and_drops(msg, sk, skb);
256 if (bt_sk(sk)->skb_msg_name)
257 bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
261 skb_free_datagram(sk, skb);
263 return err ? : copied;
265 EXPORT_SYMBOL(bt_sock_recvmsg);
267 static long bt_sock_data_wait(struct sock *sk, long timeo)
269 DECLARE_WAITQUEUE(wait, current);
271 add_wait_queue(sk_sleep(sk), &wait);
273 set_current_state(TASK_INTERRUPTIBLE);
275 if (!skb_queue_empty(&sk->sk_receive_queue))
278 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
281 if (signal_pending(current) || !timeo)
284 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
286 timeo = schedule_timeout(timeo);
288 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
291 __set_current_state(TASK_RUNNING);
292 remove_wait_queue(sk_sleep(sk), &wait);
296 int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
297 struct msghdr *msg, size_t size, int flags)
299 struct sock *sk = sock->sk;
301 size_t target, copied = 0;
307 BT_DBG("sk %p size %zu", sk, size);
311 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
312 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
318 skb = skb_dequeue(&sk->sk_receive_queue);
320 if (copied >= target)
323 err = sock_error(sk);
326 if (sk->sk_shutdown & RCV_SHUTDOWN)
333 timeo = bt_sock_data_wait(sk, timeo);
335 if (signal_pending(current)) {
336 err = sock_intr_errno(timeo);
342 chunk = min_t(unsigned int, skb->len, size);
343 #ifdef CONFIG_TIZEN_WIP
344 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
346 if (skb_copy_datagram_msg(skb, 0, msg, chunk)) {
348 skb_queue_head(&sk->sk_receive_queue, skb);
356 sock_recv_ts_and_drops(msg, sk, skb);
358 if (!(flags & MSG_PEEK)) {
359 int skb_len = skb_headlen(skb);
361 if (chunk <= skb_len) {
362 __skb_pull(skb, chunk);
364 struct sk_buff *frag;
366 __skb_pull(skb, skb_len);
369 skb_walk_frags(skb, frag) {
370 if (chunk <= frag->len) {
371 /* Pulling partial data */
373 skb->data_len -= chunk;
374 __skb_pull(frag, chunk);
376 } else if (frag->len) {
377 /* Pulling all frag data */
379 skb->len -= frag->len;
380 skb->data_len -= frag->len;
381 __skb_pull(frag, frag->len);
387 skb_queue_head(&sk->sk_receive_queue, skb);
393 /* put message back and return */
394 skb_queue_head(&sk->sk_receive_queue, skb);
401 return copied ? : err;
403 EXPORT_SYMBOL(bt_sock_stream_recvmsg);
405 static inline unsigned int bt_accept_poll(struct sock *parent)
407 struct list_head *p, *n;
410 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
411 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
412 if (sk->sk_state == BT_CONNECTED ||
413 (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
414 sk->sk_state == BT_CONNECT2))
415 return POLLIN | POLLRDNORM;
421 unsigned int bt_sock_poll(struct file *file, struct socket *sock,
424 struct sock *sk = sock->sk;
425 unsigned int mask = 0;
427 BT_DBG("sock %p, sk %p", sock, sk);
429 poll_wait(file, sk_sleep(sk), wait);
431 if (sk->sk_state == BT_LISTEN)
432 return bt_accept_poll(sk);
434 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
436 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
438 if (sk->sk_shutdown & RCV_SHUTDOWN)
439 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
441 if (sk->sk_shutdown == SHUTDOWN_MASK)
444 if (!skb_queue_empty(&sk->sk_receive_queue))
445 mask |= POLLIN | POLLRDNORM;
447 if (sk->sk_state == BT_CLOSED)
450 if (sk->sk_state == BT_CONNECT ||
451 sk->sk_state == BT_CONNECT2 ||
452 sk->sk_state == BT_CONFIG)
455 if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
456 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
458 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
462 EXPORT_SYMBOL(bt_sock_poll);
464 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
466 struct sock *sk = sock->sk;
471 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
475 if (sk->sk_state == BT_LISTEN)
478 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
481 err = put_user(amount, (int __user *) arg);
485 if (sk->sk_state == BT_LISTEN)
489 skb = skb_peek(&sk->sk_receive_queue);
490 amount = skb ? skb->len : 0;
492 err = put_user(amount, (int __user *) arg);
496 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
500 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
510 EXPORT_SYMBOL(bt_sock_ioctl);
512 /* This function expects the sk lock to be held when called */
513 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
515 DECLARE_WAITQUEUE(wait, current);
520 add_wait_queue(sk_sleep(sk), &wait);
521 set_current_state(TASK_INTERRUPTIBLE);
522 while (sk->sk_state != state) {
528 if (signal_pending(current)) {
529 err = sock_intr_errno(timeo);
534 timeo = schedule_timeout(timeo);
536 set_current_state(TASK_INTERRUPTIBLE);
538 err = sock_error(sk);
542 __set_current_state(TASK_RUNNING);
543 remove_wait_queue(sk_sleep(sk), &wait);
546 EXPORT_SYMBOL(bt_sock_wait_state);
548 /* This function expects the sk lock to be held when called */
549 int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
551 DECLARE_WAITQUEUE(wait, current);
557 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
559 add_wait_queue(sk_sleep(sk), &wait);
560 set_current_state(TASK_INTERRUPTIBLE);
561 while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
567 if (signal_pending(current)) {
568 err = sock_intr_errno(timeo);
573 timeo = schedule_timeout(timeo);
575 set_current_state(TASK_INTERRUPTIBLE);
577 err = sock_error(sk);
581 __set_current_state(TASK_RUNNING);
582 remove_wait_queue(sk_sleep(sk), &wait);
586 EXPORT_SYMBOL(bt_sock_wait_ready);
588 #ifdef CONFIG_PROC_FS
589 struct bt_seq_state {
590 struct bt_sock_list *l;
593 static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
594 __acquires(seq->private->l->lock)
596 struct bt_seq_state *s = seq->private;
597 struct bt_sock_list *l = s->l;
600 return seq_hlist_start_head(&l->head, *pos);
603 static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
605 struct bt_seq_state *s = seq->private;
606 struct bt_sock_list *l = s->l;
608 return seq_hlist_next(v, &l->head, pos);
611 static void bt_seq_stop(struct seq_file *seq, void *v)
612 __releases(seq->private->l->lock)
614 struct bt_seq_state *s = seq->private;
615 struct bt_sock_list *l = s->l;
617 read_unlock(&l->lock);
620 static int bt_seq_show(struct seq_file *seq, void *v)
622 struct bt_seq_state *s = seq->private;
623 struct bt_sock_list *l = s->l;
625 if (v == SEQ_START_TOKEN) {
626 seq_puts(seq ,"sk RefCnt Rmem Wmem User Inode Parent");
628 if (l->custom_seq_show) {
630 l->custom_seq_show(seq, v);
635 struct sock *sk = sk_entry(v);
636 struct bt_sock *bt = bt_sk(sk);
639 "%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
641 atomic_read(&sk->sk_refcnt),
642 sk_rmem_alloc_get(sk),
643 sk_wmem_alloc_get(sk),
644 from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
646 bt->parent? sock_i_ino(bt->parent): 0LU);
648 if (l->custom_seq_show) {
650 l->custom_seq_show(seq, v);
658 static const struct seq_operations bt_seq_ops = {
659 .start = bt_seq_start,
665 static int bt_seq_open(struct inode *inode, struct file *file)
667 struct bt_sock_list *sk_list;
668 struct bt_seq_state *s;
670 sk_list = PDE_DATA(inode);
671 s = __seq_open_private(file, &bt_seq_ops,
672 sizeof(struct bt_seq_state));
680 static const struct file_operations bt_fops = {
684 .release = seq_release_private
687 int bt_procfs_init(struct net *net, const char *name,
688 struct bt_sock_list* sk_list,
689 int (* seq_show)(struct seq_file *, void *))
691 sk_list->custom_seq_show = seq_show;
693 if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
698 void bt_procfs_cleanup(struct net *net, const char *name)
700 remove_proc_entry(name, net->proc_net);
703 int bt_procfs_init(struct net *net, const char *name,
704 struct bt_sock_list* sk_list,
705 int (* seq_show)(struct seq_file *, void *))
710 void bt_procfs_cleanup(struct net *net, const char *name)
714 EXPORT_SYMBOL(bt_procfs_init);
715 EXPORT_SYMBOL(bt_procfs_cleanup);
717 static struct net_proto_family bt_sock_family_ops = {
718 .owner = THIS_MODULE,
719 .family = PF_BLUETOOTH,
720 .create = bt_sock_create,
723 struct dentry *bt_debugfs;
724 EXPORT_SYMBOL_GPL(bt_debugfs);
726 static int __init bt_init(void)
731 BUILD_BUG_ON(sizeof(struct bt_skb_cb) > sizeof(skb->cb));
733 BT_INFO("Core ver %s", VERSION);
739 bt_debugfs = debugfs_create_dir("bluetooth", NULL);
741 err = bt_sysfs_init();
745 err = sock_register(&bt_sock_family_ops);
751 BT_INFO("HCI device and connection manager initialized");
753 err = hci_sock_init();
773 sock_unregister(PF_BLUETOOTH);
779 static void __exit bt_exit(void)
787 sock_unregister(PF_BLUETOOTH);
791 debugfs_remove_recursive(bt_debugfs);
794 subsys_initcall(bt_init);
795 module_exit(bt_exit);
797 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
798 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
799 MODULE_VERSION(VERSION);
800 MODULE_LICENSE("GPL");
801 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);