* externally
*/
-DEFINE_HOOK(lm_client_connect,
- (uint8_t proto, uint16_t instance, vrf_id_t vrf_id),
- (proto, instance, vrf_id));
-DEFINE_HOOK(lm_client_disconnect, (uint8_t proto, uint16_t instance),
- (proto, instance));
+DEFINE_HOOK(lm_client_connect, (struct zserv *client, vrf_id_t vrf_id),
+ (client, vrf_id));
+DEFINE_HOOK(lm_client_disconnect, (struct zserv *client), (client));
DEFINE_HOOK(lm_get_chunk,
- (struct label_manager_chunk * *lmc, uint8_t proto,
- uint16_t instance, uint8_t keep, uint32_t size, uint32_t base,
- vrf_id_t vrf_id),
- (lmc, proto, instance, keep, size, base, vrf_id));
+ (struct label_manager_chunk * *lmc, struct zserv *client,
+ uint8_t keep, uint32_t size, uint32_t base, vrf_id_t vrf_id),
+ (lmc, client, keep, size, base, vrf_id));
DEFINE_HOOK(lm_release_chunk,
- (uint8_t proto, uint16_t instance, uint32_t start, uint32_t end),
- (proto, instance, start, end));
+ (struct zserv *client, uint32_t start, uint32_t end),
+ (client, start, end));
DEFINE_HOOK(lm_cbs_inited, (), ());
/* define wrappers to be called in zapi_msg.c (as hooks must be called in
* source file where they were defined)
*/
-void lm_client_connect_call(uint8_t proto, uint16_t instance, vrf_id_t vrf_id)
+void lm_client_connect_call(struct zserv *client, vrf_id_t vrf_id)
{
- hook_call(lm_client_connect, proto, instance, vrf_id);
+ hook_call(lm_client_connect, client, vrf_id);
}
-void lm_get_chunk_call(struct label_manager_chunk **lmc, uint8_t proto,
- uint16_t instance, uint8_t keep, uint32_t size,
- uint32_t base, vrf_id_t vrf_id)
+void lm_get_chunk_call(struct label_manager_chunk **lmc, struct zserv *client,
+ uint8_t keep, uint32_t size, uint32_t base,
+ vrf_id_t vrf_id)
{
- hook_call(lm_get_chunk, lmc, proto, instance, keep, size, base, vrf_id);
+ hook_call(lm_get_chunk, lmc, client, keep, size, base, vrf_id);
}
-void lm_release_chunk_call(uint8_t proto, uint16_t instance, uint32_t start,
- uint32_t end)
+void lm_release_chunk_call(struct zserv *client, uint32_t start, uint32_t end)
{
- hook_call(lm_release_chunk, proto, instance, start, end);
+ hook_call(lm_release_chunk, client, start, end);
}
/* forward declarations of the static functions to be used for some hooks */
-static int label_manager_connect(uint8_t proto, uint16_t instance,
- vrf_id_t vrf_id);
-static int label_manager_disconnect(uint8_t proto, uint16_t instance);
+static int label_manager_connect(struct zserv *client, vrf_id_t vrf_id);
+static int label_manager_disconnect(struct zserv *client);
static int label_manager_get_chunk(struct label_manager_chunk **lmc,
- uint8_t proto, uint16_t instance,
- uint8_t keep, uint32_t size, uint32_t base,
+ struct zserv *client, uint8_t keep,
+ uint32_t size, uint32_t base,
vrf_id_t vrf_id);
+static int label_manager_release_label_chunk(struct zserv *client,
+ uint32_t start, uint32_t end);
void delete_label_chunk(void *val)
{
* @param instance Instance, to identify the owner
* @return Number of chunks released
*/
-int release_daemon_label_chunks(uint8_t proto, unsigned short instance)
+int release_daemon_label_chunks(struct zserv *client)
{
struct listnode *node;
struct label_manager_chunk *lmc;
int ret;
if (IS_ZEBRA_DEBUG_PACKET)
- zlog_debug("%s: Releasing chunks for client proto %s, instance %d",
- __func__, zebra_route_string(proto), instance);
+ zlog_debug("%s: Releasing chunks for client proto %s, instance %d, session %u",
+ __func__, zebra_route_string(client->proto),
+ client->instance, client->session_id);
for (ALL_LIST_ELEMENTS_RO(lbl_mgr.lc_list, node, lmc)) {
- if (lmc->proto == proto && lmc->instance == instance
- && lmc->keep == 0) {
+ if (lmc->proto == client->proto &&
+ lmc->instance == client->instance &&
+ lmc->session_id == client->session_id && lmc->keep == 0) {
ret = release_label_chunk(lmc->proto, lmc->instance,
+ lmc->session_id,
lmc->start, lmc->end);
if (ret == 0)
count++;
int lm_client_disconnect_cb(struct zserv *client)
{
- uint8_t proto = client->proto;
- uint16_t instance = client->instance;
-
- hook_call(lm_client_disconnect, proto, instance);
+ hook_call(lm_client_disconnect, client);
return 0;
}
hook_register(lm_client_connect, label_manager_connect);
hook_register(lm_client_disconnect, label_manager_disconnect);
hook_register(lm_get_chunk, label_manager_get_chunk);
- hook_register(lm_release_chunk, release_label_chunk);
+ hook_register(lm_release_chunk, label_manager_release_label_chunk);
}
void lm_hooks_unregister(void)
{
hook_unregister(lm_client_connect, label_manager_connect);
hook_unregister(lm_client_disconnect, label_manager_disconnect);
hook_unregister(lm_get_chunk, label_manager_get_chunk);
- hook_unregister(lm_release_chunk, release_label_chunk);
+ hook_unregister(lm_release_chunk, label_manager_release_label_chunk);
}
/**
}
/* alloc and fill a label chunk */
-struct label_manager_chunk *create_label_chunk(uint8_t proto,
- unsigned short instance,
- uint8_t keep, uint32_t start,
- uint32_t end)
+struct label_manager_chunk *
+create_label_chunk(uint8_t proto, unsigned short instance, uint32_t session_id,
+ uint8_t keep, uint32_t start, uint32_t end)
{
/* alloc chunk, fill it and return it */
struct label_manager_chunk *lmc =
lmc->end = end;
lmc->proto = proto;
lmc->instance = instance;
+ lmc->session_id = session_id;
lmc->keep = keep;
return lmc;
/* attempt to get a specific label chunk */
static struct label_manager_chunk *
assign_specific_label_chunk(uint8_t proto, unsigned short instance,
- uint8_t keep, uint32_t size, uint32_t base)
+ uint32_t session_id, uint8_t keep, uint32_t size,
+ uint32_t base)
{
struct label_manager_chunk *lmc;
struct listnode *node, *next = NULL;
if (lmc->proto != NO_PROTO)
return NULL;
- if (end < lmc->end) {
+ if (end <= lmc->end) {
last_node = node;
break;
}
/* insert chunk between existing chunks */
if (insert_node) {
- lmc = create_label_chunk(proto, instance, keep, base, end);
+ lmc = create_label_chunk(proto, instance, session_id, keep,
+ base, end);
listnode_add_before(lbl_mgr.lc_list, insert_node, lmc);
return lmc;
}
delete_label_chunk(death);
}
- lmc = create_label_chunk(proto, instance, keep, base, end);
+ lmc = create_label_chunk(proto, instance, session_id, keep,
+ base, end);
if (last_node)
listnode_add_before(lbl_mgr.lc_list, last_node, lmc);
else
} else {
/* create a new chunk past all the existing ones and link at
* tail */
- lmc = create_label_chunk(proto, instance, keep, base, end);
+ lmc = create_label_chunk(proto, instance, session_id, keep,
+ base, end);
listnode_add(lbl_mgr.lc_list, lmc);
return lmc;
}
* @param base Desired starting label of the chunk; if MPLS_LABEL_BASE_ANY it does not apply
* @return Pointer to the assigned label chunk, or NULL if the request could not be satisfied
*/
-struct label_manager_chunk *assign_label_chunk(uint8_t proto,
- unsigned short instance,
- uint8_t keep, uint32_t size,
- uint32_t base)
+struct label_manager_chunk *
+assign_label_chunk(uint8_t proto, unsigned short instance, uint32_t session_id,
+ uint8_t keep, uint32_t size, uint32_t base)
{
struct label_manager_chunk *lmc;
struct listnode *node;
- uint32_t prev_end = 0;
+ uint32_t prev_end = MPLS_LABEL_UNRESERVED_MIN;
/* handle chunks request with a specific base label */
if (base != MPLS_LABEL_BASE_ANY)
- return assign_specific_label_chunk(proto, instance, keep, size,
- base);
+ return assign_specific_label_chunk(proto, instance, session_id,
+ keep, size, base);
/* appease scan-build, who gets confused by the use of macros */
assert(lbl_mgr.lc_list);
&& lmc->end - lmc->start + 1 == size) {
lmc->proto = proto;
lmc->instance = instance;
+ lmc->session_id = session_id;
lmc->keep = keep;
return lmc;
}
/* check if we hadve a "hole" behind us that we can squeeze into
*/
- if ((lmc->start > prev_end)
- && (lmc->start - prev_end >= size)) {
- lmc = create_label_chunk(proto, instance, keep,
- prev_end + 1, prev_end + size);
+ if ((lmc->start > prev_end) && (lmc->start - prev_end > size)) {
+ lmc = create_label_chunk(proto, instance, session_id,
+ keep, prev_end + 1,
+ prev_end + size);
listnode_add_before(lbl_mgr.lc_list, node, lmc);
return lmc;
}
}
/* create chunk and link at tail */
- lmc = create_label_chunk(proto, instance, keep, start_free,
+ lmc = create_label_chunk(proto, instance, session_id, keep, start_free,
start_free + size - 1);
listnode_add(lbl_mgr.lc_list, lmc);
return lmc;
}
+/**
+ * Release label chunks from a client.
+ *
+ * Called on client disconnection or reconnection. It only releases chunks
+ * with empty keep value.
+ *
+ * @param client Client zapi session
+ * @param start First label of the chunk
+ * @param end Last label of the chunk
+ * @return 0 on success
+ */
+static int label_manager_release_label_chunk(struct zserv *client,
+ uint32_t start, uint32_t end)
+{
+ return release_label_chunk(client->proto, client->instance,
+ client->session_id, start, end);
+}
+
/**
* Core function, release no longer used label chunks
*
* @param proto Daemon protocol of client, to identify the owner
* @param instance Instance, to identify the owner
+ * @param session_id Zclient session ID, to identify the zclient session
* @param start First label of the chunk
* @param end Last label of the chunk
* @return 0 on success, -1 otherwise
*/
-int release_label_chunk(uint8_t proto, unsigned short instance, uint32_t start,
- uint32_t end)
+int release_label_chunk(uint8_t proto, unsigned short instance,
+ uint32_t session_id, uint32_t start, uint32_t end)
{
struct listnode *node;
struct label_manager_chunk *lmc;
continue;
if (lmc->end != end)
continue;
- if (lmc->proto != proto || lmc->instance != instance) {
+ if (lmc->proto != proto || lmc->instance != instance ||
+ lmc->session_id != session_id) {
flog_err(EC_ZEBRA_LM_DAEMON_MISMATCH,
"%s: Daemon mismatch!!", __func__);
continue;
}
lmc->proto = NO_PROTO;
lmc->instance = 0;
+ lmc->session_id = 0;
lmc->keep = 0;
ret = 0;
break;
}
/* default functions to be called on hooks */
-static int label_manager_connect(uint8_t proto, uint16_t instance,
- vrf_id_t vrf_id)
+static int label_manager_connect(struct zserv *client, vrf_id_t vrf_id)
{
/*
* Release previous labels of same protocol and instance.
* This is done in case it restarted from an unexpected shutdown.
*/
- release_daemon_label_chunks(proto, instance);
- return lm_client_connect_response(proto, instance, vrf_id, 0);
+ release_daemon_label_chunks(client);
+ return zsend_label_manager_connect_response(client, vrf_id, 0);
}
-static int label_manager_disconnect(uint8_t proto, uint16_t instance)
+static int label_manager_disconnect(struct zserv *client)
{
- release_daemon_label_chunks(proto, instance);
+ release_daemon_label_chunks(client);
return 0;
}
static int label_manager_get_chunk(struct label_manager_chunk **lmc,
- uint8_t proto, uint16_t instance,
- uint8_t keep, uint32_t size, uint32_t base,
+ struct zserv *client, uint8_t keep,
+ uint32_t size, uint32_t base,
vrf_id_t vrf_id)
{
- *lmc = assign_label_chunk(proto, instance, keep, size, base);
- return lm_get_chunk_response(*lmc, proto, instance, vrf_id);
+ *lmc = assign_label_chunk(client->proto, client->instance,
+ client->session_id, keep, size, base);
+ return lm_get_chunk_response(*lmc, client, vrf_id);
}
/* Respond to a connect request */
int lm_client_connect_response(uint8_t proto, uint16_t instance,
- vrf_id_t vrf_id, uint8_t result)
+ uint32_t session_id, vrf_id_t vrf_id,
+ uint8_t result)
{
- struct zserv *client = zserv_find_client(proto, instance);
+ struct zserv *client = zserv_find_client_session(proto, instance,
+ session_id);
if (!client) {
- zlog_err("%s: could not find client for daemon %s instance %u",
- __func__, zebra_route_string(proto), instance);
+ zlog_err("%s: could not find client for daemon %s instance %u session %u",
+ __func__, zebra_route_string(proto), instance,
+ session_id);
return 1;
}
return zsend_label_manager_connect_response(client, vrf_id, result);
}
/* Respond to a get_chunk request */
-int lm_get_chunk_response(struct label_manager_chunk *lmc, uint8_t proto,
- uint16_t instance, vrf_id_t vrf_id)
+int lm_get_chunk_response(struct label_manager_chunk *lmc, struct zserv *client,
+ vrf_id_t vrf_id)
{
if (!lmc)
flog_err(EC_ZEBRA_LM_CANNOT_ASSIGN_CHUNK,
"Unable to assign Label Chunk to %s instance %u",
- zebra_route_string(proto), instance);
+ zebra_route_string(client->proto), client->instance);
else if (IS_ZEBRA_DEBUG_PACKET)
zlog_debug("Assigned Label Chunk %u - %u to %s instance %u",
- lmc->start, lmc->end, zebra_route_string(proto),
- instance);
+ lmc->start, lmc->end,
+ zebra_route_string(client->proto), client->instance);
- struct zserv *client = zserv_find_client(proto, instance);
- if (!client) {
- zlog_err("%s: could not find client for daemon %s instance %u",
- __func__, zebra_route_string(proto), instance);
- return 1;
- }
- return zsend_assign_label_chunk_response(client, vrf_id, proto,
- instance, lmc);
+ return zsend_assign_label_chunk_response(client, vrf_id, lmc);
}
void label_manager_close(void)
projects / mirror_frr.git / blobdiff