static clib_error_t * ioam_export_init (vlib_main_t * vm) { ioam_export_main_t *em = &ioam_export_main; clib_error_t *error = 0; u8 *name; u32 node_index = export_node.index; vlib_node_t *ip6_hbyh_node = NULL; em->vlib_main = vm; em->vnet_main = vnet_get_main (); em->set_id = IPFIX_IOAM_EXPORT_ID; ioam_export_reset_next_node (em); name = format (0, "ioam_export_%08x%c", api_version, 0); /* Ask for a correctly-sized block of API message decode slots */ em->msg_id_base = vl_msg_api_get_msg_ids ((char *) name, VL_MSG_FIRST_AVAILABLE); em->unix_time_0 = (u32) time (0); /* Store starting time */ em->vlib_time_0 = vlib_time_now (vm); error = ioam_export_plugin_api_hookup (vm); /* Add our API messages to the global name_crc hash table */ setup_message_id_table (em, &api_main); /* Hook this export node to ip6-hop-by-hop */ ip6_hbyh_node = vlib_get_node_by_name (vm, (u8 *) "ip6-hop-by-hop"); em->my_hbh_slot = vlib_node_add_next (vm, ip6_hbyh_node->index, node_index); vec_free (name); return error; }
static uword send_dhcp6_pd_client_message_process (vlib_main_t * vm, vlib_node_runtime_t * rt, vlib_frame_t * f0) { dhcp6_pd_client_main_t *cm = &dhcp6_pd_client_main; dhcp6_pd_client_state_t *client_state; uword *event_data = 0; f64 sleep_time = 1e9; f64 current_time; f64 due_time; f64 dt = 0; int i; while (true) { vlib_process_wait_for_event_or_clock (vm, sleep_time); vlib_process_get_events (vm, &event_data); vec_reset_length (event_data); current_time = vlib_time_now (vm); do { due_time = current_time + 1e9; for (i = 0; i < vec_len (cm->client_state_by_sw_if_index); i++) { client_state = &cm->client_state_by_sw_if_index[i]; if (!client_state->entry_valid) continue; if (check_pd_send_client_message (vm, client_state, current_time, &dt) && (dt < due_time)) due_time = dt; } current_time = vlib_time_now (vm); } while (due_time < current_time); sleep_time = due_time - current_time; } return 0; }
static clib_error_t * flowprobe_create_state_tables (u32 active_timer) { flowprobe_main_t *fm = &flowprobe_main; vlib_thread_main_t *tm = &vlib_thread_main; vlib_main_t *vm = vlib_get_main (); clib_error_t *error = 0; u32 num_threads; int i; /* Decide how many worker threads we have */ num_threads = 1 /* main thread */ + tm->n_threads; /* Hash table per worker */ fm->ht_log2len = FLOWPROBE_LOG2_HASHSIZE; /* Init per worker flow state and timer wheels */ if (active_timer) { vec_validate (fm->timers_per_worker, num_threads - 1); vec_validate (fm->expired_passive_per_worker, num_threads - 1); vec_validate (fm->hash_per_worker, num_threads - 1); vec_validate (fm->pool_per_worker, num_threads - 1); for (i = 0; i < num_threads; i++) { int j; pool_alloc (fm->pool_per_worker[i], 1 << fm->ht_log2len); vec_resize (fm->hash_per_worker[i], 1 << fm->ht_log2len); for (j = 0; j < (1 << fm->ht_log2len); j++) fm->hash_per_worker[i][j] = ~0; fm->timers_per_worker[i] = clib_mem_alloc (sizeof (TWT (tw_timer_wheel))); tw_timer_wheel_init_2t_1w_2048sl (fm->timers_per_worker[i], flowprobe_expired_timer_callback, 1.0, 1024); } fm->disabled = true; } else { f64 now = vlib_time_now (vm); vec_validate (fm->stateless_entry, num_threads - 1); for (i = 0; i < num_threads; i++) fm->stateless_entry[i].last_exported = now; fm->disabled = false; } fm->initialized = true; return error; }
void dhcp6_pd_send_client_message (vlib_main_t * vm, u32 sw_if_index, u8 stop, dhcp6_pd_send_client_message_params_t * params) { dhcp6_pd_client_main_t *cm = &dhcp6_pd_client_main; dhcp6_pd_client_state_t *client_state = 0; dhcp6_pd_client_state_t empty_state = { 0, }; ASSERT (~0 != sw_if_index); vec_validate_init_empty (cm->client_state_by_sw_if_index, sw_if_index, empty_state); client_state = &cm->client_state_by_sw_if_index[sw_if_index]; if (!client_state->entry_valid) { client_state->entry_valid = 1; client_state->adj_index = ~0; } stop_sending_client_message (vm, client_state); if (!stop) { client_state->keep_sending_client_message = 1; vec_free (client_state->params.prefixes); client_state->params = *params; client_state->params.prefixes = vec_dup (params->prefixes); client_state->n_left = params->mrc; client_state->start_time = vlib_time_now (vm); client_state->sleep_interval = (1 + random_f64_from_to (-0.1, 0.1)) * params->irt; client_state->due_time = 0; /* send first packet ASAP */ client_state->transaction_id = random_u32 (&cm->seed) & 0x00ffffff; client_state->buffer = create_buffer_for_client_message (vm, sw_if_index, client_state, params->msg_type); if (!client_state->buffer) client_state->keep_sending_client_message = 0; else vlib_process_signal_event (vm, send_dhcp6_pd_client_message_process_node.index, 1, 0); } }
void cj_log (u32 type, void * data0, void * data1) { u64 new_tail; cj_main_t * cjm = &cj_main; cj_record_t * r; if (cjm->enable == 0) return; new_tail = __sync_add_and_fetch (&cjm->tail, 1); r = (cj_record_t *) &(cjm->records[new_tail & (cjm->num_records - 1)]); r->time = vlib_time_now (cjm->vlib_main); r->cpu = os_get_cpu_number(); r->type = type; r->data[0] = (u64) data0; r->data[1] = (u64) data1; }
void cj_log (u32 type, void *data0, void *data1) { u64 new_tail; cj_main_t *cjm = &cj_main; cj_record_t *r; if (cjm->enable == 0) return; new_tail = clib_atomic_add_fetch (&cjm->tail, 1); r = (cj_record_t *) & (cjm->records[new_tail & (cjm->num_records - 1)]); r->time = vlib_time_now (cjm->vlib_main); r->thread_index = vlib_get_thread_index (); r->type = type; r->data[0] = pointer_to_uword (data0); r->data[1] = pointer_to_uword (data1); }
static uword perfmon_periodic_process (vlib_main_t * vm, vlib_node_runtime_t * rt, vlib_frame_t * f) { perfmon_main_t *pm = &perfmon_main; f64 now; uword *event_data = 0; uword event_type; int i; while (1) { if (pm->state == PERFMON_STATE_RUNNING) vlib_process_wait_for_event_or_clock (vm, pm->timeout_interval); else vlib_process_wait_for_event (vm); now = vlib_time_now (vm); event_type = vlib_process_get_events (vm, (uword **) & event_data); switch (event_type) { case PERFMON_START: for (i = 0; i < vec_len (event_data); i++) start_event (pm, now, event_data[i]); break; /* Handle timeout */ case ~0: handle_timeout (vm, pm, now); break; default: clib_warning ("Unexpected event %d", event_type); break; } vec_reset_length (event_data); } return 0; /* or not */ }
static vlib_buffer_t * create_buffer_for_client_message (vlib_main_t * vm, u32 sw_if_index, dhcp6_pd_client_state_t * client_state, u32 type) { dhcp6_client_common_main_t *ccm = &dhcp6_client_common_main; vnet_main_t *vnm = vnet_get_main (); vlib_buffer_t *b; u32 bi; ip6_header_t *ip; udp_header_t *udp; dhcpv6_header_t *dhcp; ip6_address_t src_addr; u32 dhcp_opt_len = 0; client_state->transaction_start = vlib_time_now (vm); u32 n_prefixes; u32 i; vnet_hw_interface_t *hw = vnet_get_sup_hw_interface (vnm, sw_if_index); vnet_sw_interface_t *sup_sw = vnet_get_sup_sw_interface (vnm, sw_if_index); vnet_sw_interface_t *sw = vnet_get_sw_interface (vnm, sw_if_index); /* Interface(s) down? */ if ((hw->flags & VNET_HW_INTERFACE_FLAG_LINK_UP) == 0) return NULL; if ((sup_sw->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) == 0) return NULL; if ((sw->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) == 0) return NULL; /* Get a link-local address */ src_addr = ip6_neighbor_get_link_local_address (sw_if_index); if (src_addr.as_u8[0] != 0xfe) { clib_warning ("Could not find source address to send DHCPv6 packet"); return NULL; } if (vlib_buffer_alloc (vm, &bi, 1) != 1) { clib_warning ("Buffer allocation failed"); return NULL; } b = vlib_get_buffer (vm, bi); vnet_buffer (b)->sw_if_index[VLIB_RX] = sw_if_index; vnet_buffer (b)->sw_if_index[VLIB_TX] = sw_if_index; client_state->adj_index = adj_mcast_add_or_lock (FIB_PROTOCOL_IP6, VNET_LINK_IP6, sw_if_index); vnet_buffer (b)->ip.adj_index[VLIB_TX] = client_state->adj_index; b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED; ip = (ip6_header_t *) vlib_buffer_get_current (b); udp = (udp_header_t *) (ip + 1); dhcp = (dhcpv6_header_t *) (udp + 1); ip->src_address = src_addr; ip->hop_limit = 255; ip->ip_version_traffic_class_and_flow_label = clib_host_to_net_u32 (0x6 << 28); ip->payload_length = 0; ip->protocol = IP_PROTOCOL_UDP; udp->src_port = clib_host_to_net_u16 (DHCPV6_CLIENT_PORT); udp->dst_port = clib_host_to_net_u16 (DHCPV6_SERVER_PORT); udp->checksum = 0; udp->length = 0; dhcp->msg_type = type; dhcp->xid[0] = (client_state->transaction_id & 0x00ff0000) >> 16; dhcp->xid[1] = (client_state->transaction_id & 0x0000ff00) >> 8; dhcp->xid[2] = (client_state->transaction_id & 0x000000ff) >> 0; void *d = (void *) dhcp->data; dhcpv6_option_t *duid; dhcpv6_elapsed_t *elapsed; dhcpv6_ia_header_t *ia_hdr; dhcpv6_ia_opt_pd_t *opt_pd; if (type == DHCPV6_MSG_SOLICIT || type == DHCPV6_MSG_REQUEST || type == DHCPV6_MSG_RENEW || type == DHCPV6_MSG_REBIND || type == DHCPV6_MSG_RELEASE) { duid = (dhcpv6_option_t *) d; duid->option = clib_host_to_net_u16 (DHCPV6_OPTION_CLIENTID); duid->length = clib_host_to_net_u16 (CLIENT_DUID_LENGTH); clib_memcpy (duid + 1, client_duid.bin_string, CLIENT_DUID_LENGTH); d += sizeof (*duid) + CLIENT_DUID_LENGTH; if (client_state->params.server_index != ~0) { server_id_t *se = &ccm->server_ids[client_state->params.server_index]; duid = (dhcpv6_option_t *) d; duid->option = clib_host_to_net_u16 (DHCPV6_OPTION_SERVERID); duid->length = clib_host_to_net_u16 (se->len); clib_memcpy (duid + 1, se->data, se->len); d += sizeof (*duid) + se->len; } elapsed = (dhcpv6_elapsed_t *) d; elapsed->opt.option = clib_host_to_net_u16 (DHCPV6_OPTION_ELAPSED_TIME); elapsed->opt.length = clib_host_to_net_u16 (sizeof (*elapsed) - sizeof (elapsed->opt)); elapsed->elapsed_10ms = 0; client_state->elapsed_pos = (char *) &elapsed->elapsed_10ms - (char *) vlib_buffer_get_current (b); d += sizeof (*elapsed); ia_hdr = (dhcpv6_ia_header_t *) d; ia_hdr->opt.option = clib_host_to_net_u16 (DHCPV6_OPTION_IA_PD); ia_hdr->iaid = clib_host_to_net_u32 (DHCPV6_CLIENT_IAID); ia_hdr->t1 = clib_host_to_net_u32 (client_state->params.T1); ia_hdr->t2 = clib_host_to_net_u32 (client_state->params.T2); d += sizeof (*ia_hdr); n_prefixes = vec_len (client_state->params.prefixes); ia_hdr->opt.length = clib_host_to_net_u16 (sizeof (*ia_hdr) + n_prefixes * sizeof (*opt_pd) - sizeof (ia_hdr->opt)); for (i = 0; i < n_prefixes; i++) { dhcp6_pd_send_client_message_params_prefix_t *pref = &client_state->params.prefixes[i]; opt_pd = (dhcpv6_ia_opt_pd_t *) d; opt_pd->opt.option = clib_host_to_net_u16 (DHCPV6_OPTION_IAPREFIX); opt_pd->opt.length = clib_host_to_net_u16 (sizeof (*opt_pd) - sizeof (opt_pd->opt)); opt_pd->addr = pref->prefix; opt_pd->prefix = pref->prefix_length; opt_pd->valid = clib_host_to_net_u32 (pref->valid_lt); opt_pd->preferred = clib_host_to_net_u32 (pref->preferred_lt); d += sizeof (*opt_pd); } } else { clib_warning ("State not implemented"); } dhcp_opt_len = ((u8 *) d) - dhcp->data; udp->length = clib_host_to_net_u16 (sizeof (*udp) + sizeof (*dhcp) + dhcp_opt_len); ip->payload_length = udp->length; b->current_length = sizeof (*ip) + sizeof (*udp) + sizeof (*dhcp) + dhcp_opt_len; ip->dst_address = all_dhcp6_relay_agents_and_servers; return b; }
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; }
static void handle_timeout (vlib_main_t * vm, perfmon_main_t * pm, f64 now) { int i; int last_set, all; last_set = clib_bitmap_last_set (pm->thread_bitmap); all = (last_set == ~0); if (all || clib_bitmap_get (pm->thread_bitmap, 0)) disable_events (pm); /* And also on worker threads */ for (i = 1; i < vec_len (vlib_mains); i++) { if (vlib_mains[i] == 0) continue; if (all || clib_bitmap_get (pm->thread_bitmap, i)) vlib_mains[i]->worker_thread_main_loop_callback = (void *) worker_thread_stop_event; } /* Make sure workers have stopped collection */ if (i > 1) { f64 deadman = vlib_time_now (vm) + 1.0; for (i = 1; i < vec_len (vlib_mains); i++) { /* Has the worker actually stopped collecting data? */ while (vlib_mains[i]->worker_thread_main_loop_callback) { if (vlib_time_now (vm) > deadman) { clib_warning ("Thread %d deadman timeout!", i); break; } vlib_process_suspend (pm->vlib_main, 1e-3); } } } scrape_and_clear_counters (pm); pm->current_event += pm->n_active; if (pm->current_event >= vec_len (pm->single_events_to_collect)) { pm->current_event = 0; pm->state = PERFMON_STATE_OFF; return; } if (all || clib_bitmap_get (pm->thread_bitmap, 0)) enable_current_events (pm); /* And also on worker threads */ for (i = 1; i < vec_len (vlib_mains); i++) { if (vlib_mains[i] == 0) continue; if (all || clib_bitmap_get (pm->thread_bitmap, i)) vlib_mains[i]->worker_thread_main_loop_callback = (void *) worker_thread_start_event; } }