rom/dos/createnewproc.c

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