Commit bc36442e authored by Arseniy Krasnov's avatar Arseniy Krasnov Committed by David S. Miller
Browse files

test/vsock: MSG_ZEROCOPY flag tests 



This adds three tests for MSG_ZEROCOPY feature:
1) SOCK_STREAM tx with different buffers.
2) SOCK_SEQPACKET tx with different buffers.
3) SOCK_STREAM test to read empty error queue of the socket.

Patch also works as preparation for the next patches for tools in this
patchset: vsock_perf and vsock_uring_test:
1) Adds several new functions to util.c - they will be also used by
   vsock_uring_test.
2) Adds two new functions for MSG_ZEROCOPY handling to a new source
   file - such source will be shared between vsock_test, vsock_perf and
   vsock_uring_test, thus avoiding code copy-pasting.

Signed-off-by: default avatarArseniy Krasnov <avkrasnov@salutedevices.com>
Reviewed-by: default avatarStefano Garzarella <sgarzare@redhat.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent bac2cac1

tools/testing/vsock/Makefile

+1 −1
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0-only

all: test vsock_perf

test: vsock_test vsock_diag_test

vsock_test: vsock_test.o timeout.o control.o util.o

vsock_test: vsock_test.o vsock_test_zerocopy.o timeout.o control.o util.o msg_zerocopy_common.o

vsock_diag_test: vsock_diag_test.o timeout.o control.o util.o

vsock_perf: vsock_perf.o

tools/testing/vsock/msg_zerocopy_common.c

0 → 100644
+87 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/* Some common code for MSG_ZEROCOPY logic

 *

 * Copyright (C) 2023 SberDevices.

 *

 * Author: Arseniy Krasnov <avkrasnov@salutedevices.com>

 */



#include <stdio.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <linux/errqueue.h>



#include "msg_zerocopy_common.h"



void enable_so_zerocopy(int fd)

{

	int val = 1;



	if (setsockopt(fd, SOL_SOCKET, SO_ZEROCOPY, &val, sizeof(val))) {

		perror("setsockopt");

		exit(EXIT_FAILURE);

	}

}



void vsock_recv_completion(int fd, const bool *zerocopied)

{

	struct sock_extended_err *serr;

	struct msghdr msg = { 0 };

	char cmsg_data[128];

	struct cmsghdr *cm;

	ssize_t res;



	msg.msg_control = cmsg_data;

	msg.msg_controllen = sizeof(cmsg_data);



	res = recvmsg(fd, &msg, MSG_ERRQUEUE);

	if (res) {

		fprintf(stderr, "failed to read error queue: %zi\n", res);

		exit(EXIT_FAILURE);

	}



	cm = CMSG_FIRSTHDR(&msg);

	if (!cm) {

		fprintf(stderr, "cmsg: no cmsg\n");

		exit(EXIT_FAILURE);

	}



	if (cm->cmsg_level != SOL_VSOCK) {

		fprintf(stderr, "cmsg: unexpected 'cmsg_level'\n");

		exit(EXIT_FAILURE);

	}



	if (cm->cmsg_type != VSOCK_RECVERR) {

		fprintf(stderr, "cmsg: unexpected 'cmsg_type'\n");

		exit(EXIT_FAILURE);

	}



	serr = (void *)CMSG_DATA(cm);

	if (serr->ee_origin != SO_EE_ORIGIN_ZEROCOPY) {

		fprintf(stderr, "serr: wrong origin: %u\n", serr->ee_origin);

		exit(EXIT_FAILURE);

	}



	if (serr->ee_errno) {

		fprintf(stderr, "serr: wrong error code: %u\n", serr->ee_errno);

		exit(EXIT_FAILURE);

	}



	/* This flag is used for tests, to check that transmission was

	 * performed as expected: zerocopy or fallback to copy. If NULL

	 * - don't care.

	 */

	if (!zerocopied)

		return;



	if (*zerocopied && (serr->ee_code & SO_EE_CODE_ZEROCOPY_COPIED)) {

		fprintf(stderr, "serr: was copy instead of zerocopy\n");

		exit(EXIT_FAILURE);

	}



	if (!*zerocopied && !(serr->ee_code & SO_EE_CODE_ZEROCOPY_COPIED)) {

		fprintf(stderr, "serr: was zerocopy instead of copy\n");

		exit(EXIT_FAILURE);

	}

}

tools/testing/vsock/msg_zerocopy_common.h

0 → 100644
+18 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0-only */

#ifndef MSG_ZEROCOPY_COMMON_H

#define MSG_ZEROCOPY_COMMON_H



#include <stdbool.h>



#ifndef SOL_VSOCK

#define SOL_VSOCK	287

#endif



#ifndef VSOCK_RECVERR

#define VSOCK_RECVERR	1

#endif



void enable_so_zerocopy(int fd);

void vsock_recv_completion(int fd, const bool *zerocopied);



#endif /* MSG_ZEROCOPY_COMMON_H */

tools/testing/vsock/util.c

+133 −0
Original line number Diff line number Diff line
@@ -11,10 +11,12 @@ 
#include <stdio.h>

#include <stdint.h>

#include <stdlib.h>

#include <string.h>

#include <signal.h>

#include <unistd.h>

#include <assert.h>

#include <sys/epoll.h>

#include <sys/mman.h>



#include "timeout.h"

#include "control.h"
@@ -444,3 +446,134 @@ unsigned long hash_djb2(const void *data, size_t len) 


	return hash;

}



size_t iovec_bytes(const struct iovec *iov, size_t iovnum)

{

	size_t bytes;

	int i;



	for (bytes = 0, i = 0; i < iovnum; i++)

		bytes += iov[i].iov_len;



	return bytes;

}



unsigned long iovec_hash_djb2(const struct iovec *iov, size_t iovnum)

{

	unsigned long hash;

	size_t iov_bytes;

	size_t offs;

	void *tmp;

	int i;



	iov_bytes = iovec_bytes(iov, iovnum);



	tmp = malloc(iov_bytes);

	if (!tmp) {

		perror("malloc");

		exit(EXIT_FAILURE);

	}



	for (offs = 0, i = 0; i < iovnum; i++) {

		memcpy(tmp + offs, iov[i].iov_base, iov[i].iov_len);

		offs += iov[i].iov_len;

	}



	hash = hash_djb2(tmp, iov_bytes);

	free(tmp);



	return hash;

}



/* Allocates and returns new 'struct iovec *' according pattern

 * in the 'test_iovec'. For each element in the 'test_iovec' it

 * allocates new element in the resulting 'iovec'. 'iov_len'

 * of the new element is copied from 'test_iovec'. 'iov_base' is

 * allocated depending on the 'iov_base' of 'test_iovec':

 *

 * 'iov_base' == NULL -> valid buf: mmap('iov_len').

 *

 * 'iov_base' == MAP_FAILED -> invalid buf:

 *               mmap('iov_len'), then munmap('iov_len').

 *               'iov_base' still contains result of

 *               mmap().

 *

 * 'iov_base' == number -> unaligned valid buf:

 *               mmap('iov_len') + number.

 *

 * 'iovnum' is number of elements in 'test_iovec'.

 *

 * Returns new 'iovec' or calls 'exit()' on error.

 */

struct iovec *alloc_test_iovec(const struct iovec *test_iovec, int iovnum)

{

	struct iovec *iovec;

	int i;



	iovec = malloc(sizeof(*iovec) * iovnum);

	if (!iovec) {

		perror("malloc");

		exit(EXIT_FAILURE);

	}



	for (i = 0; i < iovnum; i++) {

		iovec[i].iov_len = test_iovec[i].iov_len;



		iovec[i].iov_base = mmap(NULL, iovec[i].iov_len,

					 PROT_READ | PROT_WRITE,

					 MAP_PRIVATE | MAP_ANONYMOUS | MAP_POPULATE,

					 -1, 0);

		if (iovec[i].iov_base == MAP_FAILED) {

			perror("mmap");

			exit(EXIT_FAILURE);

		}



		if (test_iovec[i].iov_base != MAP_FAILED)

			iovec[i].iov_base += (uintptr_t)test_iovec[i].iov_base;

	}



	/* Unmap "invalid" elements. */

	for (i = 0; i < iovnum; i++) {

		if (test_iovec[i].iov_base == MAP_FAILED) {

			if (munmap(iovec[i].iov_base, iovec[i].iov_len)) {

				perror("munmap");

				exit(EXIT_FAILURE);

			}

		}

	}



	for (i = 0; i < iovnum; i++) {

		int j;



		if (test_iovec[i].iov_base == MAP_FAILED)

			continue;



		for (j = 0; j < iovec[i].iov_len; j++)

			((uint8_t *)iovec[i].iov_base)[j] = rand() & 0xff;

	}



	return iovec;

}



/* Frees 'iovec *', previously allocated by 'alloc_test_iovec()'.

 * On error calls 'exit()'.

 */

void free_test_iovec(const struct iovec *test_iovec,

		     struct iovec *iovec, int iovnum)

{

	int i;



	for (i = 0; i < iovnum; i++) {

		if (test_iovec[i].iov_base != MAP_FAILED) {

			if (test_iovec[i].iov_base)

				iovec[i].iov_base -= (uintptr_t)test_iovec[i].iov_base;



			if (munmap(iovec[i].iov_base, iovec[i].iov_len)) {

				perror("munmap");

				exit(EXIT_FAILURE);

			}

		}

	}



	free(iovec);

}

tools/testing/vsock/util.h

+5 −0
Original line number Diff line number Diff line
@@ -53,4 +53,9 @@ void list_tests(const struct test_case *test_cases); 
void skip_test(struct test_case *test_cases, size_t test_cases_len,

	       const char *test_id_str);

unsigned long hash_djb2(const void *data, size_t len);

size_t iovec_bytes(const struct iovec *iov, size_t iovnum);

unsigned long iovec_hash_djb2(const struct iovec *iov, size_t iovnum);

struct iovec *alloc_test_iovec(const struct iovec *test_iovec, int iovnum);

void free_test_iovec(const struct iovec *test_iovec,

		     struct iovec *iovec, int iovnum);

#endif /* UTIL_H */