3 files changed, 86 insertions, 38 deletions

diff --git a/usr.sbin/iscsid/iscsid.c b/usr.sbin/iscsid/iscsid.c
index 5be7a44ce58e..8e94c8a430c8 100644
--- a/usr.sbin/iscsid/iscsid.c
+++ b/usr.sbin/iscsid/iscsid.c
@@ -153,6 +153,7 @@ static struct connection *
 connection_new(int iscsi_fd, const struct iscsi_daemon_request *request)
 {
 	struct connection *conn;
+	struct iscsi_session_limits *isl;
 	struct addrinfo *from_ai, *to_ai;
 	const char *from_addr, *to_addr;
 #ifdef ICL_KERNEL_PROXY
@@ -171,16 +172,49 @@ connection_new(int iscsi_fd, const struct iscsi_daemon_request *request)
 	conn->conn_data_digest = CONN_DIGEST_NONE;
 	conn->conn_initial_r2t = true;
 	conn->conn_immediate_data = true;
-	conn->conn_max_data_segment_length = 8192;
-	conn->conn_max_burst_length = 262144;
-	conn->conn_first_burst_length = 65536;
+	conn->conn_max_burst_length = MAX_BURST_LENGTH;
+	conn->conn_first_burst_length = FIRST_BURST_LENGTH;
 	conn->conn_iscsi_fd = iscsi_fd;
 
 	conn->conn_session_id = request->idr_session_id;
 	memcpy(&conn->conn_conf, &request->idr_conf, sizeof(conn->conn_conf));
 	memcpy(&conn->conn_isid, &request->idr_isid, sizeof(conn->conn_isid));
 	conn->conn_tsih = request->idr_tsih;
-	memcpy(&conn->conn_limits, &request->idr_limits, sizeof(conn->conn_limits));
+
+	/*
+	 * Read the driver limits and provide reasonable defaults for the ones
+	 * the driver doesn't care about.  If a max_snd_dsl is not explicitly
+	 * provided by the driver then we'll make sure both conn->max_snd_dsl
+	 * and isl->max_snd_dsl are set to the rcv_dsl.  This preserves historic
+	 * behavior.
+	 */
+	isl = &conn->conn_limits;
+	memcpy(isl, &request->idr_limits, sizeof(*isl));
+	if (isl->isl_max_recv_data_segment_length == 0) {
+		conn->conn_max_recv_data_segment_length = 8192;
+		conn->conn_max_send_data_segment_length = 8192;
+		isl->isl_max_recv_data_segment_length = 8192;
+	} else {
+		conn->conn_max_recv_data_segment_length =
+		    isl->isl_max_recv_data_segment_length;
+		conn->conn_max_send_data_segment_length =
+		    isl->isl_max_recv_data_segment_length;
+	}
+	if (isl->isl_max_send_data_segment_length == 0) {
+		isl->isl_max_send_data_segment_length =
+		    isl->isl_max_recv_data_segment_length;
+	} else {
+		conn->conn_max_send_data_segment_length =
+		    isl->isl_max_send_data_segment_length;
+	}
+	if (isl->isl_max_burst_length == 0)
+		isl->isl_max_burst_length = conn->conn_max_burst_length;
+	if (isl->isl_first_burst_length == 0) {
+		if (isl->isl_max_burst_length < (int)conn->conn_first_burst_length)
+			isl->isl_first_burst_length = isl->isl_max_burst_length;
+		else
+			isl->isl_first_burst_length = conn->conn_first_burst_length;
+	}
 
 	from_addr = conn->conn_conf.isc_initiator_addr;
 	to_addr = conn->conn_conf.isc_target_addr;
@@ -277,7 +311,10 @@ handoff(struct connection *conn)
 	idh.idh_data_digest = conn->conn_data_digest;
 	idh.idh_initial_r2t = conn->conn_initial_r2t;
 	idh.idh_immediate_data = conn->conn_immediate_data;
-	idh.idh_max_data_segment_length = conn->conn_max_data_segment_length;
+	idh.idh_max_recv_data_segment_length =
+	    conn->conn_max_recv_data_segment_length;
+	idh.idh_max_send_data_segment_length =
+	    conn->conn_max_send_data_segment_length;
 	idh.idh_max_burst_length = conn->conn_max_burst_length;
 	idh.idh_first_burst_length = conn->conn_first_burst_length;
 
diff --git a/usr.sbin/iscsid/iscsid.h b/usr.sbin/iscsid/iscsid.h
index df4b8ec9ff42..6a4e6cd2fbc9 100644
--- a/usr.sbin/iscsid/iscsid.h
+++ b/usr.sbin/iscsid/iscsid.h
@@ -61,9 +61,10 @@ struct connection {
 	int			conn_data_digest;
 	bool			conn_initial_r2t;
 	bool			conn_immediate_data;
-	size_t			conn_max_data_segment_length;
-	size_t			conn_max_burst_length;
-	size_t			conn_first_burst_length;
+	int			conn_max_recv_data_segment_length;
+	int			conn_max_send_data_segment_length;
+	int			conn_max_burst_length;
+	int			conn_first_burst_length;
 	struct chap		*conn_mutual_chap;
 };
 
diff --git a/usr.sbin/iscsid/login.c b/usr.sbin/iscsid/login.c
index c2a8e0658849..0b2d994c1be8 100644
--- a/usr.sbin/iscsid/login.c
+++ b/usr.sbin/iscsid/login.c
@@ -330,8 +330,10 @@ static void
 login_negotiate_key(struct connection *conn, const char *name,
     const char *value)
 {
+	struct iscsi_session_limits *isl;
 	int which, tmp;
 
+	isl = &conn->conn_limits;
 	if (strcmp(name, "TargetAlias") == 0) {
 		strlcpy(conn->conn_target_alias, value,
 		    sizeof(conn->conn_target_alias));
@@ -388,30 +390,31 @@ login_negotiate_key(struct connection *conn, const char *name,
 		if (tmp <= 0)
 			log_errx(1, "received invalid "
 			    "MaxRecvDataSegmentLength");
-		if (tmp > ISCSI_MAX_DATA_SEGMENT_LENGTH) {
-			log_debugx("capping MaxRecvDataSegmentLength "
-			    "from %d to %d", tmp, ISCSI_MAX_DATA_SEGMENT_LENGTH);
-			tmp = ISCSI_MAX_DATA_SEGMENT_LENGTH;
+		if (tmp > isl->isl_max_send_data_segment_length) {
+			log_debugx("capping max_send_data_segment_length "
+			    "from %d to %d", tmp,
+			    isl->isl_max_send_data_segment_length);
+			tmp = isl->isl_max_send_data_segment_length;
 		}
-		conn->conn_max_data_segment_length = tmp;
+		conn->conn_max_send_data_segment_length = tmp;
 	} else if (strcmp(name, "MaxBurstLength") == 0) {
 		tmp = strtoul(value, NULL, 10);
 		if (tmp <= 0)
 			log_errx(1, "received invalid MaxBurstLength");
-		if (tmp > MAX_BURST_LENGTH) {
+		if (tmp > isl->isl_max_burst_length) {
 			log_debugx("capping MaxBurstLength "
-			    "from %d to %d", tmp, MAX_BURST_LENGTH);
-			tmp = MAX_BURST_LENGTH;
+			    "from %d to %d", tmp, isl->isl_max_burst_length);
+			tmp = isl->isl_max_burst_length;
 		}
 		conn->conn_max_burst_length = tmp;
 	} else if (strcmp(name, "FirstBurstLength") == 0) {
 		tmp = strtoul(value, NULL, 10);
 		if (tmp <= 0)
 			log_errx(1, "received invalid FirstBurstLength");
-		if (tmp > FIRST_BURST_LENGTH) {
+		if (tmp > isl->isl_first_burst_length) {
 			log_debugx("capping FirstBurstLength "
-			    "from %d to %d", tmp, FIRST_BURST_LENGTH);
-			tmp = FIRST_BURST_LENGTH;
+			    "from %d to %d", tmp, isl->isl_first_burst_length);
+			tmp = isl->isl_first_burst_length;
 		}
 		conn->conn_first_burst_length = tmp;
 	} else if (strcmp(name, "DefaultTime2Wait") == 0) {
@@ -440,13 +443,13 @@ login_negotiate_key(struct connection *conn, const char *name,
 		if (tmp <= 0)
 			log_errx(1, "received invalid "
 			    "InitiatorRecvDataSegmentLength");
-		if ((size_t)tmp > conn->conn_limits.isl_max_data_segment_length) {
+		if ((int)tmp > isl->isl_max_recv_data_segment_length) {
 			log_debugx("capping InitiatorRecvDataSegmentLength "
-			    "from %d to %zd", tmp,
-			    conn->conn_limits.isl_max_data_segment_length);
-			tmp = conn->conn_limits.isl_max_data_segment_length;
+			    "from %d to %d", tmp,
+			    isl->isl_max_recv_data_segment_length);
+			tmp = isl->isl_max_recv_data_segment_length;
 		}
-		conn->conn_max_data_segment_length = tmp;
+		conn->conn_max_recv_data_segment_length = tmp;
 	} else if (strcmp(name, "TargetPortalGroupTag") == 0) {
 		/* Ignore */
 	} else if (strcmp(name, "TargetRecvDataSegmentLength") == 0) {
@@ -455,13 +458,13 @@ login_negotiate_key(struct connection *conn, const char *name,
 			log_errx(1,
 			    "received invalid TargetRecvDataSegmentLength");
 		}
-		if ((size_t)tmp > conn->conn_limits.isl_max_data_segment_length) {
+		if (tmp > isl->isl_max_send_data_segment_length) {
 			log_debugx("capping TargetRecvDataSegmentLength "
-			    "from %d to %zd", tmp,
-			    conn->conn_limits.isl_max_data_segment_length);
-			tmp = conn->conn_limits.isl_max_data_segment_length;
+			    "from %d to %d", tmp,
+			    isl->isl_max_send_data_segment_length);
+			tmp = isl->isl_max_send_data_segment_length;
 		}
-		conn->conn_max_data_segment_length = tmp;
+		conn->conn_max_send_data_segment_length = tmp;
 	} else {
 		log_debugx("unknown key \"%s\"; ignoring",  name);
 	}
@@ -474,14 +477,19 @@ login_negotiate(struct connection *conn)
 	struct keys *request_keys, *response_keys;
 	struct iscsi_bhs_login_response *bhslr;
 	int i, nrequests = 0;
+	struct iscsi_session_limits *isl;
 
 	log_debugx("beginning operational parameter negotiation");
 	request = login_new_request(conn, BHSLR_STAGE_OPERATIONAL_NEGOTIATION);
 	request_keys = keys_new();
 
-	log_debugx("offload \"%s\" limits MaxRecvDataSegmentLength to %zd",
-	    conn->conn_conf.isc_offload,
-	    conn->conn_limits.isl_max_data_segment_length);
+	isl = &conn->conn_limits;
+	log_debugx("Limits for offload \"%s\" are "
+	    "MaxRecvDataSegment=%d, max_send_dsl=%d, "
+	    "MaxBurstLength=%d, FirstBurstLength=%d",
+	    conn->conn_conf.isc_offload, isl->isl_max_recv_data_segment_length,
+	    isl->isl_max_send_data_segment_length, isl->isl_max_burst_length,
+	    isl->isl_first_burst_length);
 
 	/*
 	 * The following keys are irrelevant for discovery sessions.
@@ -497,25 +505,27 @@ login_negotiate(struct connection *conn)
 			keys_add(request_keys, "DataDigest", "None");
 
 		keys_add(request_keys, "ImmediateData", "Yes");
-		keys_add_int(request_keys, "MaxBurstLength", MAX_BURST_LENGTH);
-		keys_add_int(request_keys, "FirstBurstLength", FIRST_BURST_LENGTH);
+		keys_add_int(request_keys, "MaxBurstLength",
+		    isl->isl_max_burst_length);
+		keys_add_int(request_keys, "FirstBurstLength",
+		    isl->isl_first_burst_length);
 		keys_add(request_keys, "InitialR2T", "Yes");
 		keys_add(request_keys, "MaxOutstandingR2T", "1");
 		if (conn->conn_conf.isc_iser == 1) {
 			keys_add_int(request_keys, "InitiatorRecvDataSegmentLength",
-			    conn->conn_limits.isl_max_data_segment_length);
+			    isl->isl_max_recv_data_segment_length);
 			keys_add_int(request_keys, "TargetRecvDataSegmentLength",
-			    conn->conn_limits.isl_max_data_segment_length);
+			    isl->isl_max_send_data_segment_length);
 			keys_add(request_keys, "RDMAExtensions", "Yes");
 		} else {
 			keys_add_int(request_keys, "MaxRecvDataSegmentLength",
-			    conn->conn_limits.isl_max_data_segment_length);
+			    isl->isl_max_recv_data_segment_length);
 		}
 	} else {
 		keys_add(request_keys, "HeaderDigest", "None");
 		keys_add(request_keys, "DataDigest", "None");
 		keys_add_int(request_keys, "MaxRecvDataSegmentLength",
-		    conn->conn_limits.isl_max_data_segment_length);
+		    isl->isl_max_recv_data_segment_length);
 	}
 
 	keys_add(request_keys, "DefaultTime2Wait", "0");