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