rom/exec/useralert.c

   1 /*
   2     Copyright © 1995-2012, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Display an alert in user mode.
   6     Lang: english
   7 */
   8
   9 #include <aros/debug.h>
  10 #include <exec/alerts.h>
  11 #include <exec/rawfmt.h>
  12 #include <intuition/intuition.h>
  13 #include <proto/exec.h>
  14 #include <proto/intuition.h>
  15 #include <proto/kernel.h>
  16
  17 #include "etask.h"
  18 #include "exec_intern.h"
  19 #include "exec_util.h"
  20
  21 static LONG SafeEasyRequest(struct EasyStruct *es, BOOL full, struct IntuitionBase *IntuitionBase)
  22 {
  23     LONG result;
  24     APTR req = BuildEasyRequestArgs(NULL, es, 0, NULL);
  25
  26     if (!req)
  27     {
  28         /* Return -1 if requester creation failed. This makes us to fallback to safe-mode alert. */
  29         return -1;
  30     }
  31
  32     do
  33     {
  34         result = SysReqHandler(req, NULL, TRUE);
  35
  36         if (full)
  37         {
  38             switch (result)
  39             {
  40             case 1:
  41                 NewRawDoFmt("*** Logged alert:\n%s\n", RAWFMTFUNC_SERIAL, NULL, es->es_TextFormat);
  42                 result = -2;
  43                 break;
  44             }
  45         }
  46     } while (result == -2);
  47
  48     FreeSysRequest(req);
  49     return result;
  50 }
  51
  52 static const char startstring[] = "Program failed\n";
  53 static const char endstring[]   = "\nWait for disk activity to finish.";
  54 static const char deadend_buttons[]          = "More...|Suspend|Reboot|Power off";
  55 static const char recoverable_buttons[]      = "More...|Continue";
  56 static const char full_deadend_buttons[]     = "Log|Suspend|Reboot|Power off";
  57 static const char full_recoverable_buttons[] = "Log|Continue";
  58
  59 LONG Alert_AskSuspend(struct Task *task, ULONG alertNum, char * buffer, struct ExecBase *SysBase)
  60 {
  61     LONG choice = -1;
  62     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 36);
  63
  64     if (IntuitionBase)
  65     {
  66         if (buffer)
  67         {
  68             struct IntETask *iet = GetIntETask(task);
  69             char *buf, *end;
  70             struct EasyStruct es = {
  71                 sizeof (struct EasyStruct),
  72                 0,
  73                 NULL,
  74                 buffer,
  75                 NULL,
  76             };
  77
  78             buf = Alert_AddString(buffer, startstring);
  79             buf = FormatAlert(buf, alertNum, task, iet ? iet->iet_AlertLocation : NULL, iet ? iet->iet_AlertType : AT_NONE, SysBase);
  80             end = buf;
  81             buf = Alert_AddString(buf, endstring);
  82             *buf = 0;
  83
  84             es.es_Title = Alert_GetTitle(alertNum);
  85
  86             /* Determine set of buttons */
  87             es.es_GadgetFormat = (alertNum & AT_DeadEnd) ? deadend_buttons : recoverable_buttons;
  88
  89             D(bug("[UserAlert] Body text:\n%s\n", buffer));
  90             choice = SafeEasyRequest(&es, FALSE, IntuitionBase);
  91
  92             if (choice == 1)
  93             {
  94                 /* 'More' has been pressed. Append full alert data */
  95                 FormatAlertExtra(end, iet->iet_AlertStack, iet ? iet->iet_AlertType : AT_NONE, iet ? &iet->iet_AlertData : NULL, SysBase);
  96
  97                 /* Re-post the alert, without 'More...' this time */
  98                 es.es_GadgetFormat = (alertNum & AT_DeadEnd) ? full_deadend_buttons : full_recoverable_buttons;
  99
 100                 choice = SafeEasyRequest(&es, TRUE, IntuitionBase);
 101             }
 102         }
 103
 104         CloseLibrary(&IntuitionBase->LibNode);
 105     }
 106     return choice;
 107 }
 108
 109 static LONG AskSuspend(struct Task *task, ULONG alertNum, struct ExecBase *SysBase)
 110 {
 111     char * buffer = AllocMem(ALERT_BUFFER_SIZE, MEMF_ANY);
 112
 113     LONG choice = Alert_AskSuspend(task, alertNum, buffer, SysBase);
 114
 115     FreeMem(buffer, ALERT_BUFFER_SIZE);
 116
 117     return choice;
 118 }
 119
 120
 121 /*
 122  * This function posts alerts in user-mode via Intuition requester.
 123  * Returns initial alert code if something fails and 0 if it was a recoverable
 124  * alert and everything went ok.
 125  * Note that in case of some crashes (e.g. corrupt memory list) this function
 126  * may crash itself, and this has to be handled on a lower level. This is
 127  * why we do this trick with iet_AlertCode
 128  */
 129 ULONG Exec_UserAlert(ULONG alertNum, struct ExecBase *SysBase)
 130 {
 131     struct Task *task = GET_THIS_TASK;
 132     struct IntETask *iet;
 133     LONG res;
 134
 135     /* Protect ourselves agains really hard crashes where SysBase->ThisTask is NULL.
 136        Obviously we won't go far away in such a case */
 137     if (!task)
 138         return alertNum;
 139
 140     /* Get internal task structure */
 141     if ((iet = GetIntETask(task)))
 142     {
 143         /*
 144          * If we already have alert number for this task, we are in double-crash during displaying
 145          * intuition requester. Well, take the initial alert code (because it's more helpful to the programmer)
 146          * and proceed with arch-specific Alert().
 147          * Since this is a double-crash, we may append AT_DeadEnd flag if our situation has become unrecoverable.
 148          */
 149         D(bug("[UserAlert] Task alert state: 0x%02X\n", iet->iet_AlertFlags));
 150         if (iet->iet_AlertFlags & AF_Alert)
 151         {
 152             /*
 153              * Some more logic here. Nested AN_SysScrnType should not make original alert deadend.
 154              * It just means we were unable to display it using Intuition requested because there
 155              * are no display drivers at all.
 156              */
 157             if (alertNum == AN_SysScrnType)
 158                 return iet->iet_AlertCode;
 159             else
 160                 return iet->iet_AlertCode | (alertNum & AT_DeadEnd);
 161         }
 162
 163         /*
 164          * Otherwise we can try to put up Intuition requester first. Store alert code in order in ETask
 165          * in order to indicate crash condition
 166          */
 167         iet->iet_AlertFlags |= AF_Alert;
 168         iet->iet_AlertCode   = alertNum;
 169     }
 170
 171     /*
 172      * AN_SysScrnType is somewhat special. We remember it in the ETask (just in case),
 173      * but propagate it to supervisor mode immediately. We do it because this error
 174      * means we don't have any display modes, so we won't be able to bring up the requester.
 175      */
 176     if (alertNum == AN_SysScrnType)
 177         return alertNum;
 178
 179     /* Issue a requester */
 180     res = AskSuspend(task, alertNum, SysBase);
 181     D(bug("[UserAlert] Requester result: %d\n", res));
 182
 183     /* If AskSuspend() failed, fail back to safe-mode alert */
 184     if (res == -1)
 185         return alertNum;
 186
 187     /* Halt if we need to */
 188     if (alertNum & AT_DeadEnd)
 189     {
 190         switch (res)
 191         {
 192         case 0:
 193             ShutdownA(SD_ACTION_POWEROFF);
 194             break;
 195
 196         case 3:
 197             ColdReboot();
 198             /* In case if ColdReboot() doesn't work */
 199             ShutdownA(SD_ACTION_COLDREBOOT);
 200             break;
 201         }
 202
 203         /* Well, stop if the user wants so (or if the reboot didn't work at all) */
 204         Wait(0);
 205     }
 206     return 0;
 207 }