All of lore.kernel.org
 help / color / mirror / Atom feed
* [LTP] [PATCH v3 1/3] lib/tst_checksum: add crc32c checksum
@ 2018-04-28 11:29 Alexey Kodanev
  2018-04-28 11:29 ` [LTP] [PATCH v3 2/3] sctp_big_chunk: make INIT packet in the test Alexey Kodanev
                   ` (2 more replies)
  0 siblings, 3 replies; 9+ messages in thread
From: Alexey Kodanev @ 2018-04-28 11:29 UTC (permalink / raw)
  To: ltp

It will be used to make a SCTP packet in the test.

Signed-off-by: Alexey Kodanev <alexey.kodanev@oracle.com>
---
v3: use SPDX License-Identifier

v2: As suggested by Cyril:
    * updated the docs, added section 2.2.25
    * added 'tst_' prefix
    * changed type 'int' to 'size_t' for the buffer length

 doc/test-writing-guidelines.txt |    6 +++
 include/tst_checksum.h          |   16 ++++++++
 lib/tst_checksum.c              |   81 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 103 insertions(+), 0 deletions(-)
 create mode 100644 include/tst_checksum.h
 create mode 100644 lib/tst_checksum.c

diff --git a/doc/test-writing-guidelines.txt b/doc/test-writing-guidelines.txt
index cbbfe6c..8e405a0 100644
--- a/doc/test-writing-guidelines.txt
+++ b/doc/test-writing-guidelines.txt
@@ -1366,6 +1366,12 @@ For reference to tainted kernels, see kernel documentation:
 Documentation/admin-guide/tainted-kernels.rst or
 https://www.kernel.org/doc/html/latest/admin-guide/tainted-kernels.html
 
+2.2.25 Checksums
+^^^^^^^^^^^^^^^^
+
+CRC32c checksum generation is supported by LTP. In order to use it, the
+test should include "tst_checksum.h" header, then can call tst_crc32c().
+
 2.3 Writing a testcase in shell
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
diff --git a/include/tst_checksum.h b/include/tst_checksum.h
new file mode 100644
index 0000000..4f43115
--- /dev/null
+++ b/include/tst_checksum.h
@@ -0,0 +1,16 @@
+/* SPDX-License-Identifier: GPL-2.0
+ * Copyright (c) 2018 Oracle and/or its affiliates. All Rights Reserved.
+ */
+
+#ifndef TST_CHECKSUM_H__
+#define TST_CHECKSUM_H__
+
+#include <stdint.h>
+#include <stddef.h>
+
+/*
+ * Generates CRC32c checksum.
+ */
+uint32_t tst_crc32c(uint8_t *buf, size_t buf_len);
+
+#endif
diff --git a/lib/tst_checksum.c b/lib/tst_checksum.c
new file mode 100644
index 0000000..9aaf9d4
--- /dev/null
+++ b/lib/tst_checksum.c
@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2018 Oracle and/or its affiliates. All Rights Reserved. */
+
+#include "tst_checksum.h"
+
+static const uint32_t crc32c_table[] = {
+	0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4,
+	0xc79a971f, 0x35f1141c, 0x26a1e7e8, 0xd4ca64eb,
+	0x8ad958cf, 0x78b2dbcc, 0x6be22838, 0x9989ab3b,
+	0x4d43cfd0, 0xbf284cd3, 0xac78bf27, 0x5e133c24,
+	0x105ec76f, 0xe235446c, 0xf165b798, 0x030e349b,
+	0xd7c45070, 0x25afd373, 0x36ff2087, 0xc494a384,
+	0x9a879fa0, 0x68ec1ca3, 0x7bbcef57, 0x89d76c54,
+	0x5d1d08bf, 0xaf768bbc, 0xbc267848, 0x4e4dfb4b,
+	0x20bd8ede, 0xd2d60ddd, 0xc186fe29, 0x33ed7d2a,
+	0xe72719c1, 0x154c9ac2, 0x061c6936, 0xf477ea35,
+	0xaa64d611, 0x580f5512, 0x4b5fa6e6, 0xb93425e5,
+	0x6dfe410e, 0x9f95c20d, 0x8cc531f9, 0x7eaeb2fa,
+	0x30e349b1, 0xc288cab2, 0xd1d83946, 0x23b3ba45,
+	0xf779deae, 0x05125dad, 0x1642ae59, 0xe4292d5a,
+	0xba3a117e, 0x4851927d, 0x5b016189, 0xa96ae28a,
+	0x7da08661, 0x8fcb0562, 0x9c9bf696, 0x6ef07595,
+	0x417b1dbc, 0xb3109ebf, 0xa0406d4b, 0x522bee48,
+	0x86e18aa3, 0x748a09a0, 0x67dafa54, 0x95b17957,
+	0xcba24573, 0x39c9c670, 0x2a993584, 0xd8f2b687,
+	0x0c38d26c, 0xfe53516f, 0xed03a29b, 0x1f682198,
+	0x5125dad3, 0xa34e59d0, 0xb01eaa24, 0x42752927,
+	0x96bf4dcc, 0x64d4cecf, 0x77843d3b, 0x85efbe38,
+	0xdbfc821c, 0x2997011f, 0x3ac7f2eb, 0xc8ac71e8,
+	0x1c661503, 0xee0d9600, 0xfd5d65f4, 0x0f36e6f7,
+	0x61c69362, 0x93ad1061, 0x80fde395, 0x72966096,
+	0xa65c047d, 0x5437877e, 0x4767748a, 0xb50cf789,
+	0xeb1fcbad, 0x197448ae, 0x0a24bb5a, 0xf84f3859,
+	0x2c855cb2, 0xdeeedfb1, 0xcdbe2c45, 0x3fd5af46,
+	0x7198540d, 0x83f3d70e, 0x90a324fa, 0x62c8a7f9,
+	0xb602c312, 0x44694011, 0x5739b3e5, 0xa55230e6,
+	0xfb410cc2, 0x092a8fc1, 0x1a7a7c35, 0xe811ff36,
+	0x3cdb9bdd, 0xceb018de, 0xdde0eb2a, 0x2f8b6829,
+	0x82f63b78, 0x709db87b, 0x63cd4b8f, 0x91a6c88c,
+	0x456cac67, 0xb7072f64, 0xa457dc90, 0x563c5f93,
+	0x082f63b7, 0xfa44e0b4, 0xe9141340, 0x1b7f9043,
+	0xcfb5f4a8, 0x3dde77ab, 0x2e8e845f, 0xdce5075c,
+	0x92a8fc17, 0x60c37f14, 0x73938ce0, 0x81f80fe3,
+	0x55326b08, 0xa759e80b, 0xb4091bff, 0x466298fc,
+	0x1871a4d8, 0xea1a27db, 0xf94ad42f, 0x0b21572c,
+	0xdfeb33c7, 0x2d80b0c4, 0x3ed04330, 0xccbbc033,
+	0xa24bb5a6, 0x502036a5, 0x4370c551, 0xb11b4652,
+	0x65d122b9, 0x97baa1ba, 0x84ea524e, 0x7681d14d,
+	0x2892ed69, 0xdaf96e6a, 0xc9a99d9e, 0x3bc21e9d,
+	0xef087a76, 0x1d63f975, 0x0e330a81, 0xfc588982,
+	0xb21572c9, 0x407ef1ca, 0x532e023e, 0xa145813d,
+	0x758fe5d6, 0x87e466d5, 0x94b49521, 0x66df1622,
+	0x38cc2a06, 0xcaa7a905, 0xd9f75af1, 0x2b9cd9f2,
+	0xff56bd19, 0x0d3d3e1a, 0x1e6dcdee, 0xec064eed,
+	0xc38d26c4, 0x31e6a5c7, 0x22b65633, 0xd0ddd530,
+	0x0417b1db, 0xf67c32d8, 0xe52cc12c, 0x1747422f,
+	0x49547e0b, 0xbb3ffd08, 0xa86f0efc, 0x5a048dff,
+	0x8ecee914, 0x7ca56a17, 0x6ff599e3, 0x9d9e1ae0,
+	0xd3d3e1ab, 0x21b862a8, 0x32e8915c, 0xc083125f,
+	0x144976b4, 0xe622f5b7, 0xf5720643, 0x07198540,
+	0x590ab964, 0xab613a67, 0xb831c993, 0x4a5a4a90,
+	0x9e902e7b, 0x6cfbad78, 0x7fab5e8c, 0x8dc0dd8f,
+	0xe330a81a, 0x115b2b19, 0x020bd8ed, 0xf0605bee,
+	0x24aa3f05, 0xd6c1bc06, 0xc5914ff2, 0x37faccf1,
+	0x69e9f0d5, 0x9b8273d6, 0x88d28022, 0x7ab90321,
+	0xae7367ca, 0x5c18e4c9, 0x4f48173d, 0xbd23943e,
+	0xf36e6f75, 0x0105ec76, 0x12551f82, 0xe03e9c81,
+	0x34f4f86a, 0xc69f7b69, 0xd5cf889d, 0x27a40b9e,
+	0x79b737ba, 0x8bdcb4b9, 0x988c474d, 0x6ae7c44e,
+	0xbe2da0a5, 0x4c4623a6, 0x5f16d052, 0xad7d5351,
+};
+
+uint32_t tst_crc32c(uint8_t *buf, size_t buf_len)
+{
+	uint32_t crc = 0xffffffff;
+
+	while (buf_len--)
+		crc = crc32c_table[(crc ^ (*buf++)) & 0xff] ^ (crc >> 8);
+
+	return ~crc;
+}
-- 
1.7.1


^ permalink raw reply related	[flat|nested] 9+ messages in thread

* [LTP] [PATCH v3 2/3] sctp_big_chunk: make INIT packet in the test
  2018-04-28 11:29 [LTP] [PATCH v3 1/3] lib/tst_checksum: add crc32c checksum Alexey Kodanev
@ 2018-04-28 11:29 ` Alexey Kodanev
  2018-04-28 11:29 ` [LTP] [PATCH v3 3/3] sctp_big_chunk: use SPDX-License-Identifier GPL-2.0 Alexey Kodanev
  2018-05-03 13:06 ` [LTP] [PATCH v3 1/3] lib/tst_checksum: add crc32c checksum Petr Vorel
  2 siblings, 0 replies; 9+ messages in thread
From: Alexey Kodanev @ 2018-04-28 11:29 UTC (permalink / raw)
  To: ltp

Starting from 4.17-rc2 kernel or the kernels that don't have
commit 40b4f0fd74e4 ("sctp: lack the check for ports in sctp_v6_cmp_addr"),
the test can't bind equal IPv6 addresses to a socket:

    safe_net.c:160: BROK: sctp_big_chunk.c:77:
        setsockopt(4, 132, 100, 0x7ffc7f11e498, 91644) failed: EINVAL

Since creating many different IP addresses and binding them to the
same SCTP socket is a time consuming process, prepare SCTP INIT chunk
in the test. That should fix EINVAL error returned by setsockopt()
for the mentioned kernels.

Signed-off-by: Alexey Kodanev <alexey.kodanev@oracle.com>
Reviewed-by: Xiao Yang <yangx.jy@cn.fujitsu.com>
---
v3: * changed commit message

v2: * the test doesn't support IPv6 fragmentation, TCONF in that case
    * add needs_root since we use a raw socket

 runtest/cve                             |    1 -
 testcases/network/sctp/sctp_big_chunk.c |  105 +++++++++++++++++++++++++++----
 2 files changed, 93 insertions(+), 13 deletions(-)

diff --git a/runtest/cve b/runtest/cve
index 1d9569a..2f4171c 100644
--- a/runtest/cve
+++ b/runtest/cve
@@ -33,4 +33,3 @@ cve-2017-17052 cve-2017-17052
 cve-2017-16939 cve-2017-16939
 cve-2017-17053 cve-2017-17053
 cve-2018-5803 sctp_big_chunk
-cve-2018-5803_2 sctp_big_chunk -a 10000
diff --git a/testcases/network/sctp/sctp_big_chunk.c b/testcases/network/sctp/sctp_big_chunk.c
index 55a2969..89c5e0d 100644
--- a/testcases/network/sctp/sctp_big_chunk.c
+++ b/testcases/network/sctp/sctp_big_chunk.c
@@ -24,12 +24,14 @@
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
+#include <netinet/ip.h>
+#include <netinet/ip6.h>
 #include <netdb.h>
 #include <sys/syscall.h>
-#include <fcntl.h>
 
 #include "tst_test.h"
 #include "tst_safe_stdio.h"
+#include "tst_checksum.h"
 #include "lapi/netinet_in.h"
 #include "lapi/socket.h"
 #include "lapi/sctp.h"
@@ -38,6 +40,8 @@ static int port;
 static int sfd, cfd;
 static struct sockaddr_in6 rmt, loc;
 
+static uint8_t packet[IP_MAXPACKET];
+static int pkt_len;
 static char *addr_param;
 static int addr_num = 3273;
 
@@ -53,35 +57,108 @@ static void setup_server(void)
 	tst_res(TINFO, "sctp server listen on %d", port);
 
 	SAFE_LISTEN(sfd, 1);
+
+	srand(port);
+}
+
+static void update_packet_field(size_t *off, void *buf, size_t buf_len)
+{
+	memcpy(packet + *off, buf, buf_len);
+	*off += buf_len;
 }
 
 static void setup_client(void)
 {
-	struct sockaddr_in6 addr_buf[addr_num];
+	struct ip6_hdr ip6;
+	const size_t ip6_hdr_len = sizeof(ip6);
+	size_t cmn_hdr_off;
+	size_t off;
 	int i;
 
-	cfd = SAFE_SOCKET(AF_INET6, SOCK_STREAM, IPPROTO_SCTP);
+	memset(&ip6, 0, sizeof(ip6));
+	ip6.ip6_flow = htonl(6 << 28 | 2 << 20);
+	ip6.ip6_hops = 64;
+	ip6.ip6_nxt = IPPROTO_SCTP;
+	ip6.ip6_src.s6_addr[15] = 1;
+	ip6.ip6_dst.s6_addr[15] = 1;
 	rmt.sin6_family = AF_INET6;
 	rmt.sin6_addr = in6addr_loopback;
-	rmt.sin6_port = htons(port);
 
-	tst_res(TINFO, "bind %d additional IP addresses", addr_num);
+	/* SCTP common header */
+	off = ip6_hdr_len;
+
+	uint16_t src_port = htons(port - 1);
+	uint16_t dst_port = htons(port);
+	uint32_t vtag = 0;
+	uint32_t checksum = 0;
+
+	update_packet_field(&off, &src_port, 2);
+	update_packet_field(&off, &dst_port, 2);
+	update_packet_field(&off, &vtag, 4);
+	update_packet_field(&off, &checksum, 4);
+	cmn_hdr_off = off;
+
+	/* SCTP INIT chunk */
+	uint16_t chunk_len;
+
+	packet[off++] = 1;
+	packet[off++] = 0;
+	off += 2; /* chunk length, will be set in the end */
+
+	uint32_t init_tag = rand();
+	uint32_t rwnd = htonl(106496);
+	uint16_t outs = htons(10);
+	uint16_t ins = htons(65535);
+	uint32_t init_tsn = rand();
+
+	update_packet_field(&off, &init_tag, 4);
+	update_packet_field(&off, &rwnd, 4);
+	update_packet_field(&off, &outs, 2);
+	update_packet_field(&off, &ins, 2);
+	update_packet_field(&off, &init_tsn, 4);
 
-	memset(addr_buf, 0, sizeof(addr_buf));
+	/* SCTP optional parameter for IPv6 addresses */
+	uint16_t param_type = htons(6);
+	uint16_t param_len = htons(20);
+
+	/* IPv6(40) + SCTP_COMMON(12) + SCTP_CHUNK(20) + SCTP_OPT(65460)) */
 	for (i = 0; i < addr_num; ++i) {
-		addr_buf[i].sin6_family = AF_INET6;
-		addr_buf[i].sin6_addr = in6addr_loopback;
+		update_packet_field(&off, &param_type, 2);
+		update_packet_field(&off, &param_len, 2);
+		packet[off + 15] = 1;
+		off += 16;
 	}
+	pkt_len = off;
+
+	tst_res(TINFO, "set chunk length %zu", pkt_len - cmn_hdr_off);
+	chunk_len = htons(pkt_len - cmn_hdr_off);
+	memcpy(packet + cmn_hdr_off + 2, &chunk_len, 2);
+
+	/* set checksum for SCTP: common header + INIT chunk */
+	uint32_t csum = tst_crc32c(packet + ip6_hdr_len, pkt_len - ip6_hdr_len);
+
+	memcpy(packet + ip6_hdr_len + 8, &csum, 4);
+
+	ip6.ip6_plen = htons(pkt_len - ip6_hdr_len);
+	memcpy(packet, &ip6, ip6_hdr_len);
 
-	SAFE_SETSOCKOPT(cfd, SOL_SCTP, SCTP_SOCKOPT_BINDX_ADD, addr_buf,
-			sizeof(addr_buf));
+	cfd = SAFE_SOCKET(AF_INET6, SOCK_RAW, IPPROTO_RAW);
 }
 
+static const char mtu_path[] = "/sys/class/net/lo/mtu";
+static const unsigned int max_mtu = 65535;
+static unsigned int mtu;
+
 static void setup(void)
 {
 	if (tst_parse_int(addr_param, &addr_num, 1, INT_MAX))
 		tst_brk(TBROK, "wrong address number '%s'", addr_param);
 
+	/* We don't fragment IPv6 packet here yet, check that MTU is 65535 */
+	SAFE_FILE_SCANF(mtu_path, "%d", &mtu);
+	if (mtu < max_mtu)
+		tst_brk(TCONF, "Test needs that 'lo' MTU has %d", max_mtu);
+
 	setup_server();
 	setup_client();
 }
@@ -89,6 +166,7 @@ static void setup(void)
 static void run(void)
 {
 	int pid = SAFE_FORK();
+	int i;
 
 	if (!pid) {
 		struct sockaddr_in6 addr6;
@@ -99,8 +177,10 @@ static void run(void)
 		exit(0);
 	}
 
-	fcntl(cfd, F_SETFL, O_NONBLOCK);
-	connect(cfd, (struct sockaddr *)&rmt, sizeof(rmt));
+	for (i = 0; i < 3; ++i) {
+		SAFE_SENDTO(1, cfd, packet, pkt_len, 0,
+			(struct sockaddr *)&rmt, sizeof(rmt));
+	}
 
 	SAFE_KILL(pid, SIGKILL);
 	SAFE_WAITPID(pid, NULL, 0);
@@ -114,6 +194,7 @@ static struct tst_option options[] = {
 };
 
 static struct tst_test test = {
+	.needs_root = 1,
 	.setup = setup,
 	.forks_child = 1,
 	.test_all = run,
-- 
1.7.1


^ permalink raw reply related	[flat|nested] 9+ messages in thread

* [LTP] [PATCH v3 3/3] sctp_big_chunk: use SPDX-License-Identifier GPL-2.0
  2018-04-28 11:29 [LTP] [PATCH v3 1/3] lib/tst_checksum: add crc32c checksum Alexey Kodanev
  2018-04-28 11:29 ` [LTP] [PATCH v3 2/3] sctp_big_chunk: make INIT packet in the test Alexey Kodanev
@ 2018-04-28 11:29 ` Alexey Kodanev
  2018-05-03 13:16   ` Petr Vorel
  2018-05-03 13:06 ` [LTP] [PATCH v3 1/3] lib/tst_checksum: add crc32c checksum Petr Vorel
  2 siblings, 1 reply; 9+ messages in thread
From: Alexey Kodanev @ 2018-04-28 11:29 UTC (permalink / raw)
  To: ltp

Signed-off-by: Alexey Kodanev <alexey.kodanev@oracle.com>
---
v3: new patch in v3

 testcases/network/sctp/sctp_big_chunk.c |   17 ++---------------
 1 files changed, 2 insertions(+), 15 deletions(-)

diff --git a/testcases/network/sctp/sctp_big_chunk.c b/testcases/network/sctp/sctp_big_chunk.c
index 89c5e0d..333e502 100644
--- a/testcases/network/sctp/sctp_big_chunk.c
+++ b/testcases/network/sctp/sctp_big_chunk.c
@@ -1,18 +1,5 @@
-/*
- * Copyright (c) 2018 Oracle and/or its affiliates. All Rights Reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of
- * the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it would be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2018 Oracle and/or its affiliates. All Rights Reserved.
  *
  * Regression test-case for the crash caused by over-sized SCTP chunk,
  * fixed by upstream commit 07f2c7ab6f8d ("sctp: verify size of a new
-- 
1.7.1


^ permalink raw reply related	[flat|nested] 9+ messages in thread

* [LTP] [PATCH v3 1/3] lib/tst_checksum: add crc32c checksum
  2018-04-28 11:29 [LTP] [PATCH v3 1/3] lib/tst_checksum: add crc32c checksum Alexey Kodanev
  2018-04-28 11:29 ` [LTP] [PATCH v3 2/3] sctp_big_chunk: make INIT packet in the test Alexey Kodanev
  2018-04-28 11:29 ` [LTP] [PATCH v3 3/3] sctp_big_chunk: use SPDX-License-Identifier GPL-2.0 Alexey Kodanev
@ 2018-05-03 13:06 ` Petr Vorel
  2018-05-04 10:50   ` Alexey Kodanev
  2 siblings, 1 reply; 9+ messages in thread
From: Petr Vorel @ 2018-05-03 13:06 UTC (permalink / raw)
  To: ltp

Hi Alexey,

> It will be used to make a SCTP packet in the test.

> Signed-off-by: Alexey Kodanev <alexey.kodanev@oracle.com>
> ---
> v3: use SPDX License-Identifier

> v2: As suggested by Cyril:
>     * updated the docs, added section 2.2.25
>     * added 'tst_' prefix
>     * changed type 'int' to 'size_t' for the buffer length

>  doc/test-writing-guidelines.txt |    6 +++
>  include/tst_checksum.h          |   16 ++++++++
>  lib/tst_checksum.c              |   81 +++++++++++++++++++++++++++++++++++++++
>  3 files changed, 103 insertions(+), 0 deletions(-)
>  create mode 100644 include/tst_checksum.h
>  create mode 100644 lib/tst_checksum.c

Whole patchset LGTM.

BTW sctp_big_chunk still uses crazy big load on kernels before 4.17 rc2 :(.


Kind regards,
Petr

^ permalink raw reply	[flat|nested] 9+ messages in thread

* [LTP] [PATCH v3 3/3] sctp_big_chunk: use SPDX-License-Identifier GPL-2.0
  2018-04-28 11:29 ` [LTP] [PATCH v3 3/3] sctp_big_chunk: use SPDX-License-Identifier GPL-2.0 Alexey Kodanev
@ 2018-05-03 13:16   ` Petr Vorel
  2018-05-04 10:51     ` Alexey Kodanev
  0 siblings, 1 reply; 9+ messages in thread
From: Petr Vorel @ 2018-05-03 13:16 UTC (permalink / raw)
  To: ltp

Hi Alexey,

> - * This program is free software; you can redistribute it and/or
> - * modify it under the terms of the GNU General Public License as
> - * published by the Free Software Foundation; either version 2 of
> - * the License, or (at your option) any later version.
...
> +// SPDX-License-Identifier: GPL-2.0
Shouldn't it be:
// SPDX-License-Identifier: GPL-2.0-or-later

As this was stated in previous license?
https://spdx.org/licenses/GPL-2.0-or-later.html
https://spdx.org/licenses/


Kind regards,
Petr


^ permalink raw reply	[flat|nested] 9+ messages in thread

* [LTP] [PATCH v3 1/3] lib/tst_checksum: add crc32c checksum
  2018-05-03 13:06 ` [LTP] [PATCH v3 1/3] lib/tst_checksum: add crc32c checksum Petr Vorel
@ 2018-05-04 10:50   ` Alexey Kodanev
  2018-05-04 13:46     ` Alexey Kodanev
  2018-05-04 15:13     ` Petr Vorel
  0 siblings, 2 replies; 9+ messages in thread
From: Alexey Kodanev @ 2018-05-04 10:50 UTC (permalink / raw)
  To: ltp

On 05/03/2018 04:06 PM, Petr Vorel wrote:
> Hi Alexey,
> 
>> It will be used to make a SCTP packet in the test.
> 
>> Signed-off-by: Alexey Kodanev <alexey.kodanev@oracle.com>
>> ---
>> v3: use SPDX License-Identifier
> 
>> v2: As suggested by Cyril:
>>     * updated the docs, added section 2.2.25
>>     * added 'tst_' prefix
>>     * changed type 'int' to 'size_t' for the buffer length
> 
>>  doc/test-writing-guidelines.txt |    6 +++
>>  include/tst_checksum.h          |   16 ++++++++
>>  lib/tst_checksum.c              |   81 +++++++++++++++++++++++++++++++++++++++
>>  3 files changed, 103 insertions(+), 0 deletions(-)
>>  create mode 100644 include/tst_checksum.h
>>  create mode 100644 lib/tst_checksum.c
> 
> Whole patchset LGTM.
> 
> BTW sctp_big_chunk still uses crazy big load on kernels before 4.17 rc2 :(.


I wonder, what is the time the test needs to complete on your system,
could you post the numbers at least from 'time' command? Does it take
minutes? I've not seen it takes more than a second.

Will remove sending this packet 3 times, it should be enough to send
it just once. I assume, the load is on the server, in the kernel?
i.e. when it receives and processes that INIT packet.

What is the time in 4.17-rc2 with this change:

diff --git a/testcases/network/sctp/sctp_big_chunk.c b/testcases/network/sctp/sctp_big_chunk.c
index 333e502..c663f71 100644
--- a/testcases/network/sctp/sctp_big_chunk.c
+++ b/testcases/network/sctp/sctp_big_chunk.c
@@ -109,11 +109,11 @@ static void setup_client(void)
        uint16_t param_len = htons(20);

        /* IPv6(40) + SCTP_COMMON(12) + SCTP_CHUNK(20) + SCTP_OPT(65460)) */
-       for (i = 0; i < addr_num; ++i) {
+       for (i = 1; i <= addr_num; ++i) {
                update_packet_field(&off, &param_type, 2);
                update_packet_field(&off, &param_len, 2);
-               packet[off + 15] = 1;
-               off += 16;
+               off += 12;
+               update_packet_field(&off, &i, 4);
        }
        pkt_len = off;

when we are using unique addresses...

^ permalink raw reply related	[flat|nested] 9+ messages in thread

* [LTP] [PATCH v3 3/3] sctp_big_chunk: use SPDX-License-Identifier GPL-2.0
  2018-05-03 13:16   ` Petr Vorel
@ 2018-05-04 10:51     ` Alexey Kodanev
  0 siblings, 0 replies; 9+ messages in thread
From: Alexey Kodanev @ 2018-05-04 10:51 UTC (permalink / raw)
  To: ltp

On 05/03/2018 04:16 PM, Petr Vorel wrote:
> Hi Alexey,
> 
>> - * This program is free software; you can redistribute it and/or
>> - * modify it under the terms of the GNU General Public License as
>> - * published by the Free Software Foundation; either version 2 of
>> - * the License, or (at your option) any later version.
> ...
>> +// SPDX-License-Identifier: GPL-2.0
> Shouldn't it be:
> // SPDX-License-Identifier: GPL-2.0-or-later
> > As this was stated in previous license?

Right, good catch!

^ permalink raw reply	[flat|nested] 9+ messages in thread

* [LTP] [PATCH v3 1/3] lib/tst_checksum: add crc32c checksum
  2018-05-04 10:50   ` Alexey Kodanev
@ 2018-05-04 13:46     ` Alexey Kodanev
  2018-05-04 15:13     ` Petr Vorel
  1 sibling, 0 replies; 9+ messages in thread
From: Alexey Kodanev @ 2018-05-04 13:46 UTC (permalink / raw)
  To: ltp

On 04.05.2018 13:50, Alexey Kodanev wrote:
> On 05/03/2018 04:06 PM, Petr Vorel wrote:
>> Hi Alexey,
>>
>>> It will be used to make a SCTP packet in the test.
>>
>>> Signed-off-by: Alexey Kodanev <alexey.kodanev@oracle.com>
>>> ---
>>> v3: use SPDX License-Identifier
>>
>>> v2: As suggested by Cyril:
>>>     * updated the docs, added section 2.2.25
>>>     * added 'tst_' prefix
>>>     * changed type 'int' to 'size_t' for the buffer length
>>
>>>  doc/test-writing-guidelines.txt |    6 +++
>>>  include/tst_checksum.h          |   16 ++++++++
>>>  lib/tst_checksum.c              |   81 +++++++++++++++++++++++++++++++++++++++
>>>  3 files changed, 103 insertions(+), 0 deletions(-)
>>>  create mode 100644 include/tst_checksum.h
>>>  create mode 100644 lib/tst_checksum.c
>>
>> Whole patchset LGTM.

Removed sending the packet three times, fixed SPDX License-Identifier and
applied. Thanks!

^ permalink raw reply	[flat|nested] 9+ messages in thread

* [LTP] [PATCH v3 1/3] lib/tst_checksum: add crc32c checksum
  2018-05-04 10:50   ` Alexey Kodanev
  2018-05-04 13:46     ` Alexey Kodanev
@ 2018-05-04 15:13     ` Petr Vorel
  1 sibling, 0 replies; 9+ messages in thread
From: Petr Vorel @ 2018-05-04 15:13 UTC (permalink / raw)
  To: ltp

Hi Alexey,

> > BTW sctp_big_chunk still uses crazy big load on kernels before 4.17 rc2 :(.

> I wonder, what is the time the test needs to complete on your system,
> could you post the numbers at least from 'time' command? Does it take
> minutes? I've not seen it takes more than a second.
I'm testing it on several OS (SLES 15, Centos 7, Debian 9, ...) which all have kernels
older than 4.17-rc2. It behaves like DOS - the only thing I can do is to restart machines :(.
With vanilla kernel 4.17-rc2 it works well.

> Will remove sending this packet 3 times, it should be enough to send
> it just once. I assume, the load is on the server, in the kernel?
> i.e. when it receives and processes that INIT packet.

> What is the time in 4.17-rc2 with this change:
I'll let you know.

> diff --git a/testcases/network/sctp/sctp_big_chunk.c b/testcases/network/sctp/sctp_big_chunk.c
> index 333e502..c663f71 100644
> --- a/testcases/network/sctp/sctp_big_chunk.c
> +++ b/testcases/network/sctp/sctp_big_chunk.c
> @@ -109,11 +109,11 @@ static void setup_client(void)
>         uint16_t param_len = htons(20);

>         /* IPv6(40) + SCTP_COMMON(12) + SCTP_CHUNK(20) + SCTP_OPT(65460)) */
> -       for (i = 0; i < addr_num; ++i) {
> +       for (i = 1; i <= addr_num; ++i) {
>                 update_packet_field(&off, &param_type, 2);
>                 update_packet_field(&off, &param_len, 2);
> -               packet[off + 15] = 1;
> -               off += 16;
> +               off += 12;
> +               update_packet_field(&off, &i, 4);
>         }
>         pkt_len = off;

> when we are using unique addresses...


Kind regards,
Petr

^ permalink raw reply	[flat|nested] 9+ messages in thread

end of thread, other threads:[~2018-05-04 15:13 UTC | newest]

Thread overview: 9+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2018-04-28 11:29 [LTP] [PATCH v3 1/3] lib/tst_checksum: add crc32c checksum Alexey Kodanev
2018-04-28 11:29 ` [LTP] [PATCH v3 2/3] sctp_big_chunk: make INIT packet in the test Alexey Kodanev
2018-04-28 11:29 ` [LTP] [PATCH v3 3/3] sctp_big_chunk: use SPDX-License-Identifier GPL-2.0 Alexey Kodanev
2018-05-03 13:16   ` Petr Vorel
2018-05-04 10:51     ` Alexey Kodanev
2018-05-03 13:06 ` [LTP] [PATCH v3 1/3] lib/tst_checksum: add crc32c checksum Petr Vorel
2018-05-04 10:50   ` Alexey Kodanev
2018-05-04 13:46     ` Alexey Kodanev
2018-05-04 15:13     ` Petr Vorel

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.