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)
 42static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
 43static DEFINE_RWLOCK(bt_proto_lock);
 44
 45static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
 46static 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
 58static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
 59static 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
 71void 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}
 80EXPORT_SYMBOL(bt_sock_reclassify_lock);
 81
 82int 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}
100EXPORT_SYMBOL(bt_sock_register);
101
102void 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}
111EXPORT_SYMBOL(bt_sock_unregister);
112
113static 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
143struct 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}
170EXPORT_SYMBOL(bt_sock_alloc);
171
172void 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}
178EXPORT_SYMBOL(bt_sock_link);
179
180void 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}
186EXPORT_SYMBOL(bt_sock_unlink);
187
188void 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}
225EXPORT_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 */
230void 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}
239EXPORT_SYMBOL(bt_accept_unlink);
240
241struct 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
248restart:
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}
296EXPORT_SYMBOL(bt_accept_dequeue);
297
298int 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}
356EXPORT_SYMBOL(bt_sock_recvmsg);
357
358static 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
387int 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
486out:
487	release_sock(sk);
488	return copied ? : err;
489}
490EXPORT_SYMBOL(bt_sock_stream_recvmsg);
491
492static 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
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}
547EXPORT_SYMBOL(bt_sock_poll);
548
549int 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}
587EXPORT_SYMBOL(bt_sock_ioctl);
588
589/* This function expects the sk lock to be held when called */
590int 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}
623EXPORT_SYMBOL(bt_sock_wait_state);
624
625/* This function expects the sk lock to be held when called */
626int 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}
663EXPORT_SYMBOL(bt_sock_wait_ready);
664
665#ifdef CONFIG_PROC_FS
666static 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
675static 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
682static 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
690static 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
727static 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
734int 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
745void bt_procfs_cleanup(struct net *net, const char *name)
746{
747	remove_proc_entry(name, net->proc_net);
748}
749#else
750int 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
757void bt_procfs_cleanup(struct net *net, const char *name)
758{
759}
760#endif
761EXPORT_SYMBOL(bt_procfs_init);
762EXPORT_SYMBOL(bt_procfs_cleanup);
763
764static const struct net_proto_family bt_sock_family_ops = {
765	.owner	= THIS_MODULE,
766	.family	= PF_BLUETOOTH,
767	.create	= bt_sock_create,
768};
769
770struct dentry *bt_debugfs;
771EXPORT_SYMBOL_GPL(bt_debugfs);
772
773#define VERSION __stringify(BT_SUBSYS_VERSION) "." \
774		__stringify(BT_SUBSYS_REVISION)
775
776static 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
820cleanup_sco:
821	sco_exit();
822cleanup_cap:
823	l2cap_exit();
824cleanup_socket:
825	hci_sock_cleanup();
826unregister_socket:
827	sock_unregister(PF_BLUETOOTH);
828cleanup_sysfs:
829	bt_sysfs_cleanup();
830cleanup_led:
831	bt_leds_cleanup();
832	return err;
833}
834
835static 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
854subsys_initcall(bt_init);
855module_exit(bt_exit);
856
857MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
858MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
859MODULE_VERSION(VERSION);
860MODULE_LICENSE("GPL");
861MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);