[mirror_frr.git] / lib / flex_algo.h

// SPDX-License-Identifier: GPL-2.0-or-later
/*********************************************************************
 * Copyright 2022 Hiroki Shirokura, LINE Corporation
 * Copyright 2022 Masakazu Asama
 * Copyright 2022 6WIND S.A.
 *
 * flex_algo.h: Flexible Algorithm library
 *
 * Authors
 * -------
 * Hiroki Shirokura
 * Masakazu Asama
 * Louis Scalbert
 */

#ifndef _FRR_FLEX_ALGO_H
#define _FRR_FLEX_ALGO_H

#include "admin_group.h"
#include "linklist.h"
#include "prefix.h"
#include "segment_routing.h"

#define FLEX_ALGO_PRIO_DEFAULT 128

#define CALC_TYPE_SPF 0

/* flex-algo definition flags */

/* M-flag (aka. prefix-metric)
 * Flex-Algorithm specific prefix and ASBR metric MUST be used
 */
#define FAD_FLAG_M 0x80

/*
 * Metric Type values from RFC9350 section 5.1
 */
enum flex_algo_metric_type {
	MT_IGP = 0,
	MT_MIN_UNI_LINK_DELAY = 1,
	MT_TE_DEFAULT = 2,
};


/* Flex-Algo data about a given algorithm.
 * It includes the definition and some local data.
 */
struct flex_algo {
	/* Flex-Algo definition */
	uint8_t algorithm;
	enum flex_algo_metric_type metric_type;
	uint8_t calc_type;
	uint8_t priority;
	uint8_t flags;

	/* extended admin-groups */
	struct admin_group admin_group_exclude_any;
	struct admin_group admin_group_include_any;
	struct admin_group admin_group_include_all;

	/* Exclude SRLG Sub-TLV is not yet supported by IS-IS
	 * True if a Exclude SRLG Sub-TLV has been found
	 */
	bool exclude_srlg;

	/* True if an unsupported sub-TLV other Exclude SRLG
	 * has been received.
	 * A router that receives an unsupported definition
	 * that is elected must not participate in the algorithm.
	 * This boolean prevents future sub-TLV from being considered
	 * as supported.
	 */
	bool unsupported_subtlv;

	/* Flex-Algo local data */

	/* True if the local definition must be advertised */
	bool advertise_definition;

	/* which dataplane must be used for the algorithm */
#define FLEX_ALGO_SR_MPLS 0x01
#define FLEX_ALGO_SRV6 0x02
#define FLEX_ALGO_IP 0x04
	uint8_t dataplanes;

	/* True if the Algorithm is locally enabled (ie. a definition has been
	 * found and is supported).
	 */
	bool state;

	/*
	 * This property can be freely extended among different routing
	 * protocols. Since Flex-Algo is an IGP protocol agnostic, both IS-IS
	 * and OSPF can implement Flex-Algo. The struct flex_algo thus provides
	 * the general data structure of Flex-Algo, and the value of extending
	 * it with the IGP protocol is provided by this property.
	 */
	void *data;
};

typedef void *(*flex_algo_allocator_t)(void *);
typedef void (*flex_algo_releaser_t)(void *);

struct flex_algos {
	flex_algo_allocator_t allocator;
	flex_algo_releaser_t releaser;
	struct list *flex_algos;
};

/*
 * Flex-Algo Utilities
 */
struct flex_algos *flex_algos_alloc(flex_algo_allocator_t allocator,
				    flex_algo_releaser_t releaser);
void flex_algos_free(struct flex_algos *flex_algos);
struct flex_algo *flex_algo_alloc(struct flex_algos *flex_algos,
				  uint8_t algorithm, void *arg);
struct flex_algo *flex_algo_lookup(struct flex_algos *flex_algos,
				   uint8_t algorithm);
void flex_algos_free(struct flex_algos *flex_algos);
bool flex_algo_definition_cmp(struct flex_algo *fa1, struct flex_algo *fa2);
void flex_algo_delete(struct flex_algos *flex_algos, uint8_t algorithm);
bool flex_algo_id_valid(uint16_t algorithm);
char *flex_algo_metric_type_print(char *type_str, size_t sz,
				  enum flex_algo_metric_type metric_type);

bool flex_algo_get_state(struct flex_algos *flex_algos, uint8_t algorithm);

void flex_algo_set_state(struct flex_algos *flex_algos, uint8_t algorithm,
			 bool state);
#endif /* _FRR_FLEX_ALGO_H */
Commit	Line	Data
735fb37d HS	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/*********************************************************************
	3	* Copyright 2022 Hiroki Shirokura, LINE Corporation
	4	* Copyright 2022 Masakazu Asama
	5	* Copyright 2022 6WIND S.A.
	6	*
	7	* flex_algo.h: Flexible Algorithm library
	8	*
	9	* Authors
	10	* -------
	11	* Hiroki Shirokura
	12	* Masakazu Asama
	13	* Louis Scalbert
	14	*/
	15
	16	#ifndef _FRR_FLEX_ALGO_H
	17	#define _FRR_FLEX_ALGO_H
	18
	19	#include "admin_group.h"
	20	#include "linklist.h"
	21	#include "prefix.h"
	22	#include "segment_routing.h"
	23
	24	#define FLEX_ALGO_PRIO_DEFAULT 128
	25
	26	#define CALC_TYPE_SPF 0
	27
	28	/* flex-algo definition flags */
	29
	30	/* M-flag (aka. prefix-metric)
	31	* Flex-Algorithm specific prefix and ASBR metric MUST be used
	32	*/
	33	#define FAD_FLAG_M 0x80
	34
	35	/*
	36	* Metric Type values from RFC9350 section 5.1
	37	*/
	38	enum flex_algo_metric_type {
	39	MT_IGP = 0,
	40	MT_MIN_UNI_LINK_DELAY = 1,
	41	MT_TE_DEFAULT = 2,
	42	};
	43
	44
	45	/* Flex-Algo data about a given algorithm.
	46	* It includes the definition and some local data.
	47	*/
	48	struct flex_algo {
	49	/* Flex-Algo definition */
	50	uint8_t algorithm;
	51	enum flex_algo_metric_type metric_type;
	52	uint8_t calc_type;
	53	uint8_t priority;
	54	uint8_t flags;
	55
	56	/* extended admin-groups */
	57	struct admin_group admin_group_exclude_any;
	58	struct admin_group admin_group_include_any;
	59	struct admin_group admin_group_include_all;
	60
	61	/* Exclude SRLG Sub-TLV is not yet supported by IS-IS
	62	* True if a Exclude SRLG Sub-TLV has been found
	63	*/
	64	bool exclude_srlg;
65
66	/* True if an unsupported sub-TLV other Exclude SRLG
67	* has been received.
68	* A router that receives an unsupported definition
69	* that is elected must not participate in the algorithm.
70	* This boolean prevents future sub-TLV from being considered
71	* as supported.
72	*/
73	bool unsupported_subtlv;
74
75	/* Flex-Algo local data */
76
77	/* True if the local definition must be advertised */
78	bool advertise_definition;
79
80	/* which dataplane must be used for the algorithm */
81	#define FLEX_ALGO_SR_MPLS 0x01
82	#define FLEX_ALGO_SRV6 0x02
83	#define FLEX_ALGO_IP 0x04
84	uint8_t dataplanes;
85
3f55b8c6 LS	86	/* True if the Algorithm is locally enabled (ie. a definition has been
	87	* found and is supported).
	88	*/
	89	bool state;
	90
735fb37d HS	91	/*
	92	* This property can be freely extended among different routing
	93	* protocols. Since Flex-Algo is an IGP protocol agnostic, both IS-IS
	94	* and OSPF can implement Flex-Algo. The struct flex_algo thus provides
	95	* the general data structure of Flex-Algo, and the value of extending
	96	* it with the IGP protocol is provided by this property.
	97	*/
	98	void *data;
	99	};
	100
	101	typedef void (flex_algo_allocator_t)(void *);
	102	typedef void (flex_algo_releaser_t)(void );
	103
	104	struct flex_algos {
	105	flex_algo_allocator_t allocator;
	106	flex_algo_releaser_t releaser;
	107	struct list *flex_algos;
	108	};
	109
	110	/*
	111	* Flex-Algo Utilities
	112	*/
	113	struct flex_algos *flex_algos_alloc(flex_algo_allocator_t allocator,
	114	flex_algo_releaser_t releaser);
87acad86	115	void flex_algos_free(struct flex_algos *flex_algos);
735fb37d HS	116	struct flex_algo flex_algo_alloc(struct flex_algos flex_algos,
	117	uint8_t algorithm, void *arg);
	118	struct flex_algo flex_algo_lookup(struct flex_algos flex_algos,
	119	uint8_t algorithm);
	120	void flex_algos_free(struct flex_algos *flex_algos);
	121	bool flex_algo_definition_cmp(struct flex_algo fa1, struct flex_algo fa2);
	122	void flex_algo_delete(struct flex_algos *flex_algos, uint8_t algorithm);
	123	bool flex_algo_id_valid(uint16_t algorithm);
	124	char flex_algo_metric_type_print(char type_str, size_t sz,
	125	enum flex_algo_metric_type metric_type);
	126
3f55b8c6 LS	127	bool flex_algo_get_state(struct flex_algos *flex_algos, uint8_t algorithm);
	128
	129	void flex_algo_set_state(struct flex_algos *flex_algos, uint8_t algorithm,
	130	bool state);
735fb37d	131	#endif /* _FRR_FLEX_ALGO_H */