compiler/clib/__vfork.c

   1 /*
   2     Copyright © 2008-2012, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <proto/exec.h>
   7 #include <proto/dos.h>
   8 #include <exec/exec.h>
   9 #include <exec/tasks.h>
  10 #include <dos/dos.h>
  11 #include <aros/cpu.h>
  12
  13 #include <sys/types.h>
  14 #include <unistd.h>
  15 #include <setjmp.h>
  16 #include <errno.h>
  17 #include <assert.h>
  18 #include <stdlib.h>
  19 #include <stdio.h>
  20
  21 #include "__arosc_privdata.h"
  22 #include "__fdesc.h"
  23 #include "__vfork.h"
  24 #include "__exec.h"
  25
  26 #define DEBUG 0
  27
  28 #include <aros/debug.h>
  29 #include <aros/startup.h>
  30
  31 /* The following functions are used to update the childs and parents privdata
  32    for the parent pretending to be running as child and for the child to take over. It is called
  33    in the following sequence:
  34    parent_enterpretendchild() is called in vfork so the parent pretends to be running as child
  35    child_takeover() is called by child if exec*() so it can continue from the parent state
  36    parent_leavepretendchild() is called by parent to switch back to be running as parent
  37 */
  38 static void parent_enterpretendchild(struct vfork_data *udata);
  39 static void child_takeover(struct vfork_data *udata);
  40 static void parent_leavepretendchild(struct vfork_data *udata);
  41
  42 LONG launcher()
  43 {
  44     D(bug("launcher: Entered child launcher, ThisTask=%p\n", SysBase->ThisTask));
  45
  46     struct Task *this = FindTask(NULL);
  47     struct vfork_data *udata = this->tc_UserData;
  48     BYTE child_signal;
  49     struct aroscbase *aroscbase = NULL, *pbase = udata->parent_aroscbase;
  50
  51     /* Allocate signal for parent->child communication */
  52     child_signal = udata->child_signal = AllocSignal(-1);
  53     D(bug("launcher: Allocated child signal: %d\n", udata->child_signal));
  54     if(udata->child_signal == -1)
  55     {
  56         /* Lie */
  57         udata->child_errno = ENOMEM;
  58         Signal(udata->parent, 1 << udata->parent_signal);
  59         return -1;
  60     }
  61
  62     if(__register_init_fdarray(pbase))
  63         aroscbase = (struct aroscbase *)OpenLibrary((STRPTR) "arosc.library", 0);
  64     if(!aroscbase)
  65     {
  66         FreeSignal(child_signal);
  67         udata->child_errno = ENOMEM;
  68         Signal(udata->parent, 1 << udata->parent_signal);
  69         return -1;
  70     }
  71     D(bug("launcher: Opened aroscbase: %x\n", aroscbase));
  72
  73     aroscbase->acb_flags |= VFORK_PARENT;
  74
  75     udata->child_aroscbase = aroscbase;
  76     aroscbase->acb_parent_does_upath = pbase->acb_doupath;
  77
  78     if(setjmp(udata->child_exitjmp) == 0)
  79     {
  80         __arosc_program_startup(udata->child_exitjmp, &udata->child_error);
  81
  82         /* Setup complete, signal parent */
  83         D(bug("launcher: Signaling parent that we finished setup\n"));
  84         Signal(udata->parent, 1 << udata->parent_signal);
  85
  86         D(bug("launcher: Child waiting for exec or exit\n"));
  87         Wait(1 << udata->child_signal);
  88
  89         if(udata->child_executed)
  90         {
  91             APTR exec_id;
  92
  93             D(bug("launcher: child executed\n"));
  94
  95             child_takeover(udata);
  96
  97             /* Filenames passed from parent obey parent's acb_doupath */
  98
  99             aroscbase->acb_doupath = udata->child_aroscbase->acb_parent_does_upath;
 100             D(bug("launcher: acb_doupath == %d for __exec_prepare()\n", aroscbase->acb_doupath));
 101
 102             exec_id = udata->exec_id = __exec_prepare(
 103                 udata->exec_filename,
 104                 0,
 105                 udata->exec_argv,
 106                 udata->exec_envp
 107             );
 108
 109             /* Reset handling of upath */
 110             aroscbase->acb_doupath = 0;
 111             udata->child_errno = errno;
 112
 113             D(bug("launcher: informing parent that we have run __exec_prepare\n"));
 114             /* Inform parent that we have run __exec_prepare */
 115             Signal(udata->parent, 1 << udata->parent_signal);
 116
 117             /* Wait 'till __exec_do() is called on parent process */
 118             D(bug("launcher: Waiting parent to get the result\n"));
 119             Wait(1 << udata->child_signal);
 120
 121             D(bug("launcher: informing parent that we won't use udata anymore\n"));
 122             /* Inform parent that we won't use udata anymore */
 123             Signal(udata->parent, 1 << udata->parent_signal);
 124
 125             if (exec_id)
 126             {
 127                 D(bug("launcher: executing command\n"));
 128                 __exec_do(exec_id);
 129
 130                 assert(0); /* Should not be reached */
 131             }
 132             else
 133             {
 134                 D(bug("launcher: exit because execve returned with an error\n"));
 135                 _exit(0);
 136             }
 137         }
 138         else /* !udata->child_executed */
 139         {
 140             D(bug("launcher: child not executed\n"));
 141
 142             D(bug("launcher: informing parent that we won't use udata anymore\n"));
 143             /* Inform parent that we won't use udata anymore */
 144             Signal(udata->parent, 1 << udata->parent_signal);
 145         }
 146     }
 147     else
 148     {
 149         D(bug("launcher: freeing child_signal\n"));
 150         FreeSignal(child_signal);
 151     }
 152
 153     CloseLibrary((struct Library *)aroscbase);
 154
 155     D(bug("Child Done\n"));
 156
 157     return 0;
 158 }
 159
 160 /* This can be good for debugging */
 161 #ifdef __arm__
 162 #define SP 8
 163 #define ALT 27
 164 #endif
 165
 166 #ifndef SP
 167 #define SP  _JMPLEN - 1
 168 #define ALT _JMPLEN - 1
 169 #endif
 170
 171 pid_t __vfork(jmp_buf env)
 172 {
 173     struct aroscbase *aroscbase = __aros_getbase_aroscbase();
 174     struct Task *this = FindTask(NULL);
 175     struct ETask *etask = NULL;
 176     struct vfork_data *udata = AllocMem(sizeof(struct vfork_data), MEMF_ANY | MEMF_CLEAR);
 177     if(udata == NULL)
 178     {
 179         errno = ENOMEM;
 180         vfork_longjmp(env, -1);
 181     }
 182     D(bug("__vfork: Parent: allocated udata %p, jmp_buf %p\n", udata, udata->vfork_jmp));
 183     *udata->vfork_jmp = *env;
 184
 185     struct TagItem tags[] =
 186     {
 187         { NP_Entry,         (IPTR) launcher  },
 188         { NP_CloseInput,    (IPTR) FALSE     },
 189         { NP_CloseOutput,   (IPTR) FALSE     },
 190         { NP_CloseError,    (IPTR) FALSE     },
 191         { NP_Cli,           (IPTR) TRUE      },
 192         { NP_Name,          (IPTR) "vfork()" },
 193         { NP_UserData,      (IPTR) udata     },
 194         { NP_NotifyOnDeath, (IPTR) TRUE      },
 195         { TAG_DONE,         0                }
 196     };
 197
 198     D(bug("__vfork: Parent: initial jmp_buf %p\n", env));
 199     D(bug("__vfork: Parent: ip: %p, stack: %p, alt: 0x%p\n", env->retaddr, env->regs[SP], env->regs[ALT]));
 200     D(bug("__vfork: Parent: Current altstack 0x%p\n", *((void **)this->tc_SPLower)));
 201     D(hexdump(env, 0, sizeof(jmp_buf) + sizeof(void *) * 4));
 202
 203     udata->parent = this;
 204     udata->prev = aroscbase->acb_vfork_data;
 205
 206     D(bug("__vfork: Parent: Saved old parent's vfork_data: %p\n", udata->prev));
 207     udata->parent_aroscbase = aroscbase;
 208
 209     D(bug("__vfork: Parent: Allocating parent signal\n"));
 210     /* Allocate signal for child->parent communication */
 211     udata->parent_signal = AllocSignal(-1);
 212     if(udata->parent_signal == -1)
 213     {
 214         /* Couldn't allocate the signal, return -1 */
 215         FreeMem(udata, sizeof(struct vfork_data));
 216         errno = ENOMEM;
 217         vfork_longjmp(env, -1);
 218     }
 219
 220     D(bug("__vfork: Parent: Creating child\n"));
 221     udata->child = (struct Task*) CreateNewProc(tags);
 222
 223     if(udata->child == NULL)
 224     {
 225         /* Something went wrong, return -1 */
 226         FreeMem(udata, sizeof(struct vfork_data));
 227         errno = ENOMEM; /* Most likely */
 228         vfork_longjmp(env, -1);
 229     }
 230     D(bug("__vfork: Parent: Child created %p, waiting to finish setup\n", udata->child));
 231     udata->child_id = GetETaskID(udata->child);
 232     D(bug("__vfork: Parent: Got unique child id: %d\n", udata->child_id));
 233
 234     /* Wait for child to finish setup */
 235     Wait(1 << udata->parent_signal);
 236
 237     if(udata->child_errno)
 238     {
 239         /* An error occured during child setup */
 240         errno = udata->child_errno;
 241         vfork_longjmp(env, -1);
 242     }
 243
 244     D(bug("__vfork: Parent: Setting jmp_buf at %p\n", udata->parent_newexitjmp));
 245     if(setjmp(udata->parent_newexitjmp) == 0)
 246     {
 247         udata->parent_olderrorptr = __arosc_set_errorptr(&udata->child_error);
 248         udata->child_error = *udata->parent_olderrorptr;
 249         __arosc_set_exitjmp(udata->parent_newexitjmp, udata->parent_oldexitjmp);
 250
 251         parent_enterpretendchild(udata);
 252
 253         D(bug("__vfork: Child %d jumping to jmp_buf %p\n", udata->child_id, &udata->vfork_jmp));
 254         D(bug("__vfork: ip: %p, stack: %p alt: %p\n", udata->vfork_jmp[0].retaddr, udata->vfork_jmp[0].regs[SP],
 255               udata->vfork_jmp[0].regs[ALT]));
 256
 257         vfork_longjmp(udata->vfork_jmp, 0);
 258         assert(0); /* not reached */
 259         return (pid_t) 0;
 260     }
 261     else /* setjmp() != 0; so child has exited() */
 262     {
 263         D(bug("__vfork: Child: child exiting\n or executed\n"));
 264
 265         /* Stack may have been overwritten when we return here,
 266          * we jump to here from a function lower in the call chain
 267          */
 268         aroscbase = __aros_getbase_aroscbase();
 269         udata = aroscbase->acb_vfork_data;
 270
 271         D(bug("__vfork: Child: acb_vfork_data = %x\n", udata));
 272
 273         if(!udata->child_executed)
 274         {
 275             D(bug("__vfork: Child: not executed\n"));
 276
 277             /* et_Result is normally set in startup code but no exec was performed
 278                so we have to mimic the startup code
 279             */
 280             etask = GetETask(udata->child);
 281             if (etask)
 282                 etask->et_Result1 = udata->child_error;
 283
 284             D(bug("__vfork: Child: Signaling child %p, signal %d\n", udata->child, udata->child_signal));
 285             Signal(udata->child, 1 << udata->child_signal);
 286         }
 287
 288         D(bug("__vfork: Parent: Waiting for child to finish using udata, me=%p, signal %d\n", FindTask(NULL), udata->parent_signal));
 289         /* Wait for child to finish using udata */
 290         Wait(1 << udata->parent_signal);
 291
 292         D(bug("__vfork: Parent: fflushing\n"));
 293         fflush(NULL);
 294
 295         D(bug("__vfork: Parent: restoring startup buffer\n"));
 296         /* Restore parent startup buffer */
 297         jmp_buf dummy;
 298         __arosc_set_exitjmp(udata->parent_oldexitjmp, dummy);
 299
 300         D(bug("__vfork: Parent: freeing parent signal\n"));
 301         FreeSignal(udata->parent_signal);
 302
 303         errno = udata->child_errno;
 304
 305         parent_leavepretendchild(udata);
 306
 307         /* Save some data from udata before udata is being freed */
 308         ULONG child_id = udata->child_id;
 309         jmp_buf env; *env = *udata->vfork_jmp;
 310
 311         D(bug("__vfork: Parent: freeing udata\n"));
 312         FreeMem(udata, sizeof(struct vfork_data));
 313
 314         D(bug("__vfork: Parent jumping to jmp_buf %p (child=%d)\n", env, child_id));
 315         D(bug("__vfork: ip: %p, stack: %p\n", env->retaddr, env->regs[SP]));
 316         vfork_longjmp(env, child_id);
 317         assert(0); /* not reached */
 318         return (pid_t) 1;
 319     }
 320 }
 321
 322
 323 static void parent_enterpretendchild(struct vfork_data *udata)
 324 {
 325     struct aroscbase *aroscbase = __aros_getbase_aroscbase();
 326     D(bug("parent_enterpretendchild(%x): entered\n", udata));
 327
 328     aroscbase->acb_vfork_data = udata;
 329
 330     /* Remember and switch malloc mempool */
 331     udata->parent_mempool = aroscbase->acb_mempool;
 332     aroscbase->acb_mempool = udata->child_aroscbase->acb_mempool;
 333
 334     /* Remember and switch env var list */
 335     udata->parent_env_list = aroscbase->acb_env_list;
 336     aroscbase->acb_env_list = udata->child_aroscbase->acb_env_list;
 337
 338     /* Remember and switch fd descriptor table */
 339     udata->parent_internalpool = aroscbase->acb_internalpool;
 340     aroscbase->acb_internalpool = udata->child_aroscbase->acb_internalpool;
 341     __getfdarray((APTR *)&udata->parent_fd_array, &udata->parent_numslots);
 342     __setfdarraybase(udata->child_aroscbase);
 343
 344     /* Remember and switch chdir fields */
 345     udata->parent_cd_changed = aroscbase->acb_cd_changed;
 346     aroscbase->acb_cd_changed = udata->child_aroscbase->acb_cd_changed;
 347     udata->parent_cd_lock = aroscbase->acb_cd_lock;
 348     aroscbase->acb_cd_lock = udata->child_aroscbase->acb_cd_lock;
 349     udata->parent_curdir = CurrentDir(((struct Process *)udata->child)->pr_CurrentDir);
 350
 351     /* Pretend to be running as the child created by vfork */
 352     aroscbase->acb_flags |= PRETEND_CHILD;
 353
 354     D(bug("parent_enterpretendchild: leaving\n"));
 355 }
 356
 357 static void child_takeover(struct vfork_data *udata)
 358 {
 359     struct aroscbase *aroscbase = __aros_getbase_aroscbase();
 360     D(bug("child_takeover(%x): entered\n", udata));
 361
 362     /* Set current dir to parent's current dir */
 363     aroscbase->acb_cd_changed = udata->parent_aroscbase->acb_cd_changed;
 364     aroscbase->acb_cd_lock = udata->parent_aroscbase->acb_cd_lock;
 365     CurrentDir(((struct Process *)udata->parent)->pr_CurrentDir);
 366
 367     D(bug("child_takeover(): leaving\n"));
 368 }
 369
 370 static void parent_leavepretendchild(struct vfork_data *udata)
 371 {
 372     struct aroscbase *aroscbase = __aros_getbase_aroscbase();
 373     D(bug("parent_leavepretendchild(%x): entered\n", udata));
 374
 375     /* Restore parent's malloc mempool */
 376     aroscbase->acb_mempool = udata->parent_mempool;
 377
 378     /* Restore parent's env var list */
 379     aroscbase->acb_env_list = udata->parent_env_list;
 380
 381     /* Restore parent's old fd_array */
 382     aroscbase->acb_internalpool = udata->parent_internalpool;
 383     __setfdarray(udata->parent_fd_array, udata->parent_numslots);
 384
 385     /* Switch to currentdir from before vfork() call */
 386     aroscbase->acb_cd_changed = udata->parent_cd_changed;
 387     aroscbase->acb_cd_lock = udata->parent_cd_lock;
 388     CurrentDir(udata->parent_curdir);
 389
 390     /* Switch to previous vfork_data */
 391     aroscbase->acb_vfork_data = udata->prev;
 392     if(aroscbase->acb_vfork_data == NULL)
 393         aroscbase->acb_flags &= ~PRETEND_CHILD;
 394
 395     D(bug("parent_leavepretendchild: leaving\n"));
 396 }