[mirror_frr.git] / lib / memtypes.c

/*
 * Memory type definitions. This file is parsed by memtypes.awk to extract
 * MTYPE_ and memory_list_.. information in order to autogenerate 
 * memtypes.h.
 *
 * The script is sensitive to the format (though not whitespace), see
 * the top of memtypes.awk for more details.
 */

#include "zebra.h"
#include "memory.h"

struct memory_list memory_list_lib[] =
{
  { MTYPE_TMP,			"Temporary memory"		},
  { MTYPE_STRVEC,		"String vector"			},
  { MTYPE_VECTOR,		"Vector"			},
  { MTYPE_VECTOR_INDEX,		"Vector index"			},
  { MTYPE_LINK_LIST,		"Link List"			},
  { MTYPE_LINK_NODE,		"Link Node"			},
  { MTYPE_THREAD,		"Thread"			},
  { MTYPE_THREAD_MASTER,	"Thread master"			},
  { MTYPE_THREAD_STATS,		"Thread stats"			},
  { MTYPE_VTY,			"VTY"				},
  { MTYPE_VTY_OUT_BUF,		"VTY output buffer"		},
  { MTYPE_VTY_HIST,		"VTY history"			},
  { MTYPE_IF,			"Interface"			},
  { MTYPE_CONNECTED,		"Connected" 			},
  { MTYPE_NBR_CONNECTED,		"Neighbor Connected" 			},
  { MTYPE_CONNECTED_LABEL,	"Connected interface label"	},
  { MTYPE_BUFFER,		"Buffer"			},
  { MTYPE_BUFFER_DATA,		"Buffer data"			},
  { MTYPE_STREAM,		"Stream"			},
  { MTYPE_STREAM_DATA,		"Stream data"			},
  { MTYPE_STREAM_FIFO,		"Stream FIFO"			},
  { MTYPE_PREFIX,		"Prefix"			},
  { MTYPE_PREFIX_IPV4,		"Prefix IPv4"			},
  { MTYPE_PREFIX_IPV6,		"Prefix IPv6"			},
  { MTYPE_HASH,			"Hash"				},
  { MTYPE_HASH_BACKET,		"Hash Bucket"			},
  { MTYPE_HASH_INDEX,		"Hash Index"			},
  { MTYPE_ROUTE_TABLE,		"Route table"			},
  { MTYPE_ROUTE_NODE,		"Route node"			},
  { MTYPE_DISTRIBUTE,		"Distribute list"		},
  { MTYPE_DISTRIBUTE_IFNAME,	"Dist-list ifname"		},
  { MTYPE_DISTRIBUTE_NAME,      "Dist-list name"                },
  { MTYPE_ACCESS_LIST,		"Access List"			},
  { MTYPE_ACCESS_LIST_STR,	"Access List Str"		},
  { MTYPE_ACCESS_FILTER,	"Access Filter"			},
  { MTYPE_PREFIX_LIST,		"Prefix List"			},
  { MTYPE_PREFIX_LIST_ENTRY,	"Prefix List Entry"		},
  { MTYPE_PREFIX_LIST_STR,	"Prefix List Str"		},
  { MTYPE_PREFIX_LIST_TRIE,	"Prefix List Trie Table"	},
  { MTYPE_ROUTE_MAP,		"Route map"			},
  { MTYPE_ROUTE_MAP_NAME,	"Route map name"		},
  { MTYPE_ROUTE_MAP_INDEX,	"Route map index"		},
  { MTYPE_ROUTE_MAP_RULE,	"Route map rule"		},
  { MTYPE_ROUTE_MAP_RULE_STR,	"Route map rule str"		},
  { MTYPE_ROUTE_MAP_COMPILED,	"Route map compiled"		},
  { MTYPE_ROUTE_MAP_DEP,        "Route map dependency"          },
  { MTYPE_CMD_TOKENS,		"Command desc"			},
  { MTYPE_KEY,			"Key"				},
  { MTYPE_KEYCHAIN,		"Key chain"			},
  { MTYPE_IF_RMAP,		"Interface route map"		},
  { MTYPE_IF_RMAP_NAME,		"I.f. route map name",		},
  { MTYPE_SOCKUNION,		"Socket union"			},
  { MTYPE_PRIVS,		"Privilege information"		},
  { MTYPE_ZLOG,			"Logging"			},
  { MTYPE_ZCLIENT,		"Zclient"			},
  { MTYPE_WORK_QUEUE,		"Work queue"			},
  { MTYPE_WORK_QUEUE_ITEM,	"Work queue item"		},
  { MTYPE_WORK_QUEUE_NAME,	"Work queue name string"	},
  { MTYPE_PQUEUE,		"Priority queue"		},
  { MTYPE_PQUEUE_DATA,		"Priority queue data"		},
  { MTYPE_HOST,			"Host config"			},
  { MTYPE_BFD_INFO,             "BFD info"			},
  { MTYPE_VRF,			"VRF"				},
  { MTYPE_VRF_NAME,		"VRF name"			},
  { MTYPE_VRF_BITMAP,		"VRF bit-map"			},
  { -1, NULL },
};

struct memory_list memory_list_zebra[] = 
{
  { MTYPE_RTADV_PREFIX,		"Router Advertisement Prefix"	},
  { MTYPE_ZEBRA_NS,             "Zebra Name Space"              },
  { MTYPE_ZEBRA_VRF,		"ZEBRA VRF"				},
  { MTYPE_NEXTHOP,		"Nexthop"			},
  { MTYPE_RIB,			"RIB"				},
  { MTYPE_RIB_QUEUE,		"RIB process work queue"	},
  { MTYPE_STATIC_ROUTE,		"Static route"			},
  { MTYPE_RIB_DEST,		"RIB destination"		},
  { MTYPE_RIB_TABLE_INFO,	"RIB table info"		},
  { MTYPE_RNH,		        "Nexthop tracking object"	},
  { MTYPE_NETLINK_NAME,	        "Netlink name"			},
  { -1, NULL },
};

struct memory_list memory_list_bgp[] =
{
  { MTYPE_BGP,			"BGP instance"			},
  { MTYPE_BGP_LISTENER,		"BGP listen socket details"	},
  { MTYPE_BGP_PEER,		"BGP peer"			},
  { MTYPE_BGP_PEER_HOST,	"BGP peer hostname"		},
  { MTYPE_BGP_PEER_IFNAME,      "BGP peer ifname"               },
  { MTYPE_BGP_PEER_GROUP,	"BGP Peer group"		},
  { MTYPE_BGP_PEER_GROUP_HOST,  "BGP Peer group hostname"       },
  { MTYPE_PEER_DESC,		"Peer description"		},
  { MTYPE_PEER_PASSWORD,	"Peer password string"		},
  { MTYPE_BGP_PEER_AF,		"BGP peer af"			},
  { MTYPE_BGP_UPDGRP,		"BGP update group"		},
  { MTYPE_BGP_UPD_SUBGRP,	"BGP update subgroup"		},
  { MTYPE_BGP_PACKET, 	        "BGP packet"		        },
  { MTYPE_ATTR,			"BGP attribute"			},
  { MTYPE_ATTR_EXTRA,		"BGP extra attributes"		},
  { MTYPE_AS_PATH,		"BGP aspath"			},
  { MTYPE_AS_SEG,		"BGP aspath seg"		},
  { MTYPE_AS_SEG_DATA,		"BGP aspath segment data"	},
  { MTYPE_AS_STR,		"BGP aspath str"		},
  { 0, NULL },
  { MTYPE_BGP_TABLE,		"BGP table"			},
  { MTYPE_BGP_NODE,		"BGP node"			},
  { MTYPE_BGP_ROUTE,		"BGP route"			},
  { MTYPE_BGP_ROUTE_EXTRA,	"BGP ancillary route info"	},
  { MTYPE_BGP_CONN,		"BGP connected"			},
  { MTYPE_BGP_STATIC,		"BGP static"			},
  { MTYPE_BGP_ADVERTISE_ATTR,	"BGP adv attr"			},
  { MTYPE_BGP_ADVERTISE,	"BGP adv"			},
  { MTYPE_BGP_SYNCHRONISE,	"BGP synchronise"		},
  { MTYPE_BGP_ADJ_IN,		"BGP adj in"			},
  { MTYPE_BGP_ADJ_OUT,		"BGP adj out"			},
  { MTYPE_BGP_MPATH_INFO,	"BGP multipath info"		},
  { 0, NULL },
  { MTYPE_AS_LIST,		"BGP AS list"			},
  { MTYPE_AS_FILTER,		"BGP AS filter"			},
  { MTYPE_AS_FILTER_STR,	"BGP AS filter str"		},
  { 0, NULL },
  { MTYPE_COMMUNITY,		"community"			},
  { MTYPE_COMMUNITY_VAL,	"community val"			},
  { MTYPE_COMMUNITY_STR,	"community str"			},
  { 0, NULL },
  { MTYPE_ECOMMUNITY,		"extcommunity"			},
  { MTYPE_ECOMMUNITY_VAL,	"extcommunity val"		},
  { MTYPE_ECOMMUNITY_STR,	"extcommunity str"		},
  { 0, NULL },
  { MTYPE_COMMUNITY_LIST,	"community-list"		},
  { MTYPE_COMMUNITY_LIST_NAME,	"community-list name"		},
  { MTYPE_COMMUNITY_LIST_ENTRY,	"community-list entry"		},
  { MTYPE_COMMUNITY_LIST_CONFIG,  "community-list config"	},
  { MTYPE_COMMUNITY_LIST_HANDLER, "community-list handler"	},
  { 0, NULL },
  { MTYPE_CLUSTER,		"Cluster list"			},
  { MTYPE_CLUSTER_VAL,		"Cluster list val"		},
  { 0, NULL },
  { MTYPE_BGP_PROCESS_QUEUE,	"BGP Process queue"		},
  { MTYPE_BGP_CLEAR_NODE_QUEUE, "BGP node clear queue"		},
  { 0, NULL },
  { MTYPE_TRANSIT,		"BGP transit attr"		},
  { MTYPE_TRANSIT_VAL,		"BGP transit val"		},
  { 0, NULL },
  { MTYPE_BGP_DEBUG_FILTER,     "BGP debug filter"              },
  { MTYPE_BGP_DEBUG_STR,        "BGP debug filter string"       },
  { 0, NULL },
  { MTYPE_BGP_DISTANCE,		"BGP distance"			},
  { MTYPE_BGP_NEXTHOP_CACHE,	"BGP nexthop"			},
  { MTYPE_BGP_CONFED_LIST,	"BGP confed list"		},
  { MTYPE_PEER_UPDATE_SOURCE,	"BGP peer update interface"	},
  { MTYPE_PEER_CONF_IF,	"BGP peer config interface"	},
  { MTYPE_BGP_DAMP_INFO,	"Dampening info"		},
  { MTYPE_BGP_DAMP_ARRAY,	"BGP Dampening array"		},
  { MTYPE_BGP_REGEXP,		"BGP regexp"			},
  { MTYPE_BGP_AGGREGATE,	"BGP aggregate"			},
  { MTYPE_BGP_ADDR,		"BGP own address"		},
  { 0 , NULL},
  { MTYPE_BGP_REDIST,           "BGP redistribution"            },
  { MTYPE_BGP_FILTER_NAME,      "BGP Filter Information"        },
  { MTYPE_BGP_DUMP_STR,         "BGP Dump String Information"   },
  { -1, NULL }
};

struct memory_list memory_list_rip[] =
{
  { MTYPE_RIP,                "RIP structure"			},
  { MTYPE_RIP_INFO,           "RIP route info"			},
  { MTYPE_RIP_INTERFACE,      "RIP interface"			},
  { MTYPE_RIP_PEER,           "RIP peer"			},
  { MTYPE_RIP_OFFSET_LIST,    "RIP offset list"			},
  { MTYPE_RIP_DISTANCE,       "RIP distance"			},
  { -1, NULL }
};

struct memory_list memory_list_ripng[] =
{
  { MTYPE_RIPNG,              "RIPng structure"			},
  { MTYPE_RIPNG_ROUTE,        "RIPng route info"		},
  { MTYPE_RIPNG_AGGREGATE,    "RIPng aggregate"			},
  { MTYPE_RIPNG_PEER,         "RIPng peer"			},
  { MTYPE_RIPNG_OFFSET_LIST,  "RIPng offset lst"		},
  { MTYPE_RIPNG_RTE_DATA,     "RIPng rte data"			},
  { -1, NULL }
};

struct memory_list memory_list_ospf[] =
{
  { MTYPE_OSPF_TOP,           "OSPF top"			},
  { MTYPE_OSPF_AREA,          "OSPF area"			},
  { MTYPE_OSPF_AREA_RANGE,    "OSPF area range"			},
  { MTYPE_OSPF_NETWORK,       "OSPF network"			},
  { MTYPE_OSPF_NEIGHBOR_STATIC,"OSPF static nbr"		},
  { MTYPE_OSPF_IF,            "OSPF interface"			},
  { MTYPE_OSPF_NEIGHBOR,      "OSPF neighbor"			},
  { MTYPE_OSPF_ROUTE,         "OSPF route"			},
  { MTYPE_OSPF_TMP,           "OSPF tmp mem"			},
  { MTYPE_OSPF_LSA,           "OSPF LSA"			},
  { MTYPE_OSPF_LSA_DATA,      "OSPF LSA data"			},
  { MTYPE_OSPF_LSDB,          "OSPF LSDB"			},
  { MTYPE_OSPF_PACKET,        "OSPF packet"			},
  { MTYPE_OSPF_FIFO,          "OSPF FIFO queue"			},
  { MTYPE_OSPF_VERTEX,        "OSPF vertex"			},
  { MTYPE_OSPF_VERTEX_PARENT, "OSPF vertex parent",		},
  { MTYPE_OSPF_NEXTHOP,       "OSPF nexthop"			},
  { MTYPE_OSPF_PATH,	      "OSPF path"			},
  { MTYPE_OSPF_VL_DATA,       "OSPF VL data"			},
  { MTYPE_OSPF_CRYPT_KEY,     "OSPF crypt key"			},
  { MTYPE_OSPF_EXTERNAL_INFO, "OSPF ext. info"			},
  { MTYPE_OSPF_DISTANCE,      "OSPF distance"			},
  { MTYPE_OSPF_IF_INFO,       "OSPF if info"			},
  { MTYPE_OSPF_IF_PARAMS,     "OSPF if params"			},
  { MTYPE_OSPF_MESSAGE,		"OSPF message"			},
  { -1, NULL },
};

struct memory_list memory_list_ospf6[] =
{
  { MTYPE_OSPF6_TOP,          "OSPF6 top"			},
  { MTYPE_OSPF6_AREA,         "OSPF6 area"			},
  { MTYPE_OSPF6_IF,           "OSPF6 interface"			},
  { MTYPE_OSPF6_NEIGHBOR,     "OSPF6 neighbor"			},
  { MTYPE_OSPF6_ROUTE,        "OSPF6 route"			},
  { MTYPE_OSPF6_PREFIX,       "OSPF6 prefix"			},
  { MTYPE_OSPF6_MESSAGE,      "OSPF6 message"			},
  { MTYPE_OSPF6_LSA,          "OSPF6 LSA"			},
  { MTYPE_OSPF6_LSA_SUMMARY,  "OSPF6 LSA summary"		},
  { MTYPE_OSPF6_LSDB,         "OSPF6 LSA database"		},
  { MTYPE_OSPF6_VERTEX,       "OSPF6 vertex"			},
  { MTYPE_OSPF6_SPFTREE,      "OSPF6 SPF tree"			},
  { MTYPE_OSPF6_NEXTHOP,      "OSPF6 nexthop"			},
  { MTYPE_OSPF6_EXTERNAL_INFO,"OSPF6 ext. info"			},
  { MTYPE_OSPF6_OTHER,        "OSPF6 other"			},
  { -1, NULL },
};

struct memory_list memory_list_isis[] =
{
  { MTYPE_ISIS,               "ISIS"				},
  { MTYPE_ISIS_TMP,           "ISIS TMP"			},
  { MTYPE_ISIS_CIRCUIT,       "ISIS circuit"			},
  { MTYPE_ISIS_LSP,           "ISIS LSP"			},
  { MTYPE_ISIS_ADJACENCY,     "ISIS adjacency"			},
  { MTYPE_ISIS_AREA,          "ISIS area"			},
  { MTYPE_ISIS_AREA_ADDR,     "ISIS area address"		},
  { MTYPE_ISIS_TLV,           "ISIS TLV"			},
  { MTYPE_ISIS_DYNHN,         "ISIS dyn hostname"		},
  { MTYPE_ISIS_SPFTREE,       "ISIS SPFtree"			},
  { MTYPE_ISIS_VERTEX,        "ISIS vertex"			},
  { MTYPE_ISIS_ROUTE_INFO,    "ISIS route info"			},
  { MTYPE_ISIS_NEXTHOP,       "ISIS nexthop"			},
  { MTYPE_ISIS_NEXTHOP6,      "ISIS nexthop6"			},
  { MTYPE_ISIS_DICT,          "ISIS dictionary"			},
  { MTYPE_ISIS_DICT_NODE,     "ISIS dictionary node"		},
  { -1, NULL },
};

struct memory_list memory_list_pim[] =
{
  { MTYPE_PIM_CHANNEL_OIL,       "PIM SSM (S,G) channel OIL"      },
  { MTYPE_PIM_INTERFACE,         "PIM interface"	          },
  { MTYPE_PIM_IGMP_JOIN,         "PIM interface IGMP static join" },
  { MTYPE_PIM_IGMP_SOCKET,       "PIM interface IGMP socket"      },
  { MTYPE_PIM_IGMP_GROUP,        "PIM interface IGMP group"       },
  { MTYPE_PIM_IGMP_GROUP_SOURCE, "PIM interface IGMP source"      },
  { MTYPE_PIM_NEIGHBOR,          "PIM interface neighbor"         },
  { MTYPE_PIM_IFCHANNEL,         "PIM interface (S,G) state"      },
  { MTYPE_PIM_UPSTREAM,          "PIM upstream (S,G) state"       },
  { MTYPE_PIM_SSMPINGD,          "PIM sspimgd socket"             },
  { -1, NULL },
};

struct memory_list memory_list_vtysh[] =
{
  { MTYPE_VTYSH_CONFIG,		"Vtysh configuration",		},
  { MTYPE_VTYSH_CONFIG_LINE,	"Vtysh configuration line"	},
  { -1, NULL },
};

struct mlist mlists[] __attribute__ ((unused)) = {
  { memory_list_lib,	"LIB"	},
  { memory_list_zebra,	"ZEBRA"	},
  { memory_list_rip,	"RIP"	},
  { memory_list_ripng,	"RIPNG"	},
  { memory_list_ospf,	"OSPF"	},
  { memory_list_ospf6,	"OSPF6"	},
  { memory_list_isis,	"ISIS"	},
  { memory_list_bgp,	"BGP"	},
  { memory_list_pim,	"PIM"	},
  { NULL, NULL},
};
Commit	Line	Data
2fd2fd5d	1	/*
	2	* Memory type definitions. This file is parsed by memtypes.awk to extract
	3	* MTYPE_ and memory_list_.. information in order to autogenerate
	4	* memtypes.h.
	5	*
dc830cbf	6	* The script is sensitive to the format (though not whitespace), see
dc830cbf	7	* the top of memtypes.awk for more details.
2fd2fd5d	8	*/
	9
	10	#include "zebra.h"
	11	#include "memory.h"
	12
	13	struct memory_list memory_list_lib[] =
	14	{
	15	{ MTYPE_TMP, "Temporary memory" },
	16	{ MTYPE_STRVEC, "String vector" },
	17	{ MTYPE_VECTOR, "Vector" },
	18	{ MTYPE_VECTOR_INDEX, "Vector index" },
	19	{ MTYPE_LINK_LIST, "Link List" },
	20	{ MTYPE_LINK_NODE, "Link Node" },
	21	{ MTYPE_THREAD, "Thread" },
	22	{ MTYPE_THREAD_MASTER, "Thread master" },
	23	{ MTYPE_THREAD_STATS, "Thread stats" },
2fd2fd5d	24	{ MTYPE_VTY, "VTY" },
	25	{ MTYPE_VTY_OUT_BUF, "VTY output buffer" },
	26	{ MTYPE_VTY_HIST, "VTY history" },
	27	{ MTYPE_IF, "Interface" },
	28	{ MTYPE_CONNECTED, "Connected" },
a80beece	29	{ MTYPE_NBR_CONNECTED, "Neighbor Connected" },
9c4f1c6f	30	{ MTYPE_CONNECTED_LABEL, "Connected interface label" },
2fd2fd5d	31	{ MTYPE_BUFFER, "Buffer" },
	32	{ MTYPE_BUFFER_DATA, "Buffer data" },
	33	{ MTYPE_STREAM, "Stream" },
	34	{ MTYPE_STREAM_DATA, "Stream data" },
	35	{ MTYPE_STREAM_FIFO, "Stream FIFO" },
	36	{ MTYPE_PREFIX, "Prefix" },
	37	{ MTYPE_PREFIX_IPV4, "Prefix IPv4" },
	38	{ MTYPE_PREFIX_IPV6, "Prefix IPv6" },
	39	{ MTYPE_HASH, "Hash" },
	40	{ MTYPE_HASH_BACKET, "Hash Bucket" },
	41	{ MTYPE_HASH_INDEX, "Hash Index" },
	42	{ MTYPE_ROUTE_TABLE, "Route table" },
	43	{ MTYPE_ROUTE_NODE, "Route node" },
	44	{ MTYPE_DISTRIBUTE, "Distribute list" },
	45	{ MTYPE_DISTRIBUTE_IFNAME, "Dist-list ifname" },
6e919709	46	{ MTYPE_DISTRIBUTE_NAME, "Dist-list name" },
2fd2fd5d	47	{ MTYPE_ACCESS_LIST, "Access List" },
	48	{ MTYPE_ACCESS_LIST_STR, "Access List Str" },
	49	{ MTYPE_ACCESS_FILTER, "Access Filter" },
	50	{ MTYPE_PREFIX_LIST, "Prefix List" },
2c1de2a8	51	{ MTYPE_PREFIX_LIST_ENTRY, "Prefix List Entry" },
2c1de2a8	52	{ MTYPE_PREFIX_LIST_STR, "Prefix List Str" },
7e111b6b	53	{ MTYPE_PREFIX_LIST_TRIE, "Prefix List Trie Table" },
2fd2fd5d	54	{ MTYPE_ROUTE_MAP, "Route map" },
	55	{ MTYPE_ROUTE_MAP_NAME, "Route map name" },
	56	{ MTYPE_ROUTE_MAP_INDEX, "Route map index" },
	57	{ MTYPE_ROUTE_MAP_RULE, "Route map rule" },
	58	{ MTYPE_ROUTE_MAP_RULE_STR, "Route map rule str" },
	59	{ MTYPE_ROUTE_MAP_COMPILED, "Route map compiled" },
518f0eb1	60	{ MTYPE_ROUTE_MAP_DEP, "Route map dependency" },
cd40b329	61	{ MTYPE_CMD_TOKENS, "Command desc" },
2fd2fd5d	62	{ MTYPE_KEY, "Key" },
	63	{ MTYPE_KEYCHAIN, "Key chain" },
	64	{ MTYPE_IF_RMAP, "Interface route map" },
0241684e	65	{ MTYPE_IF_RMAP_NAME, "I.f. route map name", },
2fd2fd5d	66	{ MTYPE_SOCKUNION, "Socket union" },
	67	{ MTYPE_PRIVS, "Privilege information" },
	68	{ MTYPE_ZLOG, "Logging" },
	69	{ MTYPE_ZCLIENT, "Zclient" },
354d119a	70	{ MTYPE_WORK_QUEUE, "Work queue" },
	71	{ MTYPE_WORK_QUEUE_ITEM, "Work queue item" },
	72	{ MTYPE_WORK_QUEUE_NAME, "Work queue name string" },
0241684e	73	{ MTYPE_PQUEUE, "Priority queue" },
	74	{ MTYPE_PQUEUE_DATA, "Priority queue data" },
	75	{ MTYPE_HOST, "Host config" },
7f342629	76	{ MTYPE_BFD_INFO, "BFD info" },
b72ede27 FL	77	{ MTYPE_VRF, "VRF" },
b72ede27 FL	78	{ MTYPE_VRF_NAME, "VRF name" },
7076bb2f	79	{ MTYPE_VRF_BITMAP, "VRF bit-map" },
2fd2fd5d	80	{ -1, NULL },
	81	};
	82
	83	struct memory_list memory_list_zebra[] =
	84	{
	85	{ MTYPE_RTADV_PREFIX, "Router Advertisement Prefix" },
fe18ee2d	86	{ MTYPE_ZEBRA_NS, "Zebra Name Space" },
b72ede27	87	{ MTYPE_ZEBRA_VRF, "ZEBRA VRF" },
2fd2fd5d	88	{ MTYPE_NEXTHOP, "Nexthop" },
2fd2fd5d	89	{ MTYPE_RIB, "RIB" },
354d119a	90	{ MTYPE_RIB_QUEUE, "RIB process work queue" },
c0551cbb	91	{ MTYPE_STATIC_ROUTE, "Static route" },
9fd92e3c	92	{ MTYPE_RIB_DEST, "RIB destination" },
1b5ed1b0	93	{ MTYPE_RIB_TABLE_INFO, "RIB table info" },
fb018d25	94	{ MTYPE_RNH, "Nexthop tracking object" },
8f7d9fc0	95	{ MTYPE_NETLINK_NAME, "Netlink name" },
2fd2fd5d	96	{ -1, NULL },
	97	};
	98
	99	struct memory_list memory_list_bgp[] =
	100	{
	101	{ MTYPE_BGP, "BGP instance" },
d023aec4	102	{ MTYPE_BGP_LISTENER, "BGP listen socket details" },
2fd2fd5d	103	{ MTYPE_BGP_PEER, "BGP peer" },
e387e665	104	{ MTYPE_BGP_PEER_HOST, "BGP peer hostname" },
6e919709 DS	105	{ MTYPE_BGP_PEER_IFNAME, "BGP peer ifname" },
	106	{ MTYPE_BGP_PEER_GROUP, "BGP Peer group" },
	107	{ MTYPE_BGP_PEER_GROUP_HOST, "BGP Peer group hostname" },
2fd2fd5d	108	{ MTYPE_PEER_DESC, "Peer description" },
0df7c91f	109	{ MTYPE_PEER_PASSWORD, "Peer password string" },
3f9c7369 DS	110	{ MTYPE_BGP_PEER_AF, "BGP peer af" },
	111	{ MTYPE_BGP_UPDGRP, "BGP update group" },
	112	{ MTYPE_BGP_UPD_SUBGRP, "BGP update subgroup" },
	113	{ MTYPE_BGP_PACKET, "BGP packet" },
2fd2fd5d	114	{ MTYPE_ATTR, "BGP attribute" },
fb982c25	115	{ MTYPE_ATTR_EXTRA, "BGP extra attributes" },
2fd2fd5d	116	{ MTYPE_AS_PATH, "BGP aspath" },
2fd2fd5d	117	{ MTYPE_AS_SEG, "BGP aspath seg" },
75b2dd02	118	{ MTYPE_AS_SEG_DATA, "BGP aspath segment data" },
2fd2fd5d	119	{ MTYPE_AS_STR, "BGP aspath str" },
	120	{ 0, NULL },
	121	{ MTYPE_BGP_TABLE, "BGP table" },
	122	{ MTYPE_BGP_NODE, "BGP node" },
	123	{ MTYPE_BGP_ROUTE, "BGP route" },
fb982c25	124	{ MTYPE_BGP_ROUTE_EXTRA, "BGP ancillary route info" },
6c88b44d	125	{ MTYPE_BGP_CONN, "BGP connected" },
2fd2fd5d	126	{ MTYPE_BGP_STATIC, "BGP static" },
	127	{ MTYPE_BGP_ADVERTISE_ATTR, "BGP adv attr" },
	128	{ MTYPE_BGP_ADVERTISE, "BGP adv" },
b51f126e	129	{ MTYPE_BGP_SYNCHRONISE, "BGP synchronise" },
2fd2fd5d	130	{ MTYPE_BGP_ADJ_IN, "BGP adj in" },
2fd2fd5d	131	{ MTYPE_BGP_ADJ_OUT, "BGP adj out" },
de8d5dff	132	{ MTYPE_BGP_MPATH_INFO, "BGP multipath info" },
2fd2fd5d	133	{ 0, NULL },
	134	{ MTYPE_AS_LIST, "BGP AS list" },
	135	{ MTYPE_AS_FILTER, "BGP AS filter" },
	136	{ MTYPE_AS_FILTER_STR, "BGP AS filter str" },
	137	{ 0, NULL },
	138	{ MTYPE_COMMUNITY, "community" },
	139	{ MTYPE_COMMUNITY_VAL, "community val" },
	140	{ MTYPE_COMMUNITY_STR, "community str" },
	141	{ 0, NULL },
	142	{ MTYPE_ECOMMUNITY, "extcommunity" },
	143	{ MTYPE_ECOMMUNITY_VAL, "extcommunity val" },
	144	{ MTYPE_ECOMMUNITY_STR, "extcommunity str" },
	145	{ 0, NULL },
	146	{ MTYPE_COMMUNITY_LIST, "community-list" },
	147	{ MTYPE_COMMUNITY_LIST_NAME, "community-list name" },
	148	{ MTYPE_COMMUNITY_LIST_ENTRY, "community-list entry" },
	149	{ MTYPE_COMMUNITY_LIST_CONFIG, "community-list config" },
	150	{ MTYPE_COMMUNITY_LIST_HANDLER, "community-list handler" },
	151	{ 0, NULL },
	152	{ MTYPE_CLUSTER, "Cluster list" },
	153	{ MTYPE_CLUSTER_VAL, "Cluster list val" },
	154	{ 0, NULL },
200df115	155	{ MTYPE_BGP_PROCESS_QUEUE, "BGP Process queue" },
	156	{ MTYPE_BGP_CLEAR_NODE_QUEUE, "BGP node clear queue" },
	157	{ 0, NULL },
2fd2fd5d	158	{ MTYPE_TRANSIT, "BGP transit attr" },
	159	{ MTYPE_TRANSIT_VAL, "BGP transit val" },
	160	{ 0, NULL },
16286195	161	{ MTYPE_BGP_DEBUG_FILTER, "BGP debug filter" },
6e919709	162	{ MTYPE_BGP_DEBUG_STR, "BGP debug filter string" },
16286195	163	{ 0, NULL },
2fd2fd5d	164	{ MTYPE_BGP_DISTANCE, "BGP distance" },
	165	{ MTYPE_BGP_NEXTHOP_CACHE, "BGP nexthop" },
	166	{ MTYPE_BGP_CONFED_LIST, "BGP confed list" },
	167	{ MTYPE_PEER_UPDATE_SOURCE, "BGP peer update interface" },
a80beece	168	{ MTYPE_PEER_CONF_IF, "BGP peer config interface" },
2fd2fd5d	169	{ MTYPE_BGP_DAMP_INFO, "Dampening info" },
	170	{ MTYPE_BGP_DAMP_ARRAY, "BGP Dampening array" },
	171	{ MTYPE_BGP_REGEXP, "BGP regexp" },
	172	{ MTYPE_BGP_AGGREGATE, "BGP aggregate" },
10f9bf3f	173	{ MTYPE_BGP_ADDR, "BGP own address" },
6e919709 DS	174	{ 0 , NULL},
	175	{ MTYPE_BGP_REDIST, "BGP redistribution" },
	176	{ MTYPE_BGP_FILTER_NAME, "BGP Filter Information" },
	177	{ MTYPE_BGP_DUMP_STR, "BGP Dump String Information" },
2fd2fd5d	178	{ -1, NULL }
	179	};
	180
	181	struct memory_list memory_list_rip[] =
	182	{
	183	{ MTYPE_RIP, "RIP structure" },
	184	{ MTYPE_RIP_INFO, "RIP route info" },
	185	{ MTYPE_RIP_INTERFACE, "RIP interface" },
	186	{ MTYPE_RIP_PEER, "RIP peer" },
	187	{ MTYPE_RIP_OFFSET_LIST, "RIP offset list" },
	188	{ MTYPE_RIP_DISTANCE, "RIP distance" },
	189	{ -1, NULL }
	190	};
	191
	192	struct memory_list memory_list_ripng[] =
	193	{
	194	{ MTYPE_RIPNG, "RIPng structure" },
	195	{ MTYPE_RIPNG_ROUTE, "RIPng route info" },
	196	{ MTYPE_RIPNG_AGGREGATE, "RIPng aggregate" },
	197	{ MTYPE_RIPNG_PEER, "RIPng peer" },
	198	{ MTYPE_RIPNG_OFFSET_LIST, "RIPng offset lst" },
	199	{ MTYPE_RIPNG_RTE_DATA, "RIPng rte data" },
	200	{ -1, NULL }
	201	};
	202
	203	struct memory_list memory_list_ospf[] =
	204	{
	205	{ MTYPE_OSPF_TOP, "OSPF top" },
	206	{ MTYPE_OSPF_AREA, "OSPF area" },
	207	{ MTYPE_OSPF_AREA_RANGE, "OSPF area range" },
	208	{ MTYPE_OSPF_NETWORK, "OSPF network" },
	209	{ MTYPE_OSPF_NEIGHBOR_STATIC,"OSPF static nbr" },
	210	{ MTYPE_OSPF_IF, "OSPF interface" },
	211	{ MTYPE_OSPF_NEIGHBOR, "OSPF neighbor" },
	212	{ MTYPE_OSPF_ROUTE, "OSPF route" },
	213	{ MTYPE_OSPF_TMP, "OSPF tmp mem" },
	214	{ MTYPE_OSPF_LSA, "OSPF LSA" },
	215	{ MTYPE_OSPF_LSA_DATA, "OSPF LSA data" },
	216	{ MTYPE_OSPF_LSDB, "OSPF LSDB" },
	217	{ MTYPE_OSPF_PACKET, "OSPF packet" },
	218	{ MTYPE_OSPF_FIFO, "OSPF FIFO queue" },
	219	{ MTYPE_OSPF_VERTEX, "OSPF vertex" },
eb3da6df	220	{ MTYPE_OSPF_VERTEX_PARENT, "OSPF vertex parent", },
2fd2fd5d	221	{ MTYPE_OSPF_NEXTHOP, "OSPF nexthop" },
	222	{ MTYPE_OSPF_PATH, "OSPF path" },
	223	{ MTYPE_OSPF_VL_DATA, "OSPF VL data" },
	224	{ MTYPE_OSPF_CRYPT_KEY, "OSPF crypt key" },
	225	{ MTYPE_OSPF_EXTERNAL_INFO, "OSPF ext. info" },
	226	{ MTYPE_OSPF_DISTANCE, "OSPF distance" },
	227	{ MTYPE_OSPF_IF_INFO, "OSPF if info" },
	228	{ MTYPE_OSPF_IF_PARAMS, "OSPF if params" },
	229	{ MTYPE_OSPF_MESSAGE, "OSPF message" },
	230	{ -1, NULL },
	231	};
	232
	233	struct memory_list memory_list_ospf6[] =
	234	{
	235	{ MTYPE_OSPF6_TOP, "OSPF6 top" },
	236	{ MTYPE_OSPF6_AREA, "OSPF6 area" },
	237	{ MTYPE_OSPF6_IF, "OSPF6 interface" },
	238	{ MTYPE_OSPF6_NEIGHBOR, "OSPF6 neighbor" },
	239	{ MTYPE_OSPF6_ROUTE, "OSPF6 route" },
	240	{ MTYPE_OSPF6_PREFIX, "OSPF6 prefix" },
	241	{ MTYPE_OSPF6_MESSAGE, "OSPF6 message" },
	242	{ MTYPE_OSPF6_LSA, "OSPF6 LSA" },
	243	{ MTYPE_OSPF6_LSA_SUMMARY, "OSPF6 LSA summary" },
	244	{ MTYPE_OSPF6_LSDB, "OSPF6 LSA database" },
	245	{ MTYPE_OSPF6_VERTEX, "OSPF6 vertex" },
	246	{ MTYPE_OSPF6_SPFTREE, "OSPF6 SPF tree" },
	247	{ MTYPE_OSPF6_NEXTHOP, "OSPF6 nexthop" },
	248	{ MTYPE_OSPF6_EXTERNAL_INFO,"OSPF6 ext. info" },
	249	{ MTYPE_OSPF6_OTHER, "OSPF6 other" },
	250	{ -1, NULL },
	251	};
	252
	253	struct memory_list memory_list_isis[] =
	254	{
	255	{ MTYPE_ISIS, "ISIS" },
	256	{ MTYPE_ISIS_TMP, "ISIS TMP" },
	257	{ MTYPE_ISIS_CIRCUIT, "ISIS circuit" },
	258	{ MTYPE_ISIS_LSP, "ISIS LSP" },
	259	{ MTYPE_ISIS_ADJACENCY, "ISIS adjacency" },
	260	{ MTYPE_ISIS_AREA, "ISIS area" },
	261	{ MTYPE_ISIS_AREA_ADDR, "ISIS area address" },
	262	{ MTYPE_ISIS_TLV, "ISIS TLV" },
	263	{ MTYPE_ISIS_DYNHN, "ISIS dyn hostname" },
	264	{ MTYPE_ISIS_SPFTREE, "ISIS SPFtree" },
	265	{ MTYPE_ISIS_VERTEX, "ISIS vertex" },
	266	{ MTYPE_ISIS_ROUTE_INFO, "ISIS route info" },
	267	{ MTYPE_ISIS_NEXTHOP, "ISIS nexthop" },
	268	{ MTYPE_ISIS_NEXTHOP6, "ISIS nexthop6" },
3f045a08 JB	269	{ MTYPE_ISIS_DICT, "ISIS dictionary" },
3f045a08 JB	270	{ MTYPE_ISIS_DICT_NODE, "ISIS dictionary node" },
2fd2fd5d	271	{ -1, NULL },
	272	};
	273
12e41d03 DL	274	struct memory_list memory_list_pim[] =
	275	{
	276	{ MTYPE_PIM_CHANNEL_OIL, "PIM SSM (S,G) channel OIL" },
	277	{ MTYPE_PIM_INTERFACE, "PIM interface" },
	278	{ MTYPE_PIM_IGMP_JOIN, "PIM interface IGMP static join" },
	279	{ MTYPE_PIM_IGMP_SOCKET, "PIM interface IGMP socket" },
	280	{ MTYPE_PIM_IGMP_GROUP, "PIM interface IGMP group" },
	281	{ MTYPE_PIM_IGMP_GROUP_SOURCE, "PIM interface IGMP source" },
	282	{ MTYPE_PIM_NEIGHBOR, "PIM interface neighbor" },
	283	{ MTYPE_PIM_IFCHANNEL, "PIM interface (S,G) state" },
	284	{ MTYPE_PIM_UPSTREAM, "PIM upstream (S,G) state" },
	285	{ MTYPE_PIM_SSMPINGD, "PIM sspimgd socket" },
	286	{ -1, NULL },
	287	};
	288
2fd2fd5d	289	struct memory_list memory_list_vtysh[] =
	290	{
	291	{ MTYPE_VTYSH_CONFIG, "Vtysh configuration", },
	292	{ MTYPE_VTYSH_CONFIG_LINE, "Vtysh configuration line" },
	293	{ -1, NULL },
	294	};
	295
	296	struct mlist mlists[] __attribute__ ((unused)) = {
	297	{ memory_list_lib, "LIB" },
	298	{ memory_list_zebra, "ZEBRA" },
	299	{ memory_list_rip, "RIP" },
	300	{ memory_list_ripng, "RIPNG" },
	301	{ memory_list_ospf, "OSPF" },
	302	{ memory_list_ospf6, "OSPF6" },
	303	{ memory_list_isis, "ISIS" },
	304	{ memory_list_bgp, "BGP" },
12e41d03	305	{ memory_list_pim, "PIM" },
2fd2fd5d	306	{ NULL, NULL},
2fd2fd5d	307	};