syscalls/pipe12: add new test for pipe when write bytes > PIPE_BUF
A message that is not in the archive (sent off-list or not yet received): [email protected]
PATCH v2 1/1 syscalls/pipe12: add new test for pipe when write bytes > PIPE_BUF
A pipe has a limited capacity. If the pipe with non block mode is full, then a write(2) will fail and get EAGAIN error. Otherwise, from 1 to PIPE_BUF bytes may be written.
---------------v1->v2:
1)add missing lapi/fcntl.h
2)remove useless return
---------------
--- runtest/syscalls | 1 + testcases/kernel/syscalls/pipe/.gitignore | 1 + testcases/kernel/syscalls/pipe/pipe12.c | 106 ++++++++++++++++++++++ 3 files changed, 108 insertions(+) create mode 100644 testcases/kernel/syscalls/pipe/pipe12.c
runtest/syscalls +1 -0
@@ -861,6 +861,7 @@ pipe08 pipe08 pipe09 pipe09 pipe10 pipe10 pipe11 pipe11 +pipe12 pipe12 pipe2_01 pipe2_01 pipe2_02 pipe2_02
testcases/kernel/syscalls/pipe/.gitignore +1 -0
@@ -9,3 +9,4 @@ /pipe09 /pipe10 /pipe11 +/pipe12
testcases/kernel/syscalls/pipe/pipe12.c new file +106 -0
106 lines not on this page · raw message
Signature · 1 line
2.18.0
PATCH v2 1/1 syscalls/pipe12: add new test for pipe when write bytes > PIPE_BUF
Hi!
Quoted 18 lines
testcases/kernel/syscalls/pipe/pipe12.c new file +15
-0@@ -0,0 +1,106 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Copyright (c) 2020 FUJITSU LIMITED. All rights reserved. +* Author: Yang Xu <[email protected]> +* +* Test Description: +* A pipe has a limited capacity. If the pipe with non block mode is full, +* then a write(2) will fail and get EAGAIN error. Otherwise, from 1 to +* PIPE_BUF bytes may be written. +*/ +#define _GNU_SOURCE +#include <unistd.h> +#include <stdlib.h> +#include <fcntl.h> +#include "tst_test.h"
testcases/kernel/syscalls/pipe/pipe12.c line 25
Quoted 10 lines
testcases/kernel/syscalls/pipe/pipe12.c new file +10
-0+#include "lapi/fcntl.h" + +static int fds[2 ]; +static char *wrbuf; +static char *rdbuf; +static ssize_t max_size, invalid_size; + +static struct tcase { + int full_flag; + int need_offset;
This could be called just offset, it does not have to be boolean either, we just need to write offset bytes from a buffer before we attempt to write to the pipe.
testcases/kernel/syscalls/pipe/pipe12.c line 28
Quoted 3 lines
testcases/kernel/syscalls/pipe/pipe12.c new file +3
-0+char *message; +} tcases[] = { + {1, 0, "Test on full pipe"},
"Write to full pipe"
testcases/kernel/syscalls/pipe/pipe12.c line 29
Quoted 1 line
testcases/kernel/syscalls/pipe/pipe12.c new file +1
-0+ {0, 1, "Test on non full pipe from 1 offset"},
"Write to non-empty pipe"
testcases/kernel/syscalls/pipe/pipe12.c line 30
Quoted 1 line
testcases/kernel/syscalls/pipe/pipe12.c new file +1
-0+ {0, 0, "Test on non full pipe from 0 offset"},
"Write to empty pipe"
testcases/kernel/syscalls/pipe/pipe12.c line 43
Quoted 13 lines
testcases/kernel/syscalls/pipe/pipe12.c new file +13
-0+}; + +static void verify_pipe (unsigned int n) +{ +struct tcase *tc = &tcases[n]; + +memset (rdbuf,0 , max_size); + +tst_res (TINFO ,"%s" , tc->message); +if (tc->full_flag) { +SAFE_WRITE (1 , fds[1 ], wrbuf, max_size); +TEST (write (fds[1 ],"x" ,1 )); +if (TST_RET ==0 ) {
write is required to return -1 here which is what we have to check against i.e, TST_RET != -1 means fail
Quoted 9 lines
testcases/kernel/syscalls/pipe/pipe12.c new file +9
-0+tst_res (TFAIL ,"write succeeded unexpectedly" ); + goto clean_pipe_buf; + } +if (TST_ERR ==EAGAIN ) +tst_res (TPASS |TTERRNO ,"write failed as expected" ); +else +tst_res (TFAIL |TTERRNO ,"write failed, expected EAGAIN but got" ); + }else { +if (tc->need_offset)
testcases/kernel/syscalls/pipe/pipe12.c line 62
Quoted 10 lines
testcases/kernel/syscalls/pipe/pipe12.c new file +10
-0+SAFE_WRITE (1 , fds[1 ],"x" ,1 ); +TEST (write (fds[1 ], wrbuf, invalid_size)); +if (TST_RET ==-1 ) { +tst_res (TFAIL ,"write failed unexpectedly" ); + goto clean_pipe_buf; + } +if (TST_RET == invalid_size) +tst_res (TFAIL ,"write size %ld larger than PIPE_BUF %ld" ,TST_RET , max_size); +else +tst_res (TPASS ,"write size %ld between [1, %ld]" ,TST_RET , max_size);
Here as well, write is supposed to return the number of bytes written so in this case the TST_RET must be max_size - tcase->offset which is all we have to check for, anything else than that means failure.
Quoted 17 lines
testcases/kernel/syscalls/pipe/pipe12.c new file +17
-0+ } + +clean_pipe_buf: +SAFE_READ (0 , fds[0 ], rdbuf, max_size); +} + + +static void cleanup (void ) +{ +if (fds[0 ] >0 ) +SAFE_CLOSE (fds[0 ]); +if (fds[1 ] >0 ) +SAFE_CLOSE (fds[1 ]); +if (wrbuf) +free (wrbuf); +if (rdbuf) +free (rdbuf);
testcases/kernel/syscalls/pipe/pipe12.c line 89
Quoted 10 lines
testcases/kernel/syscalls/pipe/pipe12.c new file +10
-0+} + +static void setup (void ) +{ + +TEST (pipe (fds)); +if (TST_RET ==-1 ) { +tst_brk (TBROK |TTERRNO ,"pipe" ); +return ; + }
This is exactly what SAFE_PIPE() does.
Quoted 24 lines
testcases/kernel/syscalls/pipe/pipe12.c new file +16
-0+ max_size =SAFE_FCNTL (fds[1 ],F_GETPIPE_SZ ); + invalid_size = max_size +4096 ; + wrbuf =SAFE_MALLOC (invalid_size); + rdbuf =SAFE_MALLOC (max_size); +memset (wrbuf,'x' , invalid_size); + +SAFE_FCNTL (fds[1 ],F_SETFL ,O_NONBLOCK ); +SAFE_FCNTL (fds[0 ],F_SETFL ,O_NONBLOCK ); +} + +static struct tst_test test = { + .test = verify_pipe, + .setup = setup, + .cleanup = cleanup, + .tcnt =ARRAY_SIZE (tcases), +};Signature · 7 lines
2.18.0 -- Mailing list info: https://lists.linux.it/listinfo/ltp
Signature · 2 lines
Cyril Hrubis [email protected]
PATCH v2 1/1 syscalls/pipe12: add new test for pipe when write bytes > PIPE_BUF
Hi?
Quoted 25 lines
Hi!
Quoted 24 lines
testcases/kernel/syscalls/pipe/pipe12.c new file +21
-0@@ -0,0 +1,106 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* +* Copyright (c) 2020 FUJITSU LIMITED. All rights reserved. +* Author: Yang Xu <[email protected]> +* +* Test Description: +* A pipe has a limited capacity. If the pipe with non block mode is full, +* then a write(2) will fail and get EAGAIN error. Otherwise, from 1 to +* PIPE_BUF bytes may be written. +*/ +#define _GNU_SOURCE +#include <unistd.h> +#include <stdlib.h> +#include <fcntl.h> +#include "tst_test.h" +#include "lapi/fcntl.h" + +static int fds[2 ]; +static char *wrbuf; +static char *rdbuf; +static ssize_t max_size, invalid_size;
Quoted 8 lines
testcases/kernel/syscalls/pipe/pipe12.c line 25
Quoted 4 lines
testcases/kernel/syscalls/pipe/pipe12.c new file +4
-0+ +static struct tcase { + int full_flag; + int need_offset;This could be called just offset, it does not have to be boolean either, we just need to write offset bytes from a buffer before we attempt to write to the pipe.
OK.
Quoted 11 lines
testcases/kernel/syscalls/pipe/pipe12.c line 28
Quoted 4 lines
testcases/kernel/syscalls/pipe/pipe12.c new file +3
-0+char *message; +} tcases[] = { + {1, 0, "Test on full pipe"},"Write to full pipe"
testcases/kernel/syscalls/pipe/pipe12.c line 29
Quoted 1 line
testcases/kernel/syscalls/pipe/pipe12.c new file +1
-0+ {0, 1, "Test on non full pipe from 1 offset"},"Write to non-empty pipe"
testcases/kernel/syscalls/pipe/pipe12.c line 30
Quoted 1 line
testcases/kernel/syscalls/pipe/pipe12.c new file +1
-0+ {0, 0, "Test on non full pipe from 0 offset"},"Write to empty pipe"
testcases/kernel/syscalls/pipe/pipe12.c line 32
Quoted 2 lines
testcases/kernel/syscalls/pipe/pipe12.c new file +2
-0+}; +
OK.
Quoted 30 lines
testcases/kernel/syscalls/pipe/pipe12.c line 43
Quoted 11 lines
testcases/kernel/syscalls/pipe/pipe12.c new file +11
-0+static void verify_pipe (unsigned int n) +{ +struct tcase *tc = &tcases[n]; + +memset (rdbuf,0 , max_size); + +tst_res (TINFO ,"%s" , tc->message); +if (tc->full_flag) { +SAFE_WRITE (1 , fds[1 ], wrbuf, max_size); +TEST (write (fds[1 ],"x" ,1 )); +if (TST_RET ==0 ) {write is required to return -1 here which is what we have to check against i.e, TST_RET != -1 means failQuoted 16 lines
testcases/kernel/syscalls/pipe/pipe12.c new file +16
-0+tst_res (TFAIL ,"write succeeded unexpectedly" ); + goto clean_pipe_buf; + } +if (TST_ERR ==EAGAIN ) +tst_res (TPASS |TTERRNO ,"write failed as expected" ); +else +tst_res (TFAIL |TTERRNO ,"write failed, expected EAGAIN but got" ); + }else { +if (tc->need_offset) +SAFE_WRITE (1 , fds[1 ],"x" ,1 ); +TEST (write (fds[1 ], wrbuf, invalid_size)); +if (TST_RET ==-1 ) { +tst_res (TFAIL ,"write failed unexpectedly" ); + goto clean_pipe_buf; + } +if (TST_RET == invalid_size)
Quoted 8 lines
testcases/kernel/syscalls/pipe/pipe12.c line 62
Quoted 3 lines
testcases/kernel/syscalls/pipe/pipe12.c new file +3
-0+tst_res (TFAIL ,"write size %ld larger than PIPE_BUF %ld" ,TST_RET , max_size); + else + tst_res(TPASS, "write size %ld between [1, %ld]", TST_RET, max_size);Here as well, write is supposed to return the number of bytes written so in this case the
TST_RETmust bemax_size-tcase->offsetwhich is all we have to check for, anything else than that means failure.
I have seen pipe_write kernel code[1], it only merged small size write but not large size write(large size write will still page-align size, in other word, it uses new page). So, I think it is why man-pages said "from 1 to n bytes may be written". It may exist a hole when we use a unalign offset and the sequent align-page write. I think it is normal and don't need to mean failure. "TST_RET is max_size - tcase->offset" is ok when we use [0,N*page_size-1] [page_size,page_buf-1] write or [0,a-1] [a, page_buf-1] write.
The other reason for it I guess beacause looking for a hole may drop peformance when pipe buf is large.
Also, we can print write btyes by ioctl(fd, FIONREAD, &nbytes) command (cover this ioctl test point).
[1]https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/pipe.c#n431
Quoted 22 lines
Quoted 22 lines
testcases/kernel/syscalls/pipe/pipe12.c new file +21
-0+ } + +clean_pipe_buf: +SAFE_READ (0 , fds[0 ], rdbuf, max_size); +} + + +static void cleanup (void ) +{ +if (fds[0 ] >0 ) +SAFE_CLOSE (fds[0 ]); +if (fds[1 ] >0 ) +SAFE_CLOSE (fds[1 ]); +if (wrbuf) +free (wrbuf); +if (rdbuf) +free (rdbuf); +} + +static void setup (void ) +{
Quoted 9 lines
testcases/kernel/syscalls/pipe/pipe12.c line 89
Quoted 6 lines
testcases/kernel/syscalls/pipe/pipe12.c new file +6
-0+ +TEST (pipe (fds)); +if (TST_RET ==-1 ) { +tst_brk (TBROK |TTERRNO ,"pipe" ); +return ; + }This is exactly what
SAFE_PIPE()does.
OK.
Quoted 25 lines
Quoted 24 lines
testcases/kernel/syscalls/pipe/pipe12.c new file +16
-0+ max_size =SAFE_FCNTL (fds[1 ],F_GETPIPE_SZ ); + invalid_size = max_size +4096 ; + wrbuf =SAFE_MALLOC (invalid_size); + rdbuf =SAFE_MALLOC (max_size); +memset (wrbuf,'x' , invalid_size); + +SAFE_FCNTL (fds[1 ],F_SETFL ,O_NONBLOCK ); +SAFE_FCNTL (fds[0 ],F_SETFL ,O_NONBLOCK ); +} + +static struct tst_test test = { + .test = verify_pipe, + .setup = setup, + .cleanup = cleanup, + .tcnt =ARRAY_SIZE (tcases), +};Signature · 7 lines
2.18.0 -- Mailing list info: https://lists.linux.it/listinfo/ltp
PATCH v2 1/1 syscalls/pipe12: add new test for pipe when write bytes > PIPE_BUF
Hi!
Quoted 13 lines
Quoted 4 lines
Here as well, write is supposed to return the number of bytes written so in this case the
TST_RETmust bemax_size-tcase->offsetwhich is all we have to check for, anything else than that means failure.I have seen
pipe_writekernel code[1], it only merged small size write but not large sizewrite(large size write will still page-align size, in other word, it uses new page). So, I think it is why man-pages said "from 1 to n bytes may be written". It may exist a hole when we use a unalign offset and the sequent align-page write. I think it is normal and don't need to mean failure. "TST_RETismax_size-tcase->offset" is ok when we use [0,N*page_size-1] [page_size,page_buf-1] write or [0,a-1] [a, page_buf-1] write.
Quoted 5 lines
The other reason for it I guess beacause looking for a hole may drop peformance when pipe buf is large.
Also, we can print write btyes by
ioctl(fd, FIONREAD, &nbytes)command (cover this ioctl test point).
Okay, I see that we merge only if the write fits into the free space in the current head in the right buffer. Which means that we may write less than max pipe size if we do not write in page aligned chunks.
Signature · 2 lines
Cyril Hrubis [email protected]
PATCH v3 1/1 syscalls/pipe12: add new test for pipe when write bytes > pipe size
In reply to Cyril HrubisA pipe has a limited capacity. If the pipe with non block mode is full, then a write(2) will fail and get EAGAIN error. Otherwise, from 1 to PIPE_BUF bytes may be written.
---------------v2->v3:
1)check write return value for align page-size write 2)use ioctl(fd, FIONREAD, &nbytes)
3)use SAFE_PIPE
---------------
--- runtest/syscalls | 1 + testcases/kernel/syscalls/pipe/.gitignore | 1 + testcases/kernel/syscalls/pipe/pipe12.c | 113 ++++++++++++++++++++++ 3 files changed, 115 insertions(+) create mode 100644 testcases/kernel/syscalls/pipe/pipe12.c
runtest/syscalls +1 -0
@@ -861,6 +861,7 @@ pipe08 pipe08 pipe09 pipe09 pipe10 pipe10 pipe11 pipe11 +pipe12 pipe12 pipe2_01 pipe2_01 pipe2_02 pipe2_02
testcases/kernel/syscalls/pipe/.gitignore +1 -0
@@ -9,3 +9,4 @@ /pipe09 /pipe10 /pipe11 +/pipe12
testcases/kernel/syscalls/pipe/pipe12.c new file +113 -0
113 lines not on this page · raw message
Signature · 1 line
2.18.0