ucw/trans.c

   1 /*
   2  *      The UCW Library -- Transactions
   3  *
   4  *      (c) 2008--2011 Martin Mares <mj@ucw.cz>
   5  *
   6  *      This software may be freely distributed and used according to the terms
   7  *      of the GNU Lesser General Public License.
   8  */
   9
  10 #undef LOCAL_DEBUG
  11
  12 #include <ucw/lib.h>
  13 #include <ucw/trans.h>
  14 #include <ucw/resource.h>
  15 #include <ucw/mempool.h>
  16
  17 #include <stdio.h>
  18
  19 void
  20 trans_init(void)
  21 {
  22   struct ucwlib_context *c = ucwlib_thread_context();
  23   if (!c->trans_pool)
  24     c->trans_pool = mp_new(1024);
  25 }
  26
  27 void
  28 trans_cleanup(void)
  29 {
  30   struct ucwlib_context *c = ucwlib_thread_context();
  31   if (c->trans_pool)
  32     {
  33       mp_delete(c->trans_pool);
  34       c->trans_pool = NULL;
  35     }
  36   c->current_trans = NULL;
  37 }
  38
  39 struct trans *
  40 trans_open(void)
  41 {
  42   trans_init();
  43   struct ucwlib_context *c = ucwlib_thread_context();
  44   struct mempool *mp = c->trans_pool;
  45
  46   struct mempool_state *mst = mp_push(mp);
  47   struct trans *t = mp_alloc(mp, sizeof(*t));
  48   t->trans_pool_state = mst;
  49
  50   struct respool *rp = rp_new("trans", mp);
  51   t->rpool = rp;
  52   t->prev_rpool = rp_switch(rp);
  53
  54   t->thrown_exc = NULL;
  55   t->prev_trans = c->current_trans;
  56   c->current_trans = t;
  57   DBG("Opened transaction %p", t);
  58   return t;
  59 }
  60
  61 struct trans *
  62 trans_get_current(void)
  63 {
  64   return ucwlib_thread_context() -> current_trans;
  65 }
  66
  67 struct mempool *
  68 trans_get_pool(void)
  69 {
  70   return ucwlib_thread_context() -> trans_pool;
  71 }
  72
  73 static void
  74 trans_pop(struct trans *t, struct ucwlib_context *c)
  75 {
  76   DBG("... popping trans %p", t);
  77   rp_switch(t->prev_rpool);
  78   c->current_trans = t->prev_trans;
  79 }
  80
  81 static void
  82 trans_drop(struct trans *t, struct ucwlib_context *c)
  83 {
  84   DBG("... dropping trans %p", t);
  85   mp_restore(c->trans_pool, t->trans_pool_state);
  86 }
  87
  88 void
  89 trans_commit(void)
  90 {
  91   struct ucwlib_context *c = ucwlib_thread_context();
  92   struct trans *t = c->current_trans;
  93   DBG("Committing transaction %p", t);
  94   ASSERT(t);
  95   ASSERT(!t->thrown_exc);
  96   rp_commit(t->rpool);
  97   trans_pop(t, c);
  98   trans_drop(t, c);
  99 }
 100
 101 void
 102 trans_rollback(void)
 103 {
 104   struct ucwlib_context *c = ucwlib_thread_context();
 105   struct trans *t = c->current_trans;
 106   DBG("Rolling back transaction %p", t);
 107   ASSERT(t);
 108   ASSERT(!t->thrown_exc);
 109   rp_delete(t->rpool);
 110   trans_pop(t, c);
 111   trans_drop(t, c);
 112 }
 113
 114 void
 115 trans_fold(void)
 116 {
 117   struct ucwlib_context *c = ucwlib_thread_context();
 118   struct trans *t = c->current_trans;
 119   DBG("Folding transaction %p", t);
 120   ASSERT(t);
 121   ASSERT(!t->thrown_exc);
 122   trans_pop(t, c);
 123   ASSERT(c->current_trans);     // Ensure that the parent exists
 124   res_subpool(t->rpool);
 125   t->rpool = NULL;              // To stop people from using the trans
 126 }
 127
 128 void
 129 trans_caught(void)
 130 {
 131   // Exception has been finally caught. Roll back the current transaction,
 132   // including all sub-transactions that have been folded to it during
 133   // propagation.
 134   struct trans *t = trans_get_current();
 135   struct exception *x = t->thrown_exc;
 136   ASSERT(x);
 137   DBG("... exception %p caught", x);
 138   t->thrown_exc = NULL;
 139   trans_rollback();
 140 }
 141
 142 void
 143 trans_dump(void)
 144 {
 145   struct trans *t = trans_get_current();
 146   if (!t)
 147     {
 148       puts("No transaction open.");
 149       return;
 150     }
 151
 152   while (t)
 153     {
 154       printf("Transaction %p:\n", t);
 155       struct exception *x = t->thrown_exc;
 156       if (x)
 157         printf("    Exception %s (%s) in flight\n", x->id, x->msg);
 158       rp_dump(t->rpool, 4);
 159       t = t->prev_trans;
 160     }
 161 }
 162
 163 void
 164 trans_throw_exc(struct exception *x)
 165 {
 166   struct ucwlib_context *c = ucwlib_thread_context();
 167   struct trans *t = c->current_trans;
 168   DBG("Throwing exception %s (%s) in trans %p", x->id, x->msg, t);
 169   if (!t)
 170     die("%s", x->msg);
 171
 172   // If we are already handling an exception (i.e., throw from a catch handler),
 173   // fold the current transaction into its parent.
 174   while (t->thrown_exc)
 175     {
 176       if (!t->prev_trans)
 177         die("%s", x->msg);
 178       t->thrown_exc = NULL;
 179       trans_fold();
 180       t = c->current_trans;
 181       DBG("... recursive throw propagated to parent trans %p", t);
 182     }
 183
 184   // And jump overboard.
 185   t->thrown_exc = x;
 186   longjmp(t->jmp, 1);
 187 }
 188
 189 void
 190 trans_throw(const char *id, void *object, const char *fmt, ...)
 191 {
 192   va_list args;
 193   va_start(args, fmt);
 194   trans_vthrow(id, object, fmt, args);
 195 }
 196
 197 void
 198 trans_vthrow(const char *id, void *object, const char *fmt, va_list args)
 199 {
 200   struct mempool *mp = trans_get_pool();
 201   if (!mp)
 202     vdie(fmt, args);
 203   struct exception *x = mp_alloc(mp, sizeof(*x));
 204   x->id = id;
 205   x->object = object;
 206   x->msg = mp_vprintf(mp, fmt, args);
 207   trans_throw_exc(x);
 208 }
 209
 210 struct exception *
 211 trans_current_exc(void)
 212 {
 213   return trans_get_current() -> thrown_exc;
 214 }
 215
 216 #ifdef TEST
 217
 218 static void trc_free(struct resource *r)
 219 {
 220   printf("Freeing object #%d\n", (int)(intptr_t) r->priv);
 221 }
 222
 223 static struct res_class trc = {
 224   .name = "test",
 225   .free = trc_free,
 226 };
 227
 228 int main(void)
 229 {
 230   TRANS_TRY
 231     {
 232       res_new(&trc, (void *)(intptr_t) 1);
 233       res_malloc(64, NULL);
 234       TRANS_TRY
 235         {
 236           res_new(&trc, (void *)(intptr_t) 2);
 237           res_malloc(128, NULL);
 238           trans_throw("ucw.test", "inn", "Universe failure: %d+%d=%d", 1, 2, 4);
 239         }
 240       TRANS_CATCH(x)
 241         {
 242           printf("Inner catch: %s\n", x->msg);
 243           trans_dump();
 244           TRANS_TRY
 245             {
 246               res_malloc(256, NULL);
 247               trans_throw("ucw.test.nested", "nest", "Something is wrong recursively");
 248             }
 249           TRANS_CATCH(y)
 250             {
 251               printf("Yet another layer: %s\n", y->msg);
 252               trans_dump();
 253               // trans_throw_exc(y);
 254             }
 255           TRANS_END;
 256           trans_throw("ucw.test2", "out", "Error: %s", x->msg);
 257         }
 258       TRANS_END;
 259     }
 260   TRANS_CATCH(x)
 261     {
 262       printf("Outer catch: %s\n", x->msg);
 263       trans_dump();
 264     }
 265   TRANS_END;
 266   trans_throw("ucw.test3", "glob", "Global error. Reboot globe.");
 267 #if 0
 268   trans_open();
 269   res_malloc(64, NULL);
 270   trans_dump();
 271   trans_commit();
 272 #endif
 273   trans_cleanup();
 274   return 0;
 275 }
 276
 277 #endif