Release 4.11 net/bluetooth/sco.c

/*
   BlueZ - Bluetooth protocol stack for Linux
   Copyright (C) 2000-2001 Qualcomm Incorporated

   Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation;

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
   IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
   CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

   ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
   COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
   SOFTWARE IS DISCLAIMED.
*/

/* Bluetooth SCO sockets. */

#include <linux/module.h>
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include <linux/sched/signal.h>

#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>
#include <net/bluetooth/sco.h>


static bool disable_esco;


static const struct proto_ops sco_sock_ops;


static struct bt_sock_list sco_sk_list = {
	.lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
};

/* ---- SCO connections ---- */

struct sco_conn {
	
struct hci_conn	*hcon;

	
spinlock_t	lock;
	
struct sock	*sk;

	
unsigned int    mtu;
};


#define sco_conn_lock(c)	spin_lock(&c->lock);

#define sco_conn_unlock(c)	spin_unlock(&c->lock);

static void sco_sock_close(struct sock *sk);
static void sco_sock_kill(struct sock *sk);

/* ----- SCO socket info ----- */

#define sco_pi(sk) ((struct sco_pinfo *) sk)


struct sco_pinfo {
	
struct bt_sock	bt;
	
bdaddr_t	src;
	
bdaddr_t	dst;
	
__u32		flags;
	
__u16		setting;
	
struct sco_conn	*conn;
};

/* ---- SCO timers ---- */

#define SCO_CONN_TIMEOUT	(HZ * 40)

#define SCO_DISCONN_TIMEOUT	(HZ * 2)



static void sco_sock_timeout(unsigned long arg)
{
	struct sock *sk = (struct sock *)arg;

	BT_DBG("sock %p state %d", sk, sk->sk_state);

	bh_lock_sock(sk);
	sk->sk_err = ETIMEDOUT;
	sk->sk_state_change(sk);
	bh_unlock_sock(sk);

	sco_sock_kill(sk);
	sock_put(sk);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
63
95.45%
1
50.00%
Arnaldo Carvalho de Melo
3
4.55%
1
50.00%
Total
66
100.00%
2
100.00%



static void sco_sock_set_timer(struct sock *sk, long timeout)
{
	BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
	sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
36
87.80%
1
33.33%
Arnaldo Carvalho de Melo
5
12.20%
2
66.67%
Total
41
100.00%
3
100.00%



static void sco_sock_clear_timer(struct sock *sk)
{
	BT_DBG("sock %p state %d", sk, sk->sk_state);
	sk_stop_timer(sk, &sk->sk_timer);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
28
87.50%
1
33.33%
Arnaldo Carvalho de Melo
4
12.50%
2
66.67%
Total
32
100.00%
3
100.00%

/* ---- SCO connections ---- */


static struct sco_conn *sco_conn_add(struct hci_conn *hcon)
{
	struct hci_dev *hdev = hcon->hdev;
	struct sco_conn *conn = hcon->sco_data;

	if (conn)
		return conn;

	conn = kzalloc(sizeof(struct sco_conn), GFP_KERNEL);
	if (!conn)
		return NULL;

	spin_lock_init(&conn->lock);

	hcon->sco_data = conn;
	conn->hcon = hcon;

	if (hdev->sco_mtu > 0)
		conn->mtu = hdev->sco_mtu;
	else
		conn->mtu = 60;

	BT_DBG("hcon %p conn %p", hcon, conn);

	return conn;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
104
91.23%
1
33.33%
Marcel Holtmann
9
7.89%
1
33.33%
Claudio Takahasi
1
0.88%
1
33.33%
Total
114
100.00%
3
100.00%

/* Delete channel.
 * Must be called on the locked socket. */


static void sco_chan_del(struct sock *sk, int err)
{
	struct sco_conn *conn;

	conn = sco_pi(sk)->conn;

	BT_DBG("sk %p, conn %p, err %d", sk, conn, err);

	if (conn) {
		sco_conn_lock(conn);
		conn->sk = NULL;
		sco_pi(sk)->conn = NULL;
		sco_conn_unlock(conn);

		if (conn->hcon)
			hci_conn_drop(conn->hcon);
	}

	sk->sk_state = BT_CLOSED;
	sk->sk_err   = err;
	sk->sk_state_change(sk);

	sock_set_flag(sk, SOCK_ZAPPED);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Marcel Holtmann
109
100.00%
1
100.00%
Total
109
100.00%
1
100.00%



static void sco_conn_del(struct hci_conn *hcon, int err)
{
	struct sco_conn *conn = hcon->sco_data;
	struct sock *sk;

	if (!conn)
		return;

	BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);

	/* Kill socket */
	sco_conn_lock(conn);
	sk = conn->sk;
	sco_conn_unlock(conn);

	if (sk) {
		sock_hold(sk);
		bh_lock_sock(sk);
		sco_sock_clear_timer(sk);
		sco_chan_del(sk, err);
		bh_unlock_sock(sk);
		sco_sock_kill(sk);
		sock_put(sk);
	}

	hcon->sco_data = NULL;
	kfree(conn);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
86
74.14%
1
20.00%
Kuba Pawlak
10
8.62%
1
20.00%
Marcel Holtmann
10
8.62%
1
20.00%
Andrei Emeltchenko
8
6.90%
1
20.00%
Nicholas Krause
2
1.72%
1
20.00%
Total
116
100.00%
5
100.00%



static void __sco_chan_add(struct sco_conn *conn, struct sock *sk,
			   struct sock *parent)
{
	BT_DBG("conn %p", conn);

	sco_pi(sk)->conn = conn;
	conn->sk = sk;

	if (parent)
		bt_accept_enqueue(parent, sk);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Marcel Holtmann
54
100.00%
1
100.00%
Total
54
100.00%
1
100.00%



static int sco_chan_add(struct sco_conn *conn, struct sock *sk,
			struct sock *parent)
{
	int err = 0;

	sco_conn_lock(conn);
	if (conn->sk)
		err = -EBUSY;
	else
		__sco_chan_add(conn, sk, parent);

	sco_conn_unlock(conn);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maxim Krasnyansky
60
100.00%
1
100.00%
Total
60
100.00%
1
100.00%



static int sco_connect(struct sock *sk)
{
	struct sco_conn *conn;
	struct hci_conn *hcon;
	struct hci_dev  *hdev;
	int err, type;

	BT_DBG("%pMR -> %pMR", &sco_pi(sk)->src, &sco_pi(sk)->dst);

	hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src, BDADDR_BREDR);
	if (!hdev)
		return -EHOSTUNREACH;

	hci_dev_lock(hdev);

	if (lmp_esco_capable(hdev) && !disable_esco)
		type = ESCO_LINK;
	else
		type = SCO_LINK;

	if (sco_pi(sk)->setting == BT_VOICE_TRANSPARENT &&
	    (!lmp_transp_capable(hdev) || !lmp_esco_capable(hdev))) {
		err = -EOPNOTSUPP;
		goto done;
	}

	hcon = hci_connect_sco(hdev, type, &sco_pi(sk)->dst,
			       sco_pi(sk)->setting);
	if (IS_ERR(hcon)) {
		err = PTR_ERR(hcon);
		goto done;
	}

	conn = sco_conn_add(hcon);
	if (!conn) {
		hci_conn_drop(hcon);
		err = -ENOMEM;
		goto done;
	}

	/* Update source addr of the socket */
	bacpy(&sco_pi(sk)->src, &hcon->src);

	err = sco_chan_add(conn, sk, NULL);
	if (err)
		goto done;

	if (hcon->state == BT_CONNECTED) {
		sco_sock_clear_timer(sk);
		sk->sk_state = BT_CONNECTED;
	} else {
		sk->sk_state = BT_CONNECT;
		sco_sock_set_timer(sk, sk->sk_sndtimeo);
	}

done:
	hci_dev_unlock(hdev);
	hci_dev_put(hdev);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
167
55.30%
1
6.25%
Marcel Holtmann
61
20.20%
5
31.25%
Frédéric Dalleau
43
14.24%
3
18.75%
Ville Tervo
17
5.63%
1
6.25%
Andrei Emeltchenko
6
1.99%
2
12.50%
Arnaldo Carvalho de Melo
3
0.99%
1
6.25%
Gustavo Fernando Padovan
2
0.66%
1
6.25%
Johan Hedberg
2
0.66%
1
6.25%
David Herrmann
1
0.33%
1
6.25%
Total
302
100.00%
16
100.00%



static int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
{
	struct sco_conn *conn = sco_pi(sk)->conn;
	struct sk_buff *skb;
	int err;

	/* Check outgoing MTU */
	if (len > conn->mtu)
		return -EINVAL;

	BT_DBG("sk %p len %d", sk, len);

	skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
	if (!skb)
		return err;

	if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
		kfree_skb(skb);
		return -EFAULT;
	}

	hci_send_sco(conn->hcon, skb);

	return len;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
108
85.71%
2
33.33%
Gustavo Fernando Padovan
13
10.32%
2
33.33%
Mikel Astiz
4
3.17%
1
16.67%
Al Viro
1
0.79%
1
16.67%
Total
126
100.00%
6
100.00%



static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
{
	struct sock *sk;

	sco_conn_lock(conn);
	sk = conn->sk;
	sco_conn_unlock(conn);

	if (!sk)
		goto drop;

	BT_DBG("sk %p len %d", sk, skb->len);

	if (sk->sk_state != BT_CONNECTED)
		goto drop;

	if (!sock_queue_rcv_skb(sk, skb))
		return;

drop:
	kfree_skb(skb);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
70
82.35%
1
33.33%
Marcel Holtmann
14
16.47%
1
33.33%
Arnaldo Carvalho de Melo
1
1.18%
1
33.33%
Total
85
100.00%
3
100.00%

/* -------- Socket interface ---------- */


static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
{
	struct sock *sk;

	sk_for_each(sk, &sco_sk_list.head) {
		if (sk->sk_state != BT_LISTEN)
			continue;

		if (!bacmp(&sco_pi(sk)->src, ba))
			return sk;
	}

	return NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
30
53.57%
1
25.00%
Marcel Holtmann
18
32.14%
2
50.00%
Arnaldo Carvalho de Melo
8
14.29%
1
25.00%
Total
56
100.00%
4
100.00%

/* Find socket listening on source bdaddr.
 * Returns closest match.
 */


static struct sock *sco_get_sock_listen(bdaddr_t *src)
{
	struct sock *sk = NULL, *sk1 = NULL;

	read_lock(&sco_sk_list.lock);

	sk_for_each(sk, &sco_sk_list.head) {
		if (sk->sk_state != BT_LISTEN)
			continue;

		/* Exact match. */
		if (!bacmp(&sco_pi(sk)->src, src))
			break;

		/* Closest match */
		if (!bacmp(&sco_pi(sk)->src, BDADDR_ANY))
			sk1 = sk;
	}

	read_unlock(&sco_sk_list.lock);

	return sk ? sk : sk1;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
91
88.35%
1
20.00%
Arnaldo Carvalho de Melo
9
8.74%
2
40.00%
Marcel Holtmann
2
1.94%
1
20.00%
Sasha Levin
1
0.97%
1
20.00%
Total
103
100.00%
5
100.00%



static void sco_sock_destruct(struct sock *sk)
{
	BT_DBG("sk %p", sk);

	skb_queue_purge(&sk->sk_receive_queue);
	skb_queue_purge(&sk->sk_write_queue);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
32
94.12%
1
50.00%
Arnaldo Carvalho de Melo
2
5.88%
1
50.00%
Total
34
100.00%
2
100.00%



static void sco_sock_cleanup_listen(struct sock *parent)
{
	struct sock *sk;

	BT_DBG("parent %p", parent);

	/* Close not yet accepted channels */
	while ((sk = bt_accept_dequeue(parent, NULL))) {
		sco_sock_close(sk);
		sco_sock_kill(sk);
	}

	parent->sk_state  = BT_CLOSED;
	sock_set_flag(parent, SOCK_ZAPPED);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
55
88.71%
3
50.00%
Thomas Graf
5
8.06%
1
16.67%
Arnaldo Carvalho de Melo
1
1.61%
1
16.67%
David Woodhouse
1
1.61%
1
16.67%
Total
62
100.00%
6
100.00%

/* Kill socket (only if zapped and orphan)
 * Must be called on unlocked socket.
 */


static void sco_sock_kill(struct sock *sk)
{
	if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
		return;

	BT_DBG("sk %p state %d", sk, sk->sk_state);

	/* Kill poor orphan */
	bt_sock_unlink(&sco_sk_list, sk);
	sock_set_flag(sk, SOCK_DEAD);
	sock_put(sk);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
46
79.31%
2
33.33%
Arnaldo Carvalho de Melo
5
8.62%
2
33.33%
Thomas Graf
5
8.62%
1
16.67%
James Morris
2
3.45%
1
16.67%
Total
58
100.00%
6
100.00%



static void __sco_sock_close(struct sock *sk)
{
	BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);

	switch (sk->sk_state) {
	case BT_LISTEN:
		sco_sock_cleanup_listen(sk);
		break;

	case BT_CONNECTED:
	case BT_CONFIG:
		if (sco_pi(sk)->conn->hcon) {
			sk->sk_state = BT_DISCONN;
			sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
			sco_conn_lock(sco_pi(sk)->conn);
			hci_conn_drop(sco_pi(sk)->conn->hcon);
			sco_pi(sk)->conn->hcon = NULL;
			sco_conn_unlock(sco_pi(sk)->conn);
		} else
			sco_chan_del(sk, ECONNRESET);
		break;

	case BT_CONNECT2:
	case BT_CONNECT:
	case BT_DISCONN:
		sco_chan_del(sk, ECONNRESET);
		break;

	default:
		sock_set_flag(sk, SOCK_ZAPPED);
		break;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
61
39.87%
1
11.11%
Luiz Augusto von Dentz
55
35.95%
1
11.11%
Kuba Pawlak
20
13.07%
1
11.11%
Thomas Graf
5
3.27%
1
11.11%
Marcel Holtmann
3
1.96%
1
11.11%
Vinicius Costa Gomes
3
1.96%
1
11.11%
Arnaldo Carvalho de Melo
3
1.96%
1
11.11%
Gustavo Fernando Padovan
2
1.31%
1
11.11%
David Herrmann
1
0.65%
1
11.11%
Total
153
100.00%
9
100.00%

/* Must be called on unlocked socket. */


static void sco_sock_close(struct sock *sk)
{
	sco_sock_clear_timer(sk);
	lock_sock(sk);
	__sco_sock_close(sk);
	release_sock(sk);
	sco_sock_kill(sk);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Marcel Holtmann
25
69.44%
1
50.00%
Maksim Krasnyanskiy
11
30.56%
1
50.00%
Total
36
100.00%
2
100.00%



static void sco_sock_init(struct sock *sk, struct sock *parent)
{
	BT_DBG("sk %p", sk);

	if (parent) {
		sk->sk_type = parent->sk_type;
		bt_sk(sk)->flags = bt_sk(parent)->flags;
		security_sk_clone(parent, sk);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
33
56.90%
1
25.00%
Frédéric Dalleau
14
24.14%
1
25.00%
Paul Moore
9
15.52%
1
25.00%
Arnaldo Carvalho de Melo
2
3.45%
1
25.00%
Total
58
100.00%
4
100.00%


static struct proto sco_proto = {
	.name		= "SCO",
	.owner		= THIS_MODULE,
	.obj_size	= sizeof(struct sco_pinfo)
};



static struct sock *sco_sock_alloc(struct net *net, struct socket *sock,
				   int proto, gfp_t prio, int kern)
{
	struct sock *sk;

	sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto, kern);
	if (!sk)
		return NULL;

	sock_init_data(sock, sk);
	INIT_LIST_HEAD(&bt_sk(sk)->accept_q);

	sk->sk_destruct = sco_sock_destruct;
	sk->sk_sndtimeo = SCO_CONN_TIMEOUT;

	sock_reset_flag(sk, SOCK_ZAPPED);

	sk->sk_protocol = proto;
	sk->sk_state    = BT_OPEN;

	sco_pi(sk)->setting = BT_VOICE_CVSD_16BIT;

	setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);

	bt_sock_link(&sco_sk_list, sk);
	return sk;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
68
48.23%
2
20.00%
Marcel Holtmann
34
24.11%
1
10.00%
Pavel Emelyanov
12
8.51%
1
10.00%
Eric W. Biedermann
12
8.51%
2
20.00%
Frédéric Dalleau
9
6.38%
1
10.00%
Arnaldo Carvalho de Melo
5
3.55%
2
20.00%
Al Viro
1
0.71%
1
10.00%
Total
141
100.00%
10
100.00%



static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
			   int kern)
{
	struct sock *sk;

	BT_DBG("sock %p", sock);

	sock->state = SS_UNCONNECTED;

	if (sock->type != SOCK_SEQPACKET)
		return -ESOCKTNOSUPPORT;

	sock->ops = &sco_sock_ops;

	sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
	if (!sk)
		return -ENOMEM;

	sco_sock_init(sk, NULL);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
75
80.65%
1
20.00%
Eric W. Biedermann
9
9.68%
2
40.00%
Marcel Holtmann
6
6.45%
1
20.00%
Eric Paris
3
3.23%
1
20.00%
Total
93
100.00%
5
100.00%



static int sco_sock_bind(struct socket *sock, struct sockaddr *addr,
			 int addr_len)
{
	struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
	struct sock *sk = sock->sk;
	int err = 0;

	BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);

	if (!addr || addr->sa_family != AF_BLUETOOTH)
		return -EINVAL;

	if (addr_len < sizeof(struct sockaddr_sco))
		return -EINVAL;

	lock_sock(sk);

	if (sk->sk_state != BT_OPEN) {
		err = -EBADFD;
		goto done;
	}

	if (sk->sk_type != SOCK_SEQPACKET) {
		err = -EINVAL;
		goto done;
	}

	bacpy(&sco_pi(sk)->src, &sa->sco_bdaddr);

	sk->sk_state = BT_BOUND;

done:
	release_sock(sk);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
132
83.02%
1
16.67%
David S. Miller
14
8.81%
1
16.67%
Marcel Holtmann
10
6.29%
2
33.33%
Arnaldo Carvalho de Melo
2
1.26%
1
16.67%
Andrei Emeltchenko
1
0.63%
1
16.67%
Total
159
100.00%
6
100.00%



static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
{
	struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
	struct sock *sk = sock->sk;
	int err;

	BT_DBG("sk %p", sk);

	if (alen < sizeof(struct sockaddr_sco) ||
	    addr->sa_family != AF_BLUETOOTH)
		return -EINVAL;

	if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
		return -EBADFD;

	if (sk->sk_type != SOCK_SEQPACKET)
		return -EINVAL;

	lock_sock(sk);

	/* Set destination address and psm */
	bacpy(&sco_pi(sk)->dst, &sa->sco_bdaddr);

	err = sco_connect(sk);
	if (err)
		goto done;

	err = bt_sock_wait_state(sk, BT_CONNECTED,
				 sock_sndtimeo(sk, flags & O_NONBLOCK));

done:
	release_sock(sk);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
153
91.62%
2
33.33%
Changli Gao
6
3.59%
1
16.67%
Andrei Emeltchenko
4
2.40%
1
16.67%
Arnaldo Carvalho de Melo
3
1.80%
1
16.67%
Marcel Holtmann
1
0.60%
1
16.67%
Total
167
100.00%
6
100.00%



static int sco_sock_listen(struct socket *sock, int backlog)
{
	struct sock *sk = sock->sk;
	bdaddr_t *src = &sco_pi(sk)->src;
	int err = 0;

	BT_DBG("sk %p backlog %d", sk, backlog);

	lock_sock(sk);

	if (sk->sk_state != BT_BOUND) {
		err = -EBADFD;
		goto done;
	}

	if (sk->sk_type != SOCK_SEQPACKET) {
		err = -EINVAL;
		goto done;
	}

	write_lock(&sco_sk_list.lock);

	if (__sco_get_sock_listen_by_addr(src)) {
		err = -EADDRINUSE;
		goto unlock;
	}

	sk->sk_max_ack_backlog = backlog;
	sk->sk_ack_backlog = 0;

	sk->sk_state = BT_LISTEN;

unlock:
	write_unlock(&sco_sk_list.lock);

done:
	release_sock(sk);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
85
55.56%
1
16.67%
Marcel Holtmann
64
41.83%
4
66.67%
Arnaldo Carvalho de Melo
4
2.61%
1
16.67%
Total
153
100.00%
6
100.00%



static int sco_sock_accept(struct socket *sock, struct socket *newsock,
			   int flags, bool kern)
{
	DEFINE_WAIT_FUNC(wait, woken_wake_function);
	struct sock *sk = sock->sk, *ch;
	long timeo;
	int err = 0;

	lock_sock(sk);

	timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);

	BT_DBG("sk %p timeo %ld", sk, timeo);

	/* Wait for an incoming connection. (wake-one). */
	add_wait_queue_exclusive(sk_sleep(sk), &wait);
	while (1) {
		if (sk->sk_state != BT_LISTEN) {
			err = -EBADFD;
			break;
		}

		ch = bt_accept_dequeue(sk, newsock);
		if (ch)
			break;

		if (!timeo) {
			err = -EAGAIN;
			break;
		}

		if (signal_pending(current)) {
			err = sock_intr_errno(timeo);
			break;
		}

		release_sock(sk);

		timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
		lock_sock(sk);
	}
	remove_wait_queue(sk_sleep(sk), &wait);

	if (err)
		goto done;

	newsock->state = SS_CONNECTED;

	BT_DBG("new socket %p", ch);

done:
	release_sock(sk);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
160
74.42%
1
14.29%
Peter Hurley
43
20.00%
2
28.57%
Eric Dumazet
6
2.79%
1
14.29%
David Howells
3
1.40%
1
14.29%
Arnaldo Carvalho de Melo
2
0.93%
1
14.29%
Marcel Holtmann
1
0.47%
1
14.29%
Total
215
100.00%
7
100.00%



static int sco_sock_getname(struct socket *sock, struct sockaddr *addr,
			    int *len, int peer)
{
	struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
	struct sock *sk = sock->sk;

	BT_DBG("sock %p, sk %p", sock, sk);

	addr->sa_family = AF_BLUETOOTH;
	*len = sizeof(struct sockaddr_sco);

	if (peer)
		bacpy(&sa->sco_bdaddr, &sco_pi(sk)->dst);
	else
		bacpy(&sa->sco_bdaddr, &sco_pi(sk)->src);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
106
98.15%
1
50.00%
Marcel Holtmann
2
1.85%
1
50.00%
Total
108
100.00%
2
100.00%



static int sco_sock_sendmsg(struct socket *sock, struct msghdr *msg,
			    size_t len)
{
	struct sock *sk = sock->sk;
	int err;

	BT_DBG("sock %p, sk %p", sock, sk);

	err = sock_error(sk);
	if (err)
		return err;

	if (msg->msg_flags & MSG_OOB)
		return -EOPNOTSUPP;

	lock_sock(sk);

	if (sk->sk_state == BT_CONNECTED)
		err = sco_send_frame(sk, msg, len);
	else
		err = -ENOTCONN;

	release_sock(sk);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
93
89.42%
1
25.00%
Benjamin LaHaise
9
8.65%
1
25.00%
Arnaldo Carvalho de Melo
1
0.96%
1
25.00%
Stephen Hemminger
1
0.96%
1
25.00%
Total
104
100.00%
4
100.00%



static void sco_conn_defer_accept(struct hci_conn *conn, u16 setting)
{
	struct hci_dev *hdev = conn->hdev;

	BT_DBG("conn %p", conn);

	conn->state = BT_CONFIG;

	if (!lmp_esco_capable(hdev)) {
		struct hci_cp_accept_conn_req cp;

		bacpy(&cp.bdaddr, &conn->dst);
		cp.role = 0x00; /* Ignored */

		hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
	} else {
		struct hci_cp_accept_sync_conn_req cp;

		bacpy(&cp.bdaddr, &conn->dst);
		cp.pkt_type = cpu_to_le16(conn->pkt_type);

		cp.tx_bandwidth   = cpu_to_le32(0x00001f40);
		cp.rx_bandwidth   = cpu_to_le32(0x00001f40);
		cp.content_format = cpu_to_le16(setting);

		switch (setting & SCO_AIRMODE_MASK) {
		case SCO_AIRMODE_TRANSP:
			if (conn->pkt_type & ESCO_2EV3)
				cp.max_latency = cpu_to_le16(0x0008);
			else
				cp.max_latency = cpu_to_le16(0x000D);
			cp.retrans_effort = 0x02;
			break;
		case SCO_AIRMODE_CVSD:
			cp.max_latency = cpu_to_le16(0xffff);
			cp.retrans_effort = 0xff;
			break;
		}

		hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
			     sizeof(cp), &cp);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Frédéric Dalleau
217
97.75%
3
75.00%
Joe Perches
5
2.25%
1
25.00%
Total
222
100.00%
4
100.00%



static int sco_sock_recvmsg(struct socket *sock, struct msghdr *msg,
			    size_t len, int flags)
{
	struct sock *sk = sock->sk;
	struct sco_pinfo *pi = sco_pi(sk);

	lock_sock(sk);

	if (sk->sk_state == BT_CONNECT2 &&
	    test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
		sco_conn_defer_accept(pi->conn->hcon, pi->setting);
		sk->sk_state = BT_CONFIG;

		release_sock(sk);
		return 0;
	}

	release_sock(sk);

	return bt_sock_recvmsg(sock, msg, len, flags);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Frédéric Dalleau
113
100.00%
3
100.00%
Total
113
100.00%
3
100.00%



static int sco_sock_setsockopt(struct socket *sock, int level, int optname,
			       char __user *optval, unsigned int optlen)
{
	struct sock *sk = sock->sk;
	int len, err = 0;
	struct bt_voice voice;
	u32 opt;

	BT_DBG("sk %p", sk);

	lock_sock(sk);

	switch (optname) {

	case BT_DEFER_SETUP:
		if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
			err = -EINVAL;
			break;
		}

		if (get_user(opt, (u32 __user *) optval)) {
			err = -EFAULT;
			break;
		}

		if (opt)
			set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
		else
			clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
		break;

	case BT_VOICE:
		if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
		    sk->sk_state != BT_CONNECT2) {
			err = -EINVAL;
			break;
		}

		voice.setting = sco_pi(sk)->setting;

		len = min_t(unsigned int, sizeof(voice), optlen);
		if (copy_from_user((char *)&voice, optval, len)) {
			err = -EFAULT;
			break;
		}

		/* Explicitly check for these values */
		if (voice.setting != BT_VOICE_TRANSPARENT &&
		    voice.setting != BT_VOICE_CVSD_16BIT) {
			err = -EINVAL;
			break;
		}

		sco_pi(sk)->setting = voice.setting;
		break;

	default:
		err = -ENOPROTOOPT;
		break;
	}

	release_sock(sk);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Frédéric Dalleau
200
73.26%
2
33.33%
Maksim Krasnyanskiy
70
25.64%
1
16.67%
Al Viro
1
0.37%
1
16.67%
Marcel Holtmann
1
0.37%
1
16.67%
David S. Miller
1
0.37%
1
16.67%
Total
273
100.00%
6
100.00%



static int sco_sock_getsockopt_old(struct socket *sock, int optname,
				   char __user *optval, int __user *optlen)
{
	struct sock *sk = sock->sk;
	struct sco_options opts;
	struct sco_conninfo cinfo;
	int len, err = 0;

	BT_DBG("sk %p", sk);

	if (get_user(len, optlen))
		return -EFAULT;

	lock_sock(sk);

	switch (optname) {
	case SCO_OPTIONS:
		if (sk->sk_state != BT_CONNECTED &&
		    !(sk->sk_state == BT_CONNECT2 &&
		      test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
			err = -ENOTCONN;
			break;
		}

		opts.mtu = sco_pi(sk)->conn->mtu;

		BT_DBG("mtu %d", opts.mtu);

		len = min_t(unsigned int, len, sizeof(opts));
		if (copy_to_user(optval, (char *)&opts, len))
			err = -EFAULT;

		break;

	case SCO_CONNINFO:
		if (sk->sk_state != BT_CONNECTED &&
		    !(sk->sk_state == BT_CONNECT2 &&
		      test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
			err = -ENOTCONN;
			break;
		}

		memset(&cinfo, 0, sizeof(cinfo));
		cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
		memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);

		len = min_t(unsigned int, len, sizeof(cinfo));
		if (copy_to_user(optval, (char *)&cinfo, len))
			err = -EFAULT;

		break;

	default:
		err = -ENOPROTOOPT;
		break;
	}

	release_sock(sk);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
228
73.08%
2
20.00%
Johan Hedberg
44
14.10%
1
10.00%
Marcel Holtmann
23
7.37%
4
40.00%
Vasiliy Kulikov
13
4.17%
1
10.00%
Arnaldo Carvalho de Melo
2
0.64%
1
10.00%
Al Viro
2
0.64%
1
10.00%
Total
312
100.00%
10
100.00%



static int sco_sock_getsockopt(struct socket *sock, int level, int optname,
			       char __user *optval, int __user *optlen)
{
	struct sock *sk = sock->sk;
	int len, err = 0;
	struct bt_voice voice;

	BT_DBG("sk %p", sk);

	if (level == SOL_SCO)
		return sco_sock_getsockopt_old(sock, optname, optval, optlen);

	if (get_user(len, optlen))
		return -EFAULT;

	lock_sock(sk);

	switch (optname) {

	case BT_DEFER_SETUP:
		if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
			err = -EINVAL;
			break;
		}

		if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
			     (u32 __user *)optval))
			err = -EFAULT;

		break;

	case BT_VOICE:
		voice.setting = sco_pi(sk)->setting;

		len = min_t(unsigned int, len, sizeof(voice));
		if (copy_to_user(optval, (char *)&voice, len))
			err = -EFAULT;

		break;

	default:
		err = -ENOPROTOOPT;
		break;
	}

	release_sock(sk);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Frédéric Dalleau
107
50.00%
2
66.67%
Marcel Holtmann
107
50.00%
1
33.33%
Total
214
100.00%
3
100.00%



static int sco_sock_shutdown(struct socket *sock, int how)
{
	struct sock *sk = sock->sk;
	int err = 0;

	BT_DBG("sock %p, sk %p", sock, sk);

	if (!sk)
		return 0;

	sock_hold(sk);
	lock_sock(sk);

	if (!sk->sk_shutdown) {
		sk->sk_shutdown = SHUTDOWN_MASK;
		sco_sock_clear_timer(sk);
		__sco_sock_close(sk);

		if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
		    !(current->flags & PF_EXITING))
			err = bt_sock_wait_state(sk, BT_CLOSED,
						 sk->sk_lingertime);
	}

	release_sock(sk);
	sock_put(sk);

	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Marcel Holtmann
109
85.16%
1
33.33%
Kuba Pawlak
10
7.81%
1
33.33%
Vladimir Davydov
9
7.03%
1
33.33%
Total
128
100.00%
3
100.00%



static int sco_sock_release(struct socket *sock)
{
	struct sock *sk = sock->sk;
	int err = 0;

	BT_DBG("sock %p, sk %p", sock, sk);

	if (!sk)
		return 0;

	sco_sock_close(sk);

	if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
	    !(current->flags & PF_EXITING)) {
		lock_sock(sk);
		err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
		release_sock(sk);
	}

	sock_orphan(sk);
	sco_sock_kill(sk);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
98
91.59%
2
66.67%
Vladimir Davydov
9
8.41%
1
33.33%
Total
107
100.00%
3
100.00%



static void sco_conn_ready(struct sco_conn *conn)
{
	struct sock *parent;
	struct sock *sk = conn->sk;

	BT_DBG("conn %p", conn);

	if (sk) {
		sco_sock_clear_timer(sk);
		bh_lock_sock(sk);
		sk->sk_state = BT_CONNECTED;
		sk->sk_state_change(sk);
		bh_unlock_sock(sk);
	} else {
		sco_conn_lock(conn);

		if (!conn->hcon) {
			sco_conn_unlock(conn);
			return;
		}

		parent = sco_get_sock_listen(&conn->hcon->src);
		if (!parent) {
			sco_conn_unlock(conn);
			return;
		}

		bh_lock_sock(parent);

		sk = sco_sock_alloc(sock_net(parent), NULL,
				    BTPROTO_SCO, GFP_ATOMIC, 0);
		if (!sk) {
			bh_unlock_sock(parent);
			sco_conn_unlock(conn);
			return;
		}

		sco_sock_init(sk, parent);

		bacpy(&sco_pi(sk)->src, &conn->hcon->src);
		bacpy(&sco_pi(sk)->dst, &conn->hcon->dst);

		hci_conn_hold(conn->hcon);
		__sco_chan_add(conn, sk, parent);

		if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
			sk->sk_state = BT_CONNECT2;
		else
			sk->sk_state = BT_CONNECTED;

		/* Wake up parent */
		parent->sk_data_ready(parent);

		bh_unlock_sock(parent);

		sco_conn_unlock(conn);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
174
66.92%
1
9.09%
Frédéric Dalleau
22
8.46%
1
9.09%
Andre Guedes
20
7.69%
1
9.09%
Kuba Pawlak
15
5.77%
1
9.09%
Marcel Holtmann
11
4.23%
2
18.18%
Andrei Emeltchenko
7
2.69%
1
9.09%
Eric W. Biedermann
4
1.54%
2
18.18%
Arnaldo Carvalho de Melo
4
1.54%
1
9.09%
Hideaki Yoshifuji / 吉藤英明
3
1.15%
1
9.09%
Total
260
100.00%
11
100.00%

/* ----- SCO interface with lower layer (HCI) ----- */


int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
{
	struct sock *sk;
	int lm = 0;

	BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);

	/* Find listening sockets */
	read_lock(&sco_sk_list.lock);
	sk_for_each(sk, &sco_sk_list.head) {
		if (sk->sk_state != BT_LISTEN)
			continue;

		if (!bacmp(&sco_pi(sk)->src, &hdev->bdaddr) ||
		    !bacmp(&sco_pi(sk)->src, BDADDR_ANY)) {
			lm |= HCI_LM_ACCEPT;

			if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
				*flags |= HCI_PROTO_DEFER;
			break;
		}
	}
	read_unlock(&sco_sk_list.lock);

	return lm;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Marcel Holtmann
85
62.50%
2
40.00%
Maksim Krasnyanskiy
26
19.12%
1
20.00%
Frédéric Dalleau
24
17.65%
1
20.00%
Andrei Emeltchenko
1
0.74%
1
20.00%
Total
136
100.00%
5
100.00%



static void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
{
	if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
		return;

	BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);

	if (!status) {
		struct sco_conn *conn;

		conn = sco_conn_add(hcon);
		if (conn)
			sco_conn_ready(conn);
	} else
		sco_conn_del(hcon, bt_to_errno(status));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
63
76.83%
1
20.00%
Johan Hedberg
16
19.51%
1
20.00%
Andrei Emeltchenko
2
2.44%
2
40.00%
Joe Perches
1
1.22%
1
20.00%
Total
82
100.00%
5
100.00%



static void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
{
	if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
		return;

	BT_DBG("hcon %p reason %d", hcon, reason);

	sco_conn_del(hcon, bt_to_errno(reason));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
29
60.42%
1
20.00%
Johan Hedberg
16
33.33%
1
20.00%
Andrei Emeltchenko
1
2.08%
1
20.00%
Marcel Holtmann
1
2.08%
1
20.00%
Joe Perches
1
2.08%
1
20.00%
Total
48
100.00%
5
100.00%



void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
{
	struct sco_conn *conn = hcon->sco_data;

	if (!conn)
		goto drop;

	BT_DBG("conn %p len %d", conn, skb->len);

	if (skb->len) {
		sco_recv_frame(conn, skb);
		return;
	}

drop:
	kfree_skb(skb);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
64
96.97%
1
50.00%
Arron Wang
2
3.03%
1
50.00%
Total
66
100.00%
2
100.00%


static struct hci_cb sco_cb = {
	.name		= "SCO",
	.connect_cfm	= sco_connect_cfm,
	.disconn_cfm	= sco_disconn_cfm,
};



static int sco_debugfs_show(struct seq_file *f, void *p)
{
	struct sock *sk;

	read_lock(&sco_sk_list.lock);

	sk_for_each(sk, &sco_sk_list.head) {
		seq_printf(f, "%pMR %pMR %d\n", &sco_pi(sk)->src,
			   &sco_pi(sk)->dst, sk->sk_state);
	}

	read_unlock(&sco_sk_list.lock);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
48
64.86%
2
18.18%
Marcel Holtmann
14
18.92%
4
36.36%
Arnaldo Carvalho de Melo
7
9.46%
2
18.18%
Gustavo Fernando Padovan
2
2.70%
1
9.09%
Andi Kleen
2
2.70%
1
9.09%
Andrei Emeltchenko
1
1.35%
1
9.09%
Total
74
100.00%
11
100.00%



static int sco_debugfs_open(struct inode *inode, struct file *file)
{
	return single_open(file, sco_debugfs_show, inode->i_private);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Marcel Holtmann
24
85.71%
2
66.67%
Maksim Krasnyanskiy
4
14.29%
1
33.33%
Total
28
100.00%
3
100.00%


static const struct file_operations sco_debugfs_fops = {
	.open		= sco_debugfs_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};


static struct dentry *sco_debugfs;


static const struct proto_ops sco_sock_ops = {
	.family		= PF_BLUETOOTH,
	.owner		= THIS_MODULE,
	.release	= sco_sock_release,
	.bind		= sco_sock_bind,
	.connect	= sco_sock_connect,
	.listen		= sco_sock_listen,
	.accept		= sco_sock_accept,
	.getname	= sco_sock_getname,
	.sendmsg	= sco_sock_sendmsg,
	.recvmsg	= sco_sock_recvmsg,
	.poll		= bt_sock_poll,
	.ioctl		= bt_sock_ioctl,
	.mmap		= sock_no_mmap,
	.socketpair	= sock_no_socketpair,
	.shutdown	= sco_sock_shutdown,
	.setsockopt	= sco_sock_setsockopt,
	.getsockopt	= sco_sock_getsockopt
};


static const struct net_proto_family sco_sock_family_ops = {
	.family	= PF_BLUETOOTH,
	.owner	= THIS_MODULE,
	.create	= sco_sock_create,
};



int __init sco_init(void)
{
	int err;

	BUILD_BUG_ON(sizeof(struct sockaddr_sco) > sizeof(struct sockaddr));

	err = proto_register(&sco_proto, 0);
	if (err < 0)
		return err;

	err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
	if (err < 0) {
		BT_ERR("SCO socket registration failed");
		goto error;
	}

	err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
	if (err < 0) {
		BT_ERR("Failed to create SCO proc file");
		bt_sock_unregister(BTPROTO_SCO);
		goto error;
	}

	BT_INFO("SCO socket layer initialized");

	hci_register_cb(&sco_cb);

	if (IS_ERR_OR_NULL(bt_debugfs))
		return 0;

	sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
					  NULL, &sco_debugfs_fops);

	return 0;

error:
	proto_unregister(&sco_proto);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Marcel Holtmann
46
29.11%
5
45.45%
Arnaldo Carvalho de Melo
37
23.42%
1
9.09%
Masatake YAMATO
36
22.78%
1
9.09%
Maksim Krasnyanskiy
33
20.89%
3
27.27%
Johan Hedberg
6
3.80%
1
9.09%
Total
158
100.00%
11
100.00%



void sco_exit(void)
{
	bt_procfs_cleanup(&init_net, "sco");

	debugfs_remove(sco_debugfs);

	hci_unregister_cb(&sco_cb);

	bt_sock_unregister(BTPROTO_SCO);

	proto_unregister(&sco_proto);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
14
37.84%
2
25.00%
Masatake YAMATO
8
21.62%
1
12.50%
Johan Hedberg
6
16.22%
1
12.50%
Marcel Holtmann
5
13.51%
3
37.50%
Arnaldo Carvalho de Melo
4
10.81%
1
12.50%
Total
37
100.00%
8
100.00%

module_param(disable_esco, bool, 0644);
MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Maksim Krasnyanskiy
2849
52.45%
6
5.22%
Marcel Holtmann
996
18.34%
31
26.96%
Frédéric Dalleau
750
13.81%
9
7.83%
Arnaldo Carvalho de Melo
152
2.80%
7
6.09%
Johan Hedberg
112
2.06%
4
3.48%
Maxim Krasnyansky
71
1.31%
1
0.87%
Kuba Pawlak
55
1.01%
4
3.48%
Luiz Augusto von Dentz
55
1.01%
1
0.87%
Masatake YAMATO
44
0.81%
1
0.87%
Peter Hurley
43
0.79%
2
1.74%
Rusty Russell
37
0.68%
2
1.74%
Andrei Emeltchenko
31
0.57%
4
3.48%
Eric W. Biedermann
25
0.46%
2
1.74%
Andre Guedes
20
0.37%
1
0.87%
Gustavo Fernando Padovan
19
0.35%
5
4.35%
Vladimir Davydov
18
0.33%
1
0.87%
Ville Tervo
17
0.31%
1
0.87%
Thomas Graf
15
0.28%
1
0.87%
David S. Miller
15
0.28%
2
1.74%
Vasiliy Kulikov
13
0.24%
1
0.87%
Pavel Emelyanov
12
0.22%
1
0.87%
Paul Moore
9
0.17%
1
0.87%
Benjamin LaHaise
9
0.17%
1
0.87%
Eric Dumazet
8
0.15%
2
1.74%
Joe Perches
7
0.13%
2
1.74%
Changli Gao
6
0.11%
1
0.87%
Al Viro
5
0.09%
3
2.61%
Mikel Astiz
4
0.07%
1
0.87%
Hideaki Yoshifuji / 吉藤英明
4
0.07%
2
1.74%
Robert P. J. Day
4
0.07%
1
0.87%
David Howells
3
0.06%
1
0.87%
Ingo Molnar
3
0.06%
1
0.87%
Eric Paris
3
0.06%
1
0.87%
Vinicius Costa Gomes
3
0.06%
1
0.87%
Stephen Hemminger
2
0.04%
2
1.74%
Nicholas Krause
2
0.04%
1
0.87%
James Morris
2
0.04%
1
0.87%
Andi Kleen
2
0.04%
1
0.87%
Arron Wang
2
0.04%
1
0.87%
David Herrmann
2
0.04%
1
0.87%
Sasha Levin
1
0.02%
1
0.87%
Claudio Takahasi
1
0.02%
1
0.87%
David Woodhouse
1
0.02%
1
0.87%
Total
5432
100.00%
115
100.00%
Directory: net/bluetooth

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.