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	(BTPROTO_LAST + 1)
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 	"sk_lock-AF_BLUETOOTH-BTPROTO_ISO",
56 };
57 
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",
69 };
70 
bt_sock_reclassify_lock(struct sock * sk,int proto)71 void 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 }
80 EXPORT_SYMBOL(bt_sock_reclassify_lock);
81 
bt_sock_register(int proto,const struct net_proto_family * ops)82 int 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 }
100 EXPORT_SYMBOL(bt_sock_register);
101 
bt_sock_unregister(int proto)102 void 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 }
111 EXPORT_SYMBOL(bt_sock_unregister);
112 
bt_sock_create(struct net * net,struct socket * sock,int proto,int kern)113 static 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 
bt_sock_alloc(struct net * net,struct socket * sock,struct proto * prot,int proto,gfp_t prio,int kern)143 struct 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 
155 	sock_reset_flag(sk, SOCK_ZAPPED);
156 
157 	sk->sk_protocol = proto;
158 	sk->sk_state    = BT_OPEN;
159 
160 	/* Init peer information so it can be properly monitored */
161 	if (!kern) {
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);
166 	}
167 
168 	return sk;
169 }
170 EXPORT_SYMBOL(bt_sock_alloc);
171 
bt_sock_link(struct bt_sock_list * l,struct sock * sk)172 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
173 {
174 	write_lock(&l->lock);
175 	sk_add_node(sk, &l->head);
176 	write_unlock(&l->lock);
177 }
178 EXPORT_SYMBOL(bt_sock_link);
179 
bt_sock_unlink(struct bt_sock_list * l,struct sock * sk)180 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
181 {
182 	write_lock(&l->lock);
183 	sk_del_node_init(sk);
184 	write_unlock(&l->lock);
185 }
186 EXPORT_SYMBOL(bt_sock_unlink);
187 
bt_accept_enqueue(struct sock * parent,struct sock * sk,bool bh)188 void bt_accept_enqueue(struct sock *parent, struct sock *sk, bool bh)
189 {
190 	const struct cred *old_cred;
191 	struct pid *old_pid;
192 
193 	BT_DBG("parent %p, sk %p", parent, sk);
194 
195 	sock_hold(sk);
196 
197 	if (bh)
198 		bh_lock_sock_nested(sk);
199 	else
200 		lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
201 
202 	list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
203 	bt_sk(sk)->parent = parent;
204 
205 	/* Copy credentials from parent since for incoming connections the
206 	 * socket is allocated by the kernel.
207 	 */
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);
214 
215 	put_pid(old_pid);
216 	put_cred(old_cred);
217 
218 	if (bh)
219 		bh_unlock_sock(sk);
220 	else
221 		release_sock(sk);
222 
223 	sk_acceptq_added(parent);
224 }
225 EXPORT_SYMBOL(bt_accept_enqueue);
226 
227 /* Calling function must hold the sk lock.
228  * bt_sk(sk)->parent must be non-NULL meaning sk is in the parent list.
229  */
bt_accept_unlink(struct sock * sk)230 void bt_accept_unlink(struct sock *sk)
231 {
232 	BT_DBG("sk %p state %d", sk, sk->sk_state);
233 
234 	list_del_init(&bt_sk(sk)->accept_q);
235 	sk_acceptq_removed(bt_sk(sk)->parent);
236 	bt_sk(sk)->parent = NULL;
237 	sock_put(sk);
238 }
239 EXPORT_SYMBOL(bt_accept_unlink);
240 
bt_accept_dequeue(struct sock * parent,struct socket * newsock)241 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
242 {
243 	struct bt_sock *s, *n;
244 	struct sock *sk;
245 
246 	BT_DBG("parent %p", parent);
247 
248 restart:
249 	list_for_each_entry_safe(s, n, &bt_sk(parent)->accept_q, accept_q) {
250 		sk = (struct sock *)s;
251 
252 		/* Prevent early freeing of sk due to unlink and sock_kill */
253 		sock_hold(sk);
254 		lock_sock(sk);
255 
256 		/* Check sk has not already been unlinked via
257 		 * bt_accept_unlink() due to serialisation caused by sk locking
258 		 */
259 		if (!bt_sk(sk)->parent) {
260 			BT_DBG("sk %p, already unlinked", sk);
261 			release_sock(sk);
262 			sock_put(sk);
263 
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.
267 			 */
268 			goto restart;
269 		}
270 
271 		/* sk is safely in the parent list so reduce reference count */
272 		sock_put(sk);
273 
274 		/* FIXME: Is this check still needed */
275 		if (sk->sk_state == BT_CLOSED) {
276 			bt_accept_unlink(sk);
277 			release_sock(sk);
278 			continue;
279 		}
280 
281 		if (sk->sk_state == BT_CONNECTED || !newsock ||
282 		    test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
283 			bt_accept_unlink(sk);
284 			if (newsock)
285 				sock_graft(sk, newsock);
286 
287 			release_sock(sk);
288 			return sk;
289 		}
290 
291 		release_sock(sk);
292 	}
293 
294 	return NULL;
295 }
296 EXPORT_SYMBOL(bt_accept_dequeue);
297 
bt_sock_recvmsg(struct socket * sock,struct msghdr * msg,size_t len,int flags)298 int bt_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
299 		    int flags)
300 {
301 	struct sock *sk = sock->sk;
302 	struct sk_buff *skb;
303 	size_t copied;
304 	size_t skblen;
305 	int err;
306 
307 	BT_DBG("sock %p sk %p len %zu", sock, sk, len);
308 
309 	if (flags & MSG_OOB)
310 		return -EOPNOTSUPP;
311 
312 	lock_sock(sk);
313 
314 	skb = skb_recv_datagram(sk, flags, &err);
315 	if (!skb) {
316 		if (sk->sk_shutdown & RCV_SHUTDOWN)
317 			err = 0;
318 
319 		release_sock(sk);
320 		return err;
321 	}
322 
323 	skblen = skb->len;
324 	copied = skb->len;
325 	if (len < copied) {
326 		msg->msg_flags |= MSG_TRUNC;
327 		copied = len;
328 	}
329 
330 	skb_reset_transport_header(skb);
331 	err = skb_copy_datagram_msg(skb, 0, msg, copied);
332 	if (err == 0) {
333 		sock_recv_cmsgs(msg, sk, skb);
334 
335 		if (msg->msg_name && bt_sk(sk)->skb_msg_name)
336 			bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
337 						&msg->msg_namelen);
338 
339 		if (test_bit(BT_SK_PKT_STATUS, &bt_sk(sk)->flags)) {
340 			u8 pkt_status = hci_skb_pkt_status(skb);
341 
342 			put_cmsg(msg, SOL_BLUETOOTH, BT_SCM_PKT_STATUS,
343 				 sizeof(pkt_status), &pkt_status);
344 		}
345 	}
346 
347 	skb_free_datagram(sk, skb);
348 
349 	release_sock(sk);
350 
351 	if (flags & MSG_TRUNC)
352 		copied = skblen;
353 
354 	return err ? : copied;
355 }
356 EXPORT_SYMBOL(bt_sock_recvmsg);
357 
bt_sock_data_wait(struct sock * sk,long timeo)358 static long bt_sock_data_wait(struct sock *sk, long timeo)
359 {
360 	DECLARE_WAITQUEUE(wait, current);
361 
362 	add_wait_queue(sk_sleep(sk), &wait);
363 	for (;;) {
364 		set_current_state(TASK_INTERRUPTIBLE);
365 
366 		if (!skb_queue_empty(&sk->sk_receive_queue))
367 			break;
368 
369 		if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
370 			break;
371 
372 		if (signal_pending(current) || !timeo)
373 			break;
374 
375 		sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
376 		release_sock(sk);
377 		timeo = schedule_timeout(timeo);
378 		lock_sock(sk);
379 		sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
380 	}
381 
382 	__set_current_state(TASK_RUNNING);
383 	remove_wait_queue(sk_sleep(sk), &wait);
384 	return timeo;
385 }
386 
bt_sock_stream_recvmsg(struct socket * sock,struct msghdr * msg,size_t size,int flags)387 int bt_sock_stream_recvmsg(struct socket *sock, struct msghdr *msg,
388 			   size_t size, int flags)
389 {
390 	struct sock *sk = sock->sk;
391 	int err = 0;
392 	size_t target, copied = 0;
393 	long timeo;
394 
395 	if (flags & MSG_OOB)
396 		return -EOPNOTSUPP;
397 
398 	BT_DBG("sk %p size %zu", sk, size);
399 
400 	lock_sock(sk);
401 
402 	target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
403 	timeo  = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
404 
405 	do {
406 		struct sk_buff *skb;
407 		int chunk;
408 
409 		skb = skb_dequeue(&sk->sk_receive_queue);
410 		if (!skb) {
411 			if (copied >= target)
412 				break;
413 
414 			err = sock_error(sk);
415 			if (err)
416 				break;
417 			if (sk->sk_shutdown & RCV_SHUTDOWN)
418 				break;
419 
420 			err = -EAGAIN;
421 			if (!timeo)
422 				break;
423 
424 			timeo = bt_sock_data_wait(sk, timeo);
425 
426 			if (signal_pending(current)) {
427 				err = sock_intr_errno(timeo);
428 				goto out;
429 			}
430 			continue;
431 		}
432 
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);
436 			if (!copied)
437 				copied = -EFAULT;
438 			break;
439 		}
440 		copied += chunk;
441 		size   -= chunk;
442 
443 		sock_recv_cmsgs(msg, sk, skb);
444 
445 		if (!(flags & MSG_PEEK)) {
446 			int skb_len = skb_headlen(skb);
447 
448 			if (chunk <= skb_len) {
449 				__skb_pull(skb, chunk);
450 			} else {
451 				struct sk_buff *frag;
452 
453 				__skb_pull(skb, skb_len);
454 				chunk -= skb_len;
455 
456 				skb_walk_frags(skb, frag) {
457 					if (chunk <= frag->len) {
458 						/* Pulling partial data */
459 						skb->len -= chunk;
460 						skb->data_len -= chunk;
461 						__skb_pull(frag, chunk);
462 						break;
463 					} else if (frag->len) {
464 						/* Pulling all frag data */
465 						chunk -= frag->len;
466 						skb->len -= frag->len;
467 						skb->data_len -= frag->len;
468 						__skb_pull(frag, frag->len);
469 					}
470 				}
471 			}
472 
473 			if (skb->len) {
474 				skb_queue_head(&sk->sk_receive_queue, skb);
475 				break;
476 			}
477 			kfree_skb(skb);
478 
479 		} else {
480 			/* put message back and return */
481 			skb_queue_head(&sk->sk_receive_queue, skb);
482 			break;
483 		}
484 	} while (size);
485 
486 out:
487 	release_sock(sk);
488 	return copied ? : err;
489 }
490 EXPORT_SYMBOL(bt_sock_stream_recvmsg);
491 
bt_accept_poll(struct sock * parent)492 static inline __poll_t bt_accept_poll(struct sock *parent)
493 {
494 	struct bt_sock *s, *n;
495 	struct sock *sk;
496 
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;
503 	}
504 
505 	return 0;
506 }
507 
bt_sock_poll(struct file * file,struct socket * sock,poll_table * wait)508 __poll_t bt_sock_poll(struct file *file, struct socket *sock,
509 		      poll_table *wait)
510 {
511 	struct sock *sk = sock->sk;
512 	__poll_t mask = 0;
513 
514 	poll_wait(file, sk_sleep(sk), wait);
515 
516 	if (sk->sk_state == BT_LISTEN)
517 		return bt_accept_poll(sk);
518 
519 	if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue))
520 		mask |= EPOLLERR |
521 			(sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
522 
523 	if (sk->sk_shutdown & RCV_SHUTDOWN)
524 		mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
525 
526 	if (sk->sk_shutdown == SHUTDOWN_MASK)
527 		mask |= EPOLLHUP;
528 
529 	if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
530 		mask |= EPOLLIN | EPOLLRDNORM;
531 
532 	if (sk->sk_state == BT_CLOSED)
533 		mask |= EPOLLHUP;
534 
535 	if (sk->sk_state == BT_CONNECT ||
536 	    sk->sk_state == BT_CONNECT2 ||
537 	    sk->sk_state == BT_CONFIG)
538 		return mask;
539 
540 	if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
541 		mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
542 	else
543 		sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
544 
545 	return mask;
546 }
547 EXPORT_SYMBOL(bt_sock_poll);
548 
bt_sock_ioctl(struct socket * sock,unsigned int cmd,unsigned long arg)549 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
550 {
551 	struct sock *sk = sock->sk;
552 	struct sk_buff *skb;
553 	long amount;
554 	int err;
555 
556 	BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
557 
558 	switch (cmd) {
559 	case TIOCOUTQ:
560 		if (sk->sk_state == BT_LISTEN)
561 			return -EINVAL;
562 
563 		amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
564 		if (amount < 0)
565 			amount = 0;
566 		err = put_user(amount, (int __user *)arg);
567 		break;
568 
569 	case TIOCINQ:
570 		if (sk->sk_state == BT_LISTEN)
571 			return -EINVAL;
572 
573 		lock_sock(sk);
574 		skb = skb_peek(&sk->sk_receive_queue);
575 		amount = skb ? skb->len : 0;
576 		release_sock(sk);
577 		err = put_user(amount, (int __user *)arg);
578 		break;
579 
580 	default:
581 		err = -ENOIOCTLCMD;
582 		break;
583 	}
584 
585 	return err;
586 }
587 EXPORT_SYMBOL(bt_sock_ioctl);
588 
589 /* This function expects the sk lock to be held when called */
bt_sock_wait_state(struct sock * sk,int state,unsigned long timeo)590 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
591 {
592 	DECLARE_WAITQUEUE(wait, current);
593 	int err = 0;
594 
595 	BT_DBG("sk %p", sk);
596 
597 	add_wait_queue(sk_sleep(sk), &wait);
598 	set_current_state(TASK_INTERRUPTIBLE);
599 	while (sk->sk_state != state) {
600 		if (!timeo) {
601 			err = -EINPROGRESS;
602 			break;
603 		}
604 
605 		if (signal_pending(current)) {
606 			err = sock_intr_errno(timeo);
607 			break;
608 		}
609 
610 		release_sock(sk);
611 		timeo = schedule_timeout(timeo);
612 		lock_sock(sk);
613 		set_current_state(TASK_INTERRUPTIBLE);
614 
615 		err = sock_error(sk);
616 		if (err)
617 			break;
618 	}
619 	__set_current_state(TASK_RUNNING);
620 	remove_wait_queue(sk_sleep(sk), &wait);
621 	return err;
622 }
623 EXPORT_SYMBOL(bt_sock_wait_state);
624 
625 /* This function expects the sk lock to be held when called */
bt_sock_wait_ready(struct sock * sk,unsigned int msg_flags)626 int bt_sock_wait_ready(struct sock *sk, unsigned int msg_flags)
627 {
628 	DECLARE_WAITQUEUE(wait, current);
629 	unsigned long timeo;
630 	int err = 0;
631 
632 	BT_DBG("sk %p", sk);
633 
634 	timeo = sock_sndtimeo(sk, !!(msg_flags & MSG_DONTWAIT));
635 
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)) {
639 		if (!timeo) {
640 			err = -EAGAIN;
641 			break;
642 		}
643 
644 		if (signal_pending(current)) {
645 			err = sock_intr_errno(timeo);
646 			break;
647 		}
648 
649 		release_sock(sk);
650 		timeo = schedule_timeout(timeo);
651 		lock_sock(sk);
652 		set_current_state(TASK_INTERRUPTIBLE);
653 
654 		err = sock_error(sk);
655 		if (err)
656 			break;
657 	}
658 	__set_current_state(TASK_RUNNING);
659 	remove_wait_queue(sk_sleep(sk), &wait);
660 
661 	return err;
662 }
663 EXPORT_SYMBOL(bt_sock_wait_ready);
664 
665 #ifdef CONFIG_PROC_FS
bt_seq_start(struct seq_file * seq,loff_t * pos)666 static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
667 	__acquires(seq->private->l->lock)
668 {
669 	struct bt_sock_list *l = pde_data(file_inode(seq->file));
670 
671 	read_lock(&l->lock);
672 	return seq_hlist_start_head(&l->head, *pos);
673 }
674 
bt_seq_next(struct seq_file * seq,void * v,loff_t * pos)675 static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
676 {
677 	struct bt_sock_list *l = pde_data(file_inode(seq->file));
678 
679 	return seq_hlist_next(v, &l->head, pos);
680 }
681 
bt_seq_stop(struct seq_file * seq,void * v)682 static void bt_seq_stop(struct seq_file *seq, void *v)
683 	__releases(seq->private->l->lock)
684 {
685 	struct bt_sock_list *l = pde_data(file_inode(seq->file));
686 
687 	read_unlock(&l->lock);
688 }
689 
bt_seq_show(struct seq_file * seq,void * v)690 static int bt_seq_show(struct seq_file *seq, void *v)
691 {
692 	struct bt_sock_list *l = pde_data(file_inode(seq->file));
693 
694 	if (v == SEQ_START_TOKEN) {
695 		seq_puts(seq, "sk               RefCnt Rmem   Wmem   User   Inode  Parent");
696 
697 		if (l->custom_seq_show) {
698 			seq_putc(seq, ' ');
699 			l->custom_seq_show(seq, v);
700 		}
701 
702 		seq_putc(seq, '\n');
703 	} else {
704 		struct sock *sk = sk_entry(v);
705 		struct bt_sock *bt = bt_sk(sk);
706 
707 		seq_printf(seq,
708 			   "%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
709 			   sk,
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)),
714 			   sock_i_ino(sk),
715 			   bt->parent ? sock_i_ino(bt->parent) : 0LU);
716 
717 		if (l->custom_seq_show) {
718 			seq_putc(seq, ' ');
719 			l->custom_seq_show(seq, v);
720 		}
721 
722 		seq_putc(seq, '\n');
723 	}
724 	return 0;
725 }
726 
727 static const struct seq_operations bt_seq_ops = {
728 	.start = bt_seq_start,
729 	.next  = bt_seq_next,
730 	.stop  = bt_seq_stop,
731 	.show  = bt_seq_show,
732 };
733 
bt_procfs_init(struct net * net,const char * name,struct bt_sock_list * sk_list,int (* seq_show)(struct seq_file *,void *))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 *))
737 {
738 	sk_list->custom_seq_show = seq_show;
739 
740 	if (!proc_create_seq_data(name, 0, net->proc_net, &bt_seq_ops, sk_list))
741 		return -ENOMEM;
742 	return 0;
743 }
744 
bt_procfs_cleanup(struct net * net,const char * name)745 void bt_procfs_cleanup(struct net *net, const char *name)
746 {
747 	remove_proc_entry(name, net->proc_net);
748 }
749 #else
bt_procfs_init(struct net * net,const char * name,struct bt_sock_list * sk_list,int (* seq_show)(struct seq_file *,void *))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 *))
753 {
754 	return 0;
755 }
756 
bt_procfs_cleanup(struct net * net,const char * name)757 void bt_procfs_cleanup(struct net *net, const char *name)
758 {
759 }
760 #endif
761 EXPORT_SYMBOL(bt_procfs_init);
762 EXPORT_SYMBOL(bt_procfs_cleanup);
763 
764 static const struct net_proto_family bt_sock_family_ops = {
765 	.owner	= THIS_MODULE,
766 	.family	= PF_BLUETOOTH,
767 	.create	= bt_sock_create,
768 };
769 
770 struct dentry *bt_debugfs;
771 EXPORT_SYMBOL_GPL(bt_debugfs);
772 
773 #define VERSION __stringify(BT_SUBSYS_VERSION) "." \
774 		__stringify(BT_SUBSYS_REVISION)
775 
bt_init(void)776 static int __init bt_init(void)
777 {
778 	int err;
779 
780 	sock_skb_cb_check_size(sizeof(struct bt_skb_cb));
781 
782 	BT_INFO("Core ver %s", VERSION);
783 
784 	err = bt_selftest();
785 	if (err < 0)
786 		return err;
787 
788 	bt_debugfs = debugfs_create_dir("bluetooth", NULL);
789 
790 	bt_leds_init();
791 
792 	err = bt_sysfs_init();
793 	if (err < 0)
794 		goto cleanup_led;
795 
796 	err = sock_register(&bt_sock_family_ops);
797 	if (err)
798 		goto cleanup_sysfs;
799 
800 	BT_INFO("HCI device and connection manager initialized");
801 
802 	err = hci_sock_init();
803 	if (err)
804 		goto unregister_socket;
805 
806 	err = l2cap_init();
807 	if (err)
808 		goto cleanup_socket;
809 
810 	err = sco_init();
811 	if (err)
812 		goto cleanup_cap;
813 
814 	err = mgmt_init();
815 	if (err)
816 		goto cleanup_sco;
817 
818 	return 0;
819 
820 cleanup_sco:
821 	sco_exit();
822 cleanup_cap:
823 	l2cap_exit();
824 cleanup_socket:
825 	hci_sock_cleanup();
826 unregister_socket:
827 	sock_unregister(PF_BLUETOOTH);
828 cleanup_sysfs:
829 	bt_sysfs_cleanup();
830 cleanup_led:
831 	bt_leds_cleanup();
832 	return err;
833 }
834 
bt_exit(void)835 static void __exit bt_exit(void)
836 {
837 	mgmt_exit();
838 
839 	sco_exit();
840 
841 	l2cap_exit();
842 
843 	hci_sock_cleanup();
844 
845 	sock_unregister(PF_BLUETOOTH);
846 
847 	bt_sysfs_cleanup();
848 
849 	bt_leds_cleanup();
850 
851 	debugfs_remove_recursive(bt_debugfs);
852 }
853 
854 subsys_initcall(bt_init);
855 module_exit(bt_exit);
856 
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);
862