mirror of
https://gitlab.nic.cz/labs/bird.git
synced 2025-02-14 12:06:42 +00:00
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.
This commit is contained in:
parent
4dd5b3d90e
commit
da8a23277e
@ -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.
|
||||
|
@ -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
|
||||
|
@ -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;
|
||||
}
|
||||
|
||||
|
@ -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.
|
||||
|
@ -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 */
|
||||
|
@ -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);
|
||||
}
|
||||
|
||||
|
@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -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)
|
||||
|
@ -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
|
||||
|
@ -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");
|
||||
|
@ -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,
|
||||
|
@ -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 *
|
||||
|
@ -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 */
|
||||
|
@ -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
|
||||
|
@ -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 */
|
||||
|
12
lib/timer.c
12
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");
|
||||
}
|
||||
|
||||
|
||||
|
@ -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)); } ;
|
||||
|
40
nest/iface.c
40
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
|
||||
|
10
nest/iface.h
10
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 *);
|
||||
|
@ -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 = {
|
||||
|
@ -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
|
||||
|
14
nest/proto.c
14
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);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -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 */
|
||||
|
12
nest/route.h
12
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);
|
||||
|
@ -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
|
||||
|
@ -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);
|
||||
}
|
||||
|
||||
|
@ -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;
|
||||
}
|
||||
|
@ -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 = {
|
||||
|
@ -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)
|
||||
|
@ -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;
|
||||
|
||||