Real implementation of protocol state machines. Delayed startup/shutdown

should work now. Initial feeding of protocols by interfaces/routes is
done from the event queue to prevent unwanted recursion.

TODO

@@ -8,7 +8,6 @@ Core
 
 * Fix router ID calculation
 * debug dump: dump router ID as well
-* proto_report_state() !
 
 - TOS not supported by kernel -> automatically drop routes with TOS<>0
 

lib/event.c

@@ -34,7 +34,7 @@ ev_dump(resource *r)
 
 static struct resclass ev_class = {
   "Event",
-  0,
+  sizeof(event),
   (void (*)(resource *)) ev_postpone,
   ev_dump
 };

nest/proto.c

@@ -14,26 +14,45 @@
 #include "nest/protocol.h"
 #include "lib/resource.h"
 #include "lib/lists.h"
+#include "lib/event.h"
 #include "conf/conf.h"
 #include "nest/route.h"
 #include "nest/iface.h"
 
+static pool *proto_pool;
+
 list protocol_list;
 list proto_list;
-list inactive_proto_list;
+
+static list inactive_proto_list;
+static list initial_proto_list;
+
+static char *p_states[] = { "DOWN", "START", "UP", "STOP" };
+static char *c_states[] = { "HUNGRY", "FEEDING", "HAPPY", "FLUSHING" };
+
+static void
+proto_relink(struct proto *p)
+{
+  rem_node(&p->n);
+  add_tail(p->core_state == FS_HAPPY ? &proto_list : &inactive_proto_list, &p->n);
+}
 
 void *
 proto_new(struct proto_config *c, unsigned size)
 {
   struct protocol *pr = c->proto;
-  struct proto *p = cfg_allocz(size);	/* FIXME: Allocate from global pool */
+  pool *r = rp_new(proto_pool, c->name);
+  struct proto *p = mb_alloc(r, size);
 
   p->cf = c;
   p->debug = c->debug;
+  p->name = c->name;
   p->preference = c->preference;
   p->disabled = c->disabled;
   p->proto = pr;
-  p->pool = rp_new(&root_pool, c->name);
+  p->pool = r;
+  p->attn = ev_new(r);
+  p->attn->data = p;
   return p;
 }
 
@@ -57,6 +76,7 @@ protos_preconfig(struct config *c)
 
   init_list(&proto_list);
   init_list(&inactive_proto_list);
+  init_list(&initial_proto_list);
   debug("Protocol preconfig:");
   WALK_LIST(p, protocol_list)
     {
@@ -97,27 +117,45 @@ protos_commit(struct config *c)
       debug(" %s", x->name);
       p = x->proto;
       q = p->init(x);
-      add_tail(&inactive_proto_list, &q->n);
+      q->proto_state = PS_DOWN;
+      q->core_state = FS_HUNGRY;
+      add_tail(&initial_proto_list, &q->n);
     }
   debug("\n");
 }
 
 static void
-proto_start(struct proto *p)
+proto_rethink_goal(struct proto *p)
 {
-  rem_node(&p->n);
+  struct protocol *q = p->proto;
-  if (p->disabled)
+
+  if (p->core_state == p->core_goal)
     return;
-  p->proto_state = PS_DOWN;
+  if (p->core_goal == FS_HAPPY)		/* Going up */
-  p->core_state = FS_HUNGRY;
+    {
-  if (p->proto->start && p->proto->start(p) != PS_UP)
+      if (p->core_state == FS_HUNGRY && p->proto_state == PS_DOWN)
-    bug("Delayed protocol start not supported yet");
+	{
-  p->proto_state = PS_UP;
+	  DBG("Kicking %s up\n", p->name);
-  p->core_state = FS_FEEDING;
+	  proto_notify_state(p, (q->start ? q->start(p) : PS_UP));
-  if_feed_baby(p);
+	}
-  rt_feed_baby(p);
+    }
-  p->core_state = FS_HAPPY;
+  else 					/* Going down */
-  add_tail(&proto_list, &p->n);
+    {
+      if (p->proto_state == PS_START || p->proto_state == PS_UP)
+	{
+	  DBG("Kicking %s down\n", p->name);
+	  proto_notify_state(p, (q->shutdown ? q->shutdown(p) : PS_DOWN));
+	}
+    }
+}
+
+static void
+proto_set_goal(struct proto *p, unsigned goal)
+{
+  if (p->disabled)
+    goal = FS_HUNGRY;
+  p->core_goal = goal;
+  proto_rethink_goal(p);
 }
 
 void
@@ -126,32 +164,29 @@ protos_start(void)
   struct proto *p, *n;
 
   debug("Protocol start\n");
-  WALK_LIST_DELSAFE(p, n, inactive_proto_list)
+  WALK_LIST_DELSAFE(p, n, initial_proto_list)
-    {
+    proto_set_goal(p, FS_HAPPY);
-      debug("Starting %s\n", p->cf->name);
-      proto_start(p);
-    }
 }
 
 void
 protos_dump_all(void)
 {
   struct proto *p;
-  static char *p_states[] = { "DOWN", "START", "UP", "STOP" };
-  static char *c_states[] = { "HUNGRY", "FEEDING", "HAPPY", "FLUSHING" };
 
   debug("Protocols:\n");
 
   WALK_LIST(p, proto_list)
     {
-      debug("  protocol %s: state %s/%s\n", p->cf->name, p_states[p->proto_state], c_states[p->core_state]);
+      debug("  protocol %s: state %s/%s\n", p->name, p_states[p->proto_state], c_states[p->core_state]);
       if (p->disabled)
 	debug("\tDISABLED\n");
       else if (p->proto->dump)
 	p->proto->dump(p);
     }
   WALK_LIST(p, inactive_proto_list)
-    debug("  inactive %s\n", p->cf->name);
+    debug("  inactive %s: state %s/%s\n", p->name, p_states[p->proto_state], c_states[p->core_state]);
+  WALK_LIST(p, initial_proto_list)
+    debug("  initial %s\n", p->name);
 }
 
 void
@@ -165,4 +200,84 @@ protos_build(void)
 #ifdef CONFIG_STATIC
   add_tail(&protocol_list, &proto_static.n);
 #endif
+  proto_pool = rp_new(&root_pool, "Protocols");
+}
+
+static void
+proto_fell_down(struct proto *p)
+{
+  DBG("Protocol %s down\n", p->name);
+  proto_rethink_goal(p);
+}
+
+static void
+proto_feed(void *P)
+{
+  struct proto *p = P;
+
+  DBG("Feeding protocol %s\n", p->name);
+  if_feed_baby(p);
+  rt_feed_baby(p);
+  p->core_state = FS_HAPPY;
+  proto_relink(p);
+  DBG("Protocol %s up and running\n", p->name);
+}
+
+static void
+proto_flush(void *P)
+{
+  struct proto *p = P;
+
+  DBG("Flushing protocol %s\n", p->name);
+  bug("Protocol flushing not supported yet!"); /* FIXME */
+}
+
+void
+proto_notify_state(struct proto *p, unsigned ps)
+{
+  unsigned ops = p->proto_state;
+  unsigned cs = p->core_state;
+
+  DBG("%s reporting state transition %s/%s -> */%s\n", p->name, c_states[cs], p_states[ops], p_states[ps]);
+  if (ops == ps)
+    return;
+
+  switch (ps)
+    {
+    case PS_DOWN:
+      if (cs == FS_HUNGRY)		/* Shutdown finished */
+	proto_fell_down(p);
+      else if (cs == FS_FLUSHING)	/* Still flushing... */
+	;
+      else				/* Need to start flushing */
+	goto schedule_flush;
+      break;
+    case PS_START:
+      ASSERT(ops == PS_DOWN);
+      ASSERT(cs == FS_HUNGRY);
+      break;
+    case PS_UP:
+      ASSERT(ops == PS_DOWN || ops == PS_START);
+      ASSERT(cs == FS_HUNGRY);
+      DBG("%s: Scheduling meal\n", p->name);
+      cs = FS_FEEDING;
+      p->attn->hook = proto_feed;
+      ev_schedule(p->attn);
+      break;
+    case PS_STOP:
+      if (cs == FS_FEEDING || cs == FS_HAPPY)
+	{
+	schedule_flush:
+	  DBG("%s: Scheduling flush\n", p->name);
+	  cs = FS_FLUSHING;
+	  p->attn->hook = proto_flush;
+	  ev_schedule(p->attn);
+	}
+    default:
+    error:
+      bug("Invalid state transition for %s from %s/%s to */%s", p->name, c_states[cs], p_states[ops], p_states[ps]);
+    }
+  p->proto_state = ps;
+  p->core_state = cs;
+  proto_relink(p);
 }