Commit 41572e0c authored by Maria Matejka's avatar Maria Matejka
Browse files

Merge commit 'f81702b7' into haugesund

parents 9dc1d778 f81702b7

filter/filter.c

+21 −13
Original line number Diff line number Diff line
@@ -425,6 +425,23 @@ filter_commit(struct config *new, struct config *old) 
    }

}



void channel_filter_dump(const struct filter *f)

{

  if (f == FILTER_ACCEPT)

    debug(" ALL");

  else if (f == FILTER_REJECT)

    debug(" NONE");

  else if (f == FILTER_UNDEF)

    debug(" UNDEF");

  else if (f->sym) {

    ASSERT(f->sym->filter == f);

    debug(" named filter %s", f->sym->name);

  } else {

    debug("\n");

    f_dump_line(f->root, 2);

  }

}



void filters_dump_all(void)

{

  struct symbol *sym;
@@ -444,19 +461,10 @@ void filters_dump_all(void) 
	  struct channel *c;

	  WALK_LIST(c, sym->proto->proto->channels) {

	    debug(" Channel %s (%s) IMPORT", c->name, net_label[c->net_type]);

	    if (c->in_filter == FILTER_ACCEPT)

	      debug(" ALL\n");

	    else if (c->in_filter == FILTER_REJECT)

	      debug(" NONE\n");

	    else if (c->in_filter == FILTER_UNDEF)

	      debug(" 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);

	    } else {

	    channel_filter_dump(c->in_filter);

	    debug(" EXPORT", c->name, net_label[c->net_type]);

	    channel_filter_dump(c->out_filter);

	    debug("\n");

	      f_dump_line(c->in_filter->root, 2);

	    }

	  }

	}

    }

nest/config.Y

+3 −1
Original line number Diff line number Diff line
@@ -851,8 +851,10 @@ 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]])

CF_CLI(DUMP ROUTES,,, [[Dump routes]])

{ rt_dump_all(); cli_msg(0, ""); } ;

CF_CLI(DUMP TABLES,,, [[Dump table connections]])

{ rt_dump_hooks_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]])

nest/limit.h

0 → 100644
+49 −0
Original line number Diff line number Diff line 
/*

 *	BIRD Internet Routing Daemon -- Limits

 *

 *	(c) 1998--2000 Martin Mares <mj@ucw.cz>

 *	(c) 2021 Maria Matejka <mq@jmq.cz>

 *

 *	Can be freely distributed and used under the terms of the GNU GPL.

 */



#ifndef _BIRD_LIMIT_H_

#define _BIRD_LIMIT_H_



struct limit {

  u32 max;

  u32 count;

  int (*action)(struct limit *, void *data);

};



static inline int limit_do_action(struct limit *l, void *data)

{

  return l->action ? l->action(l, data) : 1;

}



static inline int limit_push(struct limit *l, void *data)

{

  if ((l->count >= l->max) && limit_do_action(l, data))

    return 1;



  l->count++;

  return 0;

}



static inline void limit_pop(struct limit *l)

{

  --l->count;

}



static inline void limit_reset(struct limit *l)

{

  l->count = 0;

}



static inline void limit_update(struct limit *l, void *data, u32 max)

{

  if (l->count > (l->max = max))

    limit_do_action(l, data);

}



#endif

nest/proto.c

+422 −286

File changed.

Preview size limit exceeded, changes collapsed.

nest/protocol.h

+63 −60
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ 
#include "lib/resource.h"

#include "lib/event.h"

#include "nest/route.h"

#include "nest/limit.h"

#include "conf/conf.h"



struct iface;
@@ -76,7 +77,6 @@ struct protocol { 
  void (*dump)(struct proto *);			/* 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 */

  void (*get_status)(struct proto *, byte *buf); /* Get instance status (for `show protocols' command) */

  void (*get_route_info)(struct rte *, byte *buf); /* Get route information (for `show route' command) */

  int (*get_attr)(const struct eattr *, byte *buf, int buflen);	/* ASCIIfy dynamic attribute (returns GA_*) */
@@ -132,33 +132,6 @@ struct proto_config { 
};



/* Protocol statistics */

struct import_stats {

  /* Import - from protocol to core */

  u32 routes;			/* Number of routes successfully imported to the (adjacent) routing table */

  u32 filtered;			/* Number of routes rejected in import filter but kept in the routing table */

  u32 pref;			/* Number of routes selected as best in the (adjacent) routing table */

  u32 updates_received;		/* Number of route updates received */

  u32 updates_invalid;		/* Number of route updates rejected as invalid */

  u32 updates_filtered;		/* Number of route updates rejected by filters */

  u32 updates_ignored;		/* Number of route updates rejected as already in route table */

  u32 updates_accepted;		/* Number of route updates accepted and imported */

  u32 withdraws_received;	/* Number of route withdraws received */

  u32 withdraws_invalid;	/* Number of route withdraws rejected as invalid */

  u32 withdraws_ignored;	/* Number of route withdraws rejected as already not in route table */

  u32 withdraws_accepted;	/* Number of route withdraws accepted and processed */

};



struct export_stats {

  /* Export - from core to protocol */

  u32 routes;			/* Number of routes successfully exported to the protocol */

  u32 updates_received;		/* Number of route updates received */

  u32 updates_rejected;		/* Number of route updates rejected by protocol */

  u32 updates_filtered;		/* Number of route updates rejected by filters */

  u32 updates_accepted;		/* Number of route updates accepted and exported */

  u32 withdraws_received;	/* Number of route withdraws received */

  u32 withdraws_accepted;	/* Number of route withdraws accepted and processed */

};



struct proto {

  node n;				/* Node in global proto_list */

  struct protocol *proto;		/* Protocol */
@@ -277,7 +250,7 @@ void channel_graceful_restart_unlock(struct channel *c); 


#define DEFAULT_GR_WAIT	240



void channel_show_limit(struct channel_limit *l, const char *dsc);

void channel_show_limit(struct limit *l, const char *dsc, int active, int action);

void channel_show_info(struct channel *c);

void channel_cmd_debug(struct channel *c, uint mask);
@@ -432,18 +405,29 @@ extern struct proto_config *cf_dev_proto; 
#define PLA_RESTART	4	/* Force protocol restart */

#define PLA_DISABLE	5	/* Shutdown and disable protocol */



#define PLS_INITIAL	0	/* Initial limit state after protocol start */

#define PLS_ACTIVE	1	/* Limit was hit */

#define PLS_BLOCKED	2	/* Limit is active and blocking new routes */



struct channel_limit {

  u32 limit;			/* Maximum number of prefixes */

  u8 action;			/* Action to take (PLA_*) */

  u8 state;			/* State of limit (PLS_*) */

};



void channel_notify_limit(struct channel *c, struct channel_limit *l, int dir, u32 rt_count);

struct channel_limit_data {

  struct channel *c;

  int dir;

};



#define CLP__RX(_c) (&(_c)->rx_limit)

#define CLP__IN(_c) (&(_c)->in_limit)

#define CLP__OUT(_c) (&(_c)->out_limit)





#if 0

#define CHANNEL_LIMIT_LOG(_c, _dir, _op)  log(L_TRACE "%s.%s: %s limit %s %u", (_c)->proto->name, (_c)->name, #_dir, _op, (CLP__##_dir(_c))->count)

#else

#define CHANNEL_LIMIT_LOG(_c, _dir, _op)

#endif



#define CHANNEL_LIMIT_PUSH(_c, _dir)  ({ CHANNEL_LIMIT_LOG(_c, _dir, "push from"); struct channel_limit_data cld = { .c = (_c), .dir = PLD_##_dir }; limit_push(CLP__##_dir(_c), &cld); })

#define CHANNEL_LIMIT_POP(_c, _dir)   ({ limit_pop(CLP__##_dir(_c)); CHANNEL_LIMIT_LOG(_c, _dir, "pop to"); })



/*

 *	Channels
@@ -486,6 +470,7 @@ struct channel_config { 
  struct proto_config *parent;		/* Where channel is defined (proto or template) */

  struct rtable_config *table;		/* Table we're attached to */

  const struct filter *in_filter, *out_filter; /* Attached filters */



  struct channel_limit rx_limit;	/* Limit for receiving routes from protocol

					   (relevant when in_keep_filtered is active) */

  struct channel_limit in_limit;	/* Limit for importing routes from protocol */
@@ -502,7 +487,6 @@ struct channel_config { 


struct channel {

  node n;				/* Node in proto->channels */

  node table_node;			/* Node in table->channels */



  const char *name;			/* Channel name (may be NULL) */

  const struct channel_class *channel;
@@ -513,14 +497,36 @@ struct channel { 
  const struct filter *out_filter;	/* Output filter */

  struct bmap export_map;		/* Keeps track which routes were really exported */

  struct bmap export_reject_map;	/* Keeps track which routes were rejected by export filter */

  struct channel_limit rx_limit;	/* Receive limit (for in_keep_filtered) */

  struct channel_limit in_limit;	/* Input limit */

  struct channel_limit out_limit;	/* Output limit */



  struct event *feed_event;		/* Event responsible for feeding */

  struct fib_iterator feed_fit;		/* Routing table iterator used during feeding */

  struct import_stats import_stats;	/* Import statistics */

  struct export_stats export_stats;	/* Export statistics */

  struct limit rx_limit;		/* Receive limit (for in_keep_filtered) */

  struct limit in_limit;		/* Input limit */

  struct limit out_limit;		/* Output limit */



  u8 limit_actions[PLD_MAX];		/* Limit actions enum */

  u8 limit_active;			/* Flags for active limits */



  struct channel_import_stats {

    /* Import - from protocol to core */

    u32 updates_received;		/* Number of route updates received */

    u32 updates_invalid;		/* Number of route updates rejected as invalid */

    u32 updates_filtered;		/* Number of route updates rejected by filters */

    u32 updates_limited_rx;		/* Number of route updates exceeding the rx_limit */

    u32 updates_limited_in;		/* Number of route updates exceeding the in_limit */

    u32 withdraws_received;		/* Number of route withdraws received */

    u32 withdraws_invalid;		/* Number of route withdraws rejected as invalid */

  } import_stats;



  struct channel_export_stats {

    /* Export - from core to protocol */

    u32 updates_rejected;		/* Number of route updates rejected by protocol */

    u32 updates_filtered;		/* Number of route updates rejected by filters */

    u32 updates_accepted;		/* Number of route updates accepted and exported */

    u32 updates_limited;		/* Number of route updates exceeding the out_limit */

    u32 withdraws_accepted;		/* Number of route withdraws accepted and processed */

  } export_stats;



  struct rt_import_request in_req;	/* Table import connection */

  struct rt_export_request out_req;	/* Table export connection */



  u32 refeed_count;			/* Number of routes exported during refeed regardless of out_limit */
@@ -534,10 +540,7 @@ struct channel { 
  u8 stale;				/* Used in reconfiguration */



  u8 channel_state;

  u8 export_state;			/* Route export state (ES_*, see below) */

  u8 feed_active;

  u8 flush_active;

  u8 refeeding;				/* We are refeeding (valid only if export_state == ES_FEEDING) */

  u8 refeeding;				/* Refeeding the channel. */

  u8 reloadable;			/* Hook reload_routes() is allowed on the channel */

  u8 gr_lock;				/* Graceful restart mechanism should wait for this channel */

  u8 gr_wait;				/* Route export to channel is postponed until graceful restart */
@@ -585,34 +588,34 @@ struct channel { 
 * restricted by that and is on volition of the protocol. Generally, channels

 * are opened in protocols' start() hooks when going to PS_UP.

 *

 * CS_FLUSHING - The transitional state between initialized channel and closed

 * CS_STOP - The transitional state between initialized channel and closed

 * channel. The channel is still initialized, but no route exchange is allowed.

 * Instead, the associated table is running flush loop to remove routes imported

 * through the channel. After that, the channel changes state to CS_DOWN and

 * is detached from the table (the table is unlocked and the channel is unlinked

 * from it). Unlike other states, the CS_FLUSHING state is not explicitly

 * from it). Unlike other states, the CS_STOP state is not explicitly

 * entered or left by the protocol. A protocol may request to close a channel

 * (by calling channel_close()), which causes the channel to change state to

 * CS_FLUSHING and later to CS_DOWN. Also note that channels are closed

 * CS_STOP and later to CS_DOWN. Also note that channels are closed

 * automatically by the core when the protocol is going down.

 *

 * CS_PAUSE - Almost the same as CS_STOP, just the table import is kept and

 * the table export is stopped before transitioning to CS_START.

 *

 * Allowed transitions:

 *

 * CS_DOWN	-> CS_START / CS_UP

 * CS_START	-> CS_UP / CS_FLUSHING

 * CS_UP	-> CS_START / CS_FLUSHING

 * CS_FLUSHING	-> CS_DOWN (automatic)

 * CS_START	-> CS_UP / CS_STOP

 * CS_UP	-> CS_PAUSE / CS_STOP

 * CS_PAUSE	-> CS_START (automatic)

 * CS_STOP	-> CS_DOWN (automatic)

 */



#define CS_DOWN		0

#define CS_START	1

#define CS_UP		2

#define CS_FLUSHING	3



#define ES_DOWN		0

#define ES_FEEDING	1

#define ES_READY	2



#define CS_STOP		3

#define CS_PAUSE	4



struct channel_config *proto_cf_find_channel(struct proto_config *p, uint net_type);

static inline struct channel_config *proto_cf_main_channel(struct proto_config *pc)
@@ -630,7 +633,7 @@ void channel_schedule_reload(struct channel *c); 


static inline void channel_init(struct channel *c) { channel_set_state(c, CS_START); }

static inline void channel_open(struct channel *c) { channel_set_state(c, CS_UP); }

static inline void channel_close(struct channel *c) { channel_set_state(c, CS_FLUSHING); }

static inline void channel_close(struct channel *c) { channel_set_state(c, CS_STOP); }



void channel_request_feeding(struct channel *c);

void *channel_config_new(const struct channel_class *cc, const char *name, uint net_type, struct proto_config *proto);

CRA Git | Maintained and supported by SUSTech CRA and CCSE