From: Arseniy Krasnov <oxffffaa@gmail.com>
To: Bobby Eshleman <bobby.eshleman@bytedance.com>,
Stefan Hajnoczi <stefanha@redhat.com>,
Stefano Garzarella <sgarzare@redhat.com>,
"Michael S. Tsirkin" <mst@redhat.com>,
Jason Wang <jasowang@redhat.com>,
Xuan Zhuo <xuanzhuo@linux.alibaba.com>,
"David S. Miller" <davem@davemloft.net>,
Eric Dumazet <edumazet@google.com>,
Jakub Kicinski <kuba@kernel.org>, Paolo Abeni <pabeni@redhat.com>,
"K. Y. Srinivasan" <kys@microsoft.com>,
Haiyang Zhang <haiyangz@microsoft.com>,
Wei Liu <wei.liu@kernel.org>, Dexuan Cui <decui@microsoft.com>,
Bryan Tan <bryantan@vmware.com>, Vishnu Dasa <vdasa@vmware.com>,
VMware PV-Drivers Reviewers <pv-drivers@vmware.com>
Cc: Dan Carpenter <dan.carpenter@linaro.org>,
Simon Horman <simon.horman@corigine.com>,
kvm@vger.kernel.org, virtualization@lists.linux-foundation.org,
netdev@vger.kernel.org, linux-kernel@vger.kernel.org,
linux-hyperv@vger.kernel.org, bpf@vger.kernel.org,
Jiang Wang <jiang.wang@bytedance.com>
Subject: Re: [PATCH RFC net-next v4 8/8] tests: add vsock dgram tests
Date: Sun, 11 Jun 2023 23:54:57 +0300 [thread overview]
Message-ID: <484c7b6f-5ce5-ce43-2dfd-0ae3063f1e47@gmail.com> (raw)
In-Reply-To: <20230413-b4-vsock-dgram-v4-8-0cebbb2ae899@bytedance.com>
Hello Bobby!
Sorry, may be I become a little bit annoying:), but I tried to run vsock_test with
this v4 version, and again get the same crash:
# cat client.sh
./vsock_test --mode=client --control-host=192.168.1.1 --control-port=12345 --peer-cid=2
# ./client.sh
Control socket connected to 192.168.1.1:12345.
0 - SOCK_STREAM connection reset...[ 20.065237] BUG: kernel NULL pointer dereference, addre0
[ 20.065895] #PF: supervisor read access in kernel mode
[ 20.065895] #PF: error_code(0x0000) - not-present page
[ 20.065895] PGD 0 P4D 0
[ 20.065895] Oops: 0000 [#1] PREEMPT SMP PTI
[ 20.065895] CPU: 0 PID: 111 Comm: vsock_test Not tainted 6.4.0-rc3-gefcccba07069 #385
[ 20.065895] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.15.0-0-g2dd44
[ 20.065895] RIP: 0010:static_key_count+0x0/0x20
[ 20.065895] Code: 04 4c 8b 46 08 49 29 c0 4c 01 c8 4c 89 47 08 89 0e 89 56 04 48 89 46 08 f
[ 20.065895] RSP: 0018:ffffbbb000223dc0 EFLAGS: 00010202
[ 20.065895] RAX: ffffffff85709880 RBX: ffffffffc0079140 RCX: 0000000000000000
[ 20.065895] RDX: ffff9f73c2175700 RSI: 0000000000000000 RDI: 0000000000000000
[ 20.065895] RBP: ffff9f73c2385900 R08: ffffbbb000223d30 R09: ffff9f73ff896000
[ 20.065895] R10: 0000000000001000 R11: 0000000000000000 R12: ffffbbb000223e80
[ 20.065895] R13: 0000000000000000 R14: 0000000000000002 R15: ffff9f73c1cfaa80
[ 20.065895] FS: 00007f1ad82f55c0(0000) GS:ffff9f73fe400000(0000) knlGS:0000000000000000
[ 20.065895] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[ 20.065895] CR2: 0000000000000000 CR3: 000000003f954000 CR4: 00000000000006f0
[ 20.065895] Call Trace:
[ 20.065895] <TASK>
[ 20.065895] once_deferred+0xd/0x30
[ 20.065895] vsock_assign_transport+0x9a/0x1b0 [vsock]
[ 20.065895] vsock_connect+0xb4/0x3a0 [vsock]
[ 20.065895] ? var_wake_function+0x60/0x60
[ 20.065895] __sys_connect+0x9e/0xd0
[ 20.065895] ? _raw_spin_unlock_irq+0xe/0x30
[ 20.065895] ? do_setitimer+0x128/0x1f0
[ 20.065895] ? alarm_setitimer+0x4c/0x90
[ 20.065895] ? fpregs_assert_state_consistent+0x1d/0x50
[ 20.065895] ? exit_to_user_mode_prepare+0x36/0x130
[ 20.065895] __x64_sys_connect+0x11/0x20
[ 20.065895] do_syscall_64+0x3b/0xc0
[ 20.065895] entry_SYSCALL_64_after_hwframe+0x4b/0xb5
[ 20.065895] RIP: 0033:0x7f1ad822dd13
[ 20.065895] Code: 64 89 01 48 83 c8 ff c3 66 2e 0f 1f 84 00 00 00 00 00 0f 1f 44 00 00 64 8
[ 20.065895] RSP: 002b:00007ffc513e3c98 EFLAGS: 00000246 ORIG_RAX: 000000000000002a
[ 20.065895] RAX: ffffffffffffffda RBX: 000055aed298e020 RCX: 00007f1ad822dd13
[ 20.065895] RDX: 0000000000000010 RSI: 00007ffc513e3cb0 RDI: 0000000000000004
[ 20.065895] RBP: 0000000000000004 R08: 000055aed32b2018 R09: 0000000000000000
[ 20.065895] R10: 0000000000000000 R11: 0000000000000246 R12: 0000000000000000
[ 20.065895] R13: 000055aed298acb1 R14: 00007ffc513e3cb0 R15: 00007ffc513e3d40
[ 20.065895] </TASK>
[ 20.065895] Modules linked in: vsock_loopback vhost_vsock vmw_vsock_virtio_transport vmw_vb
[ 20.065895] CR2: 0000000000000000
[ 20.154060] ---[ end trace 0000000000000000 ]---
[ 20.155519] RIP: 0010:static_key_count+0x0/0x20
[ 20.156932] Code: 04 4c 8b 46 08 49 29 c0 4c 01 c8 4c 89 47 08 89 0e 89 56 04 48 89 46 08 f
[ 20.161367] RSP: 0018:ffffbbb000223dc0 EFLAGS: 00010202
[ 20.162613] RAX: ffffffff85709880 RBX: ffffffffc0079140 RCX: 0000000000000000
[ 20.164262] RDX: ffff9f73c2175700 RSI: 0000000000000000 RDI: 0000000000000000
[ 20.165934] RBP: ffff9f73c2385900 R08: ffffbbb000223d30 R09: ffff9f73ff896000
[ 20.167684] R10: 0000000000001000 R11: 0000000000000000 R12: ffffbbb000223e80
[ 20.169427] R13: 0000000000000000 R14: 0000000000000002 R15: ffff9f73c1cfaa80
[ 20.171109] FS: 00007f1ad82f55c0(0000) GS:ffff9f73fe400000(0000) knlGS:0000000000000000
[ 20.173000] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[ 20.174381] CR2: 0000000000000000 CR3: 000000003f954000 CR4: 00000000000006f0
So, what HEAD do You use? May be You have some specific config (I use x86-64 defconfig + vsock/vhost
related things) ?
Thanks, Arseniy
On 10.06.2023 03:58, Bobby Eshleman wrote:
> From: Jiang Wang <jiang.wang@bytedance.com>
>
> This patch adds tests for vsock datagram.
>
> Signed-off-by: Bobby Eshleman <bobby.eshleman@bytedance.com>
> Signed-off-by: Jiang Wang <jiang.wang@bytedance.com>
> ---
> tools/testing/vsock/util.c | 141 ++++++++++++-
> tools/testing/vsock/util.h | 6 +
> tools/testing/vsock/vsock_test.c | 432 +++++++++++++++++++++++++++++++++++++++
> 3 files changed, 578 insertions(+), 1 deletion(-)
>
> diff --git a/tools/testing/vsock/util.c b/tools/testing/vsock/util.c
> index 01b636d3039a..811e70d7cf1e 100644
> --- a/tools/testing/vsock/util.c
> +++ b/tools/testing/vsock/util.c
> @@ -99,7 +99,8 @@ static int vsock_connect(unsigned int cid, unsigned int port, int type)
> int ret;
> int fd;
>
> - control_expectln("LISTENING");
> + if (type != SOCK_DGRAM)
> + control_expectln("LISTENING");
>
> fd = socket(AF_VSOCK, type, 0);
>
> @@ -130,6 +131,11 @@ int vsock_seqpacket_connect(unsigned int cid, unsigned int port)
> return vsock_connect(cid, port, SOCK_SEQPACKET);
> }
>
> +int vsock_dgram_connect(unsigned int cid, unsigned int port)
> +{
> + return vsock_connect(cid, port, SOCK_DGRAM);
> +}
> +
> /* Listen on <cid, port> and return the first incoming connection. The remote
> * address is stored to clientaddrp. clientaddrp may be NULL.
> */
> @@ -211,6 +217,34 @@ int vsock_seqpacket_accept(unsigned int cid, unsigned int port,
> return vsock_accept(cid, port, clientaddrp, SOCK_SEQPACKET);
> }
>
> +int vsock_dgram_bind(unsigned int cid, unsigned int port)
> +{
> + union {
> + struct sockaddr sa;
> + struct sockaddr_vm svm;
> + } addr = {
> + .svm = {
> + .svm_family = AF_VSOCK,
> + .svm_port = port,
> + .svm_cid = cid,
> + },
> + };
> + int fd;
> +
> + fd = socket(AF_VSOCK, SOCK_DGRAM, 0);
> + if (fd < 0) {
> + perror("socket");
> + exit(EXIT_FAILURE);
> + }
> +
> + if (bind(fd, &addr.sa, sizeof(addr.svm)) < 0) {
> + perror("bind");
> + exit(EXIT_FAILURE);
> + }
> +
> + return fd;
> +}
> +
> /* Transmit one byte and check the return value.
> *
> * expected_ret:
> @@ -260,6 +294,57 @@ void send_byte(int fd, int expected_ret, int flags)
> }
> }
>
> +/* Transmit one byte and check the return value.
> + *
> + * expected_ret:
> + * <0 Negative errno (for testing errors)
> + * 0 End-of-file
> + * 1 Success
> + */
> +void sendto_byte(int fd, const struct sockaddr *dest_addr, int len, int expected_ret,
> + int flags)
> +{
> + const uint8_t byte = 'A';
> + ssize_t nwritten;
> +
> + timeout_begin(TIMEOUT);
> + do {
> + nwritten = sendto(fd, &byte, sizeof(byte), flags, dest_addr,
> + len);
> + timeout_check("write");
> + } while (nwritten < 0 && errno == EINTR);
> + timeout_end();
> +
> + if (expected_ret < 0) {
> + if (nwritten != -1) {
> + fprintf(stderr, "bogus sendto(2) return value %zd\n",
> + nwritten);
> + exit(EXIT_FAILURE);
> + }
> + if (errno != -expected_ret) {
> + perror("write");
> + exit(EXIT_FAILURE);
> + }
> + return;
> + }
> +
> + if (nwritten < 0) {
> + perror("write");
> + exit(EXIT_FAILURE);
> + }
> + if (nwritten == 0) {
> + if (expected_ret == 0)
> + return;
> +
> + fprintf(stderr, "unexpected EOF while sending byte\n");
> + exit(EXIT_FAILURE);
> + }
> + if (nwritten != sizeof(byte)) {
> + fprintf(stderr, "bogus sendto(2) return value %zd\n", nwritten);
> + exit(EXIT_FAILURE);
> + }
> +}
> +
> /* Receive one byte and check the return value.
> *
> * expected_ret:
> @@ -313,6 +398,60 @@ void recv_byte(int fd, int expected_ret, int flags)
> }
> }
>
> +/* Receive one byte and check the return value.
> + *
> + * expected_ret:
> + * <0 Negative errno (for testing errors)
> + * 0 End-of-file
> + * 1 Success
> + */
> +void recvfrom_byte(int fd, struct sockaddr *src_addr, socklen_t *addrlen,
> + int expected_ret, int flags)
> +{
> + uint8_t byte;
> + ssize_t nread;
> +
> + timeout_begin(TIMEOUT);
> + do {
> + nread = recvfrom(fd, &byte, sizeof(byte), flags, src_addr, addrlen);
> + timeout_check("read");
> + } while (nread < 0 && errno == EINTR);
> + timeout_end();
> +
> + if (expected_ret < 0) {
> + if (nread != -1) {
> + fprintf(stderr, "bogus recvfrom(2) return value %zd\n",
> + nread);
> + exit(EXIT_FAILURE);
> + }
> + if (errno != -expected_ret) {
> + perror("read");
> + exit(EXIT_FAILURE);
> + }
> + return;
> + }
> +
> + if (nread < 0) {
> + perror("read");
> + exit(EXIT_FAILURE);
> + }
> + if (nread == 0) {
> + if (expected_ret == 0)
> + return;
> +
> + fprintf(stderr, "unexpected EOF while receiving byte\n");
> + exit(EXIT_FAILURE);
> + }
> + if (nread != sizeof(byte)) {
> + fprintf(stderr, "bogus recvfrom(2) return value %zd\n", nread);
> + exit(EXIT_FAILURE);
> + }
> + if (byte != 'A') {
> + fprintf(stderr, "unexpected byte read %c\n", byte);
> + exit(EXIT_FAILURE);
> + }
> +}
> +
> /* Run test cases. The program terminates if a failure occurs. */
> void run_tests(const struct test_case *test_cases,
> const struct test_opts *opts)
> diff --git a/tools/testing/vsock/util.h b/tools/testing/vsock/util.h
> index fb99208a95ea..a69e128d120c 100644
> --- a/tools/testing/vsock/util.h
> +++ b/tools/testing/vsock/util.h
> @@ -37,13 +37,19 @@ void init_signals(void);
> unsigned int parse_cid(const char *str);
> int vsock_stream_connect(unsigned int cid, unsigned int port);
> int vsock_seqpacket_connect(unsigned int cid, unsigned int port);
> +int vsock_dgram_connect(unsigned int cid, unsigned int port);
> int vsock_stream_accept(unsigned int cid, unsigned int port,
> struct sockaddr_vm *clientaddrp);
> int vsock_seqpacket_accept(unsigned int cid, unsigned int port,
> struct sockaddr_vm *clientaddrp);
> +int vsock_dgram_bind(unsigned int cid, unsigned int port);
> void vsock_wait_remote_close(int fd);
> void send_byte(int fd, int expected_ret, int flags);
> +void sendto_byte(int fd, const struct sockaddr *dest_addr, int len, int expected_ret,
> + int flags);
> void recv_byte(int fd, int expected_ret, int flags);
> +void recvfrom_byte(int fd, struct sockaddr *src_addr, socklen_t *addrlen,
> + int expected_ret, int flags);
> void run_tests(const struct test_case *test_cases,
> const struct test_opts *opts);
> void list_tests(const struct test_case *test_cases);
> diff --git a/tools/testing/vsock/vsock_test.c b/tools/testing/vsock/vsock_test.c
> index ac1bd3ac1533..ded82d39ee5d 100644
> --- a/tools/testing/vsock/vsock_test.c
> +++ b/tools/testing/vsock/vsock_test.c
> @@ -1053,6 +1053,413 @@ static void test_stream_virtio_skb_merge_server(const struct test_opts *opts)
> close(fd);
> }
>
> +static void test_dgram_sendto_client(const struct test_opts *opts)
> +{
> + union {
> + struct sockaddr sa;
> + struct sockaddr_vm svm;
> + } addr = {
> + .svm = {
> + .svm_family = AF_VSOCK,
> + .svm_port = 1234,
> + .svm_cid = opts->peer_cid,
> + },
> + };
> + int fd;
> +
> + /* Wait for the server to be ready */
> + control_expectln("BIND");
> +
> + fd = socket(AF_VSOCK, SOCK_DGRAM, 0);
> + if (fd < 0) {
> + perror("socket");
> + exit(EXIT_FAILURE);
> + }
> +
> + sendto_byte(fd, &addr.sa, sizeof(addr.svm), 1, 0);
> +
> + /* Notify the server that the client has finished */
> + control_writeln("DONE");
> +
> + close(fd);
> +}
> +
> +static void test_dgram_sendto_server(const struct test_opts *opts)
> +{
> + union {
> + struct sockaddr sa;
> + struct sockaddr_vm svm;
> + } addr = {
> + .svm = {
> + .svm_family = AF_VSOCK,
> + .svm_port = 1234,
> + .svm_cid = VMADDR_CID_ANY,
> + },
> + };
> + int len = sizeof(addr.sa);
> + int fd;
> +
> + fd = socket(AF_VSOCK, SOCK_DGRAM, 0);
> + if (fd < 0) {
> + perror("socket");
> + exit(EXIT_FAILURE);
> + }
> +
> + if (bind(fd, &addr.sa, sizeof(addr.svm)) < 0) {
> + perror("bind");
> + exit(EXIT_FAILURE);
> + }
> +
> + /* Notify the client that the server is ready */
> + control_writeln("BIND");
> +
> + recvfrom_byte(fd, &addr.sa, &len, 1, 0);
> +
> + /* Wait for the client to finish */
> + control_expectln("DONE");
> +
> + close(fd);
> +}
> +
> +static void test_dgram_connect_client(const struct test_opts *opts)
> +{
> + union {
> + struct sockaddr sa;
> + struct sockaddr_vm svm;
> + } addr = {
> + .svm = {
> + .svm_family = AF_VSOCK,
> + .svm_port = 1234,
> + .svm_cid = opts->peer_cid,
> + },
> + };
> + int ret;
> + int fd;
> +
> + /* Wait for the server to be ready */
> + control_expectln("BIND");
> +
> + fd = socket(AF_VSOCK, SOCK_DGRAM, 0);
> + if (fd < 0) {
> + perror("bind");
> + exit(EXIT_FAILURE);
> + }
> +
> + ret = connect(fd, &addr.sa, sizeof(addr.svm));
> + if (ret < 0) {
> + perror("connect");
> + exit(EXIT_FAILURE);
> + }
> +
> + send_byte(fd, 1, 0);
> +
> + /* Notify the server that the client has finished */
> + control_writeln("DONE");
> +
> + close(fd);
> +}
> +
> +static void test_dgram_connect_server(const struct test_opts *opts)
> +{
> + test_dgram_sendto_server(opts);
> +}
> +
> +static void test_dgram_multiconn_sendto_client(const struct test_opts *opts)
> +{
> + union {
> + struct sockaddr sa;
> + struct sockaddr_vm svm;
> + } addr = {
> + .svm = {
> + .svm_family = AF_VSOCK,
> + .svm_port = 1234,
> + .svm_cid = opts->peer_cid,
> + },
> + };
> + int fds[MULTICONN_NFDS];
> + int i;
> +
> + /* Wait for the server to be ready */
> + control_expectln("BIND");
> +
> + for (i = 0; i < MULTICONN_NFDS; i++) {
> + fds[i] = socket(AF_VSOCK, SOCK_DGRAM, 0);
> + if (fds[i] < 0) {
> + perror("socket");
> + exit(EXIT_FAILURE);
> + }
> + }
> +
> + for (i = 0; i < MULTICONN_NFDS; i++)
> + sendto_byte(fds[i], &addr.sa, sizeof(addr.svm), 1, 0);
> +
> + /* Notify the server that the client has finished */
> + control_writeln("DONE");
> +
> + for (i = 0; i < MULTICONN_NFDS; i++)
> + close(fds[i]);
> +}
> +
> +static void test_dgram_multiconn_sendto_server(const struct test_opts *opts)
> +{
> + union {
> + struct sockaddr sa;
> + struct sockaddr_vm svm;
> + } addr = {
> + .svm = {
> + .svm_family = AF_VSOCK,
> + .svm_port = 1234,
> + .svm_cid = VMADDR_CID_ANY,
> + },
> + };
> + int len = sizeof(addr.sa);
> + int fd;
> + int i;
> +
> + fd = socket(AF_VSOCK, SOCK_DGRAM, 0);
> + if (fd < 0) {
> + perror("socket");
> + exit(EXIT_FAILURE);
> + }
> +
> + if (bind(fd, &addr.sa, sizeof(addr.svm)) < 0) {
> + perror("bind");
> + exit(EXIT_FAILURE);
> + }
> +
> + /* Notify the client that the server is ready */
> + control_writeln("BIND");
> +
> + for (i = 0; i < MULTICONN_NFDS; i++)
> + recvfrom_byte(fd, &addr.sa, &len, 1, 0);
> +
> + /* Wait for the client to finish */
> + control_expectln("DONE");
> +
> + close(fd);
> +}
> +
> +static void test_dgram_multiconn_send_client(const struct test_opts *opts)
> +{
> + int fds[MULTICONN_NFDS];
> + int i;
> +
> + /* Wait for the server to be ready */
> + control_expectln("BIND");
> +
> + for (i = 0; i < MULTICONN_NFDS; i++) {
> + fds[i] = vsock_dgram_connect(opts->peer_cid, 1234);
> + if (fds[i] < 0) {
> + perror("socket");
> + exit(EXIT_FAILURE);
> + }
> + }
> +
> + for (i = 0; i < MULTICONN_NFDS; i++)
> + send_byte(fds[i], 1, 0);
> +
> + /* Notify the server that the client has finished */
> + control_writeln("DONE");
> +
> + for (i = 0; i < MULTICONN_NFDS; i++)
> + close(fds[i]);
> +}
> +
> +static void test_dgram_multiconn_send_server(const struct test_opts *opts)
> +{
> + union {
> + struct sockaddr sa;
> + struct sockaddr_vm svm;
> + } addr = {
> + .svm = {
> + .svm_family = AF_VSOCK,
> + .svm_port = 1234,
> + .svm_cid = VMADDR_CID_ANY,
> + },
> + };
> + int fd;
> + int i;
> +
> + fd = socket(AF_VSOCK, SOCK_DGRAM, 0);
> + if (fd < 0) {
> + perror("socket");
> + exit(EXIT_FAILURE);
> + }
> +
> + if (bind(fd, &addr.sa, sizeof(addr.svm)) < 0) {
> + perror("bind");
> + exit(EXIT_FAILURE);
> + }
> +
> + /* Notify the client that the server is ready */
> + control_writeln("BIND");
> +
> + for (i = 0; i < MULTICONN_NFDS; i++)
> + recv_byte(fd, 1, 0);
> +
> + /* Wait for the client to finish */
> + control_expectln("DONE");
> +
> + close(fd);
> +}
> +
> +static void test_dgram_msg_bounds_client(const struct test_opts *opts)
> +{
> + unsigned long recv_buf_size;
> + int page_size;
> + int msg_cnt;
> + int fd;
> +
> + fd = vsock_dgram_connect(opts->peer_cid, 1234);
> + if (fd < 0) {
> + perror("connect");
> + exit(EXIT_FAILURE);
> + }
> +
> + /* Let the server know the client is ready */
> + control_writeln("CLNTREADY");
> +
> + msg_cnt = control_readulong();
> + recv_buf_size = control_readulong();
> +
> + /* Wait, until receiver sets buffer size. */
> + control_expectln("SRVREADY");
> +
> + page_size = getpagesize();
> +
> + for (int i = 0; i < msg_cnt; i++) {
> + unsigned long curr_hash;
> + ssize_t send_size;
> + size_t buf_size;
> + void *buf;
> +
> + /* Use "small" buffers and "big" buffers. */
> + if (i & 1)
> + buf_size = page_size +
> + (rand() % (MAX_MSG_SIZE - page_size));
> + else
> + buf_size = 1 + (rand() % page_size);
> +
> + buf_size = min(buf_size, recv_buf_size);
> +
> + buf = malloc(buf_size);
> +
> + if (!buf) {
> + perror("malloc");
> + exit(EXIT_FAILURE);
> + }
> +
> + memset(buf, rand() & 0xff, buf_size);
> + /* Set at least one MSG_EOR + some random. */
> +
> + send_size = send(fd, buf, buf_size, 0);
> +
> + if (send_size < 0) {
> + perror("send");
> + exit(EXIT_FAILURE);
> + }
> +
> + if (send_size != buf_size) {
> + fprintf(stderr, "Invalid send size\n");
> + exit(EXIT_FAILURE);
> + }
> +
> + /* In theory the implementation isn't required to transmit
> + * these packets in order, so we use this SYNC control message
> + * so that server and client coordinate sending and receiving
> + * one packet at a time. The client sends a packet and waits
> + * until it has been received before sending another.
> + */
> + control_writeln("PKTSENT");
> + control_expectln("PKTRECV");
> +
> + /* Send the server a hash of the packet */
> + curr_hash = hash_djb2(buf, buf_size);
> + control_writeulong(curr_hash);
> + free(buf);
> + }
> +
> + control_writeln("SENDDONE");
> + close(fd);
> +}
> +
> +static void test_dgram_msg_bounds_server(const struct test_opts *opts)
> +{
> + const unsigned long msg_cnt = 16;
> + unsigned long sock_buf_size;
> + struct msghdr msg = {0};
> + struct iovec iov = {0};
> + char buf[MAX_MSG_SIZE];
> + socklen_t len;
> + int fd;
> + int i;
> +
> + fd = vsock_dgram_bind(VMADDR_CID_ANY, 1234);
> +
> + if (fd < 0) {
> + perror("bind");
> + exit(EXIT_FAILURE);
> + }
> +
> + /* Set receive buffer to maximum */
> + sock_buf_size = -1;
> + if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF,
> + &sock_buf_size, sizeof(sock_buf_size))) {
> + perror("setsockopt(SO_RECVBUF)");
> + exit(EXIT_FAILURE);
> + }
> +
> + /* Retrieve the receive buffer size */
> + len = sizeof(sock_buf_size);
> + if (getsockopt(fd, SOL_SOCKET, SO_RCVBUF,
> + &sock_buf_size, &len)) {
> + perror("getsockopt(SO_RECVBUF)");
> + exit(EXIT_FAILURE);
> + }
> +
> + /* Client ready to receive parameters */
> + control_expectln("CLNTREADY");
> +
> + control_writeulong(msg_cnt);
> + control_writeulong(sock_buf_size);
> +
> + /* Ready to receive data. */
> + control_writeln("SRVREADY");
> +
> + iov.iov_base = buf;
> + iov.iov_len = sizeof(buf);
> + msg.msg_iov = &iov;
> + msg.msg_iovlen = 1;
> +
> + for (i = 0; i < msg_cnt; i++) {
> + unsigned long remote_hash;
> + unsigned long curr_hash;
> + ssize_t recv_size;
> +
> + control_expectln("PKTSENT");
> + recv_size = recvmsg(fd, &msg, 0);
> + control_writeln("PKTRECV");
> +
> + if (!recv_size)
> + break;
> +
> + if (recv_size < 0) {
> + perror("recvmsg");
> + exit(EXIT_FAILURE);
> + }
> +
> + curr_hash = hash_djb2(msg.msg_iov[0].iov_base, recv_size);
> + remote_hash = control_readulong();
> +
> + if (curr_hash != remote_hash) {
> + fprintf(stderr, "Message bounds broken\n");
> + exit(EXIT_FAILURE);
> + }
> + }
> +
> + close(fd);
> +}
> +
> static struct test_case test_cases[] = {
> {
> .name = "SOCK_STREAM connection reset",
> @@ -1128,6 +1535,31 @@ static struct test_case test_cases[] = {
> .run_client = test_stream_virtio_skb_merge_client,
> .run_server = test_stream_virtio_skb_merge_server,
> },
> + {
> + .name = "SOCK_DGRAM client sendto",
> + .run_client = test_dgram_sendto_client,
> + .run_server = test_dgram_sendto_server,
> + },
> + {
> + .name = "SOCK_DGRAM client connect",
> + .run_client = test_dgram_connect_client,
> + .run_server = test_dgram_connect_server,
> + },
> + {
> + .name = "SOCK_DGRAM multiple connections using sendto",
> + .run_client = test_dgram_multiconn_sendto_client,
> + .run_server = test_dgram_multiconn_sendto_server,
> + },
> + {
> + .name = "SOCK_DGRAM multiple connections using send",
> + .run_client = test_dgram_multiconn_send_client,
> + .run_server = test_dgram_multiconn_send_server,
> + },
> + {
> + .name = "SOCK_DGRAM msg bounds",
> + .run_client = test_dgram_msg_bounds_client,
> + .run_server = test_dgram_msg_bounds_server,
> + },
> {},
> };
>
>
next prev parent reply other threads:[~2023-06-11 20:55 UTC|newest]
Thread overview: 57+ messages / expand[flat|nested] mbox.gz Atom feed top
2023-06-10 0:58 [PATCH RFC net-next v4 0/8] virtio/vsock: support datagrams Bobby Eshleman
2023-06-10 0:58 ` [PATCH RFC net-next v4 1/8] vsock/dgram: generalize recvmsg and drop transport->dgram_dequeue Bobby Eshleman
2023-06-11 20:43 ` Arseniy Krasnov
2023-06-22 14:51 ` Stefano Garzarella
2023-06-22 14:51 ` Stefano Garzarella
2023-06-22 19:23 ` Arseniy Krasnov
2023-06-22 23:34 ` Bobby Eshleman
2023-06-22 23:37 ` Bobby Eshleman
2023-06-23 8:14 ` Stefano Garzarella
2023-06-23 8:14 ` Stefano Garzarella
2023-06-22 23:25 ` Bobby Eshleman
2023-06-10 0:58 ` [PATCH RFC net-next v4 2/8] vsock: refactor transport lookup code Bobby Eshleman
2023-06-22 14:57 ` Stefano Garzarella
2023-06-22 14:57 ` Stefano Garzarella
2023-06-10 0:58 ` [PATCH RFC net-next v4 3/8] vsock: support multi-transport datagrams Bobby Eshleman
2023-06-22 15:19 ` Stefano Garzarella
2023-06-22 15:19 ` Stefano Garzarella
2023-06-23 2:50 ` Bobby Eshleman
2023-06-23 2:59 ` Bobby Eshleman
2023-06-26 14:50 ` Stefano Garzarella
2023-06-26 14:50 ` Stefano Garzarella
2023-06-10 0:58 ` [PATCH RFC net-next v4 4/8] vsock: make vsock bind reusable Bobby Eshleman
2023-06-12 9:49 ` Simon Horman
2023-06-22 23:00 ` Bobby Eshleman
2023-06-22 15:25 ` Stefano Garzarella
2023-06-22 15:25 ` Stefano Garzarella
2023-06-22 23:05 ` Bobby Eshleman
2023-06-23 8:15 ` Stefano Garzarella
2023-06-23 8:15 ` Stefano Garzarella
2023-06-10 0:58 ` [PATCH RFC net-next v4 5/8] virtio/vsock: add VIRTIO_VSOCK_F_DGRAM feature bit Bobby Eshleman
2023-06-22 15:29 ` Stefano Garzarella
2023-06-22 15:29 ` Stefano Garzarella
2023-06-22 23:06 ` Bobby Eshleman
2023-06-10 0:58 ` [PATCH RFC net-next v4 6/8] virtio/vsock: support dgrams Bobby Eshleman
2023-06-11 20:49 ` Arseniy Krasnov
2023-06-22 16:09 ` Stefano Garzarella
2023-06-22 16:09 ` Stefano Garzarella
2023-06-22 18:46 ` Arseniy Krasnov
2023-06-23 4:37 ` Bobby Eshleman
2023-06-26 15:03 ` Stefano Garzarella
2023-06-26 15:03 ` Stefano Garzarella
2023-06-27 1:19 ` Bobby Eshleman
2023-06-29 12:30 ` Stefano Garzarella
2023-06-29 12:30 ` Stefano Garzarella
2023-06-22 16:31 ` Stefano Garzarella
2023-06-22 16:31 ` Stefano Garzarella
2023-06-10 0:58 ` [PATCH RFC net-next v4 7/8] vsock: Add lockless sendmsg() support Bobby Eshleman
2023-06-12 9:53 ` Simon Horman
2023-06-22 22:59 ` Bobby Eshleman
2023-06-22 16:37 ` Stefano Garzarella
2023-06-22 16:37 ` Stefano Garzarella
2023-06-22 22:57 ` Bobby Eshleman
2023-06-10 0:58 ` [PATCH RFC net-next v4 8/8] tests: add vsock dgram tests Bobby Eshleman
2023-06-11 20:54 ` Arseniy Krasnov [this message]
2023-06-22 23:16 ` Bobby Eshleman
2023-06-23 18:34 ` Arseniy Krasnov
2023-06-23 6:33 ` Bobby Eshleman
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=484c7b6f-5ce5-ce43-2dfd-0ae3063f1e47@gmail.com \
--to=oxffffaa@gmail.com \
--cc=bobby.eshleman@bytedance.com \
--cc=bpf@vger.kernel.org \
--cc=bryantan@vmware.com \
--cc=dan.carpenter@linaro.org \
--cc=davem@davemloft.net \
--cc=decui@microsoft.com \
--cc=edumazet@google.com \
--cc=haiyangz@microsoft.com \
--cc=jasowang@redhat.com \
--cc=jiang.wang@bytedance.com \
--cc=kuba@kernel.org \
--cc=kvm@vger.kernel.org \
--cc=kys@microsoft.com \
--cc=linux-hyperv@vger.kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=mst@redhat.com \
--cc=netdev@vger.kernel.org \
--cc=pabeni@redhat.com \
--cc=pv-drivers@vmware.com \
--cc=sgarzare@redhat.com \
--cc=simon.horman@corigine.com \
--cc=stefanha@redhat.com \
--cc=vdasa@vmware.com \
--cc=virtualization@lists.linux-foundation.org \
--cc=wei.liu@kernel.org \
--cc=xuanzhuo@linux.alibaba.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
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.