blob: 70306cc9d8140f696e440de10f9fff864b0abd94 [file] [log] [blame]
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 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
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090015 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090020 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 SOFTWARE IS DISCLAIMED.
23*/
24
25/* Bluetooth address family and sockets. */
26
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/module.h>
Marcel Holtmannffcecac2013-10-17 17:24:18 -070028#include <linux/debugfs.h>
Marcel Holtmann3241ad82008-07-14 20:13:50 +020029#include <asm/ioctls.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
31#include <net/bluetooth/bluetooth.h>
Masatake YAMATO256a06c2012-07-26 01:26:32 +090032#include <linux/proc_fs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
Marcel Holtmannee485292014-12-29 20:48:35 -080034#include "selftest.h"
35
Marcel Holtmann13972ad2015-10-22 12:29:27 +020036#define VERSION "2.21"
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
38/* Bluetooth sockets */
39#define BT_MAX_PROTO 8
Stephen Hemmingerec1b4cf2009-10-05 05:58:39 +000040static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
Marcel Holtmanndb7aa1c2008-11-30 12:17:19 +010041static DEFINE_RWLOCK(bt_proto_lock);
Dave Young68845cb2008-04-01 23:58:35 -070042
Dave Young68845cb2008-04-01 23:58:35 -070043static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
Jan Engelhardt36cbd3d2009-08-05 10:42:58 -070044static const char *const bt_key_strings[BT_MAX_PROTO] = {
Dave Young68845cb2008-04-01 23:58:35 -070045 "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
Marcel Holtmanndb7aa1c2008-11-30 12:17:19 +010055static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
Jan Engelhardt36cbd3d2009-08-05 10:42:58 -070056static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
Dave Young68845cb2008-04-01 23:58:35 -070057 "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};
Marcel Holtmanndb7aa1c2008-11-30 12:17:19 +010066
Octavian Purdilab5a30dd2012-01-22 00:28:34 +020067void bt_sock_reclassify_lock(struct sock *sk, int proto)
Marcel Holtmanndb7aa1c2008-11-30 12:17:19 +010068{
Octavian Purdilab5a30dd2012-01-22 00:28:34 +020069 BUG_ON(!sk);
Marcel Holtmanndb7aa1c2008-11-30 12:17:19 +010070 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}
Octavian Purdilab5a30dd2012-01-22 00:28:34 +020076EXPORT_SYMBOL(bt_sock_reclassify_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
Stephen Hemmingerec1b4cf2009-10-05 05:58:39 +000078int bt_sock_register(int proto, const struct net_proto_family *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -070079{
Marcel Holtmann74da6262006-10-15 17:31:14 +020080 int err = 0;
81
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 if (proto < 0 || proto >= BT_MAX_PROTO)
83 return -EINVAL;
84
Marcel Holtmann74da6262006-10-15 17:31:14 +020085 write_lock(&bt_proto_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
Marcel Holtmann74da6262006-10-15 17:31:14 +020087 if (bt_proto[proto])
88 err = -EEXIST;
89 else
90 bt_proto[proto] = ops;
91
92 write_unlock(&bt_proto_lock);
93
94 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -070095}
96EXPORT_SYMBOL(bt_sock_register);
97
David Herrmannbe9f97f2013-02-24 19:36:52 +010098void bt_sock_unregister(int proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -070099{
100 if (proto < 0 || proto >= BT_MAX_PROTO)
David Herrmannbe9f97f2013-02-24 19:36:52 +0100101 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102
Marcel Holtmann74da6262006-10-15 17:31:14 +0200103 write_lock(&bt_proto_lock);
David Herrmannbe9f97f2013-02-24 19:36:52 +0100104 bt_proto[proto] = NULL;
Marcel Holtmann74da6262006-10-15 17:31:14 +0200105 write_unlock(&bt_proto_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106}
107EXPORT_SYMBOL(bt_sock_unregister);
108
Eric Paris3f378b62009-11-05 22:18:14 -0800109static int bt_sock_create(struct net *net, struct socket *sock, int proto,
110 int kern)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111{
Marcel Holtmann74da6262006-10-15 17:31:14 +0200112 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700114 if (net != &init_net)
115 return -EAFNOSUPPORT;
116
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 if (proto < 0 || proto >= BT_MAX_PROTO)
118 return -EINVAL;
119
Johannes Berg95a5afc2008-10-16 15:24:51 -0700120 if (!bt_proto[proto])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 request_module("bt-proto-%d", proto);
Marcel Holtmann74da6262006-10-15 17:31:14 +0200122
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 err = -EPROTONOSUPPORT;
Marcel Holtmann74da6262006-10-15 17:31:14 +0200124
125 read_lock(&bt_proto_lock);
126
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
Eric Paris3f378b62009-11-05 22:18:14 -0800128 err = bt_proto[proto]->create(net, sock, proto, kern);
Octavian Purdilab5a30dd2012-01-22 00:28:34 +0200129 if (!err)
130 bt_sock_reclassify_lock(sock->sk, proto);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 module_put(bt_proto[proto]->owner);
132 }
Marcel Holtmann74da6262006-10-15 17:31:14 +0200133
134 read_unlock(&bt_proto_lock);
135
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900136 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137}
138
139void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
140{
Gustavo F. Padovan94f5bfb2011-12-27 15:28:48 -0200141 write_lock(&l->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 sk_add_node(sk, &l->head);
Gustavo F. Padovan94f5bfb2011-12-27 15:28:48 -0200143 write_unlock(&l->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144}
145EXPORT_SYMBOL(bt_sock_link);
146
147void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
148{
Gustavo F. Padovan94f5bfb2011-12-27 15:28:48 -0200149 write_lock(&l->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 sk_del_node_init(sk);
Gustavo F. Padovan94f5bfb2011-12-27 15:28:48 -0200151 write_unlock(&l->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152}
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
Gustavo F. Padovan8a154a82011-12-20 17:15:56 -0200187 lock_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
189 /* FIXME: Is this check still needed */
190 if (sk->sk_state == BT_CLOSED) {
Gustavo F. Padovan8a154a82011-12-20 17:15:56 -0200191 release_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 bt_accept_unlink(sk);
193 continue;
194 }
195
Marcel Holtmannc4f912e2009-01-15 21:52:16 +0100196 if (sk->sk_state == BT_CONNECTED || !newsock ||
Vinicius Costa Gomesd0609912012-05-31 22:53:39 -0300197 test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 bt_accept_unlink(sk);
199 if (newsock)
200 sock_graft(sk, newsock);
Andrei Emeltchenkod37f50e2011-01-24 10:53:24 +0200201
Gustavo F. Padovan8a154a82011-12-20 17:15:56 -0200202 release_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 return sk;
204 }
205
Gustavo F. Padovan8a154a82011-12-20 17:15:56 -0200206 release_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 }
Andrei Emeltchenkod37f50e2011-01-24 10:53:24 +0200208
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 return NULL;
210}
211EXPORT_SYMBOL(bt_accept_dequeue);
212
Ying Xue1b784142015-03-02 15:37:48 +0800213int bt_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
214 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215{
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
Marcel Holtmanna418b892008-11-30 12:17:28 +0100222 BT_DBG("sock %p sk %p len %zu", sock, sk, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223
Marcel Holtmannd94a6102015-10-25 22:45:18 +0100224 if (flags & MSG_OOB)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 return -EOPNOTSUPP;
226
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +0200227 skb = skb_recv_datagram(sk, flags, noblock, &err);
228 if (!skb) {
Hannes Frederic Sowaf3d33422013-11-21 03:14:22 +0100229 if (sk->sk_shutdown & RCV_SHUTDOWN)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 return 0;
Hannes Frederic Sowaf3d33422013-11-21 03:14:22 +0100231
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 return err;
233 }
234
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 copied = skb->len;
236 if (len < copied) {
237 msg->msg_flags |= MSG_TRUNC;
238 copied = len;
239 }
240
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -0300241 skb_reset_transport_header(skb);
David S. Miller51f3d022014-11-05 16:46:40 -0500242 err = skb_copy_datagram_msg(skb, 0, msg, copied);
Marcel Holtmannd9763692013-10-13 12:55:28 -0700243 if (err == 0) {
Neil Horman3b885782009-10-12 13:26:31 -0700244 sock_recv_ts_and_drops(msg, sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245
Marcel Holtmannd9763692013-10-13 12:55:28 -0700246 if (bt_sk(sk)->skb_msg_name)
247 bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
248 &msg->msg_namelen);
Marcel Holtmannd9763692013-10-13 12:55:28 -0700249 }
250
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 skb_free_datagram(sk, skb);
252
253 return err ? : copied;
254}
255EXPORT_SYMBOL(bt_sock_recvmsg);
256
Mat Martineau796c86e2010-09-08 10:05:27 -0700257static 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
Eric Dumazet9cd3e072015-11-29 20:03:10 -0800274 sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
Mat Martineau796c86e2010-09-08 10:05:27 -0700275 release_sock(sk);
276 timeo = schedule_timeout(timeo);
277 lock_sock(sk);
Eric Dumazet9cd3e072015-11-29 20:03:10 -0800278 sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
Mat Martineau796c86e2010-09-08 10:05:27 -0700279 }
280
281 __set_current_state(TASK_RUNNING);
282 remove_wait_queue(sk_sleep(sk), &wait);
283 return timeo;
284}
285
Ying Xue1b784142015-03-02 15:37:48 +0800286int bt_sock_stream_recvmsg(struct socket *sock, struct msghdr *msg,
287 size_t size, int flags)
Mat Martineau796c86e2010-09-08 10:05:27 -0700288{
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
Mat Martineau796c86e2010-09-08 10:05:27 -0700297 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
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +0200313 err = sock_error(sk);
314 if (err)
Mat Martineau796c86e2010-09-08 10:05:27 -0700315 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);
David S. Miller51f3d022014-11-05 16:46:40 -0500333 if (skb_copy_datagram_msg(skb, 0, msg, chunk)) {
Mat Martineau796c86e2010-09-08 10:05:27 -0700334 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)) {
Mat Martineau5b668eb2011-07-22 14:53:59 -0700345 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
Mat Martineau796c86e2010-09-08 10:05:27 -0700372 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391static 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);
Marcel Holtmannd5f2d2b2009-02-16 02:57:30 +0100398 if (sk->sk_state == BT_CONNECTED ||
Gustavo Padovanc5daa682012-05-16 12:17:10 -0300399 (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
400 sk->sk_state == BT_CONNECT2))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 return POLLIN | POLLRDNORM;
402 }
403
404 return 0;
405}
406
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -0300407unsigned int bt_sock_poll(struct file *file, struct socket *sock,
408 poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409{
410 struct sock *sk = sock->sk;
411 unsigned int mask = 0;
412
413 BT_DBG("sock %p, sk %p", sock, sk);
414
Eric Dumazetaa395142010-04-20 13:03:51 +0000415 poll_wait(file, sk_sleep(sk), wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416
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))
Keller, Jacob E7d4c04f2013-03-28 11:19:25 +0000421 mask |= POLLERR |
Jacob Keller8facd5f2013-04-02 13:55:40 -0700422 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
Davide Libenzif348d702006-03-25 03:07:39 -0800424 if (sk->sk_shutdown & RCV_SHUTDOWN)
Eric Dumazetdb409802010-09-06 11:13:50 +0000425 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
Davide Libenzif348d702006-03-25 03:07:39 -0800426
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 if (sk->sk_shutdown == SHUTDOWN_MASK)
428 mask |= POLLHUP;
429
Eric Dumazetdb409802010-09-06 11:13:50 +0000430 if (!skb_queue_empty(&sk->sk_receive_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 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
Gustavo Padovanc5daa682012-05-16 12:17:10 -0300441 if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
443 else
Eric Dumazet9cd3e072015-11-29 20:03:10 -0800444 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445
446 return mask;
447}
448EXPORT_SYMBOL(bt_sock_poll);
449
Marcel Holtmann3241ad82008-07-14 20:13:50 +0200450int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
451{
452 struct sock *sk = sock->sk;
Marcel Holtmann43cbeee2008-07-14 20:13:51 +0200453 struct sk_buff *skb;
454 long amount;
Marcel Holtmann3241ad82008-07-14 20:13:50 +0200455 int err;
456
457 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
458
459 switch (cmd) {
Marcel Holtmann43cbeee2008-07-14 20:13:51 +0200460 case TIOCOUTQ:
461 if (sk->sk_state == BT_LISTEN)
462 return -EINVAL;
463
Eric Dumazet31e6d362009-06-17 19:05:41 -0700464 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
Marcel Holtmann43cbeee2008-07-14 20:13:51 +0200465 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
Marcel Holtmann3241ad82008-07-14 20:13:50 +0200481 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
Johan Hedberg0fba96f2013-09-25 13:26:04 +0300498/* This function expects the sk lock to be held when called */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499int 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
Eric Dumazetaa395142010-04-20 13:03:51 +0000506 add_wait_queue(sk_sleep(sk), &wait);
Peter Hurley9be4e3f2011-07-24 00:10:46 -0400507 set_current_state(TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 while (sk->sk_state != state) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 if (!timeo) {
Marcel Holtmannb4c612a2006-09-23 09:54:38 +0200510 err = -EINPROGRESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 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);
Peter Hurley9be4e3f2011-07-24 00:10:46 -0400522 set_current_state(TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523
Benjamin LaHaisec1cbe4b2005-12-13 23:22:19 -0800524 err = sock_error(sk);
525 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 }
Peter Hurley9be4e3f2011-07-24 00:10:46 -0400528 __set_current_state(TASK_RUNNING);
Eric Dumazetaa395142010-04-20 13:03:51 +0000529 remove_wait_queue(sk_sleep(sk), &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 return err;
531}
532EXPORT_SYMBOL(bt_sock_wait_state);
533
Johan Hedberge793dcf2013-09-16 13:05:19 +0300534/* 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
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900574#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{
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900608 struct bt_seq_state *s = seq->private;
609 struct bt_sock_list *l = s->l;
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900610
611 if (v == SEQ_START_TOKEN) {
Marcel Holtmannc5605752013-10-14 02:05:25 -0700612 seq_puts(seq ,"sk RefCnt Rmem Wmem User Inode Parent");
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900613
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 {
Andrei Emeltchenko09d5d4a2012-08-07 18:05:04 +0300621 struct sock *sk = sk_entry(v);
622 struct bt_sock *bt = bt_sk(sk);
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900623
Andrei Emeltchenko7028a882012-09-25 12:49:45 +0300624 seq_printf(seq,
Marcel Holtmann5f6cd792013-10-13 10:34:03 -0700625 "%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900626 sk,
627 atomic_read(&sk->sk_refcnt),
628 sk_rmem_alloc_get(sk),
629 sk_wmem_alloc_get(sk),
Eric W. Biederman1bbb3092012-10-03 20:32:17 -0700630 from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900631 sock_i_ino(sk),
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900632 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
Fabian Frederick26b0f4e2014-06-30 19:26:23 +0200644static const struct seq_operations bt_seq_ops = {
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900645 .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
Al Virod9dda782013-03-31 18:16:14 -0400656 sk_list = PDE_DATA(inode);
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900657 s = __seq_open_private(file, &bt_seq_ops,
658 sizeof(struct bt_seq_state));
Andrei Emeltchenko31f47072012-08-07 18:05:06 +0300659 if (!s)
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900660 return -ENOMEM;
661
662 s->l = sk_list;
663 return 0;
664}
665
Al Viro14805352013-04-04 19:12:06 -0400666static 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
Al Virob0316612013-04-04 19:14:33 -0400673int bt_procfs_init(struct net *net, const char *name,
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900674 struct bt_sock_list* sk_list,
675 int (* seq_show)(struct seq_file *, void *))
676{
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900677 sk_list->custom_seq_show = seq_show;
678
Al Viro4d006262013-04-04 19:16:06 -0400679 if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900680 return -ENOMEM;
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900681 return 0;
682}
683
684void bt_procfs_cleanup(struct net *net, const char *name)
685{
Gao fengece31ff2013-02-18 01:34:56 +0000686 remove_proc_entry(name, net->proc_net);
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900687}
688#else
Al Virob0316612013-04-04 19:14:33 -0400689int bt_procfs_init(struct net *net, const char *name,
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900690 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703static struct net_proto_family bt_sock_family_ops = {
704 .owner = THIS_MODULE,
705 .family = PF_BLUETOOTH,
706 .create = bt_sock_create,
707};
708
Marcel Holtmannffcecac2013-10-17 17:24:18 -0700709struct dentry *bt_debugfs;
710EXPORT_SYMBOL_GPL(bt_debugfs);
711
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712static int __init bt_init(void)
713{
Marcel Holtmann27d35282006-07-03 10:02:37 +0200714 int err;
715
Eyal Birgerb4772ef2015-03-01 14:58:29 +0200716 sock_skb_cb_check_size(sizeof(struct bt_skb_cb));
Marcel Holtmann7cb9d202014-09-14 22:50:46 +0200717
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 BT_INFO("Core ver %s", VERSION);
719
Marcel Holtmannee485292014-12-29 20:48:35 -0800720 err = bt_selftest();
721 if (err < 0)
722 return err;
723
Marcel Holtmannffcecac2013-10-17 17:24:18 -0700724 bt_debugfs = debugfs_create_dir("bluetooth", NULL);
725
Marcel Holtmann27d35282006-07-03 10:02:37 +0200726 err = bt_sysfs_init();
727 if (err < 0)
728 return err;
729
730 err = sock_register(&bt_sock_family_ops);
731 if (err < 0) {
732 bt_sysfs_cleanup();
733 return err;
734 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735
736 BT_INFO("HCI device and connection manager initialized");
737
Gustavo F. Padovan64274512011-02-07 20:08:52 -0200738 err = hci_sock_init();
739 if (err < 0)
740 goto error;
741
742 err = l2cap_init();
Anand Gadiyar0ed54da2011-02-22 12:43:26 +0530743 if (err < 0)
Gustavo F. Padovan64274512011-02-07 20:08:52 -0200744 goto sock_err;
Gustavo F. Padovan64274512011-02-07 20:08:52 -0200745
746 err = sco_init();
747 if (err < 0) {
748 l2cap_exit();
749 goto sock_err;
750 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751
Johan Hedberg6d785aa32015-03-06 21:08:51 +0200752 err = mgmt_init();
753 if (err < 0) {
754 sco_exit();
755 l2cap_exit();
756 goto sock_err;
757 }
758
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 return 0;
Gustavo F. Padovan64274512011-02-07 20:08:52 -0200760
761sock_err:
762 hci_sock_cleanup();
763
764error:
765 sock_unregister(PF_BLUETOOTH);
766 bt_sysfs_cleanup();
767
768 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769}
770
771static void __exit bt_exit(void)
772{
Johan Hedberg6d785aa32015-03-06 21:08:51 +0200773 mgmt_exit();
774
Gustavo F. Padovan64274512011-02-07 20:08:52 -0200775 sco_exit();
776
777 l2cap_exit();
778
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 hci_sock_cleanup();
780
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 sock_unregister(PF_BLUETOOTH);
Marcel Holtmann27d35282006-07-03 10:02:37 +0200782
783 bt_sysfs_cleanup();
Marcel Holtmannffcecac2013-10-17 17:24:18 -0700784
785 debugfs_remove_recursive(bt_debugfs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786}
787
788subsys_initcall(bt_init);
789module_exit(bt_exit);
790
Marcel Holtmann63fbd242008-08-18 13:23:53 +0200791MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
793MODULE_VERSION(VERSION);
794MODULE_LICENSE("GPL");
795MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);