compiler/startup/detach.c

   1 /*
   2     Copyright © 1995-2009, 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 <proto/exec.h>
  36 #include <proto/dos.h>
  37 #include <aros/asmcall.h>
  38 #include <aros/debug.h>
  39 #include <aros/symbolsets.h>
  40 #include <aros/startup.h>
  41
  42 int             __detached_manages_detach;
  43 int             __detacher_go_away;
  44 STRPTR          __detached_name;
  45 LONG            __detached_return_value;
  46 struct Process *__detacher_process;
  47
  48 AROS_UFP3S(LONG, __detach_trampoline,
  49 AROS_UFPA(char *,argstr,A0),
  50 AROS_UFPA(ULONG,argsize,D0),
  51 AROS_UFPA(struct ExecBase *,SysBase,A6));
  52
  53 static void __startup_detach(void)
  54 {
  55     struct CommandLineInterface *cli;
  56     struct Process              *newproc;
  57     BPTR                         mysegment = BNULL;
  58     STRPTR                       detached_name;
  59
  60     D(bug("Entering __startup_detach()\n"));
  61
  62     cli = Cli();
  63     /* Without a CLI detaching makes no sense, just jump to
  64        the real program.  */
  65     if (!cli)
  66     {
  67         D(bug("Wasn't started from cli.\n"));
  68         __startup_entries_next();
  69     }
  70     else
  71     {
  72         D(bug("Was started from cli.\n"));
  73         mysegment = cli->cli_Module;
  74         cli->cli_Module = BNULL;
  75
  76         detached_name = __detached_name ? __detached_name : (STRPTR) FindTask(NULL)->tc_Node.ln_Name;
  77
  78         {
  79             struct TagItem tags[] =
  80             {
  81                 { NP_Seglist,   (IPTR)mysegment            },
  82                 { NP_Entry,     (IPTR)&__detach_trampoline },
  83                 { NP_Name,      (IPTR)detached_name        },
  84                 { NP_Arguments, (IPTR)__argstr             },
  85                 { NP_Cli,       TRUE                       },
  86                 { TAG_DONE,     0                          }
  87             };
  88
  89             __detacher_process = (struct Process *)FindTask(NULL);
  90
  91             /* CreateNewProc() will take care of freeing the seglist */
  92             newproc = CreateNewProc(tags);
  93         }
  94
  95         D(bug("Process \"%s\" = 0x%x.\n", detached_name, newproc));
  96         if (!newproc)
  97         {
  98             cli->cli_Module = mysegment;
  99             __detached_return_value = RETURN_ERROR;
 100         }
 101         else
 102             while (!__detacher_go_away) Wait(SIGF_SINGLE);
 103
 104         D(bug("__detached_return_value = %d.\n", __detached_return_value));
 105         if (__detached_return_value != RETURN_OK)
 106         {
 107             PutStr(FindTask(NULL)->tc_Node.ln_Name); PutStr(": Failed to detach.\n");
 108         }
 109
 110         if (newproc)
 111         {
 112             Forbid();
 113             Signal(&newproc->pr_Task, SIGF_SINGLE);
 114         }
 115
 116         __startup_error = __detached_return_value;
 117     }
 118
 119     D(bug("Leaving __startup_detach\n"));
 120 }
 121
 122 ADD2SET(__startup_detach, program_entries, -100);
 123
 124 void __Detach(LONG retval);
 125
 126 AROS_UFH3S(LONG, __detach_trampoline,
 127 AROS_UFHA(char *,argstr,A0),
 128 AROS_UFHA(ULONG,argsize,D0),
 129 AROS_UFHA(struct ExecBase *,SysBase,A6))
 130 {
 131     AROS_USERFUNC_INIT
 132
 133     LONG retval = RETURN_OK;
 134
 135     D(bug("Entering __detach_trampoline()\n"));
 136
 137     /* The program has two options: either take care of telling the detacher
 138        process when exactly to go away, via the Detach() function, or let this
 139        startup code take care of it. If __detached_manages_detach is TRUE, then
 140        the detached process handles it, otherwise we handle it.  */
 141
 142     if (!__detached_manages_detach)
 143        __Detach(RETURN_OK);
 144
 145     __startup_entries_next();
 146
 147     /* At this point the detacher process might still be around,
 148       If the program forgot to detach, or if it couldn't, but in any
 149       case we need to tell the detacher to go away.  */
 150     __Detach(retval);
 151
 152     D(bug("Leaving __detach_trampoline\n"));
 153
 154     return 0;
 155
 156     AROS_USERFUNC_EXIT
 157 }
 158
 159 void __Detach(LONG retval)
 160 {
 161     D(bug("Entering __Detach(%d)\n", retval));
 162
 163     if (__detacher_process != NULL)
 164     {
 165         __detached_return_value = retval;
 166         __detacher_go_away      = TRUE;
 167
 168         SetSignal(0, SIGF_SINGLE);
 169         /* Tell the detacher process it can now go away */
 170         Signal(&__detacher_process->pr_Task, SIGF_SINGLE);
 171
 172         /* Wait for it to say "goodbye" */
 173         Wait(SIGF_SINGLE);
 174         __detacher_process = NULL;
 175     }
 176
 177     D(bug("Leaving __Detach\n"));
 178 }