compiler/startup/detach.c

   1 /*
   2     Copyright © 1995-2001, 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
  32 #include <aros/config.h>
  33 #include <dos/dos.h>
  34 #include <proto/exec.h>
  35 #include <proto/dos.h>
  36 #include <aros/asmcall.h>
  37 #include <aros/symbolsets.h>
  38
  39 #if (AROS_FLAVOUR & AROS_FLAVOUR_NATIVE & defined __mc68000__)
  40 asm
  41 (
  42     ".text\n"
  43     "\n"
  44     "move.l      4.w,a6\n"
  45     "bra         _detach_entry\n"
  46 );
  47 #endif
  48
  49 int             __detached_manages_detach;
  50 int             __detacher_go_away;
  51 STRPTR          __detached_name;
  52 LONG            __detached_return_value;
  53 struct Process *__detacher_process;
  54
  55 DECLARESET(PROGRAM_ENTRIES);
  56
  57 AROS_UFP3(static LONG, __detach_entry,
  58 AROS_UFHA(char *,argstr,A0),
  59 AROS_UFHA(ULONG,argsize,D0),
  60 AROS_UFHA(struct ExecBase *,SysBase,A6))  __attribute__((section(".aros.startup")));
  61
  62 AROS_UFP3(static LONG, __detach_trampoline,
  63 AROS_UFHA(char *,argstr,A0),
  64 AROS_UFHA(ULONG,argsize,D0),
  65 AROS_UFHA(struct ExecBase *,SysBase,A6));
  66
  67 AROS_UFH3(static LONG, __detach_entry,
  68 AROS_UFHA(char *,argstr,A0),
  69 AROS_UFHA(ULONG,argsize,D0),
  70 AROS_UFHA(struct ExecBase *,SysBase,A6))
  71 {
  72     AROS_USERFUNC_INIT
  73
  74     struct DosLibrary           *DOSBase;
  75     struct CommandLineInterface *cli;
  76     struct Process              *newproc;
  77     BPTR                         mysegment = NULL;
  78     STRPTR                       detached_name;
  79
  80     DOSBase = (struct DosLibrary *)OpenLibrary(DOSNAME, 39);
  81     if (!DOSBase) return RETURN_FAIL;
  82
  83     cli = Cli();
  84     /* Without a CLI detaching makes no sense, just jump to
  85        the real program.  */
  86     if (!cli)
  87     {
  88 #if 0 /* gcc 4.0 trouble. static follows non-static bla bla bla */
  89         AROS_UFC3(LONG, SETELEM(__detach_entry, program_entries)[1],
  90         AROS_UFHA(char *,argstr,A0),
  91         AROS_UFHA(ULONG,argsize,D0),
  92         AROS_UFHA(struct ExecBase *,SysBase,A6));
  93 #else
  94         AROS_UFC3(LONG, SETNAME(PROGRAM_ENTRIES)[1 + 1],
  95         AROS_UFHA(char *,argstr,A0),
  96         AROS_UFHA(ULONG,argsize,D0),
  97         AROS_UFHA(struct ExecBase *,SysBase,A6));
  98 #endif
  99
 100     }
 101
 102     mysegment = cli->cli_Module;
 103     cli->cli_Module = NULL;
 104
 105     detached_name = __detached_name ? __detached_name : (STRPTR)FindTask(NULL)->tc_Node.ln_Name;
 106
 107     {
 108         struct TagItem tags[] =
 109         {
 110             { NP_Seglist,   (IPTR)mysegment            },
 111             { NP_Entry,     (IPTR)&__detach_trampoline },
 112             { NP_Name,      (IPTR)detached_name        },
 113             { NP_Arguments, (IPTR)argstr               },
 114             { NP_Cli,       TRUE                       },
 115             { TAG_DONE,     0                          }
 116         };
 117
 118         __detacher_process = (struct Process *)FindTask(NULL);
 119
 120         /* CreateNewProc() will take care of freeing the seglist */
 121         newproc = CreateNewProc(tags);
 122     }
 123
 124     CloseLibrary((struct Library *)DOSBase);
 125
 126     if (!newproc)
 127     {
 128         cli->cli_Module = mysegment;
 129         __detached_return_value = RETURN_ERROR;
 130     }
 131     else
 132         while (!__detacher_go_away) Wait(SIGF_SINGLE);
 133
 134     if (__detached_return_value != RETURN_OK)
 135     {
 136         PutStr(FindTask(NULL)->tc_Node.ln_Name); PutStr(": Failed to detach.\n");
 137     }
 138
 139     if (newproc)
 140     {
 141         Forbid();
 142         Signal(&newproc->pr_Task, SIGF_SINGLE);
 143     }
 144
 145     return __detached_return_value;
 146
 147     AROS_USERFUNC_EXIT
 148 }
 149
 150 DEFINESET(PROGRAM_ENTRIES);
 151 ADD2SET(__detach_entry, program_entries, 0);
 152
 153 void __Detach(LONG retval);
 154
 155 AROS_UFH3(static LONG, __detach_trampoline,
 156 AROS_UFHA(char *,argstr,A0),
 157 AROS_UFHA(ULONG,argsize,D0),
 158 AROS_UFHA(struct ExecBase *,SysBase,A6))
 159 {
 160     AROS_USERFUNC_INIT
 161
 162     LONG retval;
 163
 164     /* The program has two options: either take care of telling the detacher
 165        process when exactly to go away, via the Detach() function, or let this
 166        startup code take care of it. If __detached_manages_detach is TRUE, then
 167        the detached process handles it, otherwise we handle it.  */
 168
 169     if (!__detached_manages_detach)
 170        __Detach(RETURN_OK);
 171
 172 #if 0 /* gcc 4.0 trouble. static follows non-static bla bla bla */
 173
 174     retval = AROS_UFC3(LONG, SETELEM(__detach_entry, program_entries)[1],
 175              AROS_UFHA(char *,argstr,A0),
 176              AROS_UFHA(ULONG,argsize,D0),
 177              AROS_UFHA(struct ExecBase *,SysBase,A6));
 178 #else
 179     retval = AROS_UFC3(LONG, SETNAME(PROGRAM_ENTRIES)[1 + 1],
 180              AROS_UFHA(char *,argstr,A0),
 181              AROS_UFHA(ULONG,argsize,D0),
 182              AROS_UFHA(struct ExecBase *,SysBase,A6));
 183 #endif
 184
 185     /* At this point the detacher process might still be around,
 186       If the program forgot to detach, or if it couldn't, but in any
 187       case we need to tell the detacher to go away.  */
 188     __Detach(retval);
 189
 190     return 0;
 191
 192     AROS_USERFUNC_EXIT
 193 }
 194
 195 void __Detach(LONG retval)
 196 {
 197     if (__detacher_process != NULL)
 198     {
 199         __detached_return_value = retval;
 200         __detacher_go_away      = TRUE;
 201
 202         SetSignal(0, SIGF_SINGLE);
 203         /* Tell the detacher process it can now go away */
 204         Signal(&__detacher_process->pr_Task, SIGF_SINGLE);
 205
 206         /* Wait for it to say "goodbye" */
 207         Wait(SIGF_SINGLE);
 208         __detacher_process = NULL;
 209     }
 210 }