compiler/startup/detach.c

   1 /*
   2     Copyright © 1995-2012, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Common startup code
   6     Lang: english
   7
   8     Use: To make a program detach itself from the launching CLI, use
   9          detach.o as your program's start file, before any other usual start
  10          file.
  11
  12          If you want the detached process to have a name different than the
  13          detacher's one, define the following variable in your program's
  14          source code:
  15
  16              STRPTR __detached_name = "My Preferred Program Name";
  17
  18         You can also decide to control exactly when to detach your program
  19         from the shell. To do so, simply use the function
  20
  21             Detach();
  22
  23         declared in
  24
  25             <aros/detach.h>
  26
  27         when you want to detach the program. Not using this function will
  28         result in your program being detached from the shell before the main()
  29         function is reached.
  30 */
  31 #define DEBUG 0
  32
  33 #include <aros/config.h>
  34 #include <dos/dos.h>
  35 #include <dos/stdio.h>
  36 #include <proto/exec.h>
  37 #include <proto/dos.h>
  38 #include <aros/asmcall.h>
  39 #include <aros/debug.h>
  40 #include <aros/symbolsets.h>
  41 #include <aros/startup.h>
  42
  43 int             __detached_manages_detach;
  44 int             __detacher_go_away;
  45 STRPTR          __detached_name;
  46 LONG            __detached_return_value;
  47 struct Process *__detacher_process;
  48
  49 AROS_UFP3S(LONG, __detach_trampoline,
  50 AROS_UFPA(char *,argstr,A0),
  51 AROS_UFPA(ULONG,argsize,D0),
  52 AROS_UFPA(struct ExecBase *,SysBase,A6));
  53
  54 static void __startup_detach(struct ExecBase *SysBase)
  55 {
  56     struct CommandLineInterface *cli;
  57     struct Process              *newproc;
  58     BPTR                         mysegment = BNULL;
  59     STRPTR                       detached_name;
  60
  61     D(bug("Entering __startup_detach()\n"));
  62
  63     cli = Cli();
  64     /* Without a CLI detaching makes no sense, just jump to
  65        the real program.  */
  66     if (!cli)
  67     {
  68         D(bug("Wasn't started from cli.\n"));
  69         __startup_entries_next();
  70     }
  71     else
  72     {
  73         D(bug("Was started from cli.\n"));
  74         mysegment = cli->cli_Module;
  75         cli->cli_Module = BNULL;
  76         BPTR in, out;
  77
  78         detached_name = __detached_name ? __detached_name : (STRPTR) FindTask(NULL)->tc_Node.ln_Name;
  79
  80         in  = OpenFromLock(DupLockFromFH(Input()));
  81         out = OpenFromLock(DupLockFromFH(Output()));
  82         if (IsInteractive(in))
  83             SetVBuf(in, NULL, BUF_LINE, -1);
  84         if (IsInteractive(out))
  85             SetVBuf(out, NULL, BUF_LINE, -1);
  86
  87         {
  88             struct TagItem tags[] =
  89             {
  90                 { NP_Seglist,   (IPTR)mysegment            },
  91                 { NP_Entry,     (IPTR)&__detach_trampoline },
  92                 { NP_Name,      (IPTR)detached_name        },
  93                 { NP_Arguments, (IPTR)__argstr             },
  94                 { NP_Input,     (IPTR)in                   },
  95                 { NP_CloseInput,FALSE                      },
  96                 { NP_Output,    (IPTR)out                  },
  97                 { NP_CloseOutput,FALSE                     },
  98                 { NP_Cli,       TRUE                       },
  99                 { TAG_DONE,     0                          }
 100             };
 101
 102             __detacher_process = (struct Process *)FindTask(NULL);
 103
 104             /* CreateNewProc() will take care of freeing the seglist */
 105             newproc = CreateNewProc(tags);
 106         }
 107
 108         D(bug("Process \"%s\" = 0x%x.\n", detached_name, newproc));
 109         if (!newproc)
 110         {
 111             cli->cli_Module = mysegment;
 112             __detached_return_value = RETURN_ERROR;
 113         }
 114         else
 115             while (!__detacher_go_away) Wait(SIGF_SINGLE);
 116
 117         D(bug("__detached_return_value = %d.\n", __detached_return_value));
 118         if (__detached_return_value != RETURN_OK)
 119         {
 120             PutStr(FindTask(NULL)->tc_Node.ln_Name); PutStr(": Failed to detach.\n");
 121         }
 122
 123         if (newproc)
 124         {
 125             Forbid();
 126             Signal(&newproc->pr_Task, SIGF_SINGLE);
 127         }
 128
 129         __startup_error = __detached_return_value;
 130     }
 131
 132     D(bug("Leaving __startup_detach\n"));
 133 }
 134
 135 ADD2SET(__startup_detach, PROGRAM_ENTRIES, -100);
 136
 137 void __Detach(LONG retval);
 138
 139 AROS_ENTRY(LONG, __detach_trampoline,
 140     AROS_UFHA(char *,argstr,A0),
 141     AROS_UFHA(ULONG,argsize,D0),
 142     struct ExecBase *,SysBase)
 143 {
 144     AROS_USERFUNC_INIT
 145
 146     LONG retval = RETURN_OK;
 147
 148     D(bug("Entering __detach_trampoline()\n"));
 149
 150     /* We have a CLI that is not 'attached' to a Shell,
 151      * and to get WB 1.3's C:Status to list us properly,
 152      * we need to set cli_Module to something.
 153      */
 154     Cli()->cli_Module =  (BPTR)-1;
 155
 156     /* The program has two options: either take care of telling the detacher
 157        process when exactly to go away, via the Detach() function, or let this
 158        startup code take care of it. If __detached_manages_detach is TRUE, then
 159        the detached process handles it, otherwise we handle it.  */
 160
 161     if (!__detached_manages_detach)
 162        __Detach(RETURN_OK);
 163
 164     __startup_entries_next();
 165
 166     /* At this point the detacher process might still be around,
 167       If the program forgot to detach, or if it couldn't, but in any
 168       case we need to tell the detacher to go away.  */
 169     __Detach(retval);
 170
 171     D(bug("Leaving __detach_trampoline\n"));
 172
 173     return 0;
 174
 175     AROS_USERFUNC_EXIT
 176 }
 177
 178 void __Detach(LONG retval)
 179 {
 180     D(bug("Entering __Detach(%d)\n", retval));
 181
 182     if (__detacher_process != NULL)
 183     {
 184         __detached_return_value = retval;
 185         __detacher_go_away      = TRUE;
 186
 187         SetSignal(0, SIGF_SINGLE);
 188         /* Tell the detacher process it can now go away */
 189         Signal(&__detacher_process->pr_Task, SIGF_SINGLE);
 190
 191         /* Wait for it to say "goodbye" */
 192         Wait(SIGF_SINGLE);
 193         __detacher_process = NULL;
 194
 195         Close(Input());
 196         SelectInput(BNULL);
 197         Close(Output());
 198         SelectOutput(BNULL);
 199     }
 200
 201     D(bug("Leaving __Detach\n"));
 202 }