blob: 2021c481cdb657a8011938f5e8486c4c93f0c116 [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 Holtmanna7474392014-02-20 12:44:20 -080034#define VERSION "2.19"
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
36/* Bluetooth sockets */
37#define BT_MAX_PROTO 8
Stephen Hemmingerec1b4cf2009-10-05 05:58:39 +000038static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
Marcel Holtmanndb7aa1c2008-11-30 12:17:19 +010039static DEFINE_RWLOCK(bt_proto_lock);
Dave Young68845cb2008-04-01 23:58:35 -070040
Dave Young68845cb2008-04-01 23:58:35 -070041static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
Jan Engelhardt36cbd3d2009-08-05 10:42:58 -070042static const char *const bt_key_strings[BT_MAX_PROTO] = {
Dave Young68845cb2008-04-01 23:58:35 -070043 "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
44 "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
45 "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
46 "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
47 "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
48 "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
49 "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
50 "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
51};
52
Marcel Holtmanndb7aa1c2008-11-30 12:17:19 +010053static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
Jan Engelhardt36cbd3d2009-08-05 10:42:58 -070054static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
Dave Young68845cb2008-04-01 23:58:35 -070055 "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
56 "slock-AF_BLUETOOTH-BTPROTO_HCI",
57 "slock-AF_BLUETOOTH-BTPROTO_SCO",
58 "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
59 "slock-AF_BLUETOOTH-BTPROTO_BNEP",
60 "slock-AF_BLUETOOTH-BTPROTO_CMTP",
61 "slock-AF_BLUETOOTH-BTPROTO_HIDP",
62 "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
63};
Marcel Holtmanndb7aa1c2008-11-30 12:17:19 +010064
Octavian Purdilab5a30dd2012-01-22 00:28:34 +020065void bt_sock_reclassify_lock(struct sock *sk, int proto)
Marcel Holtmanndb7aa1c2008-11-30 12:17:19 +010066{
Octavian Purdilab5a30dd2012-01-22 00:28:34 +020067 BUG_ON(!sk);
Marcel Holtmanndb7aa1c2008-11-30 12:17:19 +010068 BUG_ON(sock_owned_by_user(sk));
69
70 sock_lock_init_class_and_name(sk,
71 bt_slock_key_strings[proto], &bt_slock_key[proto],
72 bt_key_strings[proto], &bt_lock_key[proto]);
73}
Octavian Purdilab5a30dd2012-01-22 00:28:34 +020074EXPORT_SYMBOL(bt_sock_reclassify_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
Stephen Hemmingerec1b4cf2009-10-05 05:58:39 +000076int bt_sock_register(int proto, const struct net_proto_family *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -070077{
Marcel Holtmann74da6262006-10-15 17:31:14 +020078 int err = 0;
79
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 if (proto < 0 || proto >= BT_MAX_PROTO)
81 return -EINVAL;
82
Marcel Holtmann74da6262006-10-15 17:31:14 +020083 write_lock(&bt_proto_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
Marcel Holtmann74da6262006-10-15 17:31:14 +020085 if (bt_proto[proto])
86 err = -EEXIST;
87 else
88 bt_proto[proto] = ops;
89
90 write_unlock(&bt_proto_lock);
91
92 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093}
94EXPORT_SYMBOL(bt_sock_register);
95
David Herrmannbe9f97f2013-02-24 19:36:52 +010096void bt_sock_unregister(int proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -070097{
98 if (proto < 0 || proto >= BT_MAX_PROTO)
David Herrmannbe9f97f2013-02-24 19:36:52 +010099 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
Marcel Holtmann74da6262006-10-15 17:31:14 +0200101 write_lock(&bt_proto_lock);
David Herrmannbe9f97f2013-02-24 19:36:52 +0100102 bt_proto[proto] = NULL;
Marcel Holtmann74da6262006-10-15 17:31:14 +0200103 write_unlock(&bt_proto_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104}
105EXPORT_SYMBOL(bt_sock_unregister);
106
Eric Paris3f378b62009-11-05 22:18:14 -0800107static int bt_sock_create(struct net *net, struct socket *sock, int proto,
108 int kern)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109{
Marcel Holtmann74da6262006-10-15 17:31:14 +0200110 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700112 if (net != &init_net)
113 return -EAFNOSUPPORT;
114
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 if (proto < 0 || proto >= BT_MAX_PROTO)
116 return -EINVAL;
117
Johannes Berg95a5afc2008-10-16 15:24:51 -0700118 if (!bt_proto[proto])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 request_module("bt-proto-%d", proto);
Marcel Holtmann74da6262006-10-15 17:31:14 +0200120
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 err = -EPROTONOSUPPORT;
Marcel Holtmann74da6262006-10-15 17:31:14 +0200122
123 read_lock(&bt_proto_lock);
124
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
Eric Paris3f378b62009-11-05 22:18:14 -0800126 err = bt_proto[proto]->create(net, sock, proto, kern);
Octavian Purdilab5a30dd2012-01-22 00:28:34 +0200127 if (!err)
128 bt_sock_reclassify_lock(sock->sk, proto);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 module_put(bt_proto[proto]->owner);
130 }
Marcel Holtmann74da6262006-10-15 17:31:14 +0200131
132 read_unlock(&bt_proto_lock);
133
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900134 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135}
136
137void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
138{
Gustavo F. Padovan94f5bfb2011-12-27 15:28:48 -0200139 write_lock(&l->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 sk_add_node(sk, &l->head);
Gustavo F. Padovan94f5bfb2011-12-27 15:28:48 -0200141 write_unlock(&l->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142}
143EXPORT_SYMBOL(bt_sock_link);
144
145void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
146{
Gustavo F. Padovan94f5bfb2011-12-27 15:28:48 -0200147 write_lock(&l->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 sk_del_node_init(sk);
Gustavo F. Padovan94f5bfb2011-12-27 15:28:48 -0200149 write_unlock(&l->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150}
151EXPORT_SYMBOL(bt_sock_unlink);
152
153void bt_accept_enqueue(struct sock *parent, struct sock *sk)
154{
155 BT_DBG("parent %p, sk %p", parent, sk);
156
157 sock_hold(sk);
158 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
159 bt_sk(sk)->parent = parent;
160 parent->sk_ack_backlog++;
161}
162EXPORT_SYMBOL(bt_accept_enqueue);
163
164void bt_accept_unlink(struct sock *sk)
165{
166 BT_DBG("sk %p state %d", sk, sk->sk_state);
167
168 list_del_init(&bt_sk(sk)->accept_q);
169 bt_sk(sk)->parent->sk_ack_backlog--;
170 bt_sk(sk)->parent = NULL;
171 sock_put(sk);
172}
173EXPORT_SYMBOL(bt_accept_unlink);
174
175struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
176{
177 struct list_head *p, *n;
178 struct sock *sk;
179
180 BT_DBG("parent %p", parent);
181
182 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
183 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
184
Gustavo F. Padovan8a154a82011-12-20 17:15:56 -0200185 lock_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186
187 /* FIXME: Is this check still needed */
188 if (sk->sk_state == BT_CLOSED) {
Gustavo F. Padovan8a154a82011-12-20 17:15:56 -0200189 release_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 bt_accept_unlink(sk);
191 continue;
192 }
193
Marcel Holtmannc4f912e2009-01-15 21:52:16 +0100194 if (sk->sk_state == BT_CONNECTED || !newsock ||
Vinicius Costa Gomesd0609912012-05-31 22:53:39 -0300195 test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 bt_accept_unlink(sk);
197 if (newsock)
198 sock_graft(sk, newsock);
Andrei Emeltchenkod37f50e2011-01-24 10:53:24 +0200199
Gustavo F. Padovan8a154a82011-12-20 17:15:56 -0200200 release_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 return sk;
202 }
203
Gustavo F. Padovan8a154a82011-12-20 17:15:56 -0200204 release_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 }
Andrei Emeltchenkod37f50e2011-01-24 10:53:24 +0200206
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 return NULL;
208}
209EXPORT_SYMBOL(bt_accept_dequeue);
210
211int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
Marcel Holtmannc4f912e2009-01-15 21:52:16 +0100212 struct msghdr *msg, size_t len, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213{
214 int noblock = flags & MSG_DONTWAIT;
215 struct sock *sk = sock->sk;
216 struct sk_buff *skb;
217 size_t copied;
218 int err;
219
Marcel Holtmanna418b892008-11-30 12:17:28 +0100220 BT_DBG("sock %p sk %p len %zu", sock, sk, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
222 if (flags & (MSG_OOB))
223 return -EOPNOTSUPP;
224
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +0200225 skb = skb_recv_datagram(sk, flags, noblock, &err);
226 if (!skb) {
Hannes Frederic Sowaf3d33422013-11-21 03:14:22 +0100227 if (sk->sk_shutdown & RCV_SHUTDOWN)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 return 0;
Hannes Frederic Sowaf3d33422013-11-21 03:14:22 +0100229
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 return err;
231 }
232
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 copied = skb->len;
234 if (len < copied) {
235 msg->msg_flags |= MSG_TRUNC;
236 copied = len;
237 }
238
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -0300239 skb_reset_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
Marcel Holtmannd9763692013-10-13 12:55:28 -0700241 if (err == 0) {
Neil Horman3b885782009-10-12 13:26:31 -0700242 sock_recv_ts_and_drops(msg, sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
Marcel Holtmannd9763692013-10-13 12:55:28 -0700244 if (bt_sk(sk)->skb_msg_name)
245 bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
246 &msg->msg_namelen);
Marcel Holtmannd9763692013-10-13 12:55:28 -0700247 }
248
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 skb_free_datagram(sk, skb);
250
251 return err ? : copied;
252}
253EXPORT_SYMBOL(bt_sock_recvmsg);
254
Mat Martineau796c86e2010-09-08 10:05:27 -0700255static long bt_sock_data_wait(struct sock *sk, long timeo)
256{
257 DECLARE_WAITQUEUE(wait, current);
258
259 add_wait_queue(sk_sleep(sk), &wait);
260 for (;;) {
261 set_current_state(TASK_INTERRUPTIBLE);
262
263 if (!skb_queue_empty(&sk->sk_receive_queue))
264 break;
265
266 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
267 break;
268
269 if (signal_pending(current) || !timeo)
270 break;
271
272 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
273 release_sock(sk);
274 timeo = schedule_timeout(timeo);
275 lock_sock(sk);
276 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
277 }
278
279 __set_current_state(TASK_RUNNING);
280 remove_wait_queue(sk_sleep(sk), &wait);
281 return timeo;
282}
283
284int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
285 struct msghdr *msg, size_t size, int flags)
286{
287 struct sock *sk = sock->sk;
288 int err = 0;
289 size_t target, copied = 0;
290 long timeo;
291
292 if (flags & MSG_OOB)
293 return -EOPNOTSUPP;
294
Mat Martineau796c86e2010-09-08 10:05:27 -0700295 BT_DBG("sk %p size %zu", sk, size);
296
297 lock_sock(sk);
298
299 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
300 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
301
302 do {
303 struct sk_buff *skb;
304 int chunk;
305
306 skb = skb_dequeue(&sk->sk_receive_queue);
307 if (!skb) {
308 if (copied >= target)
309 break;
310
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +0200311 err = sock_error(sk);
312 if (err)
Mat Martineau796c86e2010-09-08 10:05:27 -0700313 break;
314 if (sk->sk_shutdown & RCV_SHUTDOWN)
315 break;
316
317 err = -EAGAIN;
318 if (!timeo)
319 break;
320
321 timeo = bt_sock_data_wait(sk, timeo);
322
323 if (signal_pending(current)) {
324 err = sock_intr_errno(timeo);
325 goto out;
326 }
327 continue;
328 }
329
330 chunk = min_t(unsigned int, skb->len, size);
Mat Martineau5b668eb2011-07-22 14:53:59 -0700331 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
Mat Martineau796c86e2010-09-08 10:05:27 -0700332 skb_queue_head(&sk->sk_receive_queue, skb);
333 if (!copied)
334 copied = -EFAULT;
335 break;
336 }
337 copied += chunk;
338 size -= chunk;
339
340 sock_recv_ts_and_drops(msg, sk, skb);
341
342 if (!(flags & MSG_PEEK)) {
Mat Martineau5b668eb2011-07-22 14:53:59 -0700343 int skb_len = skb_headlen(skb);
344
345 if (chunk <= skb_len) {
346 __skb_pull(skb, chunk);
347 } else {
348 struct sk_buff *frag;
349
350 __skb_pull(skb, skb_len);
351 chunk -= skb_len;
352
353 skb_walk_frags(skb, frag) {
354 if (chunk <= frag->len) {
355 /* Pulling partial data */
356 skb->len -= chunk;
357 skb->data_len -= chunk;
358 __skb_pull(frag, chunk);
359 break;
360 } else if (frag->len) {
361 /* Pulling all frag data */
362 chunk -= frag->len;
363 skb->len -= frag->len;
364 skb->data_len -= frag->len;
365 __skb_pull(frag, frag->len);
366 }
367 }
368 }
369
Mat Martineau796c86e2010-09-08 10:05:27 -0700370 if (skb->len) {
371 skb_queue_head(&sk->sk_receive_queue, skb);
372 break;
373 }
374 kfree_skb(skb);
375
376 } else {
377 /* put message back and return */
378 skb_queue_head(&sk->sk_receive_queue, skb);
379 break;
380 }
381 } while (size);
382
383out:
384 release_sock(sk);
385 return copied ? : err;
386}
387EXPORT_SYMBOL(bt_sock_stream_recvmsg);
388
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389static inline unsigned int bt_accept_poll(struct sock *parent)
390{
391 struct list_head *p, *n;
392 struct sock *sk;
393
394 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
395 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
Marcel Holtmannd5f2d2b2009-02-16 02:57:30 +0100396 if (sk->sk_state == BT_CONNECTED ||
Gustavo Padovanc5daa682012-05-16 12:17:10 -0300397 (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
398 sk->sk_state == BT_CONNECT2))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 return POLLIN | POLLRDNORM;
400 }
401
402 return 0;
403}
404
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -0300405unsigned int bt_sock_poll(struct file *file, struct socket *sock,
406 poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407{
408 struct sock *sk = sock->sk;
409 unsigned int mask = 0;
410
411 BT_DBG("sock %p, sk %p", sock, sk);
412
Eric Dumazetaa395142010-04-20 13:03:51 +0000413 poll_wait(file, sk_sleep(sk), wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414
415 if (sk->sk_state == BT_LISTEN)
416 return bt_accept_poll(sk);
417
418 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
Keller, Jacob E7d4c04f2013-03-28 11:19:25 +0000419 mask |= POLLERR |
Jacob Keller8facd5f2013-04-02 13:55:40 -0700420 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421
Davide Libenzif348d702006-03-25 03:07:39 -0800422 if (sk->sk_shutdown & RCV_SHUTDOWN)
Eric Dumazetdb409802010-09-06 11:13:50 +0000423 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
Davide Libenzif348d702006-03-25 03:07:39 -0800424
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 if (sk->sk_shutdown == SHUTDOWN_MASK)
426 mask |= POLLHUP;
427
Eric Dumazetdb409802010-09-06 11:13:50 +0000428 if (!skb_queue_empty(&sk->sk_receive_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 mask |= POLLIN | POLLRDNORM;
430
431 if (sk->sk_state == BT_CLOSED)
432 mask |= POLLHUP;
433
434 if (sk->sk_state == BT_CONNECT ||
435 sk->sk_state == BT_CONNECT2 ||
436 sk->sk_state == BT_CONFIG)
437 return mask;
438
Gustavo Padovanc5daa682012-05-16 12:17:10 -0300439 if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
441 else
442 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
443
444 return mask;
445}
446EXPORT_SYMBOL(bt_sock_poll);
447
Marcel Holtmann3241ad82008-07-14 20:13:50 +0200448int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
449{
450 struct sock *sk = sock->sk;
Marcel Holtmann43cbeee2008-07-14 20:13:51 +0200451 struct sk_buff *skb;
452 long amount;
Marcel Holtmann3241ad82008-07-14 20:13:50 +0200453 int err;
454
455 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
456
457 switch (cmd) {
Marcel Holtmann43cbeee2008-07-14 20:13:51 +0200458 case TIOCOUTQ:
459 if (sk->sk_state == BT_LISTEN)
460 return -EINVAL;
461
Eric Dumazet31e6d362009-06-17 19:05:41 -0700462 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
Marcel Holtmann43cbeee2008-07-14 20:13:51 +0200463 if (amount < 0)
464 amount = 0;
465 err = put_user(amount, (int __user *) arg);
466 break;
467
468 case TIOCINQ:
469 if (sk->sk_state == BT_LISTEN)
470 return -EINVAL;
471
472 lock_sock(sk);
473 skb = skb_peek(&sk->sk_receive_queue);
474 amount = skb ? skb->len : 0;
475 release_sock(sk);
476 err = put_user(amount, (int __user *) arg);
477 break;
478
Marcel Holtmann3241ad82008-07-14 20:13:50 +0200479 case SIOCGSTAMP:
480 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
481 break;
482
483 case SIOCGSTAMPNS:
484 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
485 break;
486
487 default:
488 err = -ENOIOCTLCMD;
489 break;
490 }
491
492 return err;
493}
494EXPORT_SYMBOL(bt_sock_ioctl);
495
Johan Hedberg0fba96f2013-09-25 13:26:04 +0300496/* This function expects the sk lock to be held when called */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
498{
499 DECLARE_WAITQUEUE(wait, current);
500 int err = 0;
501
502 BT_DBG("sk %p", sk);
503
Eric Dumazetaa395142010-04-20 13:03:51 +0000504 add_wait_queue(sk_sleep(sk), &wait);
Peter Hurley9be4e3f2011-07-24 00:10:46 -0400505 set_current_state(TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 while (sk->sk_state != state) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 if (!timeo) {
Marcel Holtmannb4c612a2006-09-23 09:54:38 +0200508 err = -EINPROGRESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 break;
510 }
511
512 if (signal_pending(current)) {
513 err = sock_intr_errno(timeo);
514 break;
515 }
516
517 release_sock(sk);
518 timeo = schedule_timeout(timeo);
519 lock_sock(sk);
Peter Hurley9be4e3f2011-07-24 00:10:46 -0400520 set_current_state(TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521
Benjamin LaHaisec1cbe4b2005-12-13 23:22:19 -0800522 err = sock_error(sk);
523 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 }
Peter Hurley9be4e3f2011-07-24 00:10:46 -0400526 __set_current_state(TASK_RUNNING);
Eric Dumazetaa395142010-04-20 13:03:51 +0000527 remove_wait_queue(sk_sleep(sk), &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 return err;
529}
530EXPORT_SYMBOL(bt_sock_wait_state);
531
Johan Hedberge793dcf2013-09-16 13:05:19 +0300532/* This function expects the sk lock to be held when called */
533int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
534{
535 DECLARE_WAITQUEUE(wait, current);
536 unsigned long timeo;
537 int err = 0;
538
539 BT_DBG("sk %p", sk);
540
541 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
542
543 add_wait_queue(sk_sleep(sk), &wait);
544 set_current_state(TASK_INTERRUPTIBLE);
545 while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
546 if (!timeo) {
547 err = -EAGAIN;
548 break;
549 }
550
551 if (signal_pending(current)) {
552 err = sock_intr_errno(timeo);
553 break;
554 }
555
556 release_sock(sk);
557 timeo = schedule_timeout(timeo);
558 lock_sock(sk);
559 set_current_state(TASK_INTERRUPTIBLE);
560
561 err = sock_error(sk);
562 if (err)
563 break;
564 }
565 __set_current_state(TASK_RUNNING);
566 remove_wait_queue(sk_sleep(sk), &wait);
567
568 return err;
569}
570EXPORT_SYMBOL(bt_sock_wait_ready);
571
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900572#ifdef CONFIG_PROC_FS
573struct bt_seq_state {
574 struct bt_sock_list *l;
575};
576
577static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
578 __acquires(seq->private->l->lock)
579{
580 struct bt_seq_state *s = seq->private;
581 struct bt_sock_list *l = s->l;
582
583 read_lock(&l->lock);
584 return seq_hlist_start_head(&l->head, *pos);
585}
586
587static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
588{
589 struct bt_seq_state *s = seq->private;
590 struct bt_sock_list *l = s->l;
591
592 return seq_hlist_next(v, &l->head, pos);
593}
594
595static void bt_seq_stop(struct seq_file *seq, void *v)
596 __releases(seq->private->l->lock)
597{
598 struct bt_seq_state *s = seq->private;
599 struct bt_sock_list *l = s->l;
600
601 read_unlock(&l->lock);
602}
603
604static int bt_seq_show(struct seq_file *seq, void *v)
605{
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900606 struct bt_seq_state *s = seq->private;
607 struct bt_sock_list *l = s->l;
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900608
609 if (v == SEQ_START_TOKEN) {
Marcel Holtmannc5605752013-10-14 02:05:25 -0700610 seq_puts(seq ,"sk RefCnt Rmem Wmem User Inode Parent");
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900611
612 if (l->custom_seq_show) {
613 seq_putc(seq, ' ');
614 l->custom_seq_show(seq, v);
615 }
616
617 seq_putc(seq, '\n');
618 } else {
Andrei Emeltchenko09d5d4a2012-08-07 18:05:04 +0300619 struct sock *sk = sk_entry(v);
620 struct bt_sock *bt = bt_sk(sk);
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900621
Andrei Emeltchenko7028a882012-09-25 12:49:45 +0300622 seq_printf(seq,
Marcel Holtmann5f6cd792013-10-13 10:34:03 -0700623 "%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900624 sk,
625 atomic_read(&sk->sk_refcnt),
626 sk_rmem_alloc_get(sk),
627 sk_wmem_alloc_get(sk),
Eric W. Biederman1bbb3092012-10-03 20:32:17 -0700628 from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900629 sock_i_ino(sk),
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900630 bt->parent? sock_i_ino(bt->parent): 0LU);
631
632 if (l->custom_seq_show) {
633 seq_putc(seq, ' ');
634 l->custom_seq_show(seq, v);
635 }
636
637 seq_putc(seq, '\n');
638 }
639 return 0;
640}
641
642static struct seq_operations bt_seq_ops = {
643 .start = bt_seq_start,
644 .next = bt_seq_next,
645 .stop = bt_seq_stop,
646 .show = bt_seq_show,
647};
648
649static int bt_seq_open(struct inode *inode, struct file *file)
650{
651 struct bt_sock_list *sk_list;
652 struct bt_seq_state *s;
653
Al Virod9dda782013-03-31 18:16:14 -0400654 sk_list = PDE_DATA(inode);
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900655 s = __seq_open_private(file, &bt_seq_ops,
656 sizeof(struct bt_seq_state));
Andrei Emeltchenko31f47072012-08-07 18:05:06 +0300657 if (!s)
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900658 return -ENOMEM;
659
660 s->l = sk_list;
661 return 0;
662}
663
Al Viro14805352013-04-04 19:12:06 -0400664static const struct file_operations bt_fops = {
665 .open = bt_seq_open,
666 .read = seq_read,
667 .llseek = seq_lseek,
668 .release = seq_release_private
669};
670
Al Virob0316612013-04-04 19:14:33 -0400671int bt_procfs_init(struct net *net, const char *name,
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900672 struct bt_sock_list* sk_list,
673 int (* seq_show)(struct seq_file *, void *))
674{
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900675 sk_list->custom_seq_show = seq_show;
676
Al Viro4d006262013-04-04 19:16:06 -0400677 if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900678 return -ENOMEM;
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900679 return 0;
680}
681
682void bt_procfs_cleanup(struct net *net, const char *name)
683{
Gao fengece31ff2013-02-18 01:34:56 +0000684 remove_proc_entry(name, net->proc_net);
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900685}
686#else
Al Virob0316612013-04-04 19:14:33 -0400687int bt_procfs_init(struct net *net, const char *name,
Masatake YAMATO256a06c2012-07-26 01:26:32 +0900688 struct bt_sock_list* sk_list,
689 int (* seq_show)(struct seq_file *, void *))
690{
691 return 0;
692}
693
694void bt_procfs_cleanup(struct net *net, const char *name)
695{
696}
697#endif
698EXPORT_SYMBOL(bt_procfs_init);
699EXPORT_SYMBOL(bt_procfs_cleanup);
700
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701static struct net_proto_family bt_sock_family_ops = {
702 .owner = THIS_MODULE,
703 .family = PF_BLUETOOTH,
704 .create = bt_sock_create,
705};
706
Marcel Holtmannffcecac2013-10-17 17:24:18 -0700707struct dentry *bt_debugfs;
708EXPORT_SYMBOL_GPL(bt_debugfs);
709
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710static int __init bt_init(void)
711{
Marcel Holtmann27d35282006-07-03 10:02:37 +0200712 int err;
713
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 BT_INFO("Core ver %s", VERSION);
715
Marcel Holtmannffcecac2013-10-17 17:24:18 -0700716 bt_debugfs = debugfs_create_dir("bluetooth", NULL);
717
Marcel Holtmann27d35282006-07-03 10:02:37 +0200718 err = bt_sysfs_init();
719 if (err < 0)
720 return err;
721
722 err = sock_register(&bt_sock_family_ops);
723 if (err < 0) {
724 bt_sysfs_cleanup();
725 return err;
726 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727
728 BT_INFO("HCI device and connection manager initialized");
729
Gustavo F. Padovan64274512011-02-07 20:08:52 -0200730 err = hci_sock_init();
731 if (err < 0)
732 goto error;
733
734 err = l2cap_init();
Anand Gadiyar0ed54da2011-02-22 12:43:26 +0530735 if (err < 0)
Gustavo F. Padovan64274512011-02-07 20:08:52 -0200736 goto sock_err;
Gustavo F. Padovan64274512011-02-07 20:08:52 -0200737
738 err = sco_init();
739 if (err < 0) {
740 l2cap_exit();
741 goto sock_err;
742 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743
744 return 0;
Gustavo F. Padovan64274512011-02-07 20:08:52 -0200745
746sock_err:
747 hci_sock_cleanup();
748
749error:
750 sock_unregister(PF_BLUETOOTH);
751 bt_sysfs_cleanup();
752
753 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754}
755
756static void __exit bt_exit(void)
757{
Gustavo F. Padovan64274512011-02-07 20:08:52 -0200758 sco_exit();
759
760 l2cap_exit();
761
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 hci_sock_cleanup();
763
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 sock_unregister(PF_BLUETOOTH);
Marcel Holtmann27d35282006-07-03 10:02:37 +0200765
766 bt_sysfs_cleanup();
Marcel Holtmannffcecac2013-10-17 17:24:18 -0700767
768 debugfs_remove_recursive(bt_debugfs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769}
770
771subsys_initcall(bt_init);
772module_exit(bt_exit);
773
Marcel Holtmann63fbd242008-08-18 13:23:53 +0200774MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
776MODULE_VERSION(VERSION);
777MODULE_LICENSE("GPL");
778MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);