static inline u8
check_pd_send_client_message (vlib_main_t * vm,
dhcp6_pd_client_state_t * client_state,
f64 current_time, f64 * due_time)
{
vlib_buffer_t *p0;
vlib_frame_t *f;
u32 *to_next;
u32 next_index;
vlib_buffer_t *c0;
ip6_header_t *ip;
udp_header_t *udp;
u32 ci0;
int bogus_length = 0;
dhcp6_pd_send_client_message_params_t *params;
f64 now = vlib_time_now (vm);
if (!client_state->keep_sending_client_message)
return false;
params = &client_state->params;
if (client_state->due_time > current_time)
{
*due_time = client_state->due_time;
return true;
}
p0 = client_state->buffer;
next_index = ip6_rewrite_mcast_node.index;
c0 = vlib_buffer_copy (vm, p0);
ci0 = vlib_get_buffer_index (vm, c0);
ip = (ip6_header_t *) vlib_buffer_get_current (c0);
udp = (udp_header_t *) (ip + 1);
u16 *elapsed_field = (u16 *) ((void *) ip + client_state->elapsed_pos);
*elapsed_field =
clib_host_to_net_u16 ((u16)
((now - client_state->transaction_start) * 100));
udp->checksum = 0;
udp->checksum =
ip6_tcp_udp_icmp_compute_checksum (vm, 0, ip, &bogus_length);
f = vlib_get_frame_to_node (vm, next_index);
to_next = vlib_frame_vector_args (f);
to_next[0] = ci0;
f->n_vectors = 1;
vlib_put_frame_to_node (vm, next_index, f);
if (params->mrc != 0 && --client_state->n_left == 0)
stop_sending_client_message (vm, client_state);
else
{
client_state->sleep_interval =
(2 + random_f64_from_to (-0.1, 0.1)) * client_state->sleep_interval;
if (client_state->sleep_interval > params->mrt)
client_state->sleep_interval =
(1 + random_f64_from_to (-0.1, 0.1)) * params->mrt;
client_state->due_time = current_time + client_state->sleep_interval;
if (params->mrd != 0
&& current_time > client_state->start_time + params->mrd)
stop_sending_client_message (vm, client_state);
else
*due_time = client_state->due_time;
}
return client_state->keep_sending_client_message;
}
/*
* fish pkts back from the recycle queue/freelist
* un-flatten the context chains
*/
static void replication_recycle_callback (vlib_main_t *vm,
vlib_buffer_free_list_t * fl)
{
vlib_frame_t * f = 0;
u32 n_left_from;
u32 n_left_to_next = 0;
u32 n_this_frame = 0;
u32 * from;
u32 * to_next = 0;
u32 bi0, pi0;
vlib_buffer_t *b0;
vlib_buffer_t *bnext0;
int i;
replication_main_t * rm = &replication_main;
replication_context_t * ctx;
u32 feature_node_index = 0;
uword cpu_number = vm->cpu_index;
// All buffers in the list are destined to the same recycle node.
// Pull the recycle node index from the first buffer.
// Note: this could be sped up if the node index were stuffed into
// the freelist itself.
if (vec_len (fl->aligned_buffers) > 0) {
bi0 = fl->aligned_buffers[0];
b0 = vlib_get_buffer (vm, bi0);
ctx = pool_elt_at_index (rm->contexts[cpu_number],
b0->clone_count);
feature_node_index = ctx->recycle_node_index;
} else if (vec_len (fl->unaligned_buffers) > 0) {
bi0 = fl->unaligned_buffers[0];
b0 = vlib_get_buffer (vm, bi0);
ctx = pool_elt_at_index (rm->contexts[cpu_number], b0->clone_count);
feature_node_index = ctx->recycle_node_index;
}
/* aligned, unaligned buffers */
for (i = 0; i < 2; i++)
{
if (i == 0)
{
from = fl->aligned_buffers;
n_left_from = vec_len (from);
}
else
{
from = fl->unaligned_buffers;
n_left_from = vec_len (from);
}
while (n_left_from > 0)
{
if (PREDICT_FALSE(n_left_to_next == 0))
{
if (f)
{
f->n_vectors = n_this_frame;
vlib_put_frame_to_node (vm, feature_node_index, f);
}
f = vlib_get_frame_to_node (vm, feature_node_index);
to_next = vlib_frame_vector_args (f);
n_left_to_next = VLIB_FRAME_SIZE;
n_this_frame = 0;
}
bi0 = from[0];
if (PREDICT_TRUE(n_left_from > 1))
{
pi0 = from[1];
vlib_prefetch_buffer_with_index(vm,pi0,LOAD);
}
bnext0 = b0 = vlib_get_buffer (vm, bi0);
// Mark that this buffer was just recycled
b0->flags |= VLIB_BUFFER_IS_RECYCLED;
// If buffer is traced, mark frame as traced
if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
f->flags |= VLIB_FRAME_TRACE;
while (bnext0->flags & VLIB_BUFFER_NEXT_PRESENT)
{
from += 1;
n_left_from -= 1;
bnext0 = vlib_get_buffer (vm, bnext0->next_buffer);
}
to_next[0] = bi0;
from++;
to_next++;
n_this_frame++;
n_left_to_next--;
n_left_from--;
}
}
vec_reset_length (fl->aligned_buffers);
vec_reset_length (fl->unaligned_buffers);
if (f)
{
ASSERT(n_this_frame);
f->n_vectors = n_this_frame;
vlib_put_frame_to_node (vm, feature_node_index, f);
}
}
