1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
/* 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;
}
|
