Bluetooth: silence lockdep warning
[linux-3.10.git] / net / bluetooth / af_bluetooth.c
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
29 #include <linux/types.h>
30 #include <linux/list.h>
31 #include <linux/errno.h>
32 #include <linux/kernel.h>
33 #include <linux/sched.h>
34 #include <linux/skbuff.h>
35 #include <linux/init.h>
36 #include <linux/poll.h>
37 #include <net/sock.h>
38 #include <asm/ioctls.h>
39 #include <linux/kmod.h>
40
41 #include <net/bluetooth/bluetooth.h>
42
43 #define VERSION "2.16"
44
45 /* Bluetooth sockets */
46 #define BT_MAX_PROTO    8
47 static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
48 static DEFINE_RWLOCK(bt_proto_lock);
49
50 static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
51 static const char *const bt_key_strings[BT_MAX_PROTO] = {
52         "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
53         "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
54         "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
55         "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
56         "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
57         "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
58         "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
59         "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
60 };
61
62 static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
63 static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
64         "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
65         "slock-AF_BLUETOOTH-BTPROTO_HCI",
66         "slock-AF_BLUETOOTH-BTPROTO_SCO",
67         "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
68         "slock-AF_BLUETOOTH-BTPROTO_BNEP",
69         "slock-AF_BLUETOOTH-BTPROTO_CMTP",
70         "slock-AF_BLUETOOTH-BTPROTO_HIDP",
71         "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
72 };
73
74 void bt_sock_reclassify_lock(struct sock *sk, int proto)
75 {
76         BUG_ON(!sk);
77         BUG_ON(sock_owned_by_user(sk));
78
79         sock_lock_init_class_and_name(sk,
80                         bt_slock_key_strings[proto], &bt_slock_key[proto],
81                                 bt_key_strings[proto], &bt_lock_key[proto]);
82 }
83 EXPORT_SYMBOL(bt_sock_reclassify_lock);
84
85 int bt_sock_register(int proto, const struct net_proto_family *ops)
86 {
87         int err = 0;
88
89         if (proto < 0 || proto >= BT_MAX_PROTO)
90                 return -EINVAL;
91
92         write_lock(&bt_proto_lock);
93
94         if (bt_proto[proto])
95                 err = -EEXIST;
96         else
97                 bt_proto[proto] = ops;
98
99         write_unlock(&bt_proto_lock);
100
101         return err;
102 }
103 EXPORT_SYMBOL(bt_sock_register);
104
105 int bt_sock_unregister(int proto)
106 {
107         int err = 0;
108
109         if (proto < 0 || proto >= BT_MAX_PROTO)
110                 return -EINVAL;
111
112         write_lock(&bt_proto_lock);
113
114         if (!bt_proto[proto])
115                 err = -ENOENT;
116         else
117                 bt_proto[proto] = NULL;
118
119         write_unlock(&bt_proto_lock);
120
121         return err;
122 }
123 EXPORT_SYMBOL(bt_sock_unregister);
124
125 static int bt_sock_create(struct net *net, struct socket *sock, int proto,
126                           int kern)
127 {
128         int err;
129
130         if (net != &init_net)
131                 return -EAFNOSUPPORT;
132
133         if (proto < 0 || proto >= BT_MAX_PROTO)
134                 return -EINVAL;
135
136         if (!bt_proto[proto])
137                 request_module("bt-proto-%d", proto);
138
139         err = -EPROTONOSUPPORT;
140
141         read_lock(&bt_proto_lock);
142
143         if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
144                 err = bt_proto[proto]->create(net, sock, proto, kern);
145                 if (!err)
146                         bt_sock_reclassify_lock(sock->sk, proto);
147                 module_put(bt_proto[proto]->owner);
148         }
149
150         read_unlock(&bt_proto_lock);
151
152         return err;
153 }
154
155 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
156 {
157         write_lock(&l->lock);
158         sk_add_node(sk, &l->head);
159         write_unlock(&l->lock);
160 }
161 EXPORT_SYMBOL(bt_sock_link);
162
163 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
164 {
165         write_lock(&l->lock);
166         sk_del_node_init(sk);
167         write_unlock(&l->lock);
168 }
169 EXPORT_SYMBOL(bt_sock_unlink);
170
171 void bt_accept_enqueue(struct sock *parent, struct sock *sk)
172 {
173         BT_DBG("parent %p, sk %p", parent, sk);
174
175         sock_hold(sk);
176         list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
177         bt_sk(sk)->parent = parent;
178         parent->sk_ack_backlog++;
179 }
180 EXPORT_SYMBOL(bt_accept_enqueue);
181
182 void bt_accept_unlink(struct sock *sk)
183 {
184         BT_DBG("sk %p state %d", sk, sk->sk_state);
185
186         list_del_init(&bt_sk(sk)->accept_q);
187         bt_sk(sk)->parent->sk_ack_backlog--;
188         bt_sk(sk)->parent = NULL;
189         sock_put(sk);
190 }
191 EXPORT_SYMBOL(bt_accept_unlink);
192
193 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
194 {
195         struct list_head *p, *n;
196         struct sock *sk;
197
198         BT_DBG("parent %p", parent);
199
200         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
201                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
202
203                 lock_sock(sk);
204
205                 /* FIXME: Is this check still needed */
206                 if (sk->sk_state == BT_CLOSED) {
207                         release_sock(sk);
208                         bt_accept_unlink(sk);
209                         continue;
210                 }
211
212                 if (sk->sk_state == BT_CONNECTED || !newsock ||
213                                                 bt_sk(parent)->defer_setup) {
214                         bt_accept_unlink(sk);
215                         if (newsock)
216                                 sock_graft(sk, newsock);
217
218                         release_sock(sk);
219                         return sk;
220                 }
221
222                 release_sock(sk);
223         }
224
225         return NULL;
226 }
227 EXPORT_SYMBOL(bt_accept_dequeue);
228
229 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
230                                 struct msghdr *msg, size_t len, int flags)
231 {
232         int noblock = flags & MSG_DONTWAIT;
233         struct sock *sk = sock->sk;
234         struct sk_buff *skb;
235         size_t copied;
236         int err;
237
238         BT_DBG("sock %p sk %p len %zu", sock, sk, len);
239
240         if (flags & (MSG_OOB))
241                 return -EOPNOTSUPP;
242
243         skb = skb_recv_datagram(sk, flags, noblock, &err);
244         if (!skb) {
245                 if (sk->sk_shutdown & RCV_SHUTDOWN)
246                         return 0;
247                 return err;
248         }
249
250         msg->msg_namelen = 0;
251
252         copied = skb->len;
253         if (len < copied) {
254                 msg->msg_flags |= MSG_TRUNC;
255                 copied = len;
256         }
257
258         skb_reset_transport_header(skb);
259         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
260         if (err == 0)
261                 sock_recv_ts_and_drops(msg, sk, skb);
262
263         skb_free_datagram(sk, skb);
264
265         return err ? : copied;
266 }
267 EXPORT_SYMBOL(bt_sock_recvmsg);
268
269 static long bt_sock_data_wait(struct sock *sk, long timeo)
270 {
271         DECLARE_WAITQUEUE(wait, current);
272
273         add_wait_queue(sk_sleep(sk), &wait);
274         for (;;) {
275                 set_current_state(TASK_INTERRUPTIBLE);
276
277                 if (!skb_queue_empty(&sk->sk_receive_queue))
278                         break;
279
280                 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
281                         break;
282
283                 if (signal_pending(current) || !timeo)
284                         break;
285
286                 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
287                 release_sock(sk);
288                 timeo = schedule_timeout(timeo);
289                 lock_sock(sk);
290                 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
291         }
292
293         __set_current_state(TASK_RUNNING);
294         remove_wait_queue(sk_sleep(sk), &wait);
295         return timeo;
296 }
297
298 int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
299                                struct msghdr *msg, size_t size, int flags)
300 {
301         struct sock *sk = sock->sk;
302         int err = 0;
303         size_t target, copied = 0;
304         long timeo;
305
306         if (flags & MSG_OOB)
307                 return -EOPNOTSUPP;
308
309         msg->msg_namelen = 0;
310
311         BT_DBG("sk %p size %zu", sk, size);
312
313         lock_sock(sk);
314
315         target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
316         timeo  = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
317
318         do {
319                 struct sk_buff *skb;
320                 int chunk;
321
322                 skb = skb_dequeue(&sk->sk_receive_queue);
323                 if (!skb) {
324                         if (copied >= target)
325                                 break;
326
327                         err = sock_error(sk);
328                         if (err)
329                                 break;
330                         if (sk->sk_shutdown & RCV_SHUTDOWN)
331                                 break;
332
333                         err = -EAGAIN;
334                         if (!timeo)
335                                 break;
336
337                         timeo = bt_sock_data_wait(sk, timeo);
338
339                         if (signal_pending(current)) {
340                                 err = sock_intr_errno(timeo);
341                                 goto out;
342                         }
343                         continue;
344                 }
345
346                 chunk = min_t(unsigned int, skb->len, size);
347                 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
348                         skb_queue_head(&sk->sk_receive_queue, skb);
349                         if (!copied)
350                                 copied = -EFAULT;
351                         break;
352                 }
353                 copied += chunk;
354                 size   -= chunk;
355
356                 sock_recv_ts_and_drops(msg, sk, skb);
357
358                 if (!(flags & MSG_PEEK)) {
359                         int skb_len = skb_headlen(skb);
360
361                         if (chunk <= skb_len) {
362                                 __skb_pull(skb, chunk);
363                         } else {
364                                 struct sk_buff *frag;
365
366                                 __skb_pull(skb, skb_len);
367                                 chunk -= skb_len;
368
369                                 skb_walk_frags(skb, frag) {
370                                         if (chunk <= frag->len) {
371                                                 /* Pulling partial data */
372                                                 skb->len -= chunk;
373                                                 skb->data_len -= chunk;
374                                                 __skb_pull(frag, chunk);
375                                                 break;
376                                         } else if (frag->len) {
377                                                 /* Pulling all frag data */
378                                                 chunk -= frag->len;
379                                                 skb->len -= frag->len;
380                                                 skb->data_len -= frag->len;
381                                                 __skb_pull(frag, frag->len);
382                                         }
383                                 }
384                         }
385
386                         if (skb->len) {
387                                 skb_queue_head(&sk->sk_receive_queue, skb);
388                                 break;
389                         }
390                         kfree_skb(skb);
391
392                 } else {
393                         /* put message back and return */
394                         skb_queue_head(&sk->sk_receive_queue, skb);
395                         break;
396                 }
397         } while (size);
398
399 out:
400         release_sock(sk);
401         return copied ? : err;
402 }
403 EXPORT_SYMBOL(bt_sock_stream_recvmsg);
404
405 static inline unsigned int bt_accept_poll(struct sock *parent)
406 {
407         struct list_head *p, *n;
408         struct sock *sk;
409
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                                         (bt_sk(parent)->defer_setup &&
414                                                 sk->sk_state == BT_CONNECT2))
415                         return POLLIN | POLLRDNORM;
416         }
417
418         return 0;
419 }
420
421 unsigned int bt_sock_poll(struct file *file, struct socket *sock, poll_table *wait)
422 {
423         struct sock *sk = sock->sk;
424         unsigned int mask = 0;
425
426         BT_DBG("sock %p, sk %p", sock, sk);
427
428         poll_wait(file, sk_sleep(sk), wait);
429
430         if (sk->sk_state == BT_LISTEN)
431                 return bt_accept_poll(sk);
432
433         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
434                 mask |= POLLERR;
435
436         if (sk->sk_shutdown & RCV_SHUTDOWN)
437                 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
438
439         if (sk->sk_shutdown == SHUTDOWN_MASK)
440                 mask |= POLLHUP;
441
442         if (!skb_queue_empty(&sk->sk_receive_queue))
443                 mask |= POLLIN | POLLRDNORM;
444
445         if (sk->sk_state == BT_CLOSED)
446                 mask |= POLLHUP;
447
448         if (sk->sk_state == BT_CONNECT ||
449                         sk->sk_state == BT_CONNECT2 ||
450                         sk->sk_state == BT_CONFIG)
451                 return mask;
452
453         if (sock_writeable(sk))
454                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
455         else
456                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
457
458         return mask;
459 }
460 EXPORT_SYMBOL(bt_sock_poll);
461
462 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
463 {
464         struct sock *sk = sock->sk;
465         struct sk_buff *skb;
466         long amount;
467         int err;
468
469         BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
470
471         switch (cmd) {
472         case TIOCOUTQ:
473                 if (sk->sk_state == BT_LISTEN)
474                         return -EINVAL;
475
476                 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
477                 if (amount < 0)
478                         amount = 0;
479                 err = put_user(amount, (int __user *) arg);
480                 break;
481
482         case TIOCINQ:
483                 if (sk->sk_state == BT_LISTEN)
484                         return -EINVAL;
485
486                 lock_sock(sk);
487                 skb = skb_peek(&sk->sk_receive_queue);
488                 amount = skb ? skb->len : 0;
489                 release_sock(sk);
490                 err = put_user(amount, (int __user *) arg);
491                 break;
492
493         case SIOCGSTAMP:
494                 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
495                 break;
496
497         case SIOCGSTAMPNS:
498                 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
499                 break;
500
501         default:
502                 err = -ENOIOCTLCMD;
503                 break;
504         }
505
506         return err;
507 }
508 EXPORT_SYMBOL(bt_sock_ioctl);
509
510 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
511 {
512         DECLARE_WAITQUEUE(wait, current);
513         int err = 0;
514
515         BT_DBG("sk %p", sk);
516
517         add_wait_queue(sk_sleep(sk), &wait);
518         set_current_state(TASK_INTERRUPTIBLE);
519         while (sk->sk_state != state) {
520                 if (!timeo) {
521                         err = -EINPROGRESS;
522                         break;
523                 }
524
525                 if (signal_pending(current)) {
526                         err = sock_intr_errno(timeo);
527                         break;
528                 }
529
530                 release_sock(sk);
531                 timeo = schedule_timeout(timeo);
532                 lock_sock(sk);
533                 set_current_state(TASK_INTERRUPTIBLE);
534
535                 err = sock_error(sk);
536                 if (err)
537                         break;
538         }
539         __set_current_state(TASK_RUNNING);
540         remove_wait_queue(sk_sleep(sk), &wait);
541         return err;
542 }
543 EXPORT_SYMBOL(bt_sock_wait_state);
544
545 static struct net_proto_family bt_sock_family_ops = {
546         .owner  = THIS_MODULE,
547         .family = PF_BLUETOOTH,
548         .create = bt_sock_create,
549 };
550
551 static int __init bt_init(void)
552 {
553         int err;
554
555         BT_INFO("Core ver %s", VERSION);
556
557         err = bt_sysfs_init();
558         if (err < 0)
559                 return err;
560
561         err = sock_register(&bt_sock_family_ops);
562         if (err < 0) {
563                 bt_sysfs_cleanup();
564                 return err;
565         }
566
567         BT_INFO("HCI device and connection manager initialized");
568
569         err = hci_sock_init();
570         if (err < 0)
571                 goto error;
572
573         err = l2cap_init();
574         if (err < 0)
575                 goto sock_err;
576
577         err = sco_init();
578         if (err < 0) {
579                 l2cap_exit();
580                 goto sock_err;
581         }
582
583         return 0;
584
585 sock_err:
586         hci_sock_cleanup();
587
588 error:
589         sock_unregister(PF_BLUETOOTH);
590         bt_sysfs_cleanup();
591
592         return err;
593 }
594
595 static void __exit bt_exit(void)
596 {
597
598         sco_exit();
599
600         l2cap_exit();
601
602         hci_sock_cleanup();
603
604         sock_unregister(PF_BLUETOOTH);
605
606         bt_sysfs_cleanup();
607 }
608
609 subsys_initcall(bt_init);
610 module_exit(bt_exit);
611
612 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
613 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
614 MODULE_VERSION(VERSION);
615 MODULE_LICENSE("GPL");
616 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);