unwind_prot.c

   1 /* unwind_prot.c - a simple unwind-protect system for internal variables */
   2
   3 /* I can't stand it anymore!  Please can't we just write the
   4    whole Unix system in lisp or something? */
   5
   6 /* Copyright (C) 1987-2021 Free Software Foundation, Inc.
   7
   8    This file is part of GNU Bash, the Bourne Again SHell.
   9
  10    Bash is free software: you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation, either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    Bash is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with Bash.  If not, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24 /* **************************************************************** */
  25 /*                                                                  */
  26 /*                    Unwind Protection Scheme for Bash             */
  27 /*                                                                  */
  28 /* **************************************************************** */
  29 #include "config.h"
  30
  31 #include "bashtypes.h"
  32 #include "bashansi.h"
  33
  34 #if defined (HAVE_UNISTD_H)
  35 #  include <unistd.h>
  36 #endif
  37
  38 #if defined (HAVE_STDDEF_H)
  39 #  include <stddef.h>
  40 #endif
  41
  42 #ifndef offsetof
  43 #  define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
  44 #endif
  45
  46 #include "command.h"
  47 #include "general.h"
  48 #include "unwind_prot.h"
  49 #include "sig.h"
  50 #include "quit.h"
  51 #include "bashintl.h"   /* for _() */
  52 #include "error.h"      /* for internal_warning */
  53 #include "ocache.h"
  54
  55 /* Structure describing a saved variable and the value to restore it to.  */
  56 typedef struct {
  57   char *variable;
  58   int size;
  59   char desired_setting[1]; /* actual size is `size' */
  60 } SAVED_VAR;
  61
  62 /* If HEAD.CLEANUP is null, then ARG.V contains a tag to throw back to.
  63    If HEAD.CLEANUP is restore_variable, then SV.V contains the saved
  64    variable.  Otherwise, call HEAD.CLEANUP (ARG.V) to clean up.  */
  65 typedef union uwp {
  66   struct uwp_head {
  67     union uwp *next;
  68     Function *cleanup;
  69   } head;
  70   struct {
  71     struct uwp_head uwp_head;
  72     char *v;
  73   } arg;
  74   struct {
  75     struct uwp_head uwp_head;
  76     SAVED_VAR v;
  77   } sv;
  78 } UNWIND_ELT;
  79
  80 static void without_interrupts PARAMS((VFunction *, char *, char *));
  81 static void unwind_frame_discard_internal PARAMS((char *, char *));
  82 static void unwind_frame_run_internal PARAMS((char *, char *));
  83 static void add_unwind_protect_internal PARAMS((Function *, char *));
  84 static void remove_unwind_protect_internal PARAMS((char *, char *));
  85 static void run_unwind_protects_internal PARAMS((char *, char *));
  86 static void clear_unwind_protects_internal PARAMS((char *, char *));
  87 static inline void restore_variable PARAMS((SAVED_VAR *));
  88 static void unwind_protect_mem_internal PARAMS((char *, char *));
  89
  90 static UNWIND_ELT *unwind_protect_list = (UNWIND_ELT *)NULL;
  91
  92 /* Allocating from a cache of unwind-protect elements */
  93 #define UWCACHESIZE     128
  94
  95 sh_obj_cache_t uwcache = {0, 0, 0};
  96
  97 #if 0
  98 #define uwpalloc(elt)   (elt) = (UNWIND_ELT *)xmalloc (sizeof (UNWIND_ELT))
  99 #define uwpfree(elt)    free(elt)
 100 #else
 101 #define uwpalloc(elt)   ocache_alloc (uwcache, UNWIND_ELT, elt)
 102 #define uwpfree(elt)    ocache_free (uwcache, UNWIND_ELT, elt)
 103 #endif
 104
 105 void
 106 uwp_init ()
 107 {
 108   ocache_create (uwcache, UNWIND_ELT, UWCACHESIZE);
 109 }
 110
 111 /* Run a function without interrupts.  This relies on the fact that the
 112    FUNCTION cannot call QUIT (). */
 113 static void
 114 without_interrupts (function, arg1, arg2)
 115      VFunction *function;
 116      char *arg1, *arg2;
 117 {
 118   (*function)(arg1, arg2);
 119 }
 120
 121 /* Start the beginning of a region. */
 122 void
 123 begin_unwind_frame (tag)
 124      char *tag;
 125 {
 126   add_unwind_protect ((Function *)NULL, tag);
 127 }
 128
 129 /* Discard the unwind protects back to TAG. */
 130 void
 131 discard_unwind_frame (tag)
 132      char *tag;
 133 {
 134   if (unwind_protect_list)
 135     without_interrupts (unwind_frame_discard_internal, tag, (char *)NULL);
 136 }
 137
 138 /* Run the unwind protects back to TAG. */
 139 void
 140 run_unwind_frame (tag)
 141      char *tag;
 142 {
 143   if (unwind_protect_list)
 144     without_interrupts (unwind_frame_run_internal, tag, (char *)NULL);
 145 }
 146
 147 /* Add the function CLEANUP with ARG to the list of unwindable things. */
 148 void
 149 add_unwind_protect (cleanup, arg)
 150      Function *cleanup;
 151      char *arg;
 152 {
 153   without_interrupts (add_unwind_protect_internal, (char *)cleanup, arg);
 154 }
 155
 156 /* Remove the top unwind protect from the list. */
 157 void
 158 remove_unwind_protect ()
 159 {
 160   if (unwind_protect_list)
 161     without_interrupts
 162       (remove_unwind_protect_internal, (char *)NULL, (char *)NULL);
 163 }
 164
 165 /* Run the list of cleanup functions in unwind_protect_list. */
 166 void
 167 run_unwind_protects ()
 168 {
 169   if (unwind_protect_list)
 170     without_interrupts
 171       (run_unwind_protects_internal, (char *)NULL, (char *)NULL);
 172 }
 173
 174 /* Erase the unwind-protect list.  If flags is 1, free the elements. */
 175 void
 176 clear_unwind_protect_list (flags)
 177      int flags;
 178 {
 179   char *flag;
 180
 181   if (unwind_protect_list)
 182     {
 183       flag = flags ? "" : (char *)NULL;
 184       without_interrupts
 185         (clear_unwind_protects_internal, flag, (char *)NULL);
 186     }
 187 }
 188
 189 int
 190 have_unwind_protects ()
 191 {
 192   return (unwind_protect_list != 0);
 193 }
 194
 195 int
 196 unwind_protect_tag_on_stack (tag)
 197      const char *tag;
 198 {
 199   UNWIND_ELT *elt;
 200
 201   elt = unwind_protect_list;
 202   while (elt)
 203     {
 204       if (elt->head.cleanup == 0 && STREQ (elt->arg.v, tag))
 205         return 1;
 206       elt = elt->head.next;
 207     }
 208   return 0;
 209 }
 210
 211 /* **************************************************************** */
 212 /*                                                                  */
 213 /*                      The Actual Functions                        */
 214 /*                                                                  */
 215 /* **************************************************************** */
 216
 217 static void
 218 add_unwind_protect_internal (cleanup, arg)
 219      Function *cleanup;
 220      char *arg;
 221 {
 222   UNWIND_ELT *elt;
 223
 224   uwpalloc (elt);
 225   elt->head.next = unwind_protect_list;
 226   elt->head.cleanup = cleanup;
 227   elt->arg.v = arg;
 228   unwind_protect_list = elt;
 229 }
 230
 231 static void
 232 remove_unwind_protect_internal (ignore1, ignore2)
 233      char *ignore1, *ignore2;
 234 {
 235   UNWIND_ELT *elt;
 236
 237   elt = unwind_protect_list;
 238   if (elt)
 239     {
 240       unwind_protect_list = unwind_protect_list->head.next;
 241       uwpfree (elt);
 242     }
 243 }
 244
 245 static void
 246 run_unwind_protects_internal (ignore1, ignore2)
 247      char *ignore1, *ignore2;
 248 {
 249   unwind_frame_run_internal ((char *) NULL, (char *) NULL);
 250 }
 251
 252 static void
 253 clear_unwind_protects_internal (flag, ignore)
 254      char *flag, *ignore;
 255 {
 256   if (flag)
 257     {
 258       while (unwind_protect_list)
 259         remove_unwind_protect_internal ((char *)NULL, (char *)NULL);
 260     }
 261   unwind_protect_list = (UNWIND_ELT *)NULL;
 262 }
 263
 264 static void
 265 unwind_frame_discard_internal (tag, ignore)
 266      char *tag, *ignore;
 267 {
 268   UNWIND_ELT *elt;
 269   int found;
 270
 271   found = 0;
 272   while (elt = unwind_protect_list)
 273     {
 274       unwind_protect_list = unwind_protect_list->head.next;
 275       if (elt->head.cleanup == 0 && (STREQ (elt->arg.v, tag)))
 276         {
 277           uwpfree (elt);
 278           found = 1;
 279           break;
 280         }
 281       else
 282         uwpfree (elt);
 283     }
 284
 285   if (found == 0)
 286     internal_warning (_("unwind_frame_discard: %s: frame not found"), tag);
 287 }
 288
 289 /* Restore the value of a variable, based on the contents of SV.
 290    sv->desired_setting is a block of memory SIZE bytes long holding the
 291    value itself.  This block of memory is copied back into the variable. */
 292 static inline void
 293 restore_variable (sv)
 294      SAVED_VAR *sv;
 295 {
 296   FASTCOPY (sv->desired_setting, sv->variable, sv->size);
 297 }
 298
 299 static void
 300 unwind_frame_run_internal (tag, ignore)
 301      char *tag, *ignore;
 302 {
 303   UNWIND_ELT *elt;
 304   int found;
 305
 306   found = 0;
 307   while (elt = unwind_protect_list)
 308     {
 309       unwind_protect_list = elt->head.next;
 310
 311       /* If tag, then compare. */
 312       if (elt->head.cleanup == 0)
 313         {
 314           if (tag && STREQ (elt->arg.v, tag))
 315             {
 316               uwpfree (elt);
 317               found = 1;
 318               break;
 319             }
 320         }
 321       else
 322         {
 323           if (elt->head.cleanup == (Function *) restore_variable)
 324             restore_variable (&elt->sv.v);
 325           else
 326             (*(elt->head.cleanup)) (elt->arg.v);
 327         }
 328
 329       uwpfree (elt);
 330     }
 331   if (tag && found == 0)
 332     internal_warning (_("unwind_frame_run: %s: frame not found"), tag);
 333 }
 334
 335 static void
 336 unwind_protect_mem_internal (var, psize)
 337      char *var;
 338      char *psize;
 339 {
 340   int size, allocated;
 341   UNWIND_ELT *elt;
 342
 343   size = *(int *) psize;
 344   allocated = size + offsetof (UNWIND_ELT, sv.v.desired_setting[0]);
 345   if (allocated < sizeof (UNWIND_ELT))
 346     allocated = sizeof (UNWIND_ELT);
 347   elt = (UNWIND_ELT *)xmalloc (allocated);
 348   elt->head.next = unwind_protect_list;
 349   elt->head.cleanup = (Function *) restore_variable;
 350   elt->sv.v.variable = var;
 351   elt->sv.v.size = size;
 352   FASTCOPY (var, elt->sv.v.desired_setting, size);
 353   unwind_protect_list = elt;
 354 }
 355
 356 /* Save the value of a variable so it will be restored when unwind-protects
 357    are run.  VAR is a pointer to the variable.  SIZE is the size in
 358    bytes of VAR.  */
 359 void
 360 unwind_protect_mem (var, size)
 361      char *var;
 362      int size;
 363 {
 364   without_interrupts (unwind_protect_mem_internal, var, (char *) &size);
 365 }
 366
 367 #if defined (DEBUG)
 368 #include <stdio.h>
 369
 370 void
 371 print_unwind_protect_tags ()
 372 {
 373   UNWIND_ELT *elt;
 374
 375   elt = unwind_protect_list;
 376   while (elt)
 377     {
 378       if (elt->head.cleanup == 0)
 379         fprintf(stderr, "tag: %s\n", elt->arg.v);
 380       elt = elt->head.next;
 381     }
 382 }
 383 #endif