projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Bluetooth: Fix locking issue during fast SCO reconnection.
[deliverable/linux.git] / net / bluetooth / af_bluetooth.c
CommitLineData
8e87d142 1/*
1da177e4
LT		 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
8e87d142
YH		 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
1da177e4
LT		 18 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
8e87d142
YH		 20 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
1da177e4
LT		 22 SOFTWARE IS DISCLAIMED.
23*/
24
25/* Bluetooth address family and sockets. */
26
1da177e4 27#include <linux/module.h>
ffcecac6 28#include <linux/debugfs.h>
3241ad82 29#include <asm/ioctls.h>
1da177e4
LT		 30
31#include <net/bluetooth/bluetooth.h>
256a06c8 32#include <linux/proc_fs.h>
1da177e4 33
ee485290
MH		 34#include "selftest.h"
35
13972adc 36#define VERSION "2.21"
1da177e4
LT		 37
38/* Bluetooth sockets */
39#define BT_MAX_PROTO 8
ec1b4cf7 40static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
db7aa1c2 41static DEFINE_RWLOCK(bt_proto_lock);
68845cb2 42
68845cb2 43static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
36cbd3dc 44static const char *const bt_key_strings[BT_MAX_PROTO] = {
68845cb2
DY		 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",
53};
54
db7aa1c2 55static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
36cbd3dc 56static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
68845cb2
DY		 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",
65};
db7aa1c2 66
b5a30dda 67void bt_sock_reclassify_lock(struct sock *sk, int proto)
db7aa1c2 68{
b5a30dda 69 BUG_ON(!sk);
db7aa1c2
MH		 70 BUG_ON(sock_owned_by_user(sk));
71
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]);
75}
b5a30dda 76EXPORT_SYMBOL(bt_sock_reclassify_lock);
1da177e4 77
ec1b4cf7 78int bt_sock_register(int proto, const struct net_proto_family *ops)
1da177e4 79{
74da626a
MH		 80 int err = 0;
81
1da177e4
LT		 82 if (proto < 0 || proto >= BT_MAX_PROTO)
83 return -EINVAL;
84
74da626a
MH		 85 write_lock(&bt_proto_lock);
86
1da177e4 87 if (bt_proto[proto])
74da626a
MH		 88 err = -EEXIST;
89 else
90 bt_proto[proto] = ops;
91
92 write_unlock(&bt_proto_lock);
1da177e4 93
74da626a 94 return err;
1da177e4
LT		 95}
96EXPORT_SYMBOL(bt_sock_register);
97
be9f97f0 98void bt_sock_unregister(int proto)
1da177e4
LT		 99{
100 if (proto < 0 || proto >= BT_MAX_PROTO)
be9f97f0 101 return;
1da177e4 102
74da626a 103 write_lock(&bt_proto_lock);
be9f97f0 104 bt_proto[proto] = NULL;
74da626a 105 write_unlock(&bt_proto_lock);
1da177e4
LT		 106}
107EXPORT_SYMBOL(bt_sock_unregister);
108
3f378b68
EP		 109static int bt_sock_create(struct net *net, struct socket *sock, int proto,
110 int kern)
1da177e4 111{
74da626a 112 int err;
1da177e4 113
1b8d7ae4
EB		 114 if (net != &init_net)
115 return -EAFNOSUPPORT;
116
1da177e4
LT		 117 if (proto < 0 || proto >= BT_MAX_PROTO)
118 return -EINVAL;
119
95a5afca 120 if (!bt_proto[proto])
1da177e4 121 request_module("bt-proto-%d", proto);
74da626a 122
1da177e4 123 err = -EPROTONOSUPPORT;
74da626a
MH		 124
125 read_lock(&bt_proto_lock);
126
1da177e4 127 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
3f378b68 128 err = bt_proto[proto]->create(net, sock, proto, kern);
b5a30dda
OP		 129 if (!err)
130 bt_sock_reclassify_lock(sock->sk, proto);
1da177e4
LT		 131 module_put(bt_proto[proto]->owner);
132 }
74da626a
MH		 133
134 read_unlock(&bt_proto_lock);
135
8e87d142 136 return err;
1da177e4
LT		 137}
138
139void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
140{
94f5bfb8 141 write_lock(&l->lock);
1da177e4 142 sk_add_node(sk, &l->head);
94f5bfb8 143 write_unlock(&l->lock);
1da177e4
LT		 144}
145EXPORT_SYMBOL(bt_sock_link);
146
147void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
148{
94f5bfb8 149 write_lock(&l->lock);
1da177e4 150 sk_del_node_init(sk);
94f5bfb8 151 write_unlock(&l->lock);
1da177e4
LT		 152}
153EXPORT_SYMBOL(bt_sock_unlink);
154
155void bt_accept_enqueue(struct sock *parent, struct sock *sk)
156{
157 BT_DBG("parent %p, sk %p", parent, sk);
158
159 sock_hold(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++;
163}
164EXPORT_SYMBOL(bt_accept_enqueue);
165
166void bt_accept_unlink(struct sock *sk)
167{
168 BT_DBG("sk %p state %d", sk, sk->sk_state);
169
170 list_del_init(&bt_sk(sk)->accept_q);
171 bt_sk(sk)->parent->sk_ack_backlog--;
172 bt_sk(sk)->parent = NULL;
173 sock_put(sk);
174}
175EXPORT_SYMBOL(bt_accept_unlink);
176
177struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
178{
179 struct list_head *p, *n;
180 struct sock *sk;
181
182 BT_DBG("parent %p", parent);
183
184 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
185 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
186
8a154a8f 187 lock_sock(sk);
1da177e4
LT		 188
189 /* FIXME: Is this check still needed */
190 if (sk->sk_state == BT_CLOSED) {
8a154a8f 191 release_sock(sk);
1da177e4
LT		 192 bt_accept_unlink(sk);
193 continue;
194 }
195
c4f912e1 196 if (sk->sk_state == BT_CONNECTED || !newsock ||
d060991f 197 test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
1da177e4
LT		 198 bt_accept_unlink(sk);
199 if (newsock)
200 sock_graft(sk, newsock);
d37f50e1 201
8a154a8f 202 release_sock(sk);
1da177e4
LT		 203 return sk;
204 }
205
8a154a8f 206 release_sock(sk);
1da177e4 207 }
d37f50e1 208
1da177e4
LT		 209 return NULL;
210}
211EXPORT_SYMBOL(bt_accept_dequeue);
212
1b784140
YX		 213int bt_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
214 int flags)
1da177e4
LT		 215{
216 int noblock = flags & MSG_DONTWAIT;
217 struct sock *sk = sock->sk;
218 struct sk_buff *skb;
219 size_t copied;
220 int err;
221
a418b893 222 BT_DBG("sock %p sk %p len %zu", sock, sk, len);
1da177e4
LT		 223
224 if (flags & (MSG_OOB))
225 return -EOPNOTSUPP;
226
5a08ecce
AE		 227 skb = skb_recv_datagram(sk, flags, noblock, &err);
228 if (!skb) {
f3d33426 229 if (sk->sk_shutdown & RCV_SHUTDOWN)
1da177e4 230 return 0;
f3d33426 231
1da177e4
LT		 232 return err;
233 }
234
1da177e4
LT		 235 copied = skb->len;
236 if (len < copied) {
237 msg->msg_flags |= MSG_TRUNC;
238 copied = len;
239 }
240
badff6d0 241 skb_reset_transport_header(skb);
51f3d02b 242 err = skb_copy_datagram_msg(skb, 0, msg, copied);
d9763698 243 if (err == 0) {
3b885787 244 sock_recv_ts_and_drops(msg, sk, skb);
1da177e4 245
d9763698
MH		 246 if (bt_sk(sk)->skb_msg_name)
247 bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
248 &msg->msg_namelen);
d9763698
MH		 249 }
250
1da177e4
LT		 251 skb_free_datagram(sk, skb);
252
253 return err ? : copied;
254}
255EXPORT_SYMBOL(bt_sock_recvmsg);
256
796c86ee
MM		 257static long bt_sock_data_wait(struct sock *sk, long timeo)
258{
259 DECLARE_WAITQUEUE(wait, current);
260
261 add_wait_queue(sk_sleep(sk), &wait);
262 for (;;) {
263 set_current_state(TASK_INTERRUPTIBLE);
264
265 if (!skb_queue_empty(&sk->sk_receive_queue))
266 break;
267
268 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
269 break;
270
271 if (signal_pending(current) || !timeo)
272 break;
273
274 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
275 release_sock(sk);
276 timeo = schedule_timeout(timeo);
277 lock_sock(sk);
278 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
279 }
280
281 __set_current_state(TASK_RUNNING);
282 remove_wait_queue(sk_sleep(sk), &wait);
283 return timeo;
284}
285
1b784140
YX		 286int bt_sock_stream_recvmsg(struct socket *sock, struct msghdr *msg,
287 size_t size, int flags)
796c86ee
MM		 288{
289 struct sock *sk = sock->sk;
290 int err = 0;
291 size_t target, copied = 0;
292 long timeo;
293
294 if (flags & MSG_OOB)
295 return -EOPNOTSUPP;
296
796c86ee
MM		 297 BT_DBG("sk %p size %zu", sk, size);
298
299 lock_sock(sk);
300
301 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
302 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
303
304 do {
305 struct sk_buff *skb;
306 int chunk;
307
308 skb = skb_dequeue(&sk->sk_receive_queue);
309 if (!skb) {
310 if (copied >= target)
311 break;
312
5a08ecce
AE		 313 err = sock_error(sk);
314 if (err)
796c86ee
MM		 315 break;
316 if (sk->sk_shutdown & RCV_SHUTDOWN)
317 break;
318
319 err = -EAGAIN;
320 if (!timeo)
321 break;
322
323 timeo = bt_sock_data_wait(sk, timeo);
324
325 if (signal_pending(current)) {
326 err = sock_intr_errno(timeo);
327 goto out;
328 }
329 continue;
330 }
331
332 chunk = min_t(unsigned int, skb->len, size);
51f3d02b 333 if (skb_copy_datagram_msg(skb, 0, msg, chunk)) {
796c86ee
MM		 334 skb_queue_head(&sk->sk_receive_queue, skb);
335 if (!copied)
336 copied = -EFAULT;
337 break;
338 }
339 copied += chunk;
340 size -= chunk;
341
342 sock_recv_ts_and_drops(msg, sk, skb);
343
344 if (!(flags & MSG_PEEK)) {
5b668eb3
MM		 345 int skb_len = skb_headlen(skb);
346
347 if (chunk <= skb_len) {
348 __skb_pull(skb, chunk);
349 } else {
350 struct sk_buff *frag;
351
352 __skb_pull(skb, skb_len);
353 chunk -= skb_len;
354
355 skb_walk_frags(skb, frag) {
356 if (chunk <= frag->len) {
357 /* Pulling partial data */
358 skb->len -= chunk;
359 skb->data_len -= chunk;
360 __skb_pull(frag, chunk);
361 break;
362 } else if (frag->len) {
363 /* Pulling all frag data */
364 chunk -= frag->len;
365 skb->len -= frag->len;
366 skb->data_len -= frag->len;
367 __skb_pull(frag, frag->len);
368 }
369 }
370 }
371
796c86ee
MM		 372 if (skb->len) {
373 skb_queue_head(&sk->sk_receive_queue, skb);
374 break;
375 }
376 kfree_skb(skb);
377
378 } else {
379 /* put message back and return */
380 skb_queue_head(&sk->sk_receive_queue, skb);
381 break;
382 }
383 } while (size);
384
385out:
386 release_sock(sk);
387 return copied ? : err;
388}
389EXPORT_SYMBOL(bt_sock_stream_recvmsg);
390
1da177e4
LT		 391static inline unsigned int bt_accept_poll(struct sock *parent)
392{
393 struct list_head *p, *n;
394 struct sock *sk;
395
396 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
397 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
d5f2d2be 398 if (sk->sk_state == BT_CONNECTED ||
c5daa683
GP		 399 (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
400 sk->sk_state == BT_CONNECT2))
1da177e4
LT		 401 return POLLIN | POLLRDNORM;
402 }
403
404 return 0;
405}
406
8fc9ced3
GP		 407unsigned int bt_sock_poll(struct file *file, struct socket *sock,
408 poll_table *wait)
1da177e4
LT		 409{
410 struct sock *sk = sock->sk;
411 unsigned int mask = 0;
412
413 BT_DBG("sock %p, sk %p", sock, sk);
414
aa395145 415 poll_wait(file, sk_sleep(sk), wait);
1da177e4
LT		 416
417 if (sk->sk_state == BT_LISTEN)
418 return bt_accept_poll(sk);
419
420 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
7d4c04fc 421 mask |= POLLERR |
8facd5fb 422 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
1da177e4 423
f348d70a 424 if (sk->sk_shutdown & RCV_SHUTDOWN)
db40980f 425 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
f348d70a 426
1da177e4
LT		 427 if (sk->sk_shutdown == SHUTDOWN_MASK)
428 mask |= POLLHUP;
429
db40980f 430 if (!skb_queue_empty(&sk->sk_receive_queue))
1da177e4
LT		 431 mask |= POLLIN | POLLRDNORM;
432
433 if (sk->sk_state == BT_CLOSED)
434 mask |= POLLHUP;
435
436 if (sk->sk_state == BT_CONNECT ||
437 sk->sk_state == BT_CONNECT2 ||
438 sk->sk_state == BT_CONFIG)
439 return mask;
440
c5daa683 441 if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
1da177e4
LT		 442 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
443 else
444 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
445
446 return mask;
447}
448EXPORT_SYMBOL(bt_sock_poll);
449
3241ad82
MH		 450int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
451{
452 struct sock *sk = sock->sk;
43cbeee9
MH		 453 struct sk_buff *skb;
454 long amount;
3241ad82
MH		 455 int err;
456
457 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
458
459 switch (cmd) {
43cbeee9
MH		 460 case TIOCOUTQ:
461 if (sk->sk_state == BT_LISTEN)
462 return -EINVAL;
463
31e6d363 464 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
43cbeee9
MH		 465 if (amount < 0)
466 amount = 0;
467 err = put_user(amount, (int __user *) arg);
468 break;
469
470 case TIOCINQ:
471 if (sk->sk_state == BT_LISTEN)
472 return -EINVAL;
473
474 lock_sock(sk);
475 skb = skb_peek(&sk->sk_receive_queue);
476 amount = skb ? skb->len : 0;
477 release_sock(sk);
478 err = put_user(amount, (int __user *) arg);
479 break;
480
3241ad82
MH		 481 case SIOCGSTAMP:
482 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
483 break;
484
485 case SIOCGSTAMPNS:
486 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
487 break;
488
489 default:
490 err = -ENOIOCTLCMD;
491 break;
492 }
493
494 return err;
495}
496EXPORT_SYMBOL(bt_sock_ioctl);
497
0fba96f9 498/* This function expects the sk lock to be held when called */
1da177e4
LT		 499int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
500{
501 DECLARE_WAITQUEUE(wait, current);
502 int err = 0;
503
504 BT_DBG("sk %p", sk);
505
aa395145 506 add_wait_queue(sk_sleep(sk), &wait);
9be4e3fb 507 set_current_state(TASK_INTERRUPTIBLE);
1da177e4 508 while (sk->sk_state != state) {
1da177e4 509 if (!timeo) {
b4c612a4 510 err = -EINPROGRESS;
1da177e4
LT		 511 break;
512 }
513
514 if (signal_pending(current)) {
515 err = sock_intr_errno(timeo);
516 break;
517 }
518
519 release_sock(sk);
520 timeo = schedule_timeout(timeo);
521 lock_sock(sk);
9be4e3fb 522 set_current_state(TASK_INTERRUPTIBLE);
1da177e4 523
c1cbe4b7
BL		 524 err = sock_error(sk);
525 if (err)
1da177e4 526 break;
1da177e4 527 }
9be4e3fb 528 __set_current_state(TASK_RUNNING);
aa395145 529 remove_wait_queue(sk_sleep(sk), &wait);
1da177e4
LT		 530 return err;
531}
532EXPORT_SYMBOL(bt_sock_wait_state);
533
e793dcf0
JH		 534/* This function expects the sk lock to be held when called */
535int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
536{
537 DECLARE_WAITQUEUE(wait, current);
538 unsigned long timeo;
539 int err = 0;
540
541 BT_DBG("sk %p", sk);
542
543 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
544
545 add_wait_queue(sk_sleep(sk), &wait);
546 set_current_state(TASK_INTERRUPTIBLE);
547 while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
548 if (!timeo) {
549 err = -EAGAIN;
550 break;
551 }
552
553 if (signal_pending(current)) {
554 err = sock_intr_errno(timeo);
555 break;
556 }
557
558 release_sock(sk);
559 timeo = schedule_timeout(timeo);
560 lock_sock(sk);
561 set_current_state(TASK_INTERRUPTIBLE);
562
563 err = sock_error(sk);
564 if (err)
565 break;
566 }
567 __set_current_state(TASK_RUNNING);
568 remove_wait_queue(sk_sleep(sk), &wait);
569
570 return err;
571}
572EXPORT_SYMBOL(bt_sock_wait_ready);
573
256a06c8
MY		 574#ifdef CONFIG_PROC_FS
575struct bt_seq_state {
576 struct bt_sock_list *l;
577};
578
579static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
580 __acquires(seq->private->l->lock)
581{
582 struct bt_seq_state *s = seq->private;
583 struct bt_sock_list *l = s->l;
584
585 read_lock(&l->lock);
586 return seq_hlist_start_head(&l->head, *pos);
587}
588
589static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
590{
591 struct bt_seq_state *s = seq->private;
592 struct bt_sock_list *l = s->l;
593
594 return seq_hlist_next(v, &l->head, pos);
595}
596
597static void bt_seq_stop(struct seq_file *seq, void *v)
598 __releases(seq->private->l->lock)
599{
600 struct bt_seq_state *s = seq->private;
601 struct bt_sock_list *l = s->l;
602
603 read_unlock(&l->lock);
604}
605
606static int bt_seq_show(struct seq_file *seq, void *v)
607{
256a06c8
MY		 608 struct bt_seq_state *s = seq->private;
609 struct bt_sock_list *l = s->l;
256a06c8
MY		 610
611 if (v == SEQ_START_TOKEN) {
c5605755 612 seq_puts(seq ,"sk RefCnt Rmem Wmem User Inode Parent");
256a06c8
MY		 613
614 if (l->custom_seq_show) {
615 seq_putc(seq, ' ');
616 l->custom_seq_show(seq, v);
617 }
618
619 seq_putc(seq, '\n');
620 } else {
09d5d4aa
AE		 621 struct sock *sk = sk_entry(v);
622 struct bt_sock *bt = bt_sk(sk);
256a06c8 623
7028a886 624 seq_printf(seq,
5f6cd79f 625 "%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
256a06c8
MY		 626 sk,
627 atomic_read(&sk->sk_refcnt),
628 sk_rmem_alloc_get(sk),
629 sk_wmem_alloc_get(sk),
1bbb3095 630 from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
256a06c8 631 sock_i_ino(sk),
256a06c8
MY		 632 bt->parent? sock_i_ino(bt->parent): 0LU);
633
634 if (l->custom_seq_show) {
635 seq_putc(seq, ' ');
636 l->custom_seq_show(seq, v);
637 }
638
639 seq_putc(seq, '\n');
640 }
641 return 0;
642}
643
26b0f4e2 644static const struct seq_operations bt_seq_ops = {
256a06c8
MY		 645 .start = bt_seq_start,
646 .next = bt_seq_next,
647 .stop = bt_seq_stop,
648 .show = bt_seq_show,
649};
650
651static int bt_seq_open(struct inode *inode, struct file *file)
652{
653 struct bt_sock_list *sk_list;
654 struct bt_seq_state *s;
655
d9dda78b 656 sk_list = PDE_DATA(inode);
256a06c8
MY		 657 s = __seq_open_private(file, &bt_seq_ops,
658 sizeof(struct bt_seq_state));
31f47073 659 if (!s)
256a06c8
MY		 660 return -ENOMEM;
661
662 s->l = sk_list;
663 return 0;
664}
665
14805359
AV		 666static const struct file_operations bt_fops = {
667 .open = bt_seq_open,
668 .read = seq_read,
669 .llseek = seq_lseek,
670 .release = seq_release_private
671};
672
b0316615 673int bt_procfs_init(struct net *net, const char *name,
256a06c8
MY		 674 struct bt_sock_list* sk_list,
675 int (* seq_show)(struct seq_file *, void *))
676{
256a06c8
MY		 677 sk_list->custom_seq_show = seq_show;
678
4d006263 679 if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
256a06c8 680 return -ENOMEM;
256a06c8
MY		 681 return 0;
682}
683
684void bt_procfs_cleanup(struct net *net, const char *name)
685{
ece31ffd 686 remove_proc_entry(name, net->proc_net);
256a06c8
MY		 687}
688#else
b0316615 689int bt_procfs_init(struct net *net, const char *name,
256a06c8
MY		 690 struct bt_sock_list* sk_list,
691 int (* seq_show)(struct seq_file *, void *))
692{
693 return 0;
694}
695
696void bt_procfs_cleanup(struct net *net, const char *name)
697{
698}
699#endif
700EXPORT_SYMBOL(bt_procfs_init);
701EXPORT_SYMBOL(bt_procfs_cleanup);
702
1da177e4
LT		 703static struct net_proto_family bt_sock_family_ops = {
704 .owner = THIS_MODULE,
705 .family = PF_BLUETOOTH,
706 .create = bt_sock_create,
707};
708
ffcecac6
MH		 709struct dentry *bt_debugfs;
710EXPORT_SYMBOL_GPL(bt_debugfs);
711
1da177e4
LT		 712static int __init bt_init(void)
713{
27d35284
MH		 714 int err;
715
b4772ef8 716 sock_skb_cb_check_size(sizeof(struct bt_skb_cb));
7cb9d20f 717
1da177e4
LT		 718 BT_INFO("Core ver %s", VERSION);
719
ee485290
MH		 720 err = bt_selftest();
721 if (err < 0)
722 return err;
723
ffcecac6
MH		 724 bt_debugfs = debugfs_create_dir("bluetooth", NULL);
725
27d35284
MH		 726 err = bt_sysfs_init();
727 if (err < 0)
728 return err;
1da177e4 729
27d35284
MH		 730 err = sock_register(&bt_sock_family_ops);
731 if (err < 0) {
732 bt_sysfs_cleanup();
733 return err;
734 }
1da177e4 735
27d35284 736 BT_INFO("HCI device and connection manager initialized");
1da177e4 737
64274518
GP		 738 err = hci_sock_init();
739 if (err < 0)
740 goto error;
741
742 err = l2cap_init();
0ed54dad 743 if (err < 0)
64274518 744 goto sock_err;
64274518
GP		 745
746 err = sco_init();
747 if (err < 0) {
748 l2cap_exit();
749 goto sock_err;
750 }
1da177e4 751
6d785aa3
JH		 752 err = mgmt_init();
753 if (err < 0) {
754 sco_exit();
755 l2cap_exit();
756 goto sock_err;
757 }
758
1da177e4 759 return 0;
64274518
GP		 760
761sock_err:
762 hci_sock_cleanup();
763
764error:
765 sock_unregister(PF_BLUETOOTH);
766 bt_sysfs_cleanup();
767
768 return err;
1da177e4
LT		 769}
770
771static void __exit bt_exit(void)
772{
6d785aa3
JH		 773 mgmt_exit();
774
64274518
GP		 775 sco_exit();
776
777 l2cap_exit();
778
1da177e4
LT		 779 hci_sock_cleanup();
780
1da177e4 781 sock_unregister(PF_BLUETOOTH);
27d35284
MH		 782
783 bt_sysfs_cleanup();
ffcecac6
MH		 784
785 debugfs_remove_recursive(bt_debugfs);
1da177e4
LT		 786}
787
788subsys_initcall(bt_init);
789module_exit(bt_exit);
790
63fbd24e 791MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1da177e4
LT		 792MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
793MODULE_VERSION(VERSION);
794MODULE_LICENSE("GPL");
795MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);
Linux kernel - Deliverables
This page took 0.855209 seconds and 5 git commands to generate.