aboutsummaryrefslogtreecommitdiffstats
path: root/src
AgeCommit message (Expand)AuthorFilesLines
2017-03-13VPP-659 Improve tcp/session debugging and testingFlorin Coras15-181/+636
2017-03-13VPP-279: Document changes for vnet/vnet/devicesBilly McFall4-4/+93
2017-03-13Add MAC address check in ethernet-input node if interface in L3 modeJohn Lo1-6/+17
2017-03-13ACL plugin rejects ICMP messages (VPP-624)Pavel Kotucek1-21/+19
2017-03-13Refactor SNAT ICMP codeJuraj Sloboda4-314/+558
2017-03-10Retire vpp_liteDamjan Marion14-27/+57
2017-03-10vlib: deduplicatee code in main and worker main loopDamjan Marion4-142/+116
2017-03-10VPP-659 TCP improvementsFlorin Coras22-161/+454
2017-03-10gmon: fix code commented out by mistakeDamjan Marion1-2/+1
2017-03-10LISP: fix Proxy-ETR show command, VPP-660Filip Tehlar4-8/+184
2017-03-10Fix vat_api_hookup name collisionDave Barach1-3/+3
2017-03-10VPP-608: warnings be goneDave Barach1-0/+10
2017-03-10Fix MAP-E UT. Add functionality in MAP code to delete the pre-resolved next-h...Neale Ranns1-6/+37
2017-03-10Fix coverity CIDs 161048, 163895Pavel Kotucek2-4/+1
2017-03-10VPP-608 Fix LISP warningFlorin Coras1-0/+1
2017-03-09vlib_mains == 0 special cases be goneDave Barach16-598/+575
2017-03-09IMplementation for option to not create a FIB table entry when adding a neigh...Neale Ranns8-56/+105
2017-03-09MAP pre-resolve - use FIB to track pre-resolved next-hopNeale Ranns5-55/+192
2017-03-09Tests to target holes in adjacency and DPO test coverageNeale Ranns1-1/+3
2017-03-09include rte_config header before any other dpdk includeGabriel Ganne1-0/+1
2017-03-09dpdk: remove unnecesary CFLAGS modificationDamjan Marion1-4/+0
2017-03-08SNAT: deterministic map dumpMartin3-3/+125
2017-03-08SNAT: fix coverity warnings (VPP-608)Matus Fabian1-2/+3
2017-03-08vlib: add process restart cliDamjan Marion1-0/+20
2017-03-08ARP resilience in the absence of IP config on input and output interfacesNeale Ranns2-0/+21
2017-03-08dpdk: dpdk-input optimizations and fixesDamjan Marion4-96/+126
2017-03-08API change (only) to not create a FIB table entry when adding a neighbor entryNeale Ranns1-1/+6
2017-03-08vhost: binary API changes for interrupt modeSteven4-10/+41
2017-03-08Change dpdk input node fixed-sleep units to usecDave Barach3-5/+5
2017-03-08FLOWPERPKT: New API definition in preparation for stateful flows.Ole Troan1-1/+18
2017-03-08dpdk: Fixed QAT devices binding, bind the VFs onlyRadu Nicolau1-3/+7
2017-03-08LISP: fix gpe sub-interface lookupFilip Tehlar1-8/+8
2017-03-08BUG: multiple registrations of 'vl_api_ip6nd_proxy_details_t_handlerNeale Ranns1-7/+0
2017-03-08SNAT: user_session_dump is_ip4 and vat unformating addedMartin3-0/+20
2017-03-08Proxy ND (RFC4389 - or a sub-set thereof). This allows the 'emulation' of bri...Neale Ranns9-62/+439
2017-03-08LISP: add stats API/CLIFilip Tehlar5-0/+175
2017-03-08CGN: fix outside port calculation and set buffer error (VPP-623)Matus Fabian2-18/+33
2017-03-07Register TCP with IP only if session is enabledFlorin Coras4-8/+44
2017-03-07fix gcc 5.4 warning: argument to 'sizeof' in 'memcpy' call is the same expres...Gabriel Ganne3-17/+15
2017-03-07Missing plugin binary API command fns found after brief searchDave Barach4-2/+17
2017-03-07DHCP Multiple Servers (VPP-602, VPP-605)Neale Ranns12-191/+484
2017-03-07Fix endian issue in ARP Event ReplyWojciech Dec2-6/+8
2017-03-07CLI: hide deleted interfacesEyal Bari5-5/+40
2017-03-07In-band OAM active probe (VPP-471)AkshayaNadahalli23-59/+2742
2017-03-07CGN: Deterministic NAT (VPP-623)Matus Fabian10-164/+2258
2017-03-07Add setting of tenant VRF id for SNAT addresses (VPP-641)Juraj Sloboda4-8/+42
2017-03-07fix uninitialized ip6 keys within session.cGabriel Ganne1-0/+8
2017-03-07silence -Wmaybe-uninitialized warningGabriel Ganne1-1/+1
2017-03-07Python API: Synchronous mode.Ole Troan6-149/+380
2017-03-07make per-adj counters configurableNeale Ranns4-61/+175
, *b1; u8 *t0, *t1; /* Prefetch next iteration. */ vlib_prefetch_buffer_with_index (vm, from[2], LOAD); vlib_prefetch_buffer_with_index (vm, from[3], LOAD); bi0 = from[0]; bi1 = from[1]; b0 = vlib_get_buffer (vm, bi0); b1 = vlib_get_buffer (vm, bi1); if (b0->flags & VLIB_BUFFER_IS_TRACED) { t0 = vlib_add_trace (vm, node, b0, n_buffer_data_bytes_in_trace); clib_memcpy (t0, b0->data + b0->current_data, n_buffer_data_bytes_in_trace); } if (b1->flags & VLIB_BUFFER_IS_TRACED) { t1 = vlib_add_trace (vm, node, b1, n_buffer_data_bytes_in_trace); clib_memcpy (t1, b1->data + b1->current_data, n_buffer_data_bytes_in_trace); } from += 2; n_left -= 2; } while (n_left >= 1) { u32 bi0; vlib_buffer_t *b0; u8 *t0; bi0 = from[0]; b0 = vlib_get_buffer (vm, bi0); if (b0->flags & VLIB_BUFFER_IS_TRACED) { t0 = vlib_add_trace (vm, node, b0, n_buffer_data_bytes_in_trace); clib_memcpy (t0, b0->data + b0->current_data, n_buffer_data_bytes_in_trace); } from += 1; n_left -= 1; } } /* Free up all trace buffer memory. */ always_inline void clear_trace_buffer (void) { int i; vlib_trace_main_t *tm; /* *INDENT-OFF* */ foreach_vlib_main ( ({ tm = &this_vlib_main->trace_main; tm->trace_enable = 0; for (i = 0; i < vec_len (tm->trace_buffer_pool); i++) if (! pool_is_free_index (tm->trace_buffer_pool, i)) vec_free (tm->trace_buffer_pool[i]); pool_free (tm->trace_buffer_pool); })); /* *INDENT-ON* */ } static u8 * format_vlib_trace (u8 * s, va_list * va) { vlib_main_t *vm = va_arg (*va, vlib_main_t *); vlib_trace_header_t *h = va_arg (*va, vlib_trace_header_t *); vlib_trace_header_t *e = vec_end (h); vlib_node_t *node, *prev_node; clib_time_t *ct = &vm->clib_time; f64 t; prev_node = 0; while (h < e) { node = vlib_get_node (vm, h->node_index); if (node != prev_node) { t = (h->time - vm->cpu_time_main_loop_start) * ct->seconds_per_clock; s = format (s, "\n%U: %v", format_time_interval, "h:m:s:u", t, node->name); } prev_node = node; if (node->format_trace) s = format (s, "\n %U", node->format_trace, vm, node, h->data); else s = format (s, "\n %U", node->format_buffer, h->data); h = vlib_trace_header_next (h); } return s; } /* Root of all trace cli commands. */ /* *INDENT-OFF* */ VLIB_CLI_COMMAND (trace_cli_command,static) = { .path = "trace", .short_help = "Packet tracer commands", }; /* *INDENT-ON* */ static int trace_cmp (void *a1, void *a2) { vlib_trace_header_t **t1 = a1; vlib_trace_header_t **t2 = a2; i64 dt = t1[0]->time - t2[0]->time; return dt < 0 ? -1 : (dt > 0 ? +1 : 0); } /* * Return 1 if this packet passes the trace filter, or 0 otherwise */ u32 filter_accept (vlib_trace_main_t * tm, vlib_trace_header_t * h) { vlib_trace_header_t *e = vec_end (h); if (tm->filter_flag == 0) return 1; if (tm->filter_flag == FILTER_FLAG_INCLUDE) { while (h < e) { if (h->node_index == tm->filter_node_index) return 1; h = vlib_trace_header_next (h); } return 0; } else /* FILTER_FLAG_EXCLUDE */ { while (h < e) { if (h->node_index == tm->filter_node_index) return 0; h = vlib_trace_header_next (h); } return 1; } return 0; } /* * Remove traces from the trace buffer pool that don't pass the filter */ void trace_apply_filter (vlib_main_t * vm) { vlib_trace_main_t *tm = &vm->trace_main; vlib_trace_header_t **h; vlib_trace_header_t ***traces_to_remove = 0; u32 index; u32 trace_index; u32 n_accepted; u32 accept; if (tm->filter_flag == FILTER_FLAG_NONE) return; /* * Ideally we would retain the first N traces that pass the filter instead * of any N traces. */ n_accepted = 0; /* *INDENT-OFF* */ pool_foreach (h, tm->trace_buffer_pool, ({ accept = filter_accept(tm, h[0]); if ((n_accepted == tm->filter_count) || !accept) vec_add1 (traces_to_remove, h); else n_accepted++; })); /* *INDENT-ON* */ /* remove all traces that we don't want to keep */ for (index = 0; index < vec_len (traces_to_remove); index++) { trace_index = traces_to_remove[index] - tm->trace_buffer_pool; _vec_len (tm->trace_buffer_pool[trace_index]) = 0; pool_put_index (tm->trace_buffer_pool, trace_index); } vec_free (traces_to_remove); } static clib_error_t * cli_show_trace_buffer (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) { vlib_trace_main_t *tm; vlib_trace_header_t **h, **traces; u32 i, index = 0; char *fmt; u8 *s = 0; u32 max; /* * By default display only this many traces. To display more, explicitly * specify a max. This prevents unexpectedly huge outputs. */ max = 50; while (unformat_check_input (input) != (uword) UNFORMAT_END_OF_INPUT) { if (unformat (input, "max %d", &max)) ; else return clib_error_create ("expected 'max COUNT', got `%U'", format_unformat_error, input); } /* Get active traces from pool. */ /* *INDENT-OFF* */ foreach_vlib_main ( ({ fmt = "------------------- Start of thread %d %s -------------------\n"; s = format (s, fmt, index, vlib_worker_threads[index].name); tm = &this_vlib_main->trace_main; trace_apply_filter(this_vlib_main); traces = 0; pool_foreach (h, tm->trace_buffer_pool, ({ vec_add1 (traces, h[0]); })); if (vec_len (traces) == 0) { s = format (s, "No packets in trace buffer\n"); goto done; } /* Sort them by increasing time. */ vec_sort_with_function (traces, trace_cmp); for (i = 0; i < vec_len (traces); i++) { if (i == max) { vlib_cli_output (vm, "Limiting display to %d packets." " To display more specify max.", max); goto done; } s = format (s, "Packet %d\n%U\n\n", i + 1, format_vlib_trace, vm, traces[i]); } done: vec_free (traces); index++; })); /* *INDENT-ON* */ vlib_cli_output (vm, "%v", s); vec_free (s); return 0; } /* *INDENT-OFF* */ VLIB_CLI_COMMAND (show_trace_cli,static) = { .path = "show trace", .short_help = "Show trace buffer [max COUNT]", .function = cli_show_trace_buffer, }; /* *INDENT-ON* */ static clib_error_t * cli_add_trace_buffer (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) { unformat_input_t _line_input, *line_input = &_line_input; vlib_trace_main_t *tm; vlib_trace_node_t *tn; u32 node_index, add; u8 verbose = 0; clib_error_t *error = 0; if (!unformat_user (input, unformat_line_input, line_input)) return 0; if (vnet_trace_dummy == 0) vec_validate_aligned (vnet_trace_dummy, 2048, CLIB_CACHE_LINE_BYTES); while (unformat_check_input (line_input) != (uword) UNFORMAT_END_OF_INPUT) { if (unformat (line_input, "%U %d", unformat_vlib_node, vm, &node_index, &add)) ; else if (unformat (line_input, "verbose")) verbose = 1; else { error = clib_error_create ("expected NODE COUNT, got `%U'", format_unformat_error, line_input); goto done; } } /* *INDENT-OFF* */ foreach_vlib_main (( { tm = &this_vlib_main->trace_main; tm->verbose = verbose; vec_validate (tm->nodes, node_index); tn = tm->nodes + node_index; tn->limit += add; tm->trace_enable = 1; })); /* *INDENT-ON* */ done: unformat_free (line_input); return error; } /* *INDENT-OFF* */ VLIB_CLI_COMMAND (add_trace_cli,static) = { .path = "trace add", .short_help = "Trace given number of packets", .function = cli_add_trace_buffer, }; /* *INDENT-ON* */ /* * Configure a filter for packet traces. * * This supplements the packet trace feature so that only packets matching * the filter are included in the trace. Currently the only filter is to * keep packets that include a certain node in the trace or exclude a certain * node in the trace. * * The count of traced packets in the "trace add" command is still used to * create a certain number of traces. The "trace filter" command specifies * how many of those packets should be retained in the trace. * * For example, 1Mpps of traffic is arriving and one of those packets is being * dropped. To capture the trace for only that dropped packet, you can do: * trace filter include error-drop 1 * trace add dpdk-input 1000000 * <wait one second> * show trace * * Note that the filter could be implemented by capturing all traces and just * reducing traces displayed by the "show trace" function. But that would * require a lot of memory for storing the traces, making that infeasible. * * To remove traces from the trace pool that do not include a certain node * requires that the trace be "complete" before applying the filter. To * accomplish this, the trace pool is filtered upon each iteraction of the * main vlib loop. Doing so keeps the number of allocated traces down to a * reasonably low number. This requires that tracing for a buffer is not * performed after the vlib main loop interation completes. i.e. you can't * save away a buffer temporarily then inject it back into the graph and * expect that the trace_index is still valid (such as a traffic manager might * do). A new trace buffer should be allocated for those types of packets. * * The filter can be extended to support multiple nodes and other match * criteria (e.g. input sw_if_index, mac address) but for now just checks if * a specified node is in the trace or not in the trace. */ static clib_error_t * cli_filter_trace (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) { vlib_trace_main_t *tm = &vm->trace_main; u32 filter_node_index; u32 filter_flag; u32 filter_count; if (unformat (input, "include %U %d", unformat_vlib_node, vm, &filter_node_index, &filter_count)) { filter_flag = FILTER_FLAG_INCLUDE; } else if (unformat (input, "exclude %U %d", unformat_vlib_node, vm, &filter_node_index, &filter_count)) { filter_flag = FILTER_FLAG_EXCLUDE; } else if (unformat (input, "none")) { filter_flag = FILTER_FLAG_NONE; filter_node_index = 0; filter_count = 0; } else return clib_error_create ("expected 'include NODE COUNT' or 'exclude NODE COUNT' or 'none', got `%U'", format_unformat_error, input); /* *INDENT-OFF* */ foreach_vlib_main ( ({ tm = &this_vlib_main->trace_main; tm->filter_node_index = filter_node_index; tm->filter_flag = filter_flag; tm->filter_count = filter_count; /* * Clear the trace limits to stop any in-progress tracing * Prevents runaway trace allocations when the filter changes * (or is removed) */ vec_free (tm->nodes); })); /* *INDENT-ON* */ return 0; } /* *INDENT-OFF* */ VLIB_CLI_COMMAND (filter_trace_cli,static) = { .path = "trace filter", .short_help = "filter trace output - include NODE COUNT | exclude NODE COUNT | none", .function = cli_filter_trace, }; /* *INDENT-ON* */ static clib_error_t * cli_clear_trace_buffer (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) { clear_trace_buffer (); return 0; } /* *INDENT-OFF* */ VLIB_CLI_COMMAND (clear_trace_cli,static) = { .path = "clear trace", .short_help = "Clear trace buffer and free memory", .function = cli_clear_trace_buffer, }; /* *INDENT-ON* */ /* Dummy function to get us linked in. */ void vlib_trace_cli_reference (void) { } /* * fd.io coding-style-patch-verification: ON * * Local Variables: * eval: (c-set-style "gnu") * End: */