net/rds: Switch to the Linux-5.15 API

All of the RDS commits starting with
"uek-rpm: Disable CONFIG_RDS for UEK7"
all the way to the commit preceeding
this one are based on the Linux-5.4 API.

As such they won't even compile on Linux-5.15.

With this commit we adjust the RDS code-base
to compile and work on Linux-5.15.

Changes:
  * FMR support has been removed through a number of upstream-commits, e.g.:
    >3a578152a920 ("RDMA/core: Remove FMR device ops")
    So we follow the upstream-lead and get rid of FMR from UEK/RDS as well.
    Please note that after this change, there's some dead
    leftover code that needs to be cleaned up, e.g.
    "fmr_max_remaps".

  * Change function prototypes and calls to "copy_from_user"
    to "copy_from_sockptr" to adhere to the changes introduced by:
    >a7b75c5a8c41 ("net: pass a sockptr_t into ->setsockopt")

  * Replaced "get_seconds" by "ktime_get_real_seconds",
    since "get_seconds" was removed by:
    >aba428a0c612 ("timekeeping: Remove unused get_seconds()")

  * Function "ib_check_mr_access" now needs to know the IB device:
    >adac4cb3c1ff ("RDMA/uverbs: Check ODP in ib_check_mr_access() as well")

  * The "add" callback of "struct rds_ib_client" now returns an error:
    >11a0ae4c4bff9 ("RDMA: Allow ib_client's to fail when add() is called")
    Function "rds_ib_add_one" changed accordingly.

  * Function "ibdev_to_node" now has become a part of the RDMA API:
    >8ecfca68dc4c ("RDMA: Lift ibdev_to_node from rds to common code")

  * Function "ib_dma_alloc_coherent" disappeared:
    >2af29468e3b3 ("RDMA/core: Remove ib_dma_{alloc,free}_coherent")
    Replaced by "kzalloc_node" + "ib_dma_map_single"

  * Function "rdma_reject" now requires a reason:
    >8094ba0ace7f ("RDMA/cma: Provide ECE reject reason")

  * Without FMR support, there is no "struct ib_fmr_attr".
    All we care about for now (until cleanup) is "max_pages".

  * Function "ib_destroy_srq" no longer has a return value:
    >119181d1d432 ("RDMA: Restore ability to fail on SRQ destroy")

  * For RDMA, "pin_user_pages" is the new method to lock pages:
    >dbfe7d74376e ("rds: convert get_user_pages() --> pin_user_pages()")

  * Replace "__kernel_time_t" with "__s64" because "__kernel_time_t"
    has now become "__kernel_old_time_t", as of
    >2a785996cc5e2 ("y2038: uapi: change __kernel_time_t to __kernel_old_time_t"
    and "__kernel_old_time_t" is not available in user-land.
    Luckily, incompatibility with user-land (uapi) is not permitted
    and we know that "time64_t" has been defined as "__s64" since:
    >361a3bf005824 ("time64: Add time64.h header and define struct timespec64")

  * Use new(er) sock/TCP helpers:
    >ce3d9544ceca ("net: add sock_set_keepalive")
    >c433594c0745 ("net: add sock_no_linger")
    >12abc5ee7873 ("tcp: add tcp_sock_set_nodelay")
    >480aeb9639d6 ("tcp: add tcp_sock_set_keepcnt")
    >71c48eb81c9e ("tcp: add tcp_sock_set_keepidle")
    >d41ecaac903c ("tcp: add tcp_sock_set_keepintvl")
    >db10538a4b99 ("tcp: add tcp_sock_set_cork")

  * Support for "---help---" in Kconfig has been removed with:
    >f70f74d15ca8 kconfig: remove '---help---' support
    So we use "help" instead.

Orabug: 33590097

Signed-off-by: Gerd Rausch <[email protected]>
Reviewed-by: William Kucharski <[email protected]>

Author: gerd-rausch

include/uapi/linux/rds.h

@@ -324,9 +324,9 @@ struct rds6_info_rdma_connection {
 };
 
 struct rds_path_info {
-	__kernel_time_t	attempt_time;
-	__kernel_time_t	connect_time;
-	__kernel_time_t	reset_time;
+	__s64		attempt_time;
+	__s64		connect_time;
+	__s64		reset_time;
 	__u32		disconnect_reason;
 	__u32		connect_attempts;
 	unsigned int	index;

net/rds/Kconfig

@@ -1,21 +1,21 @@
 config RDS
 	tristate "The RDS Protocol"
 	depends on INET
-	---help---
+	help
 	  The RDS (Reliable Datagram Sockets) protocol provides reliable,
 	  sequenced delivery of datagrams over Infiniband or TCP.
 
 config RDS_RDMA
 	tristate "RDS over Infiniband and iWARP"
 	depends on RDS && INFINIBAND && INFINIBAND_ADDR_TRANS
-	---help---
+	help
 	  Allow RDS to use Infiniband as a transport.
 	  This transport supports RDMA operations.
 
 config RDS_TCP
 	tristate "RDS over TCP"
 	depends on RDS
-	---help---
+	help
 	  Allow RDS to use TCP as a transport.
 	  This transport does not support RDMA operations.
 

net/rds/af_rds.c

@@ -435,7 +435,7 @@ static int rds_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 	return 0;
 }
 
-static int rds_cancel_sent_to(struct rds_sock *rs, char __user *optval,
+static int rds_cancel_sent_to(struct rds_sock *rs, sockptr_t optval,
 			      int len)
 {
 	struct sockaddr_in6 sin6;
@@ -456,7 +456,7 @@ static int rds_cancel_sent_to(struct rds_sock *rs, char __user *optval,
 
 	/* Lets restrict copying to at most sizeof(sin6) */
 	cpy_len = min_t(int, (int)sizeof(sin6), len);
-	if (copy_from_user(&sin6, optval, cpy_len)) {
+	if (copy_from_sockptr(&sin6, optval, cpy_len)) {
 		ret = -EFAULT;
 		goto out;
 	}
@@ -490,20 +490,20 @@ static int rds_cancel_sent_to(struct rds_sock *rs, char __user *optval,
 	return ret;
 }
 
-static int rds_set_bool_option(unsigned char *optvar, char __user *optval,
+static int rds_set_bool_option(unsigned char *optvar, sockptr_t optval,
 			       int optlen)
 {
 	int value;
 
 	if (optlen < sizeof(int))
 		return -EINVAL;
-	if (get_user(value, (int __user *) optval))
+	if (copy_from_sockptr(&value, optval, sizeof(int)))
 		return -EFAULT;
 	*optvar = !!value;
 	return 0;
 }
 
-static int rds_cong_monitor(struct rds_sock *rs, char __user *optval,
+static int rds_cong_monitor(struct rds_sock *rs, sockptr_t optval,
 			    int optlen)
 {
 	int ret;
@@ -539,7 +539,7 @@ static void rds_user_conn_paths_drop(struct rds_connection *conn)
 	}
 }
 
-static int rds_user_reset(struct rds_sock *rs, char __user *optval, int optlen)
+static int rds_user_reset(struct rds_sock *rs, sockptr_t optval, int optlen)
 {
 	struct rds_reset reset;
 	struct rds_connection *conn;
@@ -549,7 +549,7 @@ static int rds_user_reset(struct rds_sock *rs, char __user *optval, int optlen)
 	if (optlen != sizeof(struct rds_reset))
 		return -EINVAL;
 
-	if (copy_from_user(&reset, (struct rds_reset __user *)optval,
+	if (copy_from_sockptr(&reset, optval,
 				sizeof(struct rds_reset)))
 		return -EFAULT;
 
@@ -589,7 +589,7 @@ static int rds_user_reset(struct rds_sock *rs, char __user *optval, int optlen)
 }
 
 #if IS_ENABLED(CONFIG_IPV6)
-static int rds6_user_reset(struct rds_sock *rs, char __user *optval, int optlen)
+static int rds6_user_reset(struct rds_sock *rs, sockptr_t optval, int optlen)
 {
 	struct rds6_reset reset;
 	struct rds_connection *conn;
@@ -598,8 +598,8 @@ static int rds6_user_reset(struct rds_sock *rs, char __user *optval, int optlen)
 	if (optlen != sizeof(struct rds6_reset))
 		return -EINVAL;
 
-	if (copy_from_user(&reset, (struct rds6_reset __user *)optval,
-			   sizeof(struct rds6_reset)))
+	if (copy_from_sockptr(&reset, optval,
+			      sizeof(struct rds6_reset)))
 		return -EFAULT;
 
 	/* Reset all conns associated with source addr */
@@ -635,7 +635,7 @@ static int rds6_user_reset(struct rds_sock *rs, char __user *optval, int optlen)
 }
 #endif
 
-static int rds_set_transport(struct rds_sock *rs, char __user *optval,
+static int rds_set_transport(struct rds_sock *rs, sockptr_t optval,
 			     int optlen)
 {
 	int t_type;
@@ -646,7 +646,7 @@ static int rds_set_transport(struct rds_sock *rs, char __user *optval,
 	if (optlen != sizeof(int))
 		return -EINVAL;
 
-	if (copy_from_user(&t_type, (int __user *)optval, sizeof(t_type)))
+	if (copy_from_sockptr(&t_type, optval, sizeof(t_type)))
 		return -EFAULT;
 
 	if (t_type < 0 || t_type >= RDS_TRANS_COUNT)
@@ -657,15 +657,15 @@ static int rds_set_transport(struct rds_sock *rs, char __user *optval,
 	return rs->rs_transport ? 0 : -ENOPROTOOPT;
 }
 
-static int rds_enable_recvtstamp(struct sock *sk, char __user *optval,
+static int rds_enable_recvtstamp(struct sock *sk, sockptr_t optval,
 				 int optlen)
 {
 	int val, valbool;
 
 	if (optlen != sizeof(int))
 		return -EFAULT;
 
-	if (get_user(val, (int __user *)optval))
+	if (copy_from_sockptr(&val, optval, sizeof(int)))
 		return -EFAULT;
 
 	valbool = val ? 1 : 0;
@@ -678,16 +678,16 @@ static int rds_enable_recvtstamp(struct sock *sk, char __user *optval,
 	return 0;
 }
 
-static int rds_recv_track_latency(struct rds_sock *rs, char __user *optval,
-				 int optlen)
+static int rds_recv_track_latency(struct rds_sock *rs, sockptr_t optval,
+				  int optlen)
 {
 	struct rds_rx_trace_so trace;
 	int i;
 
 	if (optlen != sizeof(struct rds_rx_trace_so))
 		return -EFAULT;
 
-	if (copy_from_user(&trace, optval, sizeof(trace)))
+	if (copy_from_sockptr(&trace, optval, sizeof(trace)))
 		return -EFAULT;
 
 	if (trace.rx_traces > RDS_MSG_RX_DGRAM_TRACE_MAX)
@@ -707,7 +707,7 @@ static int rds_recv_track_latency(struct rds_sock *rs, char __user *optval,
 
 
 static int rds_setsockopt(struct socket *sock, int level, int optname,
-			  char __user *optval, unsigned int optlen)
+			  sockptr_t optval, unsigned int optlen)
 {
 	struct rds_sock *rs = rds_sk_to_rs(sock->sk);
 	struct net *net = sock_net(sock->sk);

net/rds/connection.c

@@ -191,7 +191,7 @@ static void __rds_conn_path_init(struct rds_connection *conn,
 
 	cp->cp_conn = conn;
 	rds_conn_path_state_change(cp, RDS_CONN_DOWN, DR_DEFAULT, 0);
-	cp->cp_reconnect_start = get_seconds();
+	cp->cp_reconnect_start = ktime_get_real_seconds();
 	cp->cp_reconnect_warn = 1;
 	cp->cp_conn->c_proposed_version = RDS_PROTOCOL_VERSION;
 
@@ -1237,7 +1237,7 @@ EXPORT_SYMBOL_GPL(rds_conn_path_trace_state_change);
 void rds_conn_path_drop(struct rds_conn_path *cp, int reason, int err)
 {
 	struct rds_connection *conn = cp->cp_conn;
-	unsigned long now = get_seconds();
+	unsigned long now = ktime_get_real_seconds();
 
 	if (conn->c_trans->conn_path_reset) {
 		unsigned flags = RDS_CONN_PATH_RESET_WATCHDOG;

net/rds/ib.c

@@ -84,7 +84,7 @@ static struct ib_mr *rds_ib_get_dma_mr(struct ib_pd *pd, int mr_access_flags)
 	struct ib_mr *mr;
 	int err;
 
-	err = ib_check_mr_access(mr_access_flags);
+	err = ib_check_mr_access(pd->device, mr_access_flags);
 	if (err)
 		return ERR_PTR(err);
 
@@ -948,6 +948,7 @@ static int rds6_ib_conn_info_visitor(struct rds_connection *conn,
 
 		rdma_read_gids(ic->i_cm_id, (union ib_gid *)&iinfo6->src_gid,
 			       (union ib_gid *)&iinfo6->dst_gid);
+
 		rds_ibdev = ic->rds_ibdev;
 		iinfo6->max_send_wr = ic->i_send_ring.w_nr;
 		iinfo6->max_recv_wr = ic->i_recv_ring.w_nr;
@@ -1131,8 +1132,9 @@ static void rds_dev_removal_worker(struct work_struct *work)
 	rds_ib_remove_one(rds_ibdev->dev, rds_ibdev);
 }
 
-void rds_ib_add_one(struct ib_device *device)
+int rds_ib_add_one(struct ib_device *device)
 {
+	int error = 0;
 	struct rds_ib_device *rds_ibdev;
 	struct ib_device_attr *dev_attr;
 	bool has_frwr, has_fmr;
@@ -1141,26 +1143,29 @@ void rds_ib_add_one(struct ib_device *device)
 
 	/* Only handle IB (no iWARP) devices */
 	if (device->node_type != RDMA_NODE_IB_CA)
-		return;
+		return -EOPNOTSUPP;
 
 	trace_rds_ib_add_device(device, NULL, NULL, NULL,
 				"adding IB device", 0);
 
 	dev_attr = kmalloc(sizeof(*dev_attr), GFP_KERNEL);
 	if (!dev_attr) {
+		error = -ENOMEM;
 		reason = "could not allocate dev_attr";
 		goto trace_err;
 	}
 
 	memset(&uhw, 0, sizeof(uhw));
 	if ((*device->ops.query_device)(device, dev_attr, &uhw)) {
+		error = -ENOSYS;
 		reason = "query device failed";
 		goto free_attr;
 	}
 
 	rds_ibdev = kzalloc_node(sizeof(*rds_ibdev), GFP_KERNEL,
 				 ibdev_to_node(device));
 	if (!rds_ibdev) {
+		error = -ENOMEM;
 		reason = "could not allocate rds_ibdev";
 		goto free_attr;
 	}
@@ -1186,7 +1191,7 @@ void rds_ib_add_one(struct ib_device *device)
 		rds_ibdev->max_sge = RDS_IB_MAX_SGE;
 
 	WARN_ON(rds_ibdev->max_sge < 2);
-	rds_ibdev->fmr_max_remaps = dev_attr->max_map_per_fmr ?: 32;
+	rds_ibdev->fmr_max_remaps = 32;
 
 	rds_ibdev->max_1m_fmrs = dev_attr->max_mr ?
 		min_t(unsigned int, dev_attr->max_mr,
@@ -1206,6 +1211,7 @@ void rds_ib_add_one(struct ib_device *device)
 	rds_ibdev->dev = device;
 	rds_ibdev->pd = ib_alloc_pd(device, 0);
 	if (IS_ERR(rds_ibdev->pd)) {
+		error = PTR_ERR(rds_ibdev->pd);
 		rds_ibdev->pd = NULL;
 		reason = "ib_alloc_pd failed";
 		goto put_dev;
@@ -1214,6 +1220,7 @@ void rds_ib_add_one(struct ib_device *device)
 	rds_ibdev->rid_dev_wq = alloc_workqueue("rds_%s_wq", WQ_UNBOUND, 0,
 						device->name);
 	if (!rds_ibdev->rid_dev_wq) {
+		error = -ENOMEM;
 		reason = "no wq";
 		goto put_dev;
 	}
@@ -1222,29 +1229,29 @@ void rds_ib_add_one(struct ib_device *device)
 					device->num_comp_vectors, GFP_KERNEL);
 	if (!rds_ibdev->vector_load) {
 		pr_err("RDS/IB: failed to allocate vector memory\n");
+		error = -ENOMEM;
 		reason = "failed to allocate vector memory";
 		goto put_dev;
 	}
 	mutex_init(&rds_ibdev->vector_load_lock);
 
 	rds_ibdev->mr = rds_ib_get_dma_mr(rds_ibdev->pd, IB_ACCESS_LOCAL_WRITE);
 	if (IS_ERR(rds_ibdev->mr)) {
+		error = PTR_ERR(rds_ibdev->mr);
 		rds_ibdev->mr = NULL;
 		reason = "rds_ib_get_dma_mr failed";
 		goto put_dev;
 	}
 
 	has_frwr = (dev_attr->device_cap_flags & IB_DEVICE_MEM_MGT_EXTENSIONS);
-	has_fmr = device->ops.alloc_fmr &&
-		  device->ops.dealloc_fmr &&
-		  device->ops.map_phys_fmr &&
-		  device->ops.unmap_fmr;
+	has_fmr = false;
 
 	if (has_frwr && (!has_fmr || prefer_frwr)) {
 		INIT_WORK(&rds_ibdev->fastreg_reset_w, rds_ib_reset_fastreg);
 		init_rwsem(&rds_ibdev->fastreg_lock);
 		atomic_set(&rds_ibdev->fastreg_wrs, RDS_IB_DEFAULT_FREG_WR);
-		if (rds_ib_setup_fastreg(rds_ibdev)) {
+		error = rds_ib_setup_fastreg(rds_ibdev);
+		if (error) {
 			pr_err("RDS/IB: Failed to setup fastreg resources\n");
 			reason = "rds_ib_setup_fastreg failed";
 			goto put_dev;
@@ -1261,6 +1268,7 @@ void rds_ib_add_one(struct ib_device *device)
 	rds_ibdev->mr_1m_pool =
 		rds_ib_create_mr_pool(rds_ibdev, RDS_IB_MR_1M_POOL);
 	if (IS_ERR(rds_ibdev->mr_1m_pool)) {
+		error = PTR_ERR(rds_ibdev->mr_1m_pool);
 		rds_ibdev->mr_1m_pool = NULL;
 		reason = "rds_ib_create_mr_pool (1k) failed";
 		goto put_dev;
@@ -1269,17 +1277,20 @@ void rds_ib_add_one(struct ib_device *device)
 	rds_ibdev->mr_8k_pool =
 		rds_ib_create_mr_pool(rds_ibdev, RDS_IB_MR_8K_POOL);
 	if (IS_ERR(rds_ibdev->mr_8k_pool)) {
+		error = PTR_ERR(rds_ibdev->mr_8k_pool);
 		rds_ibdev->mr_8k_pool = NULL;
 		reason = "reds_ib_create_mr_pool (8k) failed";
 		goto put_dev;
 	}
 
 	if (rds_ib_srq_init(rds_ibdev)) {
+		error = -EIO;
 		reason = "rds_ib_srq_init failed";
 		goto put_dev;
 	}
 
-	if (rds_ib_alloc_caches(rds_ibdev)) {
+	error = rds_ib_alloc_caches(rds_ibdev);
+	if (error) {
 		reason = "rds_ib_alloc_caches failed";
 		goto put_dev;
 	}
@@ -1308,7 +1319,9 @@ void rds_ib_add_one(struct ib_device *device)
 trace_err:
 	if (reason)
 		trace_rds_ib_add_device_err(device, NULL, NULL, NULL,
-					    reason, 0);
+					    reason, error);
+
+	return error;
 }
 
 static void rds_ib_unregister_client(void)

net/rds/ib.h

@@ -484,13 +484,6 @@ struct rds_ib_device {
 	struct completion	*rid_dev_rem_complete;
 };
 
-static inline int ibdev_to_node(struct ib_device *ibdev)
-{
-	struct device *parent;
-
-	parent = ibdev->dev.parent;
-	return parent ? dev_to_node(parent) : NUMA_NO_NODE;
-}
 #define rdsibdev_to_node(rdsibdev) ibdev_to_node(rdsibdev->dev)
 
 /* bits for i_ack_flags */
@@ -617,7 +610,7 @@ static inline __s32 rds_qp_num(struct rds_connection *conn, int dst)
 /* ib.c */
 extern struct workqueue_struct *rds_aux_wq;
 extern struct rds_transport rds_ib_transport;
-extern void rds_ib_add_one(struct ib_device *device);
+extern int rds_ib_add_one(struct ib_device *device);
 extern void rds_ib_remove_one(struct ib_device *device, void *client_data);
 void rds_ib_srq_exit(struct rds_ib_device *rds_ibdev);
 int rds_ib_srq_init(struct rds_ib_device *rds_ibdev);