forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-12-19 9370bb92b2d16684ee45cf24e879c93c509162da 
 kernel/net/rds/af_rds.c
....@@ -1,5 +1,5 @@
11 /*
2
- * Copyright (c) 2006, 2018 Oracle and/or its affiliates. All rights reserved.
2
+ * Copyright (c) 2006, 2019 Oracle and/or its affiliates. All rights reserved.
33  *
44  * This software is available to you under a choice of one of two
55  * licenses.  You may choose to be licensed under the terms of the GNU
....@@ -254,11 +254,43 @@
254254 
255255 static int rds_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
256256 {
257
-	return -ENOIOCTLCMD;
257
+	struct rds_sock *rs = rds_sk_to_rs(sock->sk);
258
+	rds_tos_t utos, tos = 0;
259
+
260
+	switch (cmd) {
261
+	case SIOCRDSSETTOS:
262
+		if (get_user(utos, (rds_tos_t __user *)arg))
263
+			return -EFAULT;
264
+
265
+		if (rs->rs_transport &&
266
+		    rs->rs_transport->get_tos_map)
267
+			tos = rs->rs_transport->get_tos_map(utos);
268
+		else
269
+			return -ENOIOCTLCMD;
270
+
271
+		spin_lock_bh(&rds_sock_lock);
272
+		if (rs->rs_tos || rs->rs_conn) {
273
+			spin_unlock_bh(&rds_sock_lock);
274
+			return -EINVAL;
275
+		}
276
+		rs->rs_tos = tos;
277
+		spin_unlock_bh(&rds_sock_lock);
278
+		break;
279
+	case SIOCRDSGETTOS:
280
+		spin_lock_bh(&rds_sock_lock);
281
+		tos = rs->rs_tos;
282
+		spin_unlock_bh(&rds_sock_lock);
283
+		if (put_user(tos, (rds_tos_t __user *)arg))
284
+			return -EFAULT;
285
+		break;
286
+	default:
287
+		return -ENOIOCTLCMD;
288
+	}
289
+
290
+	return 0;
258291 }
259292 
260
-static int rds_cancel_sent_to(struct rds_sock *rs, char __user *optval,
261
-			      int len)
293
+static int rds_cancel_sent_to(struct rds_sock *rs, sockptr_t optval, int len)
262294 {
263295 	struct sockaddr_in6 sin6;
264296 	struct sockaddr_in sin;
....@@ -275,14 +307,15 @@
275307 		goto out;
276308 	} else if (len < sizeof(struct sockaddr_in6)) {
277309 		/* Assume IPv4 */
278
-		if (copy_from_user(&sin, optval, sizeof(struct sockaddr_in))) {
310
+		if (copy_from_sockptr(&sin, optval,
311
+				sizeof(struct sockaddr_in))) {
279312 			ret = -EFAULT;
280313 			goto out;
281314 		}
282315 		ipv6_addr_set_v4mapped(sin.sin_addr.s_addr, &sin6.sin6_addr);
283316 		sin6.sin6_port = sin.sin_port;
284317 	} else {
285
-		if (copy_from_user(&sin6, optval,
318
+		if (copy_from_sockptr(&sin6, optval,
286319 				   sizeof(struct sockaddr_in6))) {
287320 			ret = -EFAULT;
288321 			goto out;
....@@ -294,21 +327,20 @@
294327 	return ret;
295328 }
296329 
297
-static int rds_set_bool_option(unsigned char *optvar, char __user *optval,
330
+static int rds_set_bool_option(unsigned char *optvar, sockptr_t optval,
298331 			       int optlen)
299332 {
300333 	int value;
301334 
302335 	if (optlen < sizeof(int))
303336 		return -EINVAL;
304
-	if (get_user(value, (int __user *) optval))
337
+	if (copy_from_sockptr(&value, optval, sizeof(int)))
305338 		return -EFAULT;
306339 	*optvar = !!value;
307340 	return 0;
308341 }
309342 
310
-static int rds_cong_monitor(struct rds_sock *rs, char __user *optval,
311
-			    int optlen)
343
+static int rds_cong_monitor(struct rds_sock *rs, sockptr_t optval, int optlen)
312344 {
313345 	int ret;
314346 
....@@ -325,8 +357,7 @@
325357 	return ret;
326358 }
327359 
328
-static int rds_set_transport(struct rds_sock *rs, char __user *optval,
329
-			     int optlen)
360
+static int rds_set_transport(struct rds_sock *rs, sockptr_t optval, int optlen)
330361 {
331362 	int t_type;
332363 
....@@ -336,7 +367,7 @@
336367 	if (optlen != sizeof(int))
337368 		return -EINVAL;
338369 
339
-	if (copy_from_user(&t_type, (int __user *)optval, sizeof(t_type)))
370
+	if (copy_from_sockptr(&t_type, optval, sizeof(t_type)))
340371 		return -EFAULT;
341372 
342373 	if (t_type < 0 || t_type >= RDS_TRANS_COUNT)
....@@ -347,18 +378,21 @@
347378 	return rs->rs_transport ? 0 : -ENOPROTOOPT;
348379 }
349380 
350
-static int rds_enable_recvtstamp(struct sock *sk, char __user *optval,
351
-				 int optlen)
381
+static int rds_enable_recvtstamp(struct sock *sk, sockptr_t optval,
382
+				 int optlen, int optname)
352383 {
353384 	int val, valbool;
354385 
355386 	if (optlen != sizeof(int))
356387 		return -EFAULT;
357388 
358
-	if (get_user(val, (int __user *)optval))
389
+	if (copy_from_sockptr(&val, optval, sizeof(int)))
359390 		return -EFAULT;
360391 
361392 	valbool = val ? 1 : 0;
393
+
394
+	if (optname == SO_TIMESTAMP_NEW)
395
+		sock_set_flag(sk, SOCK_TSTAMP_NEW);
362396 
363397 	if (valbool)
364398 		sock_set_flag(sk, SOCK_RCVTSTAMP);
....@@ -368,7 +402,7 @@
368402 	return 0;
369403 }
370404 
371
-static int rds_recv_track_latency(struct rds_sock *rs, char __user *optval,
405
+static int rds_recv_track_latency(struct rds_sock *rs, sockptr_t optval,
372406 				  int optlen)
373407 {
374408 	struct rds_rx_trace_so trace;
....@@ -377,7 +411,7 @@
377411 	if (optlen != sizeof(struct rds_rx_trace_so))
378412 		return -EFAULT;
379413 
380
-	if (copy_from_user(&trace, optval, sizeof(trace)))
414
+	if (copy_from_sockptr(&trace, optval, sizeof(trace)))
381415 		return -EFAULT;
382416 
383417 	if (trace.rx_traces > RDS_MSG_RX_DGRAM_TRACE_MAX)
....@@ -396,7 +430,7 @@
396430 }
397431 
398432 static int rds_setsockopt(struct socket *sock, int level, int optname,
399
-			  char __user *optval, unsigned int optlen)
433
+			  sockptr_t optval, unsigned int optlen)
400434 {
401435 	struct rds_sock *rs = rds_sk_to_rs(sock->sk);
402436 	int ret;
....@@ -430,9 +464,10 @@
430464 		ret = rds_set_transport(rs, optval, optlen);
431465 		release_sock(sock->sk);
432466 		break;
433
-	case SO_TIMESTAMP:
467
+	case SO_TIMESTAMP_OLD:
468
+	case SO_TIMESTAMP_NEW:
434469 		lock_sock(sock->sk);
435
-		ret = rds_enable_recvtstamp(sock->sk, optval, optlen);
470
+		ret = rds_enable_recvtstamp(sock->sk, optval, optlen, optname);
436471 		release_sock(sock->sk);
437472 		break;
438473 	case SO_RDS_MSG_RXPATH_LATENCY:
....@@ -522,7 +557,7 @@
522557 			ret = -EDESTADDRREQ;
523558 			break;
524559 		}
525
-		if (IN_MULTICAST(ntohl(sin->sin_addr.s_addr)) ||
560
+		if (ipv4_is_multicast(sin->sin_addr.s_addr) ||
526561 		    sin->sin_addr.s_addr == htonl(INADDR_BROADCAST)) {
527562 			ret = -EINVAL;
528563 			break;
....@@ -556,7 +591,7 @@
556591 			addr4 = sin6->sin6_addr.s6_addr32[3];
557592 			if (addr4 == htonl(INADDR_ANY) ||
558593 			    addr4 == htonl(INADDR_BROADCAST) ||
559
-			    IN_MULTICAST(ntohl(addr4))) {
594
+			    ipv4_is_multicast(addr4)) {
560595 				ret = -EPROTOTYPE;
561596 				break;
562597 			}
....@@ -649,6 +684,8 @@
649684 	spin_lock_init(&rs->rs_rdma_lock);
650685 	rs->rs_rdma_keys = RB_ROOT;
651686 	rs->rs_rx_traces = 0;
687
+	rs->rs_tos = 0;
688
+	rs->rs_conn = NULL;
652689 
653690 	spin_lock_bh(&rds_sock_lock);
654691 	list_add_tail(&rs->rs_item, &rds_sock_list);
....@@ -666,7 +703,7 @@
666703 	if (sock->type != SOCK_SEQPACKET || protocol)
667704 		return -ESOCKTNOSUPPORT;
668705 
669
-	sk = sk_alloc(net, AF_RDS, GFP_ATOMIC, &rds_proto, kern);
706
+	sk = sk_alloc(net, AF_RDS, GFP_KERNEL, &rds_proto, kern);
670707 	if (!sk)
671708 		return -ENOMEM;
672709 
....@@ -702,6 +739,10 @@
702739 	spin_lock_bh(&rds_sock_lock);
703740 
704741 	list_for_each_entry(rs, &rds_sock_list, rs_item) {
742
+		/* This option only supports IPv4 sockets. */
743
+		if (!ipv6_addr_v4mapped(&rs->rs_bound_addr))
744
+			continue;
745
+
705746 		read_lock(&rs->rs_recv_lock);
706747 
707748 		/* XXX too lazy to maintain counts.. */
....@@ -723,21 +764,60 @@
723764 	lens->each = sizeof(struct rds_info_message);
724765 }
725766 
767
+#if IS_ENABLED(CONFIG_IPV6)
768
+static void rds6_sock_inc_info(struct socket *sock, unsigned int len,
769
+			       struct rds_info_iterator *iter,
770
+			       struct rds_info_lengths *lens)
771
+{
772
+	struct rds_incoming *inc;
773
+	unsigned int total = 0;
774
+	struct rds_sock *rs;
775
+
776
+	len /= sizeof(struct rds6_info_message);
777
+
778
+	spin_lock_bh(&rds_sock_lock);
779
+
780
+	list_for_each_entry(rs, &rds_sock_list, rs_item) {
781
+		read_lock(&rs->rs_recv_lock);
782
+
783
+		list_for_each_entry(inc, &rs->rs_recv_queue, i_item) {
784
+			total++;
785
+			if (total <= len)
786
+				rds6_inc_info_copy(inc, iter, &inc->i_saddr,
787
+						   &rs->rs_bound_addr, 1);
788
+		}
789
+
790
+		read_unlock(&rs->rs_recv_lock);
791
+	}
792
+
793
+	spin_unlock_bh(&rds_sock_lock);
794
+
795
+	lens->nr = total;
796
+	lens->each = sizeof(struct rds6_info_message);
797
+}
798
+#endif
799
+
726800 static void rds_sock_info(struct socket *sock, unsigned int len,
727801 			  struct rds_info_iterator *iter,
728802 			  struct rds_info_lengths *lens)
729803 {
730804 	struct rds_info_socket sinfo;
805
+	unsigned int cnt = 0;
731806 	struct rds_sock *rs;
732807 
733808 	len /= sizeof(struct rds_info_socket);
734809 
735810 	spin_lock_bh(&rds_sock_lock);
736811 
737
-	if (len < rds_sock_count)
812
+	if (len < rds_sock_count) {
813
+		cnt = rds_sock_count;
738814 		goto out;
815
+	}
739816 
740817 	list_for_each_entry(rs, &rds_sock_list, rs_item) {
818
+		/* This option only supports IPv4 sockets. */
819
+		if (!ipv6_addr_v4mapped(&rs->rs_bound_addr))
820
+			continue;
741821 		sinfo.sndbuf = rds_sk_sndbuf(rs);
742822 		sinfo.rcvbuf = rds_sk_rcvbuf(rs);
743823 		sinfo.bound_addr = rs->rs_bound_addr_v4;
....@@ -747,14 +827,50 @@
747827 		sinfo.inum = sock_i_ino(rds_rs_to_sk(rs));
748828 
749829 		rds_info_copy(iter, &sinfo, sizeof(sinfo));
830
+		cnt++;
750831 	}
751832 
752833 out:
753
-	lens->nr = rds_sock_count;
834
+	lens->nr = cnt;
754835 	lens->each = sizeof(struct rds_info_socket);
755836 
756837 	spin_unlock_bh(&rds_sock_lock);
757838 }
839
+
840
+#if IS_ENABLED(CONFIG_IPV6)
841
+static void rds6_sock_info(struct socket *sock, unsigned int len,
842
+			   struct rds_info_iterator *iter,
843
+			   struct rds_info_lengths *lens)
844
+{
845
+	struct rds6_info_socket sinfo6;
846
+	struct rds_sock *rs;
847
+
848
+	len /= sizeof(struct rds6_info_socket);
849
+
850
+	spin_lock_bh(&rds_sock_lock);
851
+
852
+	if (len < rds_sock_count)
853
+		goto out;
854
+
855
+	list_for_each_entry(rs, &rds_sock_list, rs_item) {
856
+		sinfo6.sndbuf = rds_sk_sndbuf(rs);
857
+		sinfo6.rcvbuf = rds_sk_rcvbuf(rs);
858
+		sinfo6.bound_addr = rs->rs_bound_addr;
859
+		sinfo6.connected_addr = rs->rs_conn_addr;
860
+		sinfo6.bound_port = rs->rs_bound_port;
861
+		sinfo6.connected_port = rs->rs_conn_port;
862
+		sinfo6.inum = sock_i_ino(rds_rs_to_sk(rs));
863
+
864
+		rds_info_copy(iter, &sinfo6, sizeof(sinfo6));
865
+	}
866
+
867
+ out:
868
+	lens->nr = rds_sock_count;
869
+	lens->each = sizeof(struct rds6_info_socket);
870
+
871
+	spin_unlock_bh(&rds_sock_lock);
872
+}
873
+#endif
758874 
759875 static void rds_exit(void)
760876 {
....@@ -769,6 +885,10 @@
769885 	rds_bind_lock_destroy();
770886 	rds_info_deregister_func(RDS_INFO_SOCKETS, rds_sock_info);
771887 	rds_info_deregister_func(RDS_INFO_RECV_MESSAGES, rds_sock_inc_info);
888
+#if IS_ENABLED(CONFIG_IPV6)
889
+	rds_info_deregister_func(RDS6_INFO_SOCKETS, rds6_sock_info);
890
+	rds_info_deregister_func(RDS6_INFO_RECV_MESSAGES, rds6_sock_inc_info);
891
+#endif
772892 }
773893 module_exit(rds_exit);
774894 
....@@ -806,6 +926,10 @@
806926 
807927 	rds_info_register_func(RDS_INFO_SOCKETS, rds_sock_info);
808928 	rds_info_register_func(RDS_INFO_RECV_MESSAGES, rds_sock_inc_info);
929
+#if IS_ENABLED(CONFIG_IPV6)
930
+	rds_info_register_func(RDS6_INFO_SOCKETS, rds6_sock_info);
931
+	rds_info_register_func(RDS6_INFO_RECV_MESSAGES, rds6_sock_inc_info);
932
+#endif
809933 
810934 	goto out;
811935