rom/dos/createnewproc.c

   1 /*
   2     Copyright © 1995-2009, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Create a new process
   6     Lang: English
   7 */
   8 #include <exec/memory.h>
   9 #include <exec/lists.h>
  10 #include <proto/exec.h>
  11 #include <dos/dosextens.h>
  12 #include <dos/filesystem.h>
  13 #include <dos/dostags.h>
  14 #include <dos/stdio.h>
  15 #define __DOS_NOLIBBASE__
  16 #include <proto/dos.h>
  17 #include <utility/tagitem.h>
  18 #include <intuition/intuition.h>
  19 #include <aros/symbolsets.h>
  20 #include <proto/utility.h>
  21 #include <proto/intuition.h>
  22 #include <proto/graphics.h>
  23 #include "dos_intern.h"
  24 #include LC_LIBDEFS_FILE
  25 #include <string.h>
  26
  27 static void KillCurrentProcess(void);
  28 struct Process *AddProcess(struct Process *process, STRPTR argPtr,
  29 ULONG argSize, APTR initialPC, APTR finalPC, struct DosLibrary *DOSBase);
  30
  31 static void freeLocalVars(struct Process *process, struct DosLibrary *DOSBase);
  32
  33 BOOL copyVars(struct Process *fromProcess, struct Process *toProcess, struct DosLibrary * DOSBase);
  34
  35 void internal_ChildWait(struct Task *task, struct DosLibrary * DOSBase);
  36 void internal_ChildFree(APTR tid, struct DosLibrary * DOSBase);
  37
  38 static VOID TrapHandler(ULONG alertNum);
  39 static LONG AskSuspend(const TEXT *taskName, ULONG alertNum);
  40
  41 #include <aros/debug.h>
  42
  43 /* Temporary macro */
  44 #define P(x)
  45 /*****************************************************************************
  46
  47     NAME */
  48 #include <proto/dos.h>
  49
  50         AROS_LH1(struct Process *, CreateNewProc,
  51
  52 /*  SYNOPSIS */
  53         AROS_LHA(struct TagItem *, tags, D1),
  54
  55 /*  LOCATION */
  56         struct DosLibrary *, DOSBase, 83, Dos)
  57
  58 /*  FUNCTION
  59         Create a new process using the tagitem array.
  60
  61     INPUTS
  62         tags - information on the new process.
  63
  64     RESULT
  65         Pointer to the new process or NULL on error.
  66
  67     NOTES
  68
  69     EXAMPLE
  70
  71     BUGS
  72
  73     SEE ALSO
  74
  75     INTERNALS
  76
  77 *****************************************************************************/
  78 {
  79     AROS_LIBFUNC_INIT
  80
  81     /* Allocated resources */
  82     struct Process              *process = NULL;
  83     BPTR                         input = 0, output = 0, ces = 0, curdir = 0, homedir = 0;
  84     STRPTR                       stack = NULL, name = NULL, argptr = NULL;
  85     ULONG                        namesize = 0, argsize = 0;
  86     struct MemList              *memlist = NULL;
  87     struct CommandLineInterface *cli = NULL;
  88     struct Process              *me = (struct Process *)FindTask(NULL);
  89     STRPTR                       s;
  90     ULONG                        old_sig;
  91
  92     /* TODO: NP_CommandName, NP_ConsoleTask, NP_NotifyOnDeath */
  93
  94 #define TAGDATA_NOT_SPECIFIED ~0ul
  95
  96     struct TagItem defaults[]=
  97     {
  98     /* 0 */    { NP_Seglist       , 0                           },
  99     /* 1 */    { NP_Entry         , (IPTR)NULL                  },
 100     /* 2 */    { NP_Input         , TAGDATA_NOT_SPECIFIED       },
 101     /* 3 */    { NP_CloseInput    , 1                           },
 102     /* 4 */    { NP_Output        , TAGDATA_NOT_SPECIFIED       },
 103     /* 5 */    { NP_CloseOutput   , 1                           },
 104     /* 6 */    { NP_Error         , TAGDATA_NOT_SPECIFIED       },
 105     /* 7 */    { NP_CloseError    , 1                           },
 106     /* 8 */    { NP_CurrentDir    , TAGDATA_NOT_SPECIFIED       },
 107     /* 9 */    { NP_StackSize     , AROS_STACKSIZE              },
 108     /*10 */    { NP_Name          , (IPTR)"New Process"         },
 109     /*11 */    { NP_Priority      , me->pr_Task.tc_Node.ln_Pri  },
 110     /*12 */    { NP_Arguments     , (IPTR)NULL                  },
 111     /*13 */    { NP_Cli           , 0                           },
 112     /*14 */    { NP_UserData      , (IPTR)NULL                  },
 113     /*15 */    { NP_ExitCode      , (IPTR)NULL                  },
 114     /*16 */    { NP_ExitData      , (IPTR)NULL                  },
 115     /*17 */    { NP_WindowPtr     , (IPTR)NULL                  }, /* Default: default public screen */
 116     /*18 */    { NP_CopyVars      , (IPTR)TRUE                  },
 117     /*19 */    { NP_Synchronous   , (IPTR)FALSE                 },
 118     /*20 */    { NP_FreeSeglist   , (IPTR)TRUE                  },
 119     /*21 */    { NP_HomeDir       , TAGDATA_NOT_SPECIFIED       },
 120     /*22 */    { NP_Path          , TAGDATA_NOT_SPECIFIED       }, /* Default: copy path from parent */
 121     /*23 */    { NP_NotifyOnDeath , (IPTR)FALSE                 },
 122                { TAG_END          , 0                           }
 123     };
 124
 125     /* C has no exceptions. This is a simple replacement. */
 126 #define ERROR_IF(a)  if(a) goto error  /* Throw a generic error. */
 127 #define ENOMEM_IF(a) if (a) goto enomem /* Throw out of memory. */
 128     /* Inherit the parent process' stacksize if possible */
 129     if (__is_process(me))
 130     {
 131         struct CommandLineInterface *cli = Cli();
 132
 133         if (cli)
 134         {
 135             LONG parentstack = cli->cli_DefaultStack * CLI_DEFAULTSTACK_UNIT;
 136
 137             if (parentstack > AROS_STACKSIZE)
 138             {
 139                 defaults[9].ti_Data = parentstack;
 140             }
 141         }
 142     }
 143
 144     ApplyTagChanges(defaults, tags);
 145
 146     /* If both the seglist and the entry are specified, make sure that the entry resides in the seglist */
 147     if (defaults[0].ti_Data && defaults[1].ti_Data)
 148     {
 149         BPTR seg;
 150
 151         for (seg = (BPTR) defaults[0].ti_Data; seg; seg = *(BPTR *)BADDR(seg))
 152         {
 153             if
 154             (
 155                 (UBYTE *)defaults[1].ti_Data >= (UBYTE *)BADDR(seg) &&
 156                 (UBYTE *)defaults[1].ti_Data <= ((UBYTE *)BADDR(seg) + *((ULONG *)BADDR(seg) - 1) - sizeof(BPTR))
 157             )
 158             {
 159                 break;
 160             }
 161         }
 162
 163         if (!seg)
 164             return NULL;
 165     }
 166
 167     process = (struct Process *)AllocMem(sizeof(struct Process),
 168                                          MEMF_PUBLIC | MEMF_CLEAR);
 169     ENOMEM_IF(process == NULL);
 170
 171     /* Do this early to ease implementation of failure code */
 172     NEWLIST((struct List *)&process->pr_LocalVars);
 173
 174     /* We need a minimum stack to handle interrupt contexts */
 175     if (defaults[9].ti_Data < AROS_STACKSIZE)
 176     {
 177         defaults[9].ti_Data = AROS_STACKSIZE;
 178     }
 179
 180     stack = AllocMem(defaults[9].ti_Data, MEMF_PUBLIC);
 181     ENOMEM_IF(stack == NULL);
 182
 183     s = (STRPTR)defaults[10].ti_Data;
 184
 185     while (*s++);
 186
 187     namesize = s - (STRPTR)defaults[10].ti_Data;
 188
 189     name = AllocMem(namesize, MEMF_PUBLIC);
 190     ENOMEM_IF(name == NULL);
 191
 192     /* NP_Arguments */
 193     s = (STRPTR)defaults[12].ti_Data;
 194
 195     if (s != NULL)
 196     {
 197         while(*s++);
 198
 199         argsize = s - (STRPTR)defaults[12].ti_Data;
 200         argptr  = (STRPTR)AllocVec(argsize, MEMF_PUBLIC);
 201         ENOMEM_IF(argptr == NULL);
 202     }
 203
 204     memlist = AllocMem(sizeof(struct MemList) + 2*sizeof(struct MemEntry),
 205                        MEMF_ANY);
 206     ENOMEM_IF(memlist == NULL);
 207
 208     /* NP_Cli */
 209     if (defaults[13].ti_Data != 0)
 210     {
 211         BPTR *oldpath = NULL;
 212
 213         /* Don't forget to pass tags to AllocDosObject() */
 214         cli = (struct CommandLineInterface *)AllocDosObject(DOS_CLI, tags);
 215         ENOMEM_IF(cli == NULL);
 216
 217         cli->cli_DefaultStack = (defaults[9].ti_Data + CLI_DEFAULTSTACK_UNIT - 1) / CLI_DEFAULTSTACK_UNIT;
 218
 219         if (__is_process(me))
 220         {
 221             struct CommandLineInterface *oldcli = Cli();
 222
 223             if (oldcli != NULL)
 224             {
 225                 LONG oldlen = AROS_BSTR_strlen(oldcli->cli_Prompt);
 226                 LONG newlen = GetTagData(ADO_PromptLen, 255, tags);
 227
 228                 oldpath = BADDR(oldcli->cli_CommandDir);
 229
 230                 CopyMem(BADDR(oldcli->cli_Prompt), BADDR(cli->cli_Prompt), (newlen<oldlen?newlen:oldlen) + 1);
 231             }
 232         }
 233
 234
 235         if (defaults[22].ti_Data != TAGDATA_NOT_SPECIFIED)
 236         {
 237             cli->cli_CommandDir = (BPTR) defaults[22].ti_Data;
 238         }
 239         else
 240         {
 241             BPTR *nextpath,
 242                  *newpath = &cli->cli_CommandDir;
 243
 244             while (oldpath != NULL)
 245             {
 246                 nextpath = AllocVec(2*sizeof(BPTR), MEMF_CLEAR);
 247                 ENOMEM_IF(nextpath == NULL);
 248
 249                 newpath[0]  = MKBADDR(nextpath);
 250                 nextpath[1] = DupLock(oldpath[1]);
 251                 ERROR_IF(!nextpath[1]);
 252
 253                 newpath = nextpath;
 254                 oldpath = BADDR(oldpath[0]);
 255             }
 256         }
 257     }
 258
 259     /* NP_Input */
 260
 261     if (defaults[2].ti_Data == TAGDATA_NOT_SPECIFIED)
 262     {
 263         if (__is_process(me))
 264         {
 265             input = Open("NIL:", MODE_OLDFILE);
 266             ERROR_IF(!input);
 267
 268             defaults[2].ti_Data = (IPTR)input;
 269         }
 270         else
 271         {
 272             defaults[2].ti_Data = 0;
 273         }
 274     }
 275
 276     /* NP_Output */
 277
 278     if (defaults[4].ti_Data == TAGDATA_NOT_SPECIFIED)
 279     {
 280         if (__is_process(me))
 281         {
 282             output = Open("NIL:", MODE_NEWFILE);
 283             ERROR_IF(!output);
 284
 285             defaults[4].ti_Data = (IPTR)output;
 286         }
 287         else
 288         {
 289             defaults[4].ti_Data = 0;
 290         }
 291     }
 292
 293     /* NP_Error */
 294
 295     if (defaults[6].ti_Data == TAGDATA_NOT_SPECIFIED)
 296     {
 297         if (__is_process(me))
 298         {
 299             ces = Open("NIL:", MODE_NEWFILE);
 300             ERROR_IF(!ces);
 301
 302             defaults[6].ti_Data = (IPTR)ces;
 303         }
 304         else
 305         {
 306             defaults[6].ti_Data = 0;
 307         }
 308     }
 309
 310     if (defaults[6].ti_Data)
 311     {
 312 /* unbuffered to conform to widespread clib behavior */
 313         SetVBuf((BPTR) defaults[6].ti_Data, NULL, BUF_NONE, -1);
 314     }
 315
 316     /* NP_CurrentDir */
 317
 318     if (defaults[8].ti_Data == TAGDATA_NOT_SPECIFIED)
 319     {
 320         if (__is_process(me) && me->pr_CurrentDir)
 321         {
 322             curdir = Lock("", SHARED_LOCK);
 323             ERROR_IF(!curdir);
 324
 325             defaults[8].ti_Data = (IPTR)curdir;
 326         }
 327         else
 328         {
 329             defaults[8].ti_Data = 0;
 330         }
 331     }
 332
 333     /* NP_HomeDir */
 334
 335     if (defaults[21].ti_Data == TAGDATA_NOT_SPECIFIED)
 336     {
 337         defaults[21].ti_Data = 0;
 338
 339         if (__is_process(me))
 340         {
 341             if (me->pr_HomeDir)
 342             {
 343                 homedir = DupLock(me->pr_HomeDir);
 344                 ERROR_IF(!homedir);
 345
 346                 defaults[21].ti_Data = (IPTR)homedir;
 347             }
 348         }
 349     }
 350
 351     CopyMem((APTR)defaults[10].ti_Data, name, namesize);
 352     CopyMem((APTR)defaults[12].ti_Data, argptr, argsize);
 353
 354     process->pr_Task.tc_Node.ln_Type = NT_PROCESS;
 355     process->pr_Task.tc_Node.ln_Name = name;
 356     process->pr_Task.tc_Node.ln_Pri = defaults[11].ti_Data;
 357     process->pr_Task.tc_TrapCode = TrapHandler;
 358     process->pr_Task.tc_SPLower = stack;
 359     process->pr_Task.tc_SPUpper = stack + defaults[9].ti_Data;
 360
 361 /*  process->pr_ReturnAddr; */
 362     NEWLIST(&process->pr_Task.tc_MemEntry);
 363
 364     memlist->ml_NumEntries = 3;
 365     memlist->ml_ME[0].me_Addr = process;
 366     memlist->ml_ME[0].me_Length = sizeof(struct Process);
 367     memlist->ml_ME[1].me_Addr = stack;
 368     memlist->ml_ME[1].me_Length = defaults[9].ti_Data;
 369     memlist->ml_ME[2].me_Addr = name;
 370     memlist->ml_ME[2].me_Length = namesize;
 371
 372     AddHead(&process->pr_Task.tc_MemEntry, &memlist->ml_Node);
 373
 374     process->pr_MsgPort.mp_Node.ln_Type = NT_MSGPORT;
 375     process->pr_MsgPort.mp_Flags = PA_SIGNAL;
 376     process->pr_MsgPort.mp_SigBit = SIGB_DOS;
 377     process->pr_MsgPort.mp_SigTask = process;
 378
 379     NEWLIST(&process->pr_MsgPort.mp_MsgList);
 380
 381     process->pr_SegList = (BPTR)defaults[0].ti_Data;
 382     process->pr_StackSize = defaults[9].ti_Data;
 383     process->pr_GlobVec = NULL;                    /* Unused BCPL crap */
 384     process->pr_StackBase = MKBADDR(process->pr_Task.tc_SPUpper);
 385     process->pr_Result2 = 0;
 386     process->pr_CurrentDir = (BPTR)defaults[8].ti_Data;
 387     process->pr_CIS = (BPTR)defaults[2].ti_Data;
 388     process->pr_COS = (BPTR)defaults[4].ti_Data;
 389     process->pr_CES = (BPTR)defaults[6].ti_Data;
 390     process->pr_Task.tc_UserData = (APTR)defaults[14].ti_Data;
 391
 392 /*  process->pr_ConsoleTask=; */
 393 /*  process->pr_FileSystemTask=; */
 394     process->pr_CLI = MKBADDR(cli);
 395
 396     /* Set the name of this program */
 397     internal_SetProgramName(cli, name, DOSBase);
 398     D(bug("Calling internal_SetProgramName() with name = %s\n", name));
 399
 400     process->pr_PktWait = NULL;
 401     process->pr_WindowPtr = (struct Window *)defaults[17].ti_Data;
 402     process->pr_HomeDir = (BPTR)defaults[21].ti_Data;
 403     process->pr_Flags = (defaults[3].ti_Data  ? PRF_CLOSEINPUT    : 0) |
 404                         (defaults[5].ti_Data  ? PRF_CLOSEOUTPUT   : 0) |
 405                         (defaults[7].ti_Data  ? PRF_CLOSEERROR    : 0) |
 406                         (defaults[13].ti_Data ? PRF_FREECLI       : 0) |
 407                         (defaults[19].ti_Data ? PRF_SYNCHRONOUS   : 0) |
 408                         (defaults[20].ti_Data ? PRF_FREESEGLIST   : 0) |
 409                         (defaults[23].ti_Data ? PRF_NOTIFYONDEATH : 0) |
 410                         PRF_FREEARGS | PRF_FREECURRDIR;
 411     process->pr_ExitCode = (APTR)defaults[15].ti_Data;
 412     process->pr_ExitData = defaults[16].ti_Data;
 413     process->pr_Arguments = argptr;
 414
 415     if ((BOOL)defaults[18].ti_Data)      /* NP_CopyVars */
 416     {
 417         BOOL res = copyVars(me, process, DOSBase);
 418
 419         ENOMEM_IF(res == FALSE);
 420     }
 421
 422     process->pr_ShellPrivate = 0;
 423
 424
 425     if (defaults[19].ti_Data)
 426     {
 427         me->pr_Flags |= PRF_WAITINGFORCHILD;
 428
 429         old_sig = SetSignal(0L, SIGF_SINGLE) & SIGF_SINGLE;
 430     }
 431
 432     /* argsize variable includes trailing 0 byte, but is supposed
 433        not to. */
 434
 435     if (argsize) argsize--;
 436
 437     if
 438     (
 439
 440         AddProcess
 441         (
 442             process, argptr, argsize,
 443             defaults[1].ti_Data ?
 444             (APTR)defaults[1].ti_Data:
 445             (APTR)((BPTR *)BADDR(defaults[0].ti_Data) + 1),
 446             KillCurrentProcess, DOSBase
 447         )
 448     )
 449     {
 450         /* NP_Synchronous */
 451         if (defaults[19].ti_Data)
 452         {
 453             P(kprintf("Calling ChildWait()\n"));
 454             internal_ChildWait(FindTask(NULL), DOSBase);
 455             P(kprintf("Returned from ChildWait()\n"));
 456         }
 457
 458         goto end;
 459     }
 460
 461     /* Fall through */
 462 enomem:
 463     if (__is_process(me))
 464     {
 465         SetIoErr(ERROR_NO_FREE_STORE);
 466     }
 467
 468     freeLocalVars(process, DOSBase);
 469
 470 error:
 471     if (cli != NULL)
 472     {
 473         FreeDosObject(DOS_CLI, cli);
 474     }
 475
 476     if (homedir != NULL)
 477     {
 478         UnLock(homedir);
 479     }
 480
 481     if (curdir != NULL)
 482     {
 483         UnLock(curdir);
 484     }
 485
 486     if (output != NULL)
 487     {
 488         Close(output);
 489     }
 490
 491     if (input != NULL)
 492     {
 493         Close(input);
 494     }
 495
 496     if (ces != NULL)
 497     {
 498         Close(ces);
 499     }
 500
 501     if (argptr != NULL)
 502     {
 503         FreeVec(argptr);
 504     }
 505
 506     if (memlist != NULL)
 507     {
 508         FreeMem(memlist, sizeof(struct MemList) + 2*sizeof(struct MemEntry));
 509     }
 510
 511     if (name != NULL)
 512     {
 513         FreeMem(name, namesize);
 514     }
 515
 516     if (stack != NULL)
 517     {
 518         FreeMem(stack, defaults[9].ti_Data);
 519     }
 520
 521     if (process != NULL)
 522     {
 523         FreeMem(process, sizeof(struct Process));
 524
 525         process = NULL;
 526     }
 527
 528 end:
 529
 530     if (defaults[19].ti_Data)
 531         SetSignal(SIGF_SINGLE, old_sig);
 532
 533     return process;
 534
 535     AROS_LIBFUNC_EXIT
 536 } /* CreateNewProc */
 537
 538
 539
 540
 541
 542 static void freeLocalVars(struct Process *process, struct DosLibrary *DOSBase)
 543 {
 544     struct LocalVar *varNode;
 545     struct Node     *tempNode;
 546
 547     ForeachNodeSafe(&process->pr_LocalVars,
 548                     varNode, tempNode)
 549     {
 550         P(kprintf("Freeing variable %s with value %s at %p\n",
 551                   varNode->lv_Node.ln_Name, varNode->lv_Value, varNode));
 552         FreeMem(varNode->lv_Value, varNode->lv_Len);
 553         Remove((struct Node *)varNode);
 554         FreeVec(varNode);
 555     }
 556 }
 557
 558
 559 void internal_ChildWait(struct Task *task, struct DosLibrary * DOSBase)
 560 {
 561     while (((struct Process *)task)->pr_Flags & PRF_WAITINGFORCHILD)
 562         Wait(SIGF_SINGLE);
 563 }
 564
 565
 566 void internal_ChildFree(APTR tid, struct DosLibrary * DOSBase)
 567 {
 568     struct Task    *task   = (struct Task *)tid;
 569     struct Process *parent = (struct Process *)(GetETask(task)->et_Parent);
 570
 571     D(bug("Awakening the parent task %p (called %s)\n", parent, parent->pr_Task.tc_Node.ln_Name));
 572
 573     parent->pr_Flags &= ~PRF_WAITINGFORCHILD;
 574     Signal(&parent->pr_Task, SIGF_SINGLE);
 575 }
 576
 577
 578 BOOL copyVars(struct Process *fromProcess, struct Process *toProcess, struct DosLibrary * DOSBase)
 579 {
 580     /* We must have variables to copy... */
 581     if (__is_process(fromProcess))
 582     {
 583         struct LocalVar *varNode;
 584         struct LocalVar *newVar;
 585
 586         /* We use the same strategy as in the ***Var() functions */
 587         ForeachNode(&fromProcess->pr_LocalVars, varNode)
 588         {
 589             LONG  copyLength = strlen(varNode->lv_Node.ln_Name) + 1 +
 590                 sizeof(struct LocalVar);
 591
 592             newVar = (struct LocalVar *)AllocVec(copyLength,
 593                                                  MEMF_PUBLIC | MEMF_CLEAR);
 594             if (newVar == NULL)
 595                 return FALSE;
 596
 597             CopyMem(varNode, newVar, copyLength);
 598             newVar->lv_Node.ln_Name = (char *)newVar +
 599                 sizeof(struct LocalVar);
 600             P(kprintf("Variable with name %s copied.\n",
 601                       newVar->lv_Node.ln_Name));
 602
 603             if (varNode->lv_Len)
 604             {
 605                 newVar->lv_Value = AllocMem(varNode->lv_Len, MEMF_PUBLIC);
 606
 607                 if (newVar->lv_Value == NULL)
 608                 {
 609                     /* Free variable node before shutting down */
 610                     FreeVec(newVar);
 611
 612                     return FALSE;
 613                 }
 614
 615                 CopyMem(varNode->lv_Value, newVar->lv_Value, varNode->lv_Len);
 616             }
 617
 618             AddTail((struct List *)&toProcess->pr_LocalVars,
 619                     (struct Node *)newVar);
 620         }
 621     }
 622
 623     return TRUE;
 624 }
 625
 626 #warning Q: Is there a better way to pass DOSBase to KillCurrentProcess ?
 627 static struct DosLibrary *DOSBase;
 628
 629 static int SetDosBase(LIBBASETYPEPTR __DOSBase)
 630 {
 631     D(bug("SetDosBase\n"));
 632     DOSBase = __DOSBase;
 633     return TRUE;
 634 }
 635
 636 /* At pri -1 so it is executed before the DosInit in dos_init.c */
 637 ADD2INITLIB(SetDosBase, -1)
 638
 639 static void KillCurrentProcess(void)
 640 {
 641     struct Process *me;
 642
 643     me = (struct Process *)FindTask(NULL);
 644
 645     /* Call user defined exit function before shutting down. */
 646     if (me->pr_ExitCode != NULL)
 647     {
 648         /*
 649            The Ralph Bebel's guru book says that pr_ExitCode
 650            is passed the process return code in D0 and pr_ExitData in D1,
 651            but the Matt Dillon's DICE C implementation of vfork shows that
 652            those parameters are passed also on the stack.
 653
 654            The AROS macros for functions with register parameters don't
 655            support both register and stack parameters at once, so we use
 656            the stack only. This oughta be fixed somehow.
 657         */
 658         me->pr_ExitCode(me->pr_Task.tc_UserData, me->pr_ExitData);
 659     }
 660
 661     P(kprintf("Deleting local variables\n"));
 662
 663     /* Clean up */
 664     freeLocalVars(me, DOSBase);
 665
 666     P(kprintf("Closing input stream\n"));
 667
 668     if (me->pr_Flags & PRF_CLOSEINPUT)
 669     {
 670         Close(me->pr_CIS);
 671     }
 672
 673     P(kprintf("Closing output stream\n"));
 674
 675     if (me->pr_Flags & PRF_CLOSEOUTPUT)
 676     {
 677         Close(me->pr_COS);
 678     }
 679
 680     P(kprintf("Closing error stream\n"));
 681
 682     if (me->pr_Flags & PRF_CLOSEERROR)
 683     {
 684         Close(me->pr_CES);
 685     }
 686
 687     P(kprintf("Freeing arguments\n"));
 688
 689     if (me->pr_Flags & PRF_FREEARGS)
 690     {
 691         FreeVec(me->pr_Arguments);
 692     }
 693
 694     P(kprintf("Unloading segment\n"));
 695
 696     if (me->pr_Flags & PRF_FREESEGLIST)
 697     {
 698         UnLoadSeg(me->pr_SegList);
 699     }
 700
 701     P(kprintf("Unlocking current dir\n"));
 702
 703     if (me->pr_Flags & PRF_FREECURRDIR)
 704     {
 705         UnLock(me->pr_CurrentDir);
 706     }
 707
 708     P(kprintf("Unlocking home dir\n"));
 709     UnLock(me->pr_HomeDir);
 710
 711     P(kprintf("Freeing cli structure\n"));
 712
 713     if (me->pr_Flags & PRF_FREECLI)
 714     {
 715         FreeDosObject(DOS_CLI, BADDR(me->pr_CLI));
 716     }
 717
 718     /* To implement NP_Synchronous and NP_NotifyOnDeath I need Child***()
 719        here */
 720
 721     // if(me->pr_Flags & PRF_NOTIFYONDEATH)
 722     //     Signal(GetETask(me)->iet_Parent, SIGF_CHILD);
 723
 724     if (me->pr_Flags & PRF_SYNCHRONOUS)
 725     {
 726         P(kprintf("Calling ChildFree()\n"));
 727
 728         // ChildStatus(me);
 729         internal_ChildFree(me, DOSBase);
 730     }
 731
 732     removefromrootnode(me, DOSBase);
 733
 734     RemTask(NULL);
 735
 736     CloseLibrary((struct Library * )DOSBase);
 737 }
 738
 739 static VOID TrapHandler(ULONG alertNum)
 740 {
 741     struct Task *task = FindTask(NULL);
 742
 743     if (AskSuspend(task->tc_Node.ln_Name, alertNum) == 1)
 744     {
 745         Wait(0);
 746     }
 747     else
 748     {
 749         ShowImminentReset();
 750         ShutdownA(SD_ACTION_COLDREBOOT);
 751     }
 752 }
 753
 754 static LONG AskSuspend(const TEXT *taskName, ULONG alertNum)
 755 {
 756     struct EasyStruct es =
 757     {
 758         sizeof (struct EasyStruct),
 759         0,
 760         "Software Failure",
 761         "%s\nProgram failed (error #%08lx).\n"
 762             "Wait for disk activity to finish.",
 763         "Suspend|Reboot"
 764     };
 765     CONST_APTR args[] = {taskName, (CONST_APTR)alertNum, NULL};
 766     LONG choice = 0;
 767
 768     es.es_TextFormat = "%s\nProgram failed (error #%08lx).\n"
 769         "Wait for disk activity to finish.";
 770     if (IntuitionBase != NULL)
 771     {
 772         if (IntuitionBase->FirstScreen != NULL)
 773         {
 774             choice = EasyRequestArgs(NULL, &es, NULL, args);
 775         }
 776     }
 777
 778     return choice;
 779 }
 780