From da8a23277eefb46c5482fe63ecc7f75fcc21c0a6 Mon Sep 17 00:00:00 2001
From: Maria Matejka <mq@ucw.cz>
Date: Thu, 14 Nov 2024 20:43:35 +0100
Subject: [PATCH] CLI: Dumping internal data structures to files, not to debug
 output

All the 'dump something' CLI commands now have a new mandatory
argument -- name of the file where to dump the data. This allows
for more flexible dumping even for production deployments where
the debug output is by default off.

Also the dump commands are now restricted (they weren't before)
to assure that only the appropriate users can run these time consuming
commands.
---
 doc/bird.sgml         |   8 +-
 doc/reply_codes       |   1 +
 filter/decl.m4        |  28 +++----
 filter/f-inst.c       |   4 +-
 filter/f-inst.h       |   2 +-
 filter/f-util.c       |   4 +-
 filter/filter.c       |  31 ++++----
 filter/filter.h       |   2 +-
 lib/birdlib.h         |  11 +++
 lib/event.c           |   4 +-
 lib/mempool.c         |   6 +-
 lib/resource.c        |  40 ++++++----
 lib/resource.h        |   7 +-
 lib/slab.c            |   6 +-
 lib/socket.h          |   2 +-
 lib/timer.c           |  12 +--
 nest/config.Y         |  39 +++++-----
 nest/iface.c          |  40 +++++-----
 nest/iface.h          |  10 +--
 nest/locks.c          |   6 +-
 nest/neighbor.c       |  20 ++---
 nest/proto.c          |  14 ++--
 nest/protocol.h       |   4 +-
 nest/route.h          |  12 +--
 nest/rt-attr.c        |  52 ++++++-------
 nest/rt-table.c       |  26 +++----
 proto/babel/babel.c   |  42 +++++------
 proto/bfd/bfd.c       |   4 +-
 proto/bmp/bmp.c       |   2 +-
 proto/ospf/ospf.c     |  19 +++--
 proto/rip/rip.c       |   8 +-
 proto/static/static.c |  16 ++--
 sysdep/unix/alloc.c   |  20 +++++
 sysdep/unix/io.c      | 167 +++++++++++++++++++++++++++++++++++++++---
 sysdep/unix/krt.c     |   6 +-
 sysdep/unix/main.c    |  41 ++++++++---
 sysdep/unix/unix.h    |   8 +-
 37 files changed, 463 insertions(+), 261 deletions(-)

diff --git a/doc/bird.sgml b/doc/bird.sgml
index b6b77691..5393edb2 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -1454,8 +1454,12 @@ This argument can be omitted if there exists only a single instance.
 	<tag><label id="cli-debug">debug <m/protocol/|<m/pattern/|all all|off|{ states|routes|filters|events|packets [, <m/.../] }</tag>
 	Control protocol debugging.
 
-	<tag><label id="cli-dump">dump resources|sockets|interfaces|neighbors|attributes|routes|protocols</tag>
-	Dump contents of internal data structures to the debugging output.
+	<tag><label id="cli-dump">dump resources|sockets|interfaces|neighbors|attributes|routes|protocols "<m/file/"</tag>
+	Truncates the given file and dumps contents of internal data structures
+	there. By sending SIGUSR1, you get all of these concatenated to
+	<cf/bird.dump/ in the current directory. The file is only readable for
+	the user running the daemon. The format of dump files is internal and
+	could change in the future.
 
 	<tag><label id="cli-echo">echo all|off|{ <m/list of log classes/ } [ <m/buffer-size/ ]</tag>
 	Control echoing of log messages to the command-line output.
diff --git a/doc/reply_codes b/doc/reply_codes
index 6e7e5887..aa95820e 100644
--- a/doc/reply_codes
+++ b/doc/reply_codes
@@ -72,6 +72,7 @@ Reply codes of BIRD command-line interface
 8006	Reload failed
 8007	Access denied
 8008	Evaluation runtime error
+8009	Failed to open file
 
 9000	Command too long
 9001	Parse error
diff --git a/filter/decl.m4 b/filter/decl.m4
index ea0b0995..a435cf7a 100644
--- a/filter/decl.m4
+++ b/filter/decl.m4
@@ -97,7 +97,7 @@ if ($3) return 0;
 ]])
 m4_ifelse($4,,,[[
 FID_DUMP_BODY()m4_dnl
-debug("%s" $4 "\n", INDENT, $5);
+RDUMP("%s" $4 "\n", INDENT, $5);
 ]])
 FID_INTERPRET_EXEC()m4_dnl
 const $1 $2 = whati->$2
@@ -168,7 +168,7 @@ FID_LINEARIZE_BODY()m4_dnl
   pos = linearize(dest, whati->fvar, pos);
   item->varcount = whati->varcount;
 FID_DUMP_BODY()m4_dnl
-  debug("%snumber of varargs %u\n", INDENT, item->varcount);
+  RDUMP("%snumber of varargs %u\n", INDENT, item->varcount);
 FID_SAME_BODY()m4_dnl
   if (f1->varcount != f2->varcount) return 0;
 FID_INTERPRET_BODY()
@@ -240,7 +240,7 @@ FID_NEW_METHOD()m4_dnl
   args = NULL; /* The rest is the line itself */
 FID_METHOD_CALL()    , arg$1
 FID_DUMP_BODY()m4_dnl
-f_dump_line(item->fl$1, indent + 1);
+f_dump_line(dreq, item->fl$1, indent + 1);
 FID_LINEARIZE_BODY()m4_dnl
 item->fl$1 = f_linearize(whati->f$1, $2);
 FID_SAME_BODY()m4_dnl
@@ -433,13 +433,13 @@ m4_undivert(113)
 
 ]])m4_dnl
 
-FID_DUMP_CALLER()m4_dnl			 Case in another big switch used in instruction dumping (debug)
-case INST_NAME(): f_dump_line_item_]]INST_NAME()[[(item, indent + 1); break;
+FID_DUMP_CALLER()m4_dnl			 Case in another big switch used in instruction dumping
+case INST_NAME(): f_dump_line_item_]]INST_NAME()[[(dreq, item, indent + 1); break;
 
 FID_DUMP()m4_dnl			 The dumper itself
 m4_ifdef([[FID_DUMP_BODY_EXISTS]],
-[[static inline void f_dump_line_item_]]INST_NAME()[[(const struct f_line_item *item_, const int indent)]],
-[[static inline void f_dump_line_item_]]INST_NAME()[[(const struct f_line_item *item UNUSED, const int indent UNUSED)]])
+[[static inline void f_dump_line_item_]]INST_NAME()[[(struct dump_request *dreq, const struct f_line_item *item_, const int indent)]],
+[[static inline void f_dump_line_item_]]INST_NAME()[[(struct dump_request *dreq UNUSED, const struct f_line_item *item UNUSED, const int indent UNUSED)]])
 m4_undefine([[FID_DUMP_BODY_EXISTS]])
 {
 #define item (&(item_->i_]]INST_NAME()[[))
@@ -676,22 +676,22 @@ static const char f_dump_line_indent_str[] = "                                ";
 
 FID_WR_PUT(6)
 
-void f_dump_line(const struct f_line *dest, uint indent)
+void f_dump_line(struct dump_request *dreq, const struct f_line *dest, uint indent)
 {
   if (!dest) {
-    debug("%sNo filter line (NULL)\n", INDENT);
+    RDUMP("%sNo filter line (NULL)\n", INDENT);
     return;
   }
-  debug("%sFilter line %p (len=%u)\n", INDENT, dest, dest->len);
+  RDUMP("%sFilter line %p (len=%u)\n", INDENT, dest, dest->len);
   for (uint i=0; i<dest->len; i++) {
     const struct f_line_item *item = &dest->items[i];
-    debug("%sInstruction %s at line %u\n", INDENT, f_instruction_name_(item->fi_code), item->lineno);
+    RDUMP("%sInstruction %s at line %u\n", INDENT, f_instruction_name_(item->fi_code), item->lineno);
     switch (item->fi_code) {
 FID_WR_PUT(7)
       default: bug("Unknown instruction %x in f_dump_line", item->fi_code);
     }
   }
-  debug("%sFilter line %p dump done\n", INDENT, dest);
+  RDUMP("%sFilter line %p dump done\n", INDENT, dest);
 }
 
 /* Linearize */
@@ -721,10 +721,6 @@ f_linearize_concat(const struct f_inst * const inst[], uint count, uint results)
     out->len = linearize(out, inst[i], out->len);
 
   out->results = results;
-
-#ifdef LOCAL_DEBUG
-  f_dump_line(out, 0);
-#endif
   return out;
 }
 
diff --git a/filter/f-inst.c b/filter/f-inst.c
index 8529ad62..efc82d2f 100644
--- a/filter/f-inst.c
+++ b/filter/f-inst.c
@@ -182,11 +182,11 @@
  *	m4_dnl	This structure is returned from the linearizer (105).
  *	m4_dnl	For writing directly to this structure, use FID_LINE_IN.
  *
- *	m4_dnl		f_dump_line_item_FI_EXAMPLE(const struct f_line_item *item, const int indent)
+ *	m4_dnl		f_dump_line_item_FI_EXAMPLE(struct dump_request *dreq, const struct f_line_item *item, const int indent)
  *	m4_dnl		{
  *	m4_dnl	(104)	  [[ put it here ]]
  *	m4_dnl		}
- *	m4_dnl	This code dumps the instruction on debug. Note that the argument
+ *	m4_dnl	This code dumps the instruction via RDUMP. Note that the argument
  *	m4_dnl	is the linearized instruction; if the instruction has arguments,
  *	m4_dnl	their code has already been linearized and their value is taken
  *	m4_dnl	from the value stack.
diff --git a/filter/f-inst.h b/filter/f-inst.h
index 955cfbdc..1b498e15 100644
--- a/filter/f-inst.h
+++ b/filter/f-inst.h
@@ -68,7 +68,7 @@ struct f_line *f_linearize_concat(const struct f_inst * const inst[], uint count
 static inline struct f_line *f_linearize(const struct f_inst *root, uint results)
 { return f_linearize_concat(&root, 1, results); }
 
-void f_dump_line(const struct f_line *, uint indent);
+void f_dump_line(struct dump_request *, const struct f_line *, uint indent);
 
 
 /* Recursive iteration over filter instructions */
diff --git a/filter/f-util.c b/filter/f-util.c
index 6fbdacba..680f2f54 100644
--- a/filter/f-util.c
+++ b/filter/f-util.c
@@ -251,10 +251,10 @@ ca_free(resource *r)
 }
 
 static void
-ca_dump(resource *r)
+ca_dump(struct dump_request *dreq, resource *r)
 {
   struct custom_attribute *ca = (void *) r;
-  debug("name \"%s\" id 0x%04x ea_type 0x%02x f_type 0x%02x\n",
+  RDUMP("name \"%s\" id 0x%04x ea_type 0x%02x f_type 0x%02x\n",
       ca->name, ca->fda->ea_code, ca->fda->type, ca->fda->f_type);
 }
 
diff --git a/filter/filter.c b/filter/filter.c
index 560778a8..f17de58c 100644
--- a/filter/filter.c
+++ b/filter/filter.c
@@ -181,11 +181,6 @@ interpret(struct filter_state *fs, const struct f_line *line, uint argc, const s
 #define curline fstk->estk[fstk->ecnt-1]
 #define prevline fstk->estk[fstk->ecnt-2]
 
-#ifdef LOCAL_DEBUG
-  debug("Interpreting line.");
-  f_dump_line(line, 1);
-#endif
-
   while (fstk->ecnt > 0) {
     while (curline.pos < curline.line->len) {
       const struct f_line_item *what = &(curline.line->items[curline.pos++]);
@@ -474,37 +469,37 @@ filter_commit(struct config *new, struct config *old)
     }
 }
 
-void filters_dump_all(void)
+void filters_dump_all(struct dump_request *dreq)
 {
   struct symbol *sym;
   WALK_LIST(sym, config->symbols) {
     switch (sym->class) {
       case SYM_FILTER:
-	debug("Named filter %s:\n", sym->name);
-	f_dump_line(sym->filter->root, 1);
+	RDUMP("Named filter %s:\n", sym->name);
+	f_dump_line(dreq, sym->filter->root, 1);
 	break;
       case SYM_FUNCTION:
-	debug("Function %s:\n", sym->name);
-	f_dump_line(sym->function, 1);
+	RDUMP("Function %s:\n", sym->name);
+	f_dump_line(dreq, sym->function, 1);
 	break;
       case SYM_PROTO:
 	{
-	  debug("Protocol %s:\n", sym->name);
+	  RDUMP("Protocol %s:\n", sym->name);
 	  struct channel *c;
 	  WALK_LIST(c, sym->proto->proto->channels) {
-	    debug(" Channel %s (%s) IMPORT", c->name, net_label[c->net_type]);
+	    RDUMP(" Channel %s (%s) IMPORT", c->name, net_label[c->net_type]);
 	    if (c->in_filter == FILTER_ACCEPT)
-	      debug(" ALL\n");
+	      RDUMP(" ALL\n");
 	    else if (c->in_filter == FILTER_REJECT)
-	      debug(" NONE\n");
+	      RDUMP(" NONE\n");
 	    else if (c->in_filter == FILTER_UNDEF)
-	      debug(" UNDEF\n");
+	      RDUMP(" UNDEF\n");
 	    else if (c->in_filter->sym) {
 	      ASSERT(c->in_filter->sym->filter == c->in_filter);
-	      debug(" named filter %s\n", c->in_filter->sym->name);
+	      RDUMP(" named filter %s\n", c->in_filter->sym->name);
 	    } else {
-	      debug("\n");
-	      f_dump_line(c->in_filter->root, 2);
+	      RDUMP("\n");
+	      f_dump_line(dreq, c->in_filter->root, 2);
 	    }
 	  }
 	}
diff --git a/filter/filter.h b/filter/filter.h
index 18ff0874..efb4979f 100644
--- a/filter/filter.h
+++ b/filter/filter.h
@@ -65,7 +65,7 @@ int f_same(const struct f_line *f1, const struct f_line *f2);
 
 void filter_commit(struct config *new, struct config *old);
 
-void filters_dump_all(void);
+void filters_dump_all(struct dump_request *);
 
 #define FILTER_ACCEPT NULL
 #define FILTER_REJECT ((struct filter *) 1)
diff --git a/lib/birdlib.h b/lib/birdlib.h
index 4fea3f9f..762c5fa4 100644
--- a/lib/birdlib.h
+++ b/lib/birdlib.h
@@ -242,4 +242,15 @@ static inline u64 u64_hash0(u64 v, u32 p, u64 acc)
 static inline u32 u64_hash(u64 v)
 { return hash_value(u64_hash0(v, HASH_PARAM, 0)); }
 
+/* Dumping */
+struct dump_request {
+  u64 size;
+  btime begin;
+  uint indent, offset;
+  void (*write)(struct dump_request *, const char *fmt, ...);
+  void (*report)(struct dump_request *, int state, const char *fmt, ...);
+};
+
+#define RDUMP(...)  dreq->write(dreq, __VA_ARGS__)
+
 #endif
diff --git a/lib/event.c b/lib/event.c
index 33dc00b0..6f17a618 100644
--- a/lib/event.c
+++ b/lib/event.c
@@ -36,11 +36,11 @@ ev_postpone(event *e)
 }
 
 static void
-ev_dump(resource *r)
+ev_dump(struct dump_request *dreq, resource *r)
 {
   event *e = (event *) r;
 
-  debug("(code %p, data %p, %s)\n",
+  RDUMP("(code %p, data %p, %s)\n",
 	e->hook,
 	e->data,
 	e->n.next ? "scheduled" : "inactive");
diff --git a/lib/mempool.c b/lib/mempool.c
index 9d4404f7..28bdff1d 100644
--- a/lib/mempool.c
+++ b/lib/mempool.c
@@ -44,7 +44,7 @@ struct linpool {
 _Thread_local linpool *tmp_linpool;
 
 static void lp_free(resource *);
-static void lp_dump(resource *);
+static void lp_dump(struct dump_request *, resource *);
 static resource *lp_lookup(resource *, unsigned long);
 static struct resmem lp_memsize(resource *r);
 
@@ -271,7 +271,7 @@ lp_free(resource *r)
 }
 
 static void
-lp_dump(resource *r)
+lp_dump(struct dump_request *dreq, resource *r)
 {
   linpool *m = (linpool *) r;
   struct lp_chunk *c;
@@ -281,7 +281,7 @@ lp_dump(resource *r)
     ;
   for(cntl=0, c=m->first_large; c; c=c->next, cntl++)
     ;
-  debug("(count=%d+%d total=%d+%d)\n",
+  RDUMP("(count=%d+%d total=%d+%d)\n",
 	cnt,
 	cntl,
 	m->total,
diff --git a/lib/resource.c b/lib/resource.c
index 89e559b4..b1a3df10 100644
--- a/lib/resource.c
+++ b/lib/resource.c
@@ -35,7 +35,7 @@ struct pool {
   const char *name;
 };
 
-static void pool_dump(resource *);
+static void pool_dump(struct dump_request *, resource *);
 static void pool_free(resource *);
 static resource *pool_lookup(resource *, unsigned long);
 static struct resmem pool_memsize(resource *P);
@@ -51,8 +51,6 @@ static struct resclass pool_class = {
 
 pool root_pool;
 
-static int indent;
-
 /**
  * rp_new - create a resource pool
  * @p: parent pool
@@ -100,16 +98,16 @@ pool_free(resource *P)
 }
 
 static void
-pool_dump(resource *P)
+pool_dump(struct dump_request *dreq, resource *P)
 {
   pool *p = (pool *) P;
   resource *r;
 
-  debug("%s\n", p->name);
-  indent += 3;
+  RDUMP("%s\n", p->name);
+  dreq->indent += 3;
   WALK_LIST(r, p->inside)
-    rdump(r);
-  indent -= 3;
+    rdump(dreq, r);
+  dreq->indent -= 3;
 }
 
 static struct resmem
@@ -199,20 +197,28 @@ rfree(void *res)
  * It works by calling a class-specific dump function.
  */
 void
-rdump(void *res)
+rdump(struct dump_request *dreq, void *res)
 {
   char x[16];
   resource *r = res;
 
-  bsprintf(x, "%%%ds%%p ", indent);
-  debug(x, "", r);
+  bsprintf(x, "%%%ds%%p ", dreq->indent);
+  RDUMP(x, "", r);
   if (r)
     {
-      debug("%s ", r->class->name);
-      r->class->dump(r);
+      RDUMP("%s ", r->class->name);
+      r->class->dump(dreq, r);
     }
   else
-    debug("NULL\n");
+    RDUMP("NULL\n");
+}
+
+void page_dump(struct dump_request *req);
+
+void resource_dump(struct dump_request *req)
+{
+  rdump(req, &root_pool);
+  page_dump(req);
 }
 
 struct resmem
@@ -251,6 +257,7 @@ ralloc(pool *p, struct resclass *c)
   return r;
 }
 
+#if 0
 /**
  * rlookup - look up a memory location
  * @a: memory address
@@ -273,6 +280,7 @@ rlookup(unsigned long a)
   else
     debug("Not found.\n");
 }
+#endif
 
 /**
  * resource_init - initialize the resource manager
@@ -316,11 +324,11 @@ static void mbl_free(resource *r UNUSED)
 {
 }
 
-static void mbl_debug(resource *r)
+static void mbl_debug(struct dump_request *dreq, resource *r)
 {
   struct mblock *m = (struct mblock *) r;
 
-  debug("(size=%d)\n", m->size);
+  RDUMP("(size=%d)\n", m->size);
 }
 
 static resource *
diff --git a/lib/resource.h b/lib/resource.h
index 1e9a7b78..1e8e2d2c 100644
--- a/lib/resource.h
+++ b/lib/resource.h
@@ -30,7 +30,7 @@ struct resclass {
   char *name;				/* Resource class name */
   unsigned size;			/* Standard size of single resource */
   void (*free)(resource *);		/* Freeing function */
-  void (*dump)(resource *);		/* Dump to debug output */
+  void (*dump)(struct dump_request *, resource *);	/* Dump to debug output */
   resource *(*lookup)(resource *, unsigned long);	/* Look up address (only for debugging) */
   struct resmem (*memsize)(resource *);	/* Return size of memory used by the resource, may be NULL */
 };
@@ -46,7 +46,10 @@ void resource_init(void);
 pool *rp_new(pool *, const char *);	/* Create new pool */
 pool *rp_newf(pool *, const char *, ...);	/* Create a new pool with a formatted string as its name */
 void rfree(void *);			/* Free single resource */
-void rdump(void *);			/* Dump to debug output */
+
+struct dump_request;
+void rdump(struct dump_request *, void *);	/* Dump to debug output */
+void resource_dump(struct dump_request *);	/* Dump the root pool */
 struct resmem rmemsize(void *res);		/* Return size of memory used by the resource */
 void rlookup(unsigned long);		/* Look up address (only for debugging) */
 void rmove(void *, pool *);		/* Move to a different pool */
diff --git a/lib/slab.c b/lib/slab.c
index 38d10626..571a3d95 100644
--- a/lib/slab.c
+++ b/lib/slab.c
@@ -41,7 +41,7 @@
 #endif
 
 static void slab_free(resource *r);
-static void slab_dump(resource *r);
+static void slab_dump(struct dump_request *dreq, resource *r);
 static resource *slab_lookup(resource *r, unsigned long addr);
 static struct resmem slab_memsize(resource *r);
 
@@ -378,7 +378,7 @@ slab_free(resource *r)
 }
 
 static void
-slab_dump(resource *r)
+slab_dump(struct dump_request *dreq, resource *r)
 {
   slab *s = (slab *) r;
   int ec=0, pc=0, fc=0;
@@ -389,7 +389,7 @@ slab_dump(resource *r)
     pc++;
   WALK_TLIST(sl_head, h, &s->full_heads)
     fc++;
-  debug("(%de+%dp+%df blocks per %d objs per %d bytes)\n", ec, pc, fc, s->objs_per_slab, s->obj_size);
+  RDUMP("(%de+%dp+%df blocks per %d objs per %d bytes)\n", ec, pc, fc, s->objs_per_slab, s->obj_size);
 }
 
 static struct resmem
diff --git a/lib/socket.h b/lib/socket.h
index 3417423f..edd90b9f 100644
--- a/lib/socket.h
+++ b/lib/socket.h
@@ -92,7 +92,7 @@ void sk_reallocate(sock *);		/* Free and allocate tbuf & rbuf */
 void sk_set_rbsize(sock *s, uint val);	/* Resize RX buffer */
 void sk_set_tbsize(sock *s, uint val);	/* Resize TX buffer, keeping content */
 void sk_set_tbuf(sock *s, void *tbuf);	/* Switch TX buffer, NULL-> return to internal */
-void sk_dump_all(void);
+void sk_dump_all(struct dump_request *);
 
 int sk_is_ipv4(sock *s);		/* True if socket is IPv4 */
 int sk_is_ipv6(sock *s);		/* True if socket is IPv6 */
diff --git a/lib/timer.c b/lib/timer.c
index 92da5061..b94c43ca 100644
--- a/lib/timer.c
+++ b/lib/timer.c
@@ -102,19 +102,19 @@ tm_free(resource *r)
 }
 
 static void
-tm_dump(resource *r)
+tm_dump(struct dump_request *dreq, resource *r)
 {
   timer *t = (void *) r;
 
-  debug("(code %p, data %p, ", t->hook, t->data);
+  RDUMP("(code %p, data %p, ", t->hook, t->data);
   if (t->randomize)
-    debug("rand %d, ", t->randomize);
+    RDUMP("rand %d, ", t->randomize);
   if (t->recurrent)
-    debug("recur %ld, ", t->recurrent);
+    RDUMP("recur %ld, ", t->recurrent);
   if (t->expires)
-    debug("expires in %ld ms)\n", (t->expires - current_time()) TO_MS);
+    RDUMP("expires in %ld ms)\n", (t->expires - current_time()) TO_MS);
   else
-    debug("inactive)\n");
+    RDUMP("inactive)\n");
 }
 
 
diff --git a/nest/config.Y b/nest/config.Y
index 5d755715..47fef3d7 100644
--- a/nest/config.Y
+++ b/nest/config.Y
@@ -863,26 +863,25 @@ sym_args:
  | sym_args CF_SYM_KNOWN { $$ = $1; $$->sym = $2; }
  ;
 
-
-CF_CLI_HELP(DUMP, ..., [[Dump debugging information]])
-CF_CLI(DUMP RESOURCES,,, [[Dump all allocated resource]])
-{ rdump(&root_pool); cli_msg(0, ""); } ;
-CF_CLI(DUMP SOCKETS,,, [[Dump open sockets]])
-{ sk_dump_all(); cli_msg(0, ""); } ;
-CF_CLI(DUMP EVENTS,,, [[Dump event log]])
-{ io_log_dump(); cli_msg(0, ""); } ;
-CF_CLI(DUMP INTERFACES,,, [[Dump interface information]])
-{ if_dump_all(); cli_msg(0, ""); } ;
-CF_CLI(DUMP NEIGHBORS,,, [[Dump neighbor cache]])
-{ neigh_dump_all(); cli_msg(0, ""); } ;
-CF_CLI(DUMP ATTRIBUTES,,, [[Dump attribute cache]])
-{ rta_dump_all(); cli_msg(0, ""); } ;
-CF_CLI(DUMP ROUTES,,, [[Dump routing table]])
-{ rt_dump_all(); cli_msg(0, ""); } ;
-CF_CLI(DUMP PROTOCOLS,,, [[Dump protocol information]])
-{ protos_dump_all(); cli_msg(0, ""); } ;
-CF_CLI(DUMP FILTER ALL,,, [[Dump all filters in linearized form]])
-{ filters_dump_all(); cli_msg(0, ""); } ;
+CF_CLI_HELP(DUMP, ..., [[Dump debugging information to the given file]])
+CF_CLI(DUMP RESOURCES, text,, [[Dump all allocated resource]])
+{ cmd_dump_file(this_cli, $3, "resources", resource_dump); } ;
+CF_CLI(DUMP SOCKETS, text,, [[Dump open sockets]])
+{ cmd_dump_file(this_cli, $3, "sockets", sk_dump_all); } ;
+CF_CLI(DUMP EVENTS, text,, [[Dump event log]])
+{ cmd_dump_file(this_cli, $3, "event log", io_log_dump); } ;
+CF_CLI(DUMP INTERFACES, text,, [[Dump interface information]])
+{ cmd_dump_file(this_cli, $3, "interfaces", if_dump_all); } ;
+CF_CLI(DUMP NEIGHBORS, text,, [[Dump neighbor cache]])
+{ cmd_dump_file(this_cli, $3, "neighbor cache", neigh_dump_all); } ;
+CF_CLI(DUMP ATTRIBUTES, text,, [[Dump attribute cache]])
+{ cmd_dump_file(this_cli, $3, "attribute cache", rta_dump_all); } ;
+CF_CLI(DUMP ROUTES, text,, [[Dump routing table]])
+{ cmd_dump_file(this_cli, $3, "routing tables", rt_dump_all); } ;
+CF_CLI(DUMP PROTOCOLS, text,, [[Dump protocol information]])
+{ cmd_dump_file(this_cli, $3, "protocols", protos_dump_all); } ;
+CF_CLI(DUMP FILTER ALL, text,, [[Dump all filters in linearized form]])
+{ cmd_dump_file(this_cli, $4, "filter bytecode", filters_dump_all); } ;
 
 CF_CLI(EVAL, term, <expr>, [[Evaluate an expression]])
 { cmd_eval(f_linearize($2, 1)); } ;
diff --git a/nest/iface.c b/nest/iface.c
index 6c84cbcf..499822b6 100644
--- a/nest/iface.c
+++ b/nest/iface.c
@@ -47,9 +47,9 @@ static void if_recalc_preferred(struct iface *i);
  * This function dumps contents of an &ifa to the debug output.
  */
 void
-ifa_dump(struct ifa *a)
+ifa_dump(struct dump_request *dreq, struct ifa *a)
 {
-  debug("\t%I, net %N bc %I -> %I%s%s%s%s\n", a->ip, &a->prefix, a->brd, a->opposite,
+  RDUMP("\t%I, net %N bc %I -> %I%s%s%s%s\n", a->ip, &a->prefix, a->brd, a->opposite,
 	(a->flags & IA_PRIMARY) ? " PRIMARY" : "",
 	(a->flags & IA_SECONDARY) ? " SEC" : "",
 	(a->flags & IA_HOST) ? " HOST" : "",
@@ -64,35 +64,35 @@ ifa_dump(struct ifa *a)
  * network interface to the debug output.
  */
 void
-if_dump(struct iface *i)
+if_dump(struct dump_request *dreq, struct iface *i)
 {
   struct ifa *a;
 
-  debug("IF%d: %s", i->index, i->name);
+  RDUMP("IF%d: %s", i->index, i->name);
   if (i->flags & IF_SHUTDOWN)
-    debug(" SHUTDOWN");
+    RDUMP(" SHUTDOWN");
   if (i->flags & IF_UP)
-    debug(" UP");
+    RDUMP(" UP");
   else
-    debug(" DOWN");
+    RDUMP(" DOWN");
   if (i->flags & IF_ADMIN_UP)
-    debug(" LINK-UP");
+    RDUMP(" LINK-UP");
   if (i->flags & IF_MULTIACCESS)
-    debug(" MA");
+    RDUMP(" MA");
   if (i->flags & IF_BROADCAST)
-    debug(" BC");
+    RDUMP(" BC");
   if (i->flags & IF_MULTICAST)
-    debug(" MC");
+    RDUMP(" MC");
   if (i->flags & IF_LOOPBACK)
-    debug(" LOOP");
+    RDUMP(" LOOP");
   if (i->flags & IF_IGNORE)
-    debug(" IGN");
+    RDUMP(" IGN");
   if (i->flags & IF_TMP_DOWN)
-    debug(" TDOWN");
-  debug(" MTU=%d\n", i->mtu);
+    RDUMP(" TDOWN");
+  RDUMP(" MTU=%d\n", i->mtu);
   WALK_LIST(a, i->addrs)
     {
-      ifa_dump(a);
+      ifa_dump(dreq, a);
       ASSERT(!!(a->flags & IA_PRIMARY) ==
 	     ((a == i->addr4) || (a == i->addr6) || (a == i->llv6)));
     }
@@ -105,14 +105,14 @@ if_dump(struct iface *i)
  * interfaces to the debug output.
  */
 void
-if_dump_all(void)
+if_dump_all(struct dump_request *dreq)
 {
   struct iface *i;
 
-  debug("Known network interfaces:\n");
+  RDUMP("Known network interfaces:\n");
   WALK_LIST(i, iface_list)
-    if_dump(i);
-  debug("Router ID: %08x\n", config->router_id);
+    if_dump(dreq, i);
+  RDUMP("Router ID: %08x\n", config->router_id);
 }
 
 static inline unsigned
diff --git a/nest/iface.h b/nest/iface.h
index f8e92850..1e4225ee 100644
--- a/nest/iface.h
+++ b/nest/iface.h
@@ -101,9 +101,9 @@ struct iface {
 #define IF_CHANGE_PREFERRED (IF_CHANGE_ADDR4 | IF_CHANGE_ADDR6 | IF_CHANGE_LLV6)
 
 void if_init(void);
-void if_dump(struct iface *);
-void if_dump_all(void);
-void ifa_dump(struct ifa *);
+void if_dump(struct dump_request *dreq, struct iface *);
+void if_dump_all(struct dump_request *);
+void ifa_dump(struct dump_request *dreq, struct ifa *);
 void if_show(void);
 void if_show_summary(void);
 struct iface *if_update(struct iface *);
@@ -148,8 +148,8 @@ typedef struct neighbor {
 
 neighbor *neigh_find(struct proto *p, ip_addr a, struct iface *ifa, uint flags);
 
-void neigh_dump(neighbor *);
-void neigh_dump_all(void);
+void neigh_dump(struct dump_request *, neighbor *);
+void neigh_dump_all(struct dump_request *);
 void neigh_prune(void);
 void neigh_if_up(struct iface *);
 void neigh_if_down(struct iface *);
diff --git a/nest/locks.c b/nest/locks.c
index 637f2c15..17768525 100644
--- a/nest/locks.c
+++ b/nest/locks.c
@@ -87,14 +87,14 @@ olock_free(resource *r)
 }
 
 static void
-olock_dump(resource *r)
+olock_dump(struct dump_request *dreq, resource *r)
 {
   struct object_lock *l = (struct object_lock *) r;
   static char *olock_states[] = { "free", "locked", "waiting", "event" };
 
-  debug("(%d:%s:%I:%I:%d:%d) [%s]\n", l->type, (l->iface ? l->iface->name : "?"), l->addr, l->addr_local, l->port, l->inst, olock_states[l->state]);
+  RDUMP("(%d:%s:%I:%I:%d:%d) [%s]\n", l->type, (l->iface ? l->iface->name : "?"), l->addr, l->addr_local, l->port, l->inst, olock_states[l->state]);
   if (!EMPTY_LIST(l->waiters))
-    debug(" [wanted]\n");
+    RDUMP(" [wanted]\n");
 }
 
 static struct resclass olock_class = {
diff --git a/nest/neighbor.c b/nest/neighbor.c
index 63c07f83..7db73acc 100644
--- a/nest/neighbor.c
+++ b/nest/neighbor.c
@@ -275,17 +275,17 @@ neigh_find(struct proto *p, ip_addr a, struct iface *iface, uint flags)
  * This functions dumps the contents of a given neighbor entry to debug output.
  */
 void
-neigh_dump(neighbor *n)
+neigh_dump(struct dump_request *dreq, neighbor *n)
 {
-  debug("%p %I %s %s ", n, n->addr,
+  RDUMP("%p %I %s %s ", n, n->addr,
 	n->iface ? n->iface->name : "[]",
 	n->ifreq ? n->ifreq->name : "[]");
-  debug("%s %p %08x scope %s", n->proto->name, n->data, n->aux, ip_scope_text(n->scope));
+  RDUMP("%s %p %08x scope %s", n->proto->name, n->data, n->aux, ip_scope_text(n->scope));
   if (n->flags & NEF_STICKY)
-    debug(" STICKY");
+    RDUMP(" STICKY");
   if (n->flags & NEF_ONLINK)
-    debug(" ONLINK");
-  debug("\n");
+    RDUMP(" ONLINK");
+  RDUMP("\n");
 }
 
 /**
@@ -294,16 +294,16 @@ neigh_dump(neighbor *n)
  * This function dumps the contents of the neighbor cache to debug output.
  */
 void
-neigh_dump_all(void)
+neigh_dump_all(struct dump_request *dreq)
 {
   neighbor *n;
   int i;
 
-  debug("Known neighbors:\n");
+  RDUMP("Known neighbors:\n");
   for(i=0; i<NEIGH_HASH_SIZE; i++)
     WALK_LIST(n, neigh_hash_table[i])
-      neigh_dump(n);
-  debug("\n");
+      neigh_dump(dreq, n);
+  RDUMP("\n");
 }
 
 static inline void
diff --git a/nest/proto.c b/nest/proto.c
index 36c5b576..e4caffe1 100644
--- a/nest/proto.c
+++ b/nest/proto.c
@@ -1693,27 +1693,27 @@ channel_graceful_restart_unlock(struct channel *c)
  * the internals.
  */
 void
-protos_dump_all(void)
+protos_dump_all(struct dump_request *dreq)
 {
-  debug("Protocols:\n");
+  RDUMP("Protocols:\n");
 
   struct proto *p;
   WALK_LIST(p, proto_list)
   {
-    debug("  protocol %s state %s\n", p->name, p_states[p->proto_state]);
+    RDUMP("  protocol %s state %s\n", p->name, p_states[p->proto_state]);
 
     struct channel *c;
     WALK_LIST(c, p->channels)
     {
-      debug("\tTABLE %s\n", c->table->name);
+      RDUMP("\tTABLE %s\n", c->table->name);
       if (c->in_filter)
-	debug("\tInput filter: %s\n", filter_name(c->in_filter));
+	RDUMP("\tInput filter: %s\n", filter_name(c->in_filter));
       if (c->out_filter)
-	debug("\tOutput filter: %s\n", filter_name(c->out_filter));
+	RDUMP("\tOutput filter: %s\n", filter_name(c->out_filter));
     }
 
     if (p->proto->dump && (p->proto_state != PS_DOWN))
-      p->proto->dump(p);
+      p->proto->dump(p, dreq);
   }
 }
 
diff --git a/nest/protocol.h b/nest/protocol.h
index c87d3814..d577820e 100644
--- a/nest/protocol.h
+++ b/nest/protocol.h
@@ -77,7 +77,7 @@ struct protocol {
   void (*postconfig)(struct proto_config *);			/* After configuring each instance */
   struct proto * (*init)(struct proto_config *);		/* Create new instance */
   int (*reconfigure)(struct proto *, struct proto_config *);	/* Try to reconfigure instance, returns success */
-  void (*dump)(struct proto *);			/* Debugging dump */
+  void (*dump)(struct proto *, struct dump_request *);		/* Debugging dump */
   int (*start)(struct proto *);			/* Start the instance */
   int (*shutdown)(struct proto *);		/* Stop the instance */
   void (*cleanup)(struct proto *);		/* Called after shutdown when protocol became hungry/down */
@@ -93,7 +93,7 @@ void proto_build(struct protocol *);	/* Called from protocol to register itself
 void protos_preconfig(struct config *);
 void protos_commit(struct config *new, struct config *old, int force_restart, int type);
 struct proto * proto_spawn(struct proto_config *cf, uint disabled);
-void protos_dump_all(void);
+void protos_dump_all(struct dump_request *);
 
 #define GA_UNKNOWN	0		/* Attribute not recognized */
 #define GA_NAME		1		/* Result = name */
diff --git a/nest/route.h b/nest/route.h
index 81efebeb..be3d759e 100644
--- a/nest/route.h
+++ b/nest/route.h
@@ -332,13 +332,13 @@ void rt_refresh_begin(rtable *t, struct channel *c);
 void rt_refresh_end(rtable *t, struct channel *c);
 void rt_modify_stale(rtable *t, struct channel *c);
 void rt_schedule_prune(rtable *t);
-void rte_dump(rte *);
+void rte_dump(struct dump_request *, rte *);
 void rte_free(rte *);
 rte *rte_do_cow(rte *);
 static inline rte * rte_cow(rte *r) { return (r->flags & REF_COW) ? rte_do_cow(r) : r; }
 rte *rte_cow_rta(rte *r, linpool *lp);
-void rt_dump(rtable *);
-void rt_dump_all(void);
+void rt_dump(struct dump_request *, rtable *);
+void rt_dump_all(struct dump_request *);
 int rt_feed_channel(struct channel *c);
 void rt_feed_channel_abort(struct channel *c);
 int rte_update_in(struct channel *c, const net_addr *n, rte *new, struct rte_src *src);
@@ -608,7 +608,7 @@ struct ea_walk_state {
 eattr *ea_find(ea_list *, unsigned ea);
 eattr *ea_walk(struct ea_walk_state *s, uint id, uint max);
 uintptr_t ea_get_int(ea_list *, unsigned ea, uintptr_t def);
-void ea_dump(ea_list *);
+void ea_dump(struct dump_request *, ea_list *);
 void ea_sort(ea_list *);		/* Sort entries in all sub-lists */
 unsigned ea_scan(ea_list *);		/* How many bytes do we need for merged ea_list */
 void ea_merge(ea_list *from, ea_list *to); /* Merge sub-lists to allocated buffer */
@@ -718,8 +718,8 @@ void rta__free(rta *r);
 static inline void rta_free(rta *r) { if (r && !--r->uc) rta__free(r); }
 rta *rta_do_cow(rta *o, linpool *lp);
 static inline rta * rta_cow(rta *r, linpool *lp) { return rta_is_cached(r) ? rta_do_cow(r, lp) : r; }
-void rta_dump(rta *);
-void rta_dump_all(void);
+void rta_dump(struct dump_request *, rta *);
+void rta_dump_all(struct dump_request *);
 void rta_show(struct cli *, rta *);
 
 u32 rt_get_igp_metric(rte *rt);
diff --git a/nest/rt-attr.c b/nest/rt-attr.c
index 09176632..a567720e 100644
--- a/nest/rt-attr.c
+++ b/nest/rt-attr.c
@@ -1044,40 +1044,40 @@ ea_show(struct cli *c, const eattr *e)
  * the debug output.
  */
 void
-ea_dump(ea_list *e)
+ea_dump(struct dump_request *dreq, ea_list *e)
 {
   int i;
 
   if (!e)
     {
-      debug("NONE");
+      RDUMP("NONE");
       return;
     }
   while (e)
     {
-      debug("[%c%c%c]",
+      RDUMP("[%c%c%c]",
 	    (e->flags & EALF_SORTED) ? 'S' : 's',
 	    (e->flags & EALF_BISECT) ? 'B' : 'b',
 	    (e->flags & EALF_CACHED) ? 'C' : 'c');
       for(i=0; i<e->count; i++)
 	{
 	  eattr *a = &e->attrs[i];
-	  debug(" %02x:%02x.%02x", EA_PROTO(a->id), EA_ID(a->id), a->flags);
-	  debug("=%c", "?iO?I?P???S?????" [a->type & EAF_TYPE_MASK]);
+	  RDUMP(" %02x:%02x.%02x", EA_PROTO(a->id), EA_ID(a->id), a->flags);
+	  RDUMP("=%c", "?iO?I?P???S?????" [a->type & EAF_TYPE_MASK]);
 	  if (a->originated)
-	    debug("o");
+	    RDUMP("o");
 	  if (a->type & EAF_EMBEDDED)
-	    debug(":%08x", a->u.data);
+	    RDUMP(":%08x", a->u.data);
 	  else
 	    {
 	      int j, len = a->u.ptr->length;
-	      debug("[%d]:", len);
+	      RDUMP("[%d]:", len);
 	      for(j=0; j<len; j++)
-		debug("%02x", a->u.ptr->data[j]);
+		RDUMP("%02x", a->u.ptr->data[j]);
 	    }
 	}
       if (e = e->next)
-	debug(" | ");
+	RDUMP(" | ");
     }
 }
 
@@ -1317,7 +1317,7 @@ rta_do_cow(rta *o, linpool *lp)
  * This function takes a &rta and dumps its contents to the debug output.
  */
 void
-rta_dump(rta *a)
+rta_dump(struct dump_request *dreq, rta *a)
 {
   static char *rts[] = { "", "RTS_STATIC", "RTS_INHERIT", "RTS_DEVICE",
 			 "RTS_STAT_DEV", "RTS_REDIR", "RTS_RIP",
@@ -1326,25 +1326,25 @@ rta_dump(rta *a)
 			 "RTS_RPKI", "RTS_PERF", "RTS_AGGREGATED", };
   static char *rtd[] = { "", " DEV", " HOLE", " UNREACH", " PROHIBIT" };
 
-  debug("pref=%d uc=%d %s %s%s h=%04x",
+  RDUMP("pref=%d uc=%d %s %s%s h=%04x",
 	a->pref, a->uc, rts[a->source], ip_scope_text(a->scope),
 	rtd[a->dest], a->hash_key);
   if (!a->cached)
-    debug(" !CACHED");
-  debug(" <-%I", a->from);
+    RDUMP(" !CACHED");
+  RDUMP(" <-%I", a->from);
   if (a->dest == RTD_UNICAST)
     for (struct nexthop *nh = &(a->nh); nh; nh = nh->next)
       {
-	if (ipa_nonzero(nh->gw)) debug(" ->%I", nh->gw);
-	if (nh->labels) debug(" L %d", nh->label[0]);
+	if (ipa_nonzero(nh->gw)) RDUMP(" ->%I", nh->gw);
+	if (nh->labels) RDUMP(" L %d", nh->label[0]);
 	for (int i=1; i<nh->labels; i++)
-	  debug("/%d", nh->label[i]);
-	debug(" [%s]", nh->iface ? nh->iface->name : "???");
+	  RDUMP("/%d", nh->label[i]);
+	RDUMP(" [%s]", nh->iface ? nh->iface->name : "???");
       }
   if (a->eattrs)
     {
-      debug(" EA: ");
-      ea_dump(a->eattrs);
+      RDUMP(" EA: ");
+      ea_dump(dreq, a->eattrs);
     }
 }
 
@@ -1355,20 +1355,20 @@ rta_dump(rta *a)
  * to the debug output.
  */
 void
-rta_dump_all(void)
+rta_dump_all(struct dump_request *dreq)
 {
   rta *a;
   uint h;
 
-  debug("Route attribute cache (%d entries, rehash at %d):\n", rta_cache_count, rta_cache_limit);
+  RDUMP("Route attribute cache (%d entries, rehash at %d):\n", rta_cache_count, rta_cache_limit);
   for(h=0; h<rta_cache_size; h++)
     for(a=rta_hash_table[h]; a; a=a->next)
       {
-	debug("%p ", a);
-	rta_dump(a);
-	debug("\n");
+	RDUMP("%p ", a);
+	rta_dump(dreq, a);
+	RDUMP("\n");
       }
-  debug("\n");
+  RDUMP("\n");
 }
 
 void
diff --git a/nest/rt-table.c b/nest/rt-table.c
index 8fa79f02..ee3f1188 100644
--- a/nest/rt-table.c
+++ b/nest/rt-table.c
@@ -1751,13 +1751,13 @@ rt_modify_stale(rtable *t, struct channel *c)
  * This functions dumps contents of a &rte to debug output.
  */
 void
-rte_dump(rte *e)
+rte_dump(struct dump_request *dreq, rte *e)
 {
   net *n = e->net;
-  debug("%-1N ", n->n.addr);
-  debug("PF=%02x ", e->pflags);
-  rta_dump(e->attrs);
-  debug("\n");
+  RDUMP("%-1N ", n->n.addr);
+  RDUMP("PF=%02x ", e->pflags);
+  rta_dump(dreq, e->attrs);
+  RDUMP("\n");
 }
 
 /**
@@ -1767,9 +1767,9 @@ rte_dump(rte *e)
  * This function dumps contents of a given routing table to debug output.
  */
 void
-rt_dump(rtable *t)
+rt_dump(struct dump_request *dreq, rtable *t)
 {
-  debug("Dump of routing table <%s>\n", t->name);
+  RDUMP("Dump of routing table <%s>\n", t->name);
 #ifdef DEBUGGING
   fib_check(&t->fib);
 #endif
@@ -1777,10 +1777,10 @@ rt_dump(rtable *t)
     {
       rte *e;
       for(e=n->routes; e; e=e->next)
-	rte_dump(e);
+	rte_dump(dreq, e);
     }
   FIB_WALK_END;
-  debug("\n");
+  RDUMP("\n");
 }
 
 /**
@@ -1789,13 +1789,13 @@ rt_dump(rtable *t)
  * This function dumps contents of all routing tables to debug output.
  */
 void
-rt_dump_all(void)
+rt_dump_all(struct dump_request *dreq)
 {
   rtable *t;
   node *n;
 
   WALK_LIST2(t, n, routing_tables, n)
-    rt_dump(t);
+    rt_dump(dreq, t);
 }
 
 static inline void
@@ -2057,10 +2057,10 @@ rt_free(resource *_r)
 }
 
 static void
-rt_res_dump(resource *_r)
+rt_res_dump(struct dump_request *dreq, resource *_r)
 {
   rtable *r = (rtable *) _r;
-  debug("name \"%s\", addr_type=%s, rt_count=%u, use_count=%d\n",
+  RDUMP("name \"%s\", addr_type=%s, rt_count=%u, use_count=%d\n",
       r->name, net_label[r->addr_type], r->rt_count, r->use_count);
 }
 
diff --git a/proto/babel/babel.c b/proto/babel/babel.c
index 4187d258..fe5c0599 100644
--- a/proto/babel/babel.c
+++ b/proto/babel/babel.c
@@ -2103,82 +2103,82 @@ babel_reconfigure_ifaces(struct babel_proto *p, struct babel_config *cf)
  */
 
 static void
-babel_dump_source(struct babel_source *s)
+babel_dump_source(struct dump_request *dreq, struct babel_source *s)
 {
-  debug("Source router_id %lR seqno %d metric %d expires %t\n",
+  RDUMP("Source router_id %lR seqno %d metric %d expires %t\n",
 	s->router_id, s->seqno, s->metric,
 	s->expires ? s->expires - current_time() : 0);
 }
 
 static void
-babel_dump_route(struct babel_route *r)
+babel_dump_route(struct dump_request *dreq, struct babel_route *r)
 {
-  debug("Route neigh %I if %s seqno %d metric %d/%d router_id %lR expires %t\n",
+  RDUMP("Route neigh %I if %s seqno %d metric %d/%d router_id %lR expires %t\n",
 	r->neigh->addr, r->neigh->ifa->ifname, r->seqno, r->advert_metric, r->metric,
 	r->router_id, r->expires ? r->expires - current_time() : 0);
 }
 
 static void
-babel_dump_entry(struct babel_entry *e)
+babel_dump_entry(struct dump_request *dreq, struct babel_entry *e)
 {
   struct babel_source *s;
   struct babel_route *r;
 
-  debug("Babel: Entry %N:\n", e->n.addr);
+  RDUMP("Babel: Entry %N:\n", e->n.addr);
 
   WALK_LIST(s,e->sources)
-  { debug(" "); babel_dump_source(s); }
+  { RDUMP(" "); babel_dump_source(dreq, s); }
 
   WALK_LIST(r,e->routes)
   {
-    debug(" ");
-    if (r == e->selected) debug("*");
-    babel_dump_route(r);
+    RDUMP(" ");
+    if (r == e->selected) RDUMP("*");
+    babel_dump_route(dreq, r);
   }
 }
 
 static void
-babel_dump_neighbor(struct babel_neighbor *n)
+babel_dump_neighbor(struct dump_request *dreq, struct babel_neighbor *n)
 {
-  debug("Neighbor %I txcost %d hello_map %x next seqno %d expires %t/%t\n",
+  RDUMP("Neighbor %I txcost %d hello_map %x next seqno %d expires %t/%t\n",
 	n->addr, n->txcost, n->hello_map, n->next_hello_seqno,
 	n->hello_expiry ? n->hello_expiry - current_time() : 0,
         n->ihu_expiry ? n->ihu_expiry - current_time() : 0);
 }
 
 static void
-babel_dump_iface(struct babel_iface *ifa)
+babel_dump_iface(struct dump_request *dreq, struct babel_iface *ifa)
 {
   struct babel_neighbor *n;
 
-  debug("Babel: Interface %s addr %I rxcost %d type %d hello seqno %d intervals %t %t",
+  RDUMP("Babel: Interface %s addr %I rxcost %d type %d hello seqno %d intervals %t %t",
 	ifa->ifname, ifa->addr, ifa->cf->rxcost, ifa->cf->type, ifa->hello_seqno,
 	ifa->cf->hello_interval, ifa->cf->update_interval);
-  debug(" next hop v4 %I next hop v6 %I\n", ifa->next_hop_ip4, ifa->next_hop_ip6);
+  RDUMP(" next hop v4 %I next hop v6 %I\n", ifa->next_hop_ip4, ifa->next_hop_ip6);
 
   WALK_LIST(n, ifa->neigh_list)
-  { debug(" "); babel_dump_neighbor(n); }
+  { RDUMP(" "); babel_dump_neighbor(dreq, n); }
 }
 
 static void
-babel_dump(struct proto *P)
+babel_dump(struct proto *P, struct dump_request *dreq)
 {
   struct babel_proto *p = (struct babel_proto *) P;
   struct babel_iface *ifa;
 
-  debug("Babel: router id %lR update seqno %d\n", p->router_id, p->update_seqno);
+  RDUMP("Babel: router id %lR update seqno %d\n", p->router_id, p->update_seqno);
 
   WALK_LIST(ifa, p->interfaces)
-    babel_dump_iface(ifa);
+    babel_dump_iface(dreq, ifa);
 
   FIB_WALK(&p->ip4_rtable, struct babel_entry, e)
   {
-    babel_dump_entry(e);
+    babel_dump_entry(dreq, e);
   }
   FIB_WALK_END;
   FIB_WALK(&p->ip6_rtable, struct babel_entry, e)
   {
-    babel_dump_entry(e);
+    babel_dump_entry(dreq, e);
   }
   FIB_WALK_END;
 }
diff --git a/proto/bfd/bfd.c b/proto/bfd/bfd.c
index cde7f11b..a4d186ec 100644
--- a/proto/bfd/bfd.c
+++ b/proto/bfd/bfd.c
@@ -826,11 +826,11 @@ bfd_request_free(resource *r)
 }
 
 static void
-bfd_request_dump(resource *r)
+bfd_request_dump(struct dump_request *dreq, resource *r)
 {
   struct bfd_request *req = (struct bfd_request *) r;
 
-  debug("(code %p, data %p)\n", req->hook, req->data);
+  RDUMP("(code %p, data %p)\n", req->hook, req->data);
 }
 
 static struct resclass bfd_request_class = {
diff --git a/proto/bmp/bmp.c b/proto/bmp/bmp.c
index 9603c4e8..ae768a7c 100644
--- a/proto/bmp/bmp.c
+++ b/proto/bmp/bmp.c
@@ -237,7 +237,7 @@ static void
 bmp_tx_resource_free(resource *r UNUSED) {}
 
 static void
-bmp_tx_resource_dump(resource *r UNUSED) {}
+bmp_tx_resource_dump(struct dump_request *dreq UNUSED, resource *r UNUSED) {}
 
 static struct resmem
 bmp_tx_resource_memsize(resource *r)
diff --git a/proto/ospf/ospf.c b/proto/ospf/ospf.c
index ad4b2d14..da29e6c4 100644
--- a/proto/ospf/ospf.c
+++ b/proto/ospf/ospf.c
@@ -333,32 +333,31 @@ ospf_start(struct proto *P)
 }
 
 static void
-ospf_dump(struct proto *P)
+ospf_dump(struct proto *P, struct dump_request *dreq)
 {
   struct ospf_proto *p = (struct ospf_proto *) P;
   struct ospf_iface *ifa;
   struct ospf_neighbor *n;
 
-  OSPF_TRACE(D_EVENTS, "Area number: %d", p->areano);
+  RDUMP("Area number: %d\n", p->areano);
 
   WALK_LIST(ifa, p->iface_list)
   {
-    OSPF_TRACE(D_EVENTS, "Interface: %s", ifa->ifname);
-    OSPF_TRACE(D_EVENTS, "state: %u", ifa->state);
-    OSPF_TRACE(D_EVENTS, "DR:  %R", ifa->drid);
-    OSPF_TRACE(D_EVENTS, "BDR: %R", ifa->bdrid);
+    RDUMP("Interface: %s\n", ifa->ifname);
+    RDUMP("state: %u\n", ifa->state);
+    RDUMP("DR:  %R\n", ifa->drid);
+    RDUMP("BDR: %R\n", ifa->bdrid);
     WALK_LIST(n, ifa->neigh_list)
     {
-      OSPF_TRACE(D_EVENTS, "  neighbor %R in state %u", n->rid, n->state);
+      RDUMP("  neighbor %R in state %u\n", n->rid, n->state);
     }
   }
 
   /*
-  OSPF_TRACE(D_EVENTS, "LSA graph dump start:");
+  RDUMP("LSA graph dump start:");
   ospf_top_dump(p->gr, p);
-  OSPF_TRACE(D_EVENTS, "LSA graph dump finished");
+  RDUMP("LSA graph dump finished");
   */
-  neigh_dump_all();
 }
 
 static struct proto *
diff --git a/proto/rip/rip.c b/proto/rip/rip.c
index 4bfb5756..b70b6e8e 100644
--- a/proto/rip/rip.c
+++ b/proto/rip/rip.c
@@ -1315,7 +1315,7 @@ rip_show_neighbors(struct proto *P, const char *iff)
 }
 
 static void
-rip_dump(struct proto *P)
+rip_dump(struct proto *P, struct dump_request *dreq)
 {
   struct rip_proto *p = (struct rip_proto *) P;
   struct rip_iface *ifa;
@@ -1324,12 +1324,12 @@ rip_dump(struct proto *P)
   i = 0;
   FIB_WALK(&p->rtable, struct rip_entry, en)
   {
-    debug("RIP: entry #%d: %N via %I dev %s valid %d metric %d age %t\n",
+    RDUMP("RIP: entry #%d: %N via %I dev %s valid %d metric %d age %t\n",
 	  i++, en->n.addr, en->next_hop, en->iface ? en->iface->name : "(null)",
 	  en->valid, en->metric, current_time() - en->changed);
 
     for (struct rip_rte *e = en->routes; e; e = e->next)
-      debug("RIP:   via %I metric %d expires %t\n",
+      RDUMP("RIP:   via %I metric %d expires %t\n",
 	    e->next_hop, e->metric, e->expires - current_time());
   }
   FIB_WALK_END;
@@ -1337,7 +1337,7 @@ rip_dump(struct proto *P)
   i = 0;
   WALK_LIST(ifa, p->iface_list)
   {
-    debug("RIP: interface #%d: %s, %I, up = %d, busy = %d\n",
+    RDUMP("RIP: interface #%d: %s, %I, up = %d, busy = %d\n",
 	  i++, ifa->iface->name, ifa->sk ? ifa->sk->daddr : IPA_NONE,
 	  ifa->up, ifa->tx_active);
   }
diff --git a/proto/static/static.c b/proto/static/static.c
index 661d04aa..3101db2f 100644
--- a/proto/static/static.c
+++ b/proto/static/static.c
@@ -613,27 +613,27 @@ static_cleanup(struct proto *P)
 }
 
 static void
-static_dump_rte(struct static_route *r)
+static_dump_rte(struct dump_request *dreq, struct static_route *r)
 {
-  debug("%-1N (%u): ", r->net, r->index);
+  RDUMP("%-1N (%u): ", r->net, r->index);
   if (r->dest == RTD_UNICAST)
     if (r->iface && ipa_zero(r->via))
-      debug("dev %s\n", r->iface->name);
+      RDUMP("dev %s\n", r->iface->name);
     else
-      debug("via %I%J\n", r->via, r->iface);
+      RDUMP("via %I%J\n", r->via, r->iface);
   else
-    debug("rtd %d\n", r->dest);
+    RDUMP("rtd %d\n", r->dest);
 }
 
 static void
-static_dump(struct proto *P)
+static_dump(struct proto *P, struct dump_request *dreq)
 {
   struct static_config *c = (void *) P->cf;
   struct static_route *r;
 
-  debug("Static routes:\n");
+  RDUMP("Static routes:\n");
   WALK_LIST(r, c->routes)
-    static_dump_rte(r);
+    static_dump_rte(dreq, r);
 }
 
 #define IGP_TABLE(cf, sym) ((cf)->igp_table_##sym ? (cf)->igp_table_##sym ->table : NULL )
diff --git a/sysdep/unix/alloc.c b/sysdep/unix/alloc.c
index 08fc9980..2117d919 100644
--- a/sysdep/unix/alloc.c
+++ b/sysdep/unix/alloc.c
@@ -226,6 +226,26 @@ global_free_pages_cleanup_event(void *data UNUSED)
 }
 #endif
 
+void
+page_dump(struct dump_request *dreq)
+{
+#ifdef HAVE_MMAP
+  RDUMP("Hot pages:\n");
+  node *n;
+  WALK_LIST(n, global_free_pages.pages)
+    RDUMP("  %p\n", n);
+
+  RDUMP("Cold pages:\n");
+  WALK_LIST(n, global_free_pages.empty)
+  {
+    struct empty_pages *ep = SKIP_BACK(struct empty_pages, n, n);
+    RDUMP("  %p (index)\n", ep);
+    for (uint i=0; i<ep->pos; i++)
+      RDUMP("    %p\n", ep->pages[i]);
+  }
+#endif
+}
+
 void
 resource_sys_init(void)
 {
diff --git a/sysdep/unix/io.c b/sysdep/unix/io.c
index 59b33ef1..b0632486 100644
--- a/sysdep/unix/io.c
+++ b/sysdep/unix/io.c
@@ -19,6 +19,7 @@
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/socket.h>
+#include <sys/stat.h>
 #include <sys/uio.h>
 #include <sys/un.h>
 #include <poll.h>
@@ -40,6 +41,7 @@
 #include "lib/timer.h"
 #include "lib/string.h"
 #include "nest/iface.h"
+#include "nest/cli.h"
 #include "conf/conf.h"
 
 #include "sysdep/unix/unix.h"
@@ -75,11 +77,11 @@ rf_free(resource *r)
 }
 
 static void
-rf_dump(resource *r)
+rf_dump(struct dump_request *dreq, resource *r)
 {
   struct rfile *a = (struct rfile *) r;
 
-  debug("(FILE *%p)\n", a->f);
+  RDUMP("(FILE *%p)\n", a->f);
 }
 
 static struct resclass rf_class = {
@@ -129,6 +131,147 @@ rf_fileno(struct rfile *f)
   return fileno(f->f);
 }
 
+/*
+ *	Dumping to files
+ */
+
+struct dump_request_file {
+  struct dump_request dr;
+  uint pos, max; int fd;
+  uint last_progress_info;
+  char data[0];
+};
+
+static void
+dump_to_file_flush(struct dump_request_file *req)
+{
+  if (req->fd < 0)
+    return;
+
+  for (uint sent = 0; sent < req->pos; )
+  {
+    int e = write(req->fd, &req->data[sent], req->pos - sent);
+    if (e <= 0)
+    {
+      req->dr.report(&req->dr, 8009, "Failed to write data: %m");
+      close(req->fd);
+      req->fd = -1;
+      return;
+    }
+    sent += e;
+  }
+
+  req->dr.size += req->pos;
+  req->pos = 0;
+
+  for (uint reported = 0; req->dr.size >> req->last_progress_info; req->last_progress_info++)
+    if (!reported++)
+      req->dr.report(&req->dr, -13, "... dumped %lu bytes in %t s",
+	  req->dr.size, current_time_now() - req->dr.begin);
+}
+
+static void
+dump_to_file_write(struct dump_request *dr, const char *fmt, ...)
+{
+  struct dump_request_file *req = SKIP_BACK(struct dump_request_file, dr, dr);
+
+  for (uint phase = 0; (req->fd >= 0) && (phase < 2); phase++)
+  {
+    va_list args;
+    va_start(args, fmt);
+    int i = bvsnprintf(&req->data[req->pos], req->max - req->pos, fmt, args);
+    va_end(args);
+
+    if (i >= 0)
+    {
+      req->pos += i;
+      return;
+    }
+    else
+      dump_to_file_flush(req);
+  }
+
+  bug("Too long dump call");
+}
+
+struct dump_request *
+dump_to_file_init(off_t offset)
+{
+  ASSERT_DIE(offset + sizeof(struct dump_request_file) + 1024 < (unsigned long) page_size);
+
+  struct dump_request_file *req = alloc_page() + offset;
+  *req = (struct dump_request_file) {
+    .dr = {
+      .write = dump_to_file_write,
+      .begin = current_time_now(),
+      .offset = offset,
+    },
+    .max = page_size - offset - OFFSETOF(struct dump_request_file, data[0]),
+    .fd = -1,
+  };
+
+  return &req->dr;
+}
+
+void
+dump_to_file_run(struct dump_request *dr, const char *file, const char *what, void (*dump)(struct dump_request *))
+{
+  struct dump_request_file *req = SKIP_BACK(struct dump_request_file, dr, dr);
+  req->fd = open(file, O_CREAT | O_WRONLY | O_TRUNC, S_IRUSR);
+
+  if (req->fd < 0)
+  {
+    dr->report(dr, 8009, "Failed to open file %s: %m", file);
+    goto cleanup;
+  }
+
+  dr->report(dr, -13, "Dumping %s to %s", what, file);
+
+  dump(dr);
+
+  if (req->fd >= 0)
+  {
+    dump_to_file_flush(req);
+    close(req->fd);
+  }
+
+  btime end = current_time_now();
+  dr->report(dr, 13, "Dumped %lu bytes in %t s", dr->size, end - dr->begin);
+
+cleanup:
+  free_page(((void *) req) - dr->offset);
+}
+
+struct dump_request_cli {
+  cli *cli;
+  struct dump_request dr;
+};
+
+static void
+cmd_dump_report(struct dump_request *dr, int state, const char *fmt, ...)
+{
+  struct dump_request_cli *req = SKIP_BACK(struct dump_request_cli, dr, dr);
+  va_list args;
+  va_start(args, fmt);
+  cli_vprintf(req->cli, state, fmt, args);
+  va_end(args);
+}
+
+void
+cmd_dump_file(struct cli *cli, const char *file, const char *what, void (*dump)(struct dump_request *))
+{
+  if (cli->restricted)
+    return cli_printf(cli, 8007, "Access denied");
+
+  struct dump_request_cli *req = SKIP_BACK(struct dump_request_cli, dr,
+      dump_to_file_init(OFFSETOF(struct dump_request_cli, dr)));
+
+  req->cli = cli;
+  req->dr.report = cmd_dump_report;
+
+  dump_to_file_run(&req->dr, file, what, dump);
+}
+
 
 /*
  *	Time clock
@@ -932,12 +1075,12 @@ sk_reallocate(sock *s)
 }
 
 static void
-sk_dump(resource *r)
+sk_dump(struct dump_request *dreq, resource *r)
 {
   sock *s = (sock *) r;
   static char *sk_type_names[] = { "TCP<", "TCP>", "TCP", "UDP", NULL, "IP", NULL, "MAGIC", "UNIX<", "UNIX", "SSH>", "SSH", "DEL!" };
 
-  debug("(%s, ud=%p, sa=%I, sp=%d, da=%I, dp=%d, tos=%d, ttl=%d, if=%s)\n",
+  RDUMP("(%s, ud=%p, sa=%I, sp=%d, da=%I, dp=%d, tos=%d, ttl=%d, if=%s)\n",
 	sk_type_names[s->type],
 	s->data,
 	s->saddr,
@@ -2088,19 +2231,19 @@ sk_err(sock *s, int revents)
 }
 
 void
-sk_dump_all(void)
+sk_dump_all(struct dump_request *dreq)
 {
   node *n;
   sock *s;
 
-  debug("Open sockets:\n");
+  RDUMP("Open sockets:\n");
   WALK_LIST(n, sock_list)
   {
     s = SKIP_BACK(sock, n, n);
-    debug("%p ", s);
-    sk_dump(&s->r);
+    RDUMP("%p ", s);
+    sk_dump(dreq, &s->r);
   }
-  debug("\n");
+  RDUMP("\n");
 }
 
 
@@ -2191,16 +2334,16 @@ io_close_event(void)
 }
 
 void
-io_log_dump(void)
+io_log_dump(struct dump_request *dreq)
 {
   int i;
 
-  log(L_DEBUG "Event log:");
+  RDUMP("Event log:");
   for (i = 0; i < EVENT_LOG_LENGTH; i++)
   {
     struct event_log_entry *en = event_log + (event_log_pos + i) % EVENT_LOG_LENGTH;
     if (en->hook)
-      log(L_DEBUG "  Event 0x%p 0x%p at %8d for %d ms", en->hook, en->data,
+      RDUMP("  Event 0x%p 0x%p at %8d for %d ms", en->hook, en->data,
 	  (int) ((last_time - en->timestamp) TO_MS), (int) (en->duration TO_MS));
   }
 }
diff --git a/sysdep/unix/krt.c b/sysdep/unix/krt.c
index 0664f4c1..51d0718c 100644
--- a/sysdep/unix/krt.c
+++ b/sysdep/unix/krt.c
@@ -532,14 +532,14 @@ krt_learn_init(struct krt_proto *p)
 }
 
 static void
-krt_dump(struct proto *P)
+krt_dump(struct proto *P, struct dump_request *dreq)
 {
   struct krt_proto *p = (struct krt_proto *) P;
 
   if (!KRT_CF->learn)
     return;
-  debug("KRT: Table of inheritable routes\n");
-  rt_dump(p->krt_table);
+  RDUMP("KRT: Table of inheritable routes\n");
+  rt_dump(dreq, p->krt_table);
 }
 
 #endif
diff --git a/sysdep/unix/main.c b/sysdep/unix/main.c
index b825a1f3..85acc218 100644
--- a/sysdep/unix/main.c
+++ b/sysdep/unix/main.c
@@ -48,21 +48,38 @@
  *	Debugging
  */
 
+static void
+async_dump_report(struct dump_request *dr UNUSED, int state, const char *fmt, ...)
+{
+  va_list args;
+  va_start(args, fmt);
+  vlog(((state > 1000) ? L_ERR : L_INFO)[0], fmt, args);
+  va_end(args);
+}
+
+static void
+async_dump_run(struct dump_request *dreq)
+{
+  RDUMP("ASYNC STATE DUMP\n");
+
+  rdump(dreq, &root_pool);
+  sk_dump_all(dreq);
+  // XXXX tm_dump_all();
+  if_dump_all(dreq);
+  neigh_dump_all(dreq);
+  rta_dump_all(dreq);
+  rt_dump_all(dreq);
+  protos_dump_all(dreq);
+
+  debug("\n");
+}
+
 void
 async_dump(void)
 {
-  debug("INTERNAL STATE DUMP\n\n");
-
-  rdump(&root_pool);
-  sk_dump_all();
-  // XXXX tm_dump_all();
-  if_dump_all();
-  neigh_dump_all();
-  rta_dump_all();
-  rt_dump_all();
-  protos_dump_all();
-
-  debug("\n");
+  struct dump_request *dr = dump_to_file_init(0);
+  dr->report = async_dump_report;
+  dump_to_file_run(dr, "bird.dump", "async dump", async_dump_run);
 }
 
 /*
diff --git a/sysdep/unix/unix.h b/sysdep/unix/unix.h
index 33ece06c..2b3c5d4e 100644
--- a/sysdep/unix/unix.h
+++ b/sysdep/unix/unix.h
@@ -16,6 +16,7 @@ struct pool;
 struct iface;
 struct birdsock;
 struct rfile;
+struct cli;
 
 /* main.c */
 
@@ -106,7 +107,7 @@ extern volatile sig_atomic_t async_shutdown_flag;
 
 void io_init(void);
 void io_loop(void);
-void io_log_dump(void);
+void io_log_dump(struct dump_request *);
 int sk_open_unix(struct birdsock *s, const char *name);
 struct rfile *rf_open(struct pool *, const char *name, const char *mode);
 struct rfile *rf_fdopen(pool *p, int fd, const char *mode);
@@ -115,6 +116,11 @@ int rf_fileno(struct rfile *f);
 void test_old_bird(const char *path);
 ip_addr resolve_hostname(const char *host, int type, const char **err_msg);
 
+struct dump_request *dump_to_file_init(off_t offset);
+void dump_to_file_run(struct dump_request *dr, const char *file, const char *what, void (*dump)(struct dump_request *));
+
+void cmd_dump_file(struct cli *cli, const char *file, const char *what, void (*dump)(struct dump_request *));
+
 /* krt.c bits */
 
 void krt_io_init(void);