forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-09-20 cf4ce59b3b70238352c7f1729f0f7223214828ad 
 kernel/net/bluetooth/l2cap_sock.c
....@@ -45,6 +45,7 @@
4545 static void l2cap_sock_init(struct sock *sk, struct sock *parent);
4646 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock,
4747 				     int proto, gfp_t prio, int kern);
48
+static void l2cap_sock_cleanup_listen(struct sock *parent);
4849 
4950 bool l2cap_is_socket(struct socket *sock)
5051 {
....@@ -161,7 +162,11 @@
161162 		break;
162163 	}
163164 
164
-	if (chan->psm && bdaddr_type_is_le(chan->src_type))
165
+	/* Use L2CAP_MODE_LE_FLOWCTL (CoC) in case of LE address and
166
+	 * L2CAP_MODE_EXT_FLOWCTL (ECRED) has not been set.
167
+	 */
168
+	if (chan->psm && bdaddr_type_is_le(chan->src_type) &&
169
+	    chan->mode != L2CAP_MODE_EXT_FLOWCTL)
165170 		chan->mode = L2CAP_MODE_LE_FLOWCTL;
166171 
167172 	chan->state = BT_BOUND;
....@@ -170,6 +175,21 @@
170175 done:
171176 	release_sock(sk);
172177 	return err;
178
+}
179
+
180
+static void l2cap_sock_init_pid(struct sock *sk)
181
+{
182
+	struct l2cap_chan *chan = l2cap_pi(sk)->chan;
183
+
184
+	/* Only L2CAP_MODE_EXT_FLOWCTL ever need to access the PID in order to
185
+	 * group the channels being requested.
186
+	 */
187
+	if (chan->mode != L2CAP_MODE_EXT_FLOWCTL)
188
+		return;
189
+
190
+	spin_lock(&sk->sk_peer_lock);
191
+	sk->sk_peer_pid = get_pid(task_tgid(current));
192
+	spin_unlock(&sk->sk_peer_lock);
173193 }
174194 
175195 static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr,
....@@ -240,8 +260,14 @@
240260 			return -EINVAL;
241261 	}
242262 
243
-	if (chan->psm && bdaddr_type_is_le(chan->src_type))
263
+	/* Use L2CAP_MODE_LE_FLOWCTL (CoC) in case of LE address and
264
+	 * L2CAP_MODE_EXT_FLOWCTL (ECRED) has not been set.
265
+	 */
266
+	if (chan->psm && bdaddr_type_is_le(chan->src_type) &&
267
+	    chan->mode != L2CAP_MODE_EXT_FLOWCTL)
244268 		chan->mode = L2CAP_MODE_LE_FLOWCTL;
269
+
270
+	l2cap_sock_init_pid(sk);
245271 
246272 	err = l2cap_chan_connect(chan, la.l2_psm, __le16_to_cpu(la.l2_cid),
247273 				 &la.l2_bdaddr, la.l2_bdaddr_type);
....@@ -282,15 +308,23 @@
282308 	case L2CAP_MODE_BASIC:
283309 	case L2CAP_MODE_LE_FLOWCTL:
284310 		break;
311
+	case L2CAP_MODE_EXT_FLOWCTL:
312
+		if (!enable_ecred) {
313
+			err = -EOPNOTSUPP;
314
+			goto done;
315
+		}
316
+		break;
285317 	case L2CAP_MODE_ERTM:
286318 	case L2CAP_MODE_STREAMING:
287319 		if (!disable_ertm)
288320 			break;
289
-		/* fall through */
321
+		fallthrough;
290322 	default:
291323 		err = -EOPNOTSUPP;
292324 		goto done;
293325 	}
326
+
327
+	l2cap_sock_init_pid(sk);
294328 
295329 	sk->sk_max_ack_backlog = backlog;
296330 	sk->sk_ack_backlog = 0;
....@@ -397,6 +431,24 @@
397431 	return sizeof(struct sockaddr_l2);
398432 }
399433 
434
+static int l2cap_get_mode(struct l2cap_chan *chan)
435
+{
436
+	switch (chan->mode) {
437
+	case L2CAP_MODE_BASIC:
438
+		return BT_MODE_BASIC;
439
+	case L2CAP_MODE_ERTM:
440
+		return BT_MODE_ERTM;
441
+	case L2CAP_MODE_STREAMING:
442
+		return BT_MODE_STREAMING;
443
+	case L2CAP_MODE_LE_FLOWCTL:
444
+		return BT_MODE_LE_FLOWCTL;
445
+	case L2CAP_MODE_EXT_FLOWCTL:
446
+		return BT_MODE_EXT_FLOWCTL;
447
+	}
448
+
449
+	return -EINVAL;
450
+}
451
+
400452 static int l2cap_sock_getsockopt_old(struct socket *sock, int optname,
401453 				     char __user *optval, int __user *optlen)
402454 {
....@@ -426,6 +478,20 @@
426478 			break;
427479 		}
428480 
481
+		/* Only BR/EDR modes are supported here */
482
+		switch (chan->mode) {
483
+		case L2CAP_MODE_BASIC:
484
+		case L2CAP_MODE_ERTM:
485
+		case L2CAP_MODE_STREAMING:
486
+			break;
487
+		default:
488
+			err = -EINVAL;
489
+			break;
490
+		}
491
+
492
+		if (err < 0)
493
+			break;
494
+
429495 		memset(&opts, 0, sizeof(opts));
430496 		opts.imtu     = chan->imtu;
431497 		opts.omtu     = chan->omtu;
....@@ -434,6 +500,8 @@
434500 		opts.fcs      = chan->fcs;
435501 		opts.max_tx   = chan->max_tx;
436502 		opts.txwin_size = chan->tx_win;
503
+
504
+		BT_DBG("mode 0x%2.2x", chan->mode);
437505 
438506 		len = min_t(unsigned int, len, sizeof(opts));
439507 		if (copy_to_user(optval, (char *) &opts, len))
....@@ -507,7 +575,8 @@
507575 	struct l2cap_chan *chan = l2cap_pi(sk)->chan;
508576 	struct bt_security sec;
509577 	struct bt_power pwr;
510
-	int len, err = 0;
578
+	u32 phys;
579
+	int len, mode, err = 0;
511580 
512581 	BT_DBG("sk %p", sk);
513582 
....@@ -611,6 +680,39 @@
611680 			err = -EFAULT;
612681 		break;
613682 
683
+	case BT_PHY:
684
+		if (sk->sk_state != BT_CONNECTED) {
685
+			err = -ENOTCONN;
686
+			break;
687
+		}
688
+
689
+		phys = hci_conn_get_phy(chan->conn->hcon);
690
+
691
+		if (put_user(phys, (u32 __user *) optval))
692
+			err = -EFAULT;
693
+		break;
694
+
695
+	case BT_MODE:
696
+		if (!enable_ecred) {
697
+			err = -ENOPROTOOPT;
698
+			break;
699
+		}
700
+
701
+		if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
702
+			err = -EINVAL;
703
+			break;
704
+		}
705
+
706
+		mode = l2cap_get_mode(chan);
707
+		if (mode < 0) {
708
+			err = mode;
709
+			break;
710
+		}
711
+
712
+		if (put_user(mode, (u8 __user *) optval))
713
+			err = -EFAULT;
714
+		break;
715
+
614716 	default:
615717 		err = -ENOPROTOOPT;
616718 		break;
....@@ -637,7 +739,7 @@
637739 }
638740 
639741 static int l2cap_sock_setsockopt_old(struct socket *sock, int optname,
640
-				     char __user *optval, unsigned int optlen)
742
+				     sockptr_t optval, unsigned int optlen)
641743 {
642744 	struct sock *sk = sock->sk;
643745 	struct l2cap_chan *chan = l2cap_pi(sk)->chan;
....@@ -670,7 +772,7 @@
670772 		opts.txwin_size = chan->tx_win;
671773 
672774 		len = min_t(unsigned int, sizeof(opts), optlen);
673
-		if (copy_from_user((char *) &opts, optval, len)) {
775
+		if (copy_from_sockptr(&opts, optval, len)) {
674776 			err = -EFAULT;
675777 			break;
676778 		}
....@@ -685,10 +787,8 @@
685787 			break;
686788 		}
687789 
688
-		chan->mode = opts.mode;
689
-		switch (chan->mode) {
690
-		case L2CAP_MODE_LE_FLOWCTL:
691
-			break;
790
+		/* Only BR/EDR modes are supported here */
791
+		switch (opts.mode) {
692792 		case L2CAP_MODE_BASIC:
693793 			clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
694794 			break;
....@@ -696,11 +796,18 @@
696796 		case L2CAP_MODE_STREAMING:
697797 			if (!disable_ertm)
698798 				break;
699
-			/* fall through */
799
+			fallthrough;
700800 		default:
701801 			err = -EINVAL;
702802 			break;
703803 		}
804
+
805
+		if (err < 0)
806
+			break;
807
+
808
+		chan->mode = opts.mode;
809
+
810
+		BT_DBG("mode 0x%2.2x", chan->mode);
704811 
705812 		chan->imtu = opts.imtu;
706813 		chan->omtu = opts.omtu;
....@@ -711,7 +818,7 @@
711818 		break;
712819 
713820 	case L2CAP_LM:
714
-		if (get_user(opt, (u32 __user *) optval)) {
821
+		if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
715822 			err = -EFAULT;
716823 			break;
717824 		}
....@@ -748,8 +855,47 @@
748855 	return err;
749856 }
750857 
858
+static int l2cap_set_mode(struct l2cap_chan *chan, u8 mode)
859
+{
860
+	switch (mode) {
861
+	case BT_MODE_BASIC:
862
+		if (bdaddr_type_is_le(chan->src_type))
863
+			return -EINVAL;
864
+		mode = L2CAP_MODE_BASIC;
865
+		clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
866
+		break;
867
+	case BT_MODE_ERTM:
868
+		if (!disable_ertm || bdaddr_type_is_le(chan->src_type))
869
+			return -EINVAL;
870
+		mode = L2CAP_MODE_ERTM;
871
+		break;
872
+	case BT_MODE_STREAMING:
873
+		if (!disable_ertm || bdaddr_type_is_le(chan->src_type))
874
+			return -EINVAL;
875
+		mode = L2CAP_MODE_STREAMING;
876
+		break;
877
+	case BT_MODE_LE_FLOWCTL:
878
+		if (!bdaddr_type_is_le(chan->src_type))
879
+			return -EINVAL;
880
+		mode = L2CAP_MODE_LE_FLOWCTL;
881
+		break;
882
+	case BT_MODE_EXT_FLOWCTL:
883
+		/* TODO: Add support for ECRED PDUs to BR/EDR */
884
+		if (!bdaddr_type_is_le(chan->src_type))
885
+			return -EINVAL;
886
+		mode = L2CAP_MODE_EXT_FLOWCTL;
887
+		break;
888
+	default:
889
+		return -EINVAL;
890
+	}
891
+
892
+	chan->mode = mode;
893
+
894
+	return 0;
895
+}
896
+
751897 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname,
752
-				 char __user *optval, unsigned int optlen)
898
+				 sockptr_t optval, unsigned int optlen)
753899 {
754900 	struct sock *sk = sock->sk;
755901 	struct l2cap_chan *chan = l2cap_pi(sk)->chan;
....@@ -758,6 +904,8 @@
758904 	struct l2cap_conn *conn;
759905 	int len, err = 0;
760906 	u32 opt;
907
+	u16 mtu;
908
+	u8 mode;
761909 
762910 	BT_DBG("sk %p", sk);
763911 
....@@ -781,7 +929,7 @@
781929 		sec.level = BT_SECURITY_LOW;
782930 
783931 		len = min_t(unsigned int, sizeof(sec), optlen);
784
-		if (copy_from_user((char *) &sec, optval, len)) {
932
+		if (copy_from_sockptr(&sec, optval, len)) {
785933 			err = -EFAULT;
786934 			break;
787935 		}
....@@ -799,10 +947,13 @@
799947 
800948 		conn = chan->conn;
801949 
802
-		/*change security for LE channels */
950
+		/* change security for LE channels */
803951 		if (chan->scid == L2CAP_CID_ATT) {
804
-			if (smp_conn_security(conn->hcon, sec.level))
952
+			if (smp_conn_security(conn->hcon, sec.level)) {
953
+				err = -EINVAL;
805954 				break;
955
+			}
956
+
806957 			set_bit(FLAG_PENDING_SECURITY, &chan->flags);
807958 			sk->sk_state = BT_CONFIG;
808959 			chan->state = BT_CONFIG;
....@@ -826,7 +977,7 @@
826977 			break;
827978 		}
828979 
829
-		if (get_user(opt, (u32 __user *) optval)) {
980
+		if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
830981 			err = -EFAULT;
831982 			break;
832983 		}
....@@ -841,7 +992,7 @@
841992 		break;
842993 
843994 	case BT_FLUSHABLE:
844
-		if (get_user(opt, (u32 __user *) optval)) {
995
+		if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
845996 			err = -EFAULT;
846997 			break;
847998 		}
....@@ -877,7 +1028,7 @@
8771028 		pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
8781029 
8791030 		len = min_t(unsigned int, sizeof(pwr), optlen);
880
-		if (copy_from_user((char *) &pwr, optval, len)) {
1031
+		if (copy_from_sockptr(&pwr, optval, len)) {
8811032 			err = -EFAULT;
8821033 			break;
8831034 		}
....@@ -889,7 +1040,7 @@
8891040 		break;
8901041 
8911042 	case BT_CHANNEL_POLICY:
892
-		if (get_user(opt, (u32 __user *) optval)) {
1043
+		if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
8931044 			err = -EFAULT;
8941045 			break;
8951046 		}
....@@ -931,17 +1082,56 @@
9311082 			break;
9321083 		}
9331084 
934
-		if (sk->sk_state == BT_CONNECTED) {
1085
+		if (chan->mode == L2CAP_MODE_LE_FLOWCTL &&
1086
+		    sk->sk_state == BT_CONNECTED) {
9351087 			err = -EISCONN;
9361088 			break;
9371089 		}
9381090 
939
-		if (get_user(opt, (u16 __user *) optval)) {
1091
+		if (copy_from_sockptr(&mtu, optval, sizeof(u16))) {
9401092 			err = -EFAULT;
9411093 			break;
9421094 		}
9431095 
944
-		chan->imtu = opt;
1096
+		if (chan->mode == L2CAP_MODE_EXT_FLOWCTL &&
1097
+		    sk->sk_state == BT_CONNECTED)
1098
+			err = l2cap_chan_reconfigure(chan, mtu);
1099
+		else
1100
+			chan->imtu = mtu;
1101
+
1102
+		break;
1103
+
1104
+	case BT_MODE:
1105
+		if (!enable_ecred) {
1106
+			err = -ENOPROTOOPT;
1107
+			break;
1108
+		}
1109
+
1110
+		BT_DBG("sk->sk_state %u", sk->sk_state);
1111
+
1112
+		if (sk->sk_state != BT_BOUND) {
1113
+			err = -EINVAL;
1114
+			break;
1115
+		}
1116
+
1117
+		if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
1118
+			err = -EINVAL;
1119
+			break;
1120
+		}
1121
+
1122
+		if (copy_from_sockptr(&mode, optval, sizeof(u8))) {
1123
+			err = -EFAULT;
1124
+			break;
1125
+		}
1126
+
1127
+		BT_DBG("mode %u", mode);
1128
+
1129
+		err = l2cap_set_mode(chan, mode);
1130
+		if (err)
1131
+			break;
1132
+
1133
+		BT_DBG("mode 0x%2.2x", chan->mode);
1134
+
9451135 		break;
9461136 
9471137 	default:
....@@ -996,7 +1186,11 @@
9961186 
9971187 	if (sk->sk_state == BT_CONNECT2 && test_bit(BT_SK_DEFER_SETUP,
9981188 						    &bt_sk(sk)->flags)) {
999
-		if (bdaddr_type_is_le(pi->chan->src_type)) {
1189
+		if (pi->chan->mode == L2CAP_MODE_EXT_FLOWCTL) {
1190
+			sk->sk_state = BT_CONNECTED;
1191
+			pi->chan->state = BT_CONNECTED;
1192
+			__l2cap_ecred_conn_rsp_defer(pi->chan);
1193
+		} else if (bdaddr_type_is_le(pi->chan->src_type)) {
10001194 			sk->sk_state = BT_CONNECTED;
10011195 			pi->chan->state = BT_CONNECTED;
10021196 			__l2cap_le_connect_rsp_defer(pi->chan);
....@@ -1115,14 +1309,21 @@
11151309 	struct l2cap_conn *conn;
11161310 	int err = 0;
11171311 
1118
-	BT_DBG("sock %p, sk %p", sock, sk);
1312
+	BT_DBG("sock %p, sk %p, how %d", sock, sk, how);
1313
+
1314
+	/* 'how' parameter is mapped to sk_shutdown as follows:
1315
+	 * SHUT_RD   (0) --> RCV_SHUTDOWN  (1)
1316
+	 * SHUT_WR   (1) --> SEND_SHUTDOWN (2)
1317
+	 * SHUT_RDWR (2) --> SHUTDOWN_MASK (3)
1318
+	 */
1319
+	how++;
11191320 
11201321 	if (!sk)
11211322 		return 0;
11221323 
11231324 	lock_sock(sk);
11241325 
1125
-	if (sk->sk_shutdown)
1326
+	if ((sk->sk_shutdown & how) == how)
11261327 		goto shutdown_already;
11271328 
11281329 	BT_DBG("Handling sock shutdown");
....@@ -1145,11 +1346,20 @@
11451346 		 * has already been actioned to close the L2CAP
11461347 		 * link such as by l2cap_disconnection_req().
11471348 		 */
1148
-		if (sk->sk_shutdown)
1149
-			goto has_shutdown;
1349
+		if ((sk->sk_shutdown & how) == how)
1350
+			goto shutdown_matched;
11501351 	}
11511352 
1152
-	sk->sk_shutdown = SHUTDOWN_MASK;
1353
+	/* Try setting the RCV_SHUTDOWN bit, return early if SEND_SHUTDOWN
1354
+	 * is already set
1355
+	 */
1356
+	if ((how & RCV_SHUTDOWN) && !(sk->sk_shutdown & RCV_SHUTDOWN)) {
1357
+		sk->sk_shutdown |= RCV_SHUTDOWN;
1358
+		if ((sk->sk_shutdown & how) == how)
1359
+			goto shutdown_matched;
1360
+	}
1361
+
1362
+	sk->sk_shutdown |= SEND_SHUTDOWN;
11531363 	release_sock(sk);
11541364 
11551365 	l2cap_chan_lock(chan);
....@@ -1179,7 +1389,7 @@
11791389 		err = bt_sock_wait_state(sk, BT_CLOSED,
11801390 					 sk->sk_lingertime);
11811391 
1182
-has_shutdown:
1392
+shutdown_matched:
11831393 	l2cap_chan_put(chan);
11841394 	sock_put(sk);
11851395 
....@@ -1205,9 +1415,10 @@
12051415 	if (!sk)
12061416 		return 0;
12071417 
1418
+	l2cap_sock_cleanup_listen(sk);
12081419 	bt_sock_unlink(&l2cap_sk_list, sk);
12091420 
1210
-	err = l2cap_sock_shutdown(sock, 2);
1421
+	err = l2cap_sock_shutdown(sock, SHUT_RDWR);
12111422 	chan = l2cap_pi(sk)->chan;
12121423 
12131424 	l2cap_chan_hold(chan);
....@@ -1414,6 +1625,14 @@
14141625 	if (!skb)
14151626 		return ERR_PTR(err);
14161627 
1628
+	/* Channel lock is released before requesting new skb and then
1629
+	 * reacquired thus we need to recheck channel state.
1630
+	 */
1631
+	if (chan->state != BT_CONNECTED) {
1632
+		kfree_skb(skb);
1633
+		return ERR_PTR(-ENOTCONN);
1634
+	}
1635
+
14171636 	skb->priority = sk->sk_priority;
14181637 
14191638 	bt_cb(skb)->l2cap.chan = chan;
....@@ -1483,6 +1702,13 @@
14831702 	return sk->sk_sndtimeo;
14841703 }
14851704 
1705
+static struct pid *l2cap_sock_get_peer_pid_cb(struct l2cap_chan *chan)
1706
+{
1707
+	struct sock *sk = chan->data;
1708
+
1709
+	return sk->sk_peer_pid;
1710
+}
1711
+
14861712 static void l2cap_sock_suspend_cb(struct l2cap_chan *chan)
14871713 {
14881714 	struct sock *sk = chan->data;
....@@ -1517,6 +1743,7 @@
15171743 	.suspend		= l2cap_sock_suspend_cb,
15181744 	.set_shutdown		= l2cap_sock_set_shutdown_cb,
15191745 	.get_sndtimeo		= l2cap_sock_get_sndtimeo_cb,
1746
+	.get_peer_pid		= l2cap_sock_get_peer_pid_cb,
15201747 	.alloc_skb		= l2cap_sock_alloc_skb_cb,
15211748 	.filter			= l2cap_sock_filter,
15221749 };
....@@ -1698,6 +1925,7 @@
16981925 	.recvmsg	= l2cap_sock_recvmsg,
16991926 	.poll		= bt_sock_poll,
17001927 	.ioctl		= bt_sock_ioctl,
1928
+	.gettstamp	= sock_gettstamp,
17011929 	.mmap		= sock_no_mmap,
17021930 	.socketpair	= sock_no_socketpair,
17031931 	.shutdown	= l2cap_sock_shutdown,