mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2025-01-06 12:09:26 +08:00
1368b914e9
Now that all port tests live under testsuite/sim/*/, and none live in testsuite/ directly, flatten the structure by moving all of the dirs under testsuite/sim/ to testsuite/ directly. We need to stop passing --tool to dejagnu so that it searches all dirs and not just ones that start with "sim". Since we have no other dirs in this tree, and no plans to add any, should be fine.
144 lines
2.9 KiB
C
144 lines
2.9 KiB
C
/* Check that closing a pipe with a nonempty buffer works.
|
|
#notarget: cris*-*-elf
|
|
#output: got: a\ngot: b\nexit: 0\n
|
|
*/
|
|
|
|
|
|
#include <stddef.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <limits.h>
|
|
#include <unistd.h>
|
|
#include <sched.h>
|
|
#include <signal.h>
|
|
#include <errno.h>
|
|
#include <sys/types.h>
|
|
#include <sys/wait.h>
|
|
#include <string.h>
|
|
int pip[2];
|
|
|
|
int pipemax;
|
|
|
|
int
|
|
process (void *arg)
|
|
{
|
|
char *s = arg;
|
|
int lots = pipemax + 256;
|
|
char *buf = malloc (lots);
|
|
int ret;
|
|
|
|
if (buf == NULL)
|
|
abort ();
|
|
|
|
*buf = *s;
|
|
|
|
/* The first write should go straight through. */
|
|
if (write (pip[1], buf, 1) != 1)
|
|
abort ();
|
|
|
|
*buf = s[1];
|
|
|
|
/* The second write may or may not be successful for the whole
|
|
write, but should be successful for at least the pipemax part.
|
|
As linux/limits.h clamps PIPE_BUF to 4096, but the page size is
|
|
actually 8k, we can get away with that much. There should be no
|
|
error, though. Doing this on host shows that for
|
|
x86_64-unknown-linux-gnu (2.6.14-1.1656_FC4) pipemax * 10 can be
|
|
successfully written, perhaps for similar reasons. */
|
|
ret = write (pip[1], buf, lots);
|
|
if (ret < pipemax)
|
|
{
|
|
fprintf (stderr, "ret: %d, %s, %d\n", ret, strerror (errno), pipemax);
|
|
fflush (0);
|
|
abort ();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
main (void)
|
|
{
|
|
int retcode;
|
|
int pid;
|
|
int st = 0;
|
|
long stack[16384];
|
|
char buf[1];
|
|
|
|
/* We need to turn this off because we don't want (to have to model) a
|
|
SIGPIPE resulting from the close. */
|
|
if (signal (SIGPIPE, SIG_IGN) != SIG_DFL)
|
|
abort ();
|
|
|
|
retcode = pipe (pip);
|
|
|
|
if (retcode != 0)
|
|
{
|
|
fprintf (stderr, "Bad pipe %d\n", retcode);
|
|
abort ();
|
|
}
|
|
|
|
#ifdef PIPE_MAX
|
|
pipemax = PIPE_MAX;
|
|
#else
|
|
pipemax = fpathconf (pip[1], _PC_PIPE_BUF);
|
|
#endif
|
|
|
|
if (pipemax <= 0)
|
|
{
|
|
fprintf (stderr, "Bad pipemax %d\n", pipemax);
|
|
abort ();
|
|
}
|
|
|
|
pid = clone (process, (char *) stack + sizeof (stack) - 64,
|
|
(CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND)
|
|
| SIGCHLD, "ab");
|
|
if (pid <= 0)
|
|
{
|
|
fprintf (stderr, "Bad clone %d\n", pid);
|
|
abort ();
|
|
}
|
|
|
|
while ((retcode = read (pip[0], buf, 1)) == 0)
|
|
;
|
|
|
|
if (retcode != 1)
|
|
{
|
|
fprintf (stderr, "Bad read 1: %d\n", retcode);
|
|
abort ();
|
|
}
|
|
|
|
printf ("got: %c\n", buf[0]);
|
|
|
|
/* Need to read out something from the second write too before
|
|
closing, or the writer can get EPIPE. */
|
|
while ((retcode = read (pip[0], buf, 1)) == 0)
|
|
;
|
|
|
|
if (retcode != 1)
|
|
{
|
|
fprintf (stderr, "Bad read 2: %d\n", retcode);
|
|
abort ();
|
|
}
|
|
|
|
printf ("got: %c\n", buf[0]);
|
|
|
|
if (close (pip[0]) != 0)
|
|
{
|
|
perror ("pip close");
|
|
abort ();
|
|
}
|
|
|
|
retcode = waitpid (pid, &st, __WALL);
|
|
|
|
if (retcode != pid || !WIFEXITED (st))
|
|
{
|
|
fprintf (stderr, "Bad wait %d:%d %x\n", pid, retcode, st);
|
|
perror ("errno");
|
|
abort ();
|
|
}
|
|
|
|
printf ("exit: %d\n", WEXITSTATUS (st));
|
|
return 0;
|
|
}
|