rom/dos/createnewproc.c

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