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