Simplify -I lines: change includes to ccan/
[ccan] / ccan / antithread / antithread.c
1 #include <stdlib.h>
2 #include <unistd.h>
3 #include <fcntl.h>
4 #include <stdbool.h>
5 #include <string.h>
6 #include <sys/mman.h>
7 #include <sys/types.h>
8 #include <sys/wait.h>
9 #include <errno.h>
10 #include <err.h>
11 #include "antithread.h"
12 #include <ccan/noerr/noerr.h>
13 #include <ccan/talloc/talloc.h>
14 #include <ccan/alloc/alloc.h>
15
16 /* FIXME: Valgrind support should be possible for some cases.  Tricky
17  * case is where another process allocates for you, but at worst we
18  * could reset what is valid and what isn't on every entry into the
19  * library or something. */
20
21 struct at_pool
22 {
23         const void *ctx;
24         void *pool;
25         unsigned long poolsize;
26         int fd;
27         int parent_rfd, parent_wfd;
28 };
29
30 struct athread
31 {
32         pid_t pid;
33         int rfd, wfd;
34 };
35
36 /* FIXME: Better locking through futexes. */
37 static void lock(int fd, unsigned long off)
38 {
39         struct flock fl;
40
41         fl.l_type = F_WRLCK;
42         fl.l_whence = SEEK_SET;
43         fl.l_start = off;
44         fl.l_len = 1;
45
46         while (fcntl(fd, F_SETLKW, &fl) < 0) {
47                 if (errno != EINTR)
48                         err(1, "Failure locking antithread file");
49         }
50 }
51
52 static void unlock(int fd, unsigned long off)
53 {
54         struct flock fl;
55         int serrno = errno;
56
57         fl.l_type = F_UNLCK;
58         fl.l_whence = SEEK_SET;
59         fl.l_start = off;
60         fl.l_len = 1;
61
62         fcntl(fd, F_SETLK, &fl);
63         errno = serrno;
64 }
65
66 static void *at_realloc(const void *parent, void *ptr, size_t size)
67 {
68         struct at_pool *p = talloc_find_parent_bytype(parent, struct at_pool);
69         /* FIXME: realloc in ccan/alloc? */
70         void *new;
71
72         lock(p->fd, 0);
73         if (size == 0) {
74                 alloc_free(p->pool, p->poolsize, ptr);
75                 new = NULL;
76         } else if (ptr == NULL) {
77                 /* FIXME: Alignment */
78                 new = alloc_get(p->pool, p->poolsize, size, 16);
79         } else {
80                 if (size <= alloc_size(p->pool, p->poolsize, ptr))
81                         new = ptr;
82                 else {
83                         new = alloc_get(p->pool, p->poolsize, size, 16);
84                         if (new) {
85                                 memcpy(new, ptr,
86                                        alloc_size(p->pool, p->poolsize, ptr));
87                                 alloc_free(p->pool, p->poolsize, ptr);
88                         }
89                 }
90         }
91         unlock(p->fd, 0);
92         return new;
93 }
94
95 /* We add 16MB to size.  This compensates for address randomization. */
96 #define PADDING (16 * 1024 * 1024)
97
98 /* Create a new sharable pool. */
99 struct at_pool *at_pool(unsigned long size)
100 {
101         int fd;
102         struct at_pool *p;
103         FILE *f;
104
105         /* FIXME: How much should we actually add for overhead?. */
106         size += 32 * getpagesize();
107
108         /* Round up to whole pages. */
109         size = (size + getpagesize()-1) & ~(getpagesize()-1);
110
111         f = tmpfile();
112         if (!f)
113                 return NULL;
114
115         fd = dup(fileno(f));
116         fclose_noerr(f);
117
118         if (fd < 0)
119                 return NULL;
120
121         if (ftruncate(fd, size + PADDING) != 0)
122                 goto fail_close;
123
124         p = talloc(NULL, struct at_pool);
125         if (!p)
126                 goto fail_close;
127
128         /* First map gets a nice big area. */
129         p->pool = mmap(NULL, size+PADDING, PROT_READ|PROT_WRITE, MAP_SHARED, fd,
130                        0);
131         if (p->pool == MAP_FAILED)
132                 goto fail_free;
133
134         /* Then we remap into the middle of it. */
135         munmap(p->pool, size+PADDING);
136         p->pool = mmap(p->pool + PADDING/2, size, PROT_READ|PROT_WRITE,
137                        MAP_SHARED, fd, 0);
138         if (p->pool == MAP_FAILED)
139                 goto fail_free;
140
141         /* FIXME: Destructor? */
142         p->fd = fd;
143         p->poolsize = size;
144         p->parent_rfd = p->parent_wfd = -1;
145         alloc_init(p->pool, p->poolsize);
146
147         p->ctx = talloc_add_external(p, at_realloc);
148         if (!p->ctx)
149                 goto fail_unmap;
150
151         return p;
152
153 fail_unmap:
154         munmap(p->pool, size);
155 fail_free:
156         talloc_free(p);
157 fail_close:
158         close_noerr(fd);
159         return NULL;
160 }
161
162 /* Talloc off this to allocate from within the pool. */
163 const void *at_pool_ctx(struct at_pool *atp)
164 {
165         return atp->ctx;
166 }
167
168 static int cant_destroy_self(struct athread *at)
169 {
170         /* Perhaps this means we want to detach, but it doesn't really
171          * make sense. */
172         abort();
173         return 0;
174 }
175
176 static int destroy_at(struct athread *at)
177 {
178         /* If it is already a zombie, this is harmless. */
179         kill(at->pid, SIGTERM);
180
181         close(at->rfd);
182         close(at->wfd);
183
184         /* FIXME: Should we do SIGKILL if process doesn't exit soon? */
185         if (waitpid(at->pid, NULL, 0) != at->pid)
186                 err(1, "Waiting for athread %p (pid %u)", at, at->pid);
187
188         return 0;
189 }
190
191 /* Sets up thread and forks it.  NULL on error. */
192 static struct athread *fork_thread(struct at_pool *pool)
193 {
194         int p2c[2], c2p[2];
195         struct athread *at;
196
197         /* You can't already be a child of this pool. */
198         if (pool->parent_rfd != -1)
199                 errx(1, "Can't create antithread on this pool: we're one");
200
201         /* We don't want this allocated *in* the pool. */
202         at = talloc_steal(pool, talloc(NULL, struct athread));
203
204         if (pipe(p2c) != 0)
205                 goto free;
206
207         if (pipe(c2p) != 0)
208                 goto close_p2c;
209
210         at->pid = fork();
211         if (at->pid == -1)
212                 goto close_c2p;
213
214         if (at->pid == 0) {
215                 /* Child */
216                 close(c2p[0]);
217                 close(p2c[1]);
218                 pool->parent_rfd = p2c[0];
219                 pool->parent_wfd = c2p[1];
220                 talloc_set_destructor(at, cant_destroy_self);
221         } else {
222                 /* Parent */
223                 close(c2p[1]);
224                 close(p2c[0]);
225                 at->rfd = c2p[0];
226                 at->wfd = p2c[1];
227                 talloc_set_destructor(at, destroy_at);
228         }
229
230         return at;
231 close_c2p:
232         close_noerr(c2p[0]);
233         close_noerr(c2p[1]);
234 close_p2c:
235         close_noerr(p2c[0]);
236         close_noerr(p2c[1]);
237 free:
238         talloc_free(at);
239         return NULL;
240 }
241
242 /* Creating an antithread via fork() */
243 struct athread *_at_run(struct at_pool *pool,
244                         void *(*fn)(struct at_pool *, void *),
245                         void *obj)
246 {
247         struct athread *at;
248
249         at = fork_thread(pool);
250         if (!at)
251                 return NULL;
252
253         if (at->pid == 0) {
254                 /* Child */
255                 at_tell_parent(pool, fn(pool, obj));
256                 exit(0);
257         }
258         /* Parent */
259         return at;
260 }
261
262 static unsigned int num_args(char *const argv[])
263 {
264         unsigned int i;
265
266         for (i = 0; argv[i]; i++);
267         return i;
268 }
269
270 /* Fork and execvp, with added arguments for child to grab. */
271 struct athread *at_spawn(struct at_pool *pool, void *arg, char *cmdline[])
272 {
273         struct athread *at;
274         int err;
275
276         at = fork_thread(pool);
277         if (!at)
278                 return NULL;
279
280         if (at->pid == 0) {
281                 /* child */
282                 char *argv[num_args(cmdline) + 2];
283                 argv[0] = cmdline[0];
284                 argv[1] = talloc_asprintf(NULL, "AT:%p/%lu/%i/%i/%i/%p",
285                                           pool->pool, pool->poolsize,
286                                           pool->fd, pool->parent_rfd,
287                                           pool->parent_wfd, arg);
288                 /* Copy including NULL terminator. */
289                 memcpy(&argv[2], &cmdline[1], num_args(cmdline)*sizeof(char *));
290                 execvp(argv[0], argv);
291
292                 err = errno;
293                 write(pool->parent_wfd, &err, sizeof(err));
294                 exit(1);
295         }
296
297         /* Child should always write an error code (or 0). */
298         if (read(at->rfd, &err, sizeof(err)) != sizeof(err)) {
299                 errno = ECHILD;
300                 talloc_free(at);
301                 return NULL;
302         }
303         if (err != 0) {
304                 errno = err;
305                 talloc_free(at);
306                 return NULL;
307         }
308         return at;
309 }
310
311 /* The fd to poll on */
312 int at_fd(struct athread *at)
313 {
314         return at->rfd;
315 }
316
317 /* What's the antithread saying?  Blocks if fd not ready. */
318 void *at_read(struct athread *at)
319 {
320         void *ret;
321
322         switch (read(at->rfd, &ret, sizeof(ret))) {
323         case -1:
324                 err(1, "Reading from athread %p (pid %u)", at, at->pid);
325         case 0:
326                 /* Thread died. */
327                 return NULL;
328         case sizeof(ret):
329                 return ret;
330         default:
331                 /* Should never happen. */
332                 err(1, "Short read from athread %p (pid %u)", at, at->pid);
333         }
334 }
335
336 /* Say something to a child. */
337 void at_tell(struct athread *at, const void *status)
338 {
339         if (write(at->wfd, &status, sizeof(status)) != sizeof(status))
340                 err(1, "Failure writing to athread %p (pid %u)", at, at->pid);
341 }
342
343 /* For child to grab arguments from command line (removes them) */
344 struct at_pool *at_get_pool(int *argc, char *argv[], void **arg)
345 {
346         struct at_pool *p = talloc(NULL, struct at_pool);
347         void *map;
348         int err;
349
350         if (!argv[1]) {
351                 errno = EINVAL;
352                 goto fail;
353         }
354
355         /* If they don't care, use dummy value. */
356         if (arg == NULL)
357                 arg = &map;
358
359         if (sscanf(argv[1], "AT:%p/%lu/%i/%i/%i/%p", 
360                    &p->pool, &p->poolsize, &p->fd,
361                    &p->parent_rfd, &p->parent_wfd, arg) != 6) {
362                 errno = EINVAL;
363                 goto fail;
364         }
365
366         /* FIXME: To try to adjust for address space randomization, we
367          * could re-exec a few times. */
368         map = mmap(p->pool, p->poolsize, PROT_READ|PROT_WRITE, MAP_SHARED,
369                    p->fd, 0);
370         if (map != p->pool) {
371                 fprintf(stderr, "Mapping %lu bytes @%p gave %p\n",
372                         p->poolsize, p->pool, map);
373                 errno = ENOMEM;
374                 goto fail;
375         }
376
377         p->ctx = talloc_add_external(p, at_realloc);
378         if (!p->ctx)
379                 goto fail;
380
381         /* Tell parent we're good. */
382         err = 0;
383         if (write(p->parent_wfd, &err, sizeof(err)) != sizeof(err)) {
384                 errno = EBADF;
385                 goto fail;
386         }
387
388         /* Delete AT arg. */
389         memmove(&argv[1], &argv[2], --(*argc));
390         return p;
391
392 fail:
393         /* FIXME: cleanup properly. */
394         talloc_free(p);
395         return NULL;
396 }
397
398 /* Say something to our parent (async). */
399 void at_tell_parent(struct at_pool *pool, const void *status)
400 {
401         if (pool->parent_wfd == -1)
402                 errx(1, "This process is not an antithread of this pool");
403
404         if (write(pool->parent_wfd, &status, sizeof(status)) != sizeof(status))
405                 err(1, "Failure writing to parent");
406 }
407
408 /* What's the parent saying?  Blocks if fd not ready. */
409 void *at_read_parent(struct at_pool *pool)
410 {
411         void *ret;
412
413         if (pool->parent_rfd == -1)
414                 errx(1, "This process is not an antithread of this pool");
415
416         switch (read(pool->parent_rfd, &ret, sizeof(ret))) {
417         case -1:
418                 err(1, "Reading from parent");
419         case 0:
420                 /* Parent died. */
421                 return NULL;
422         case sizeof(ret):
423                 return ret;
424         default:
425                 /* Should never happen. */
426                 err(1, "Short read from parent");
427         }
428 }
429
430 /* The fd to poll on */
431 int at_parent_fd(struct at_pool *pool)
432 {
433         if (pool->parent_rfd == -1)
434                 errx(1, "This process is not an antithread of this pool");
435
436         return pool->parent_rfd;
437 }
438
439 /* FIXME: Futexme. */
440 void at_lock(void *obj)
441 {
442         struct at_pool *p = talloc_find_parent_bytype(obj, struct at_pool);
443 #if 0
444         unsigned int *l;
445
446         /* This isn't required yet, but ensures it's a talloc ptr */
447         l = talloc_lock_ptr(obj);
448 #endif
449
450         lock(p->fd, (char *)obj - (char *)p->pool);
451
452 #if 0
453         if (*l)
454                 errx(1, "Object %p was already locked (something died?)", obj);
455         *l = 1;
456 #endif
457 }
458
459 void at_unlock(void *obj)
460 {
461         struct at_pool *p = talloc_find_parent_bytype(obj, struct at_pool);
462 #if 0
463         unsigned int *l;
464
465         l = talloc_lock_ptr(obj);
466         if (!*l)
467                 errx(1, "Object %p was already unlocked", obj);
468         *l = 0;
469 #endif
470         unlock(p->fd, (char *)obj - (char *)p->pool);
471 }
472
473 void at_lock_all(struct at_pool *p)
474 {
475         lock(p->fd, 0);
476 }
477         
478 void at_unlock_all(struct at_pool *p)
479 {
480         unlock(p->fd, 0);
481 }