static vlib_node_registration_t tapcli_rx_node;
static void tapcli_nopunt_frame (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame);
+ vlib_node_runtime_t * node,
+ vlib_frame_t * frame);
/**
* @brief Struct for the tapcli interface
*/
-typedef struct {
+typedef struct
+{
u32 unix_fd;
u32 clib_file_index;
u32 provision_fd;
/**
* @brief Struct for RX trace
*/
-typedef struct {
+typedef struct
+{
u16 sw_if_index;
} tapcli_rx_trace_t;
* @return *s - u8 - formatted string
*
*/
-u8 * format_tapcli_rx_trace (u8 * s, va_list * va)
+u8 *
+format_tapcli_rx_trace (u8 * s, va_list * va)
{
CLIB_UNUSED (vlib_main_t * vm) = va_arg (*va, vlib_main_t *);
CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *);
- vnet_main_t * vnm = vnet_get_main();
- tapcli_rx_trace_t * t = va_arg (*va, tapcli_rx_trace_t *);
- s = format (s, "%U", format_vnet_sw_if_index_name,
- vnm, t->sw_if_index);
+ vnet_main_t *vnm = vnet_get_main ();
+ tapcli_rx_trace_t *t = va_arg (*va, tapcli_rx_trace_t *);
+ s = format (s, "%U", format_vnet_sw_if_index_name, vnm, t->sw_if_index);
return s;
}
{
/** Vector of VLIB rx buffers to use. We allocate them in blocks
of VLIB_FRAME_SIZE (256). */
- u32 * rx_buffers;
+ u32 *rx_buffers;
/** Vector of iovecs for readv/writev calls. */
- struct iovec * iovecs;
+ struct iovec *iovecs;
} tapcli_per_thread_t;
/**
* @brief TAPCLI main state struct
*/
-typedef struct {
+typedef struct
+{
/** per thread variables */
- tapcli_per_thread_t * threads;
+ tapcli_per_thread_t *threads;
/** tap device destination MAC address. Required, or Linux drops pkts */
u8 ether_dst_mac[6];
u32 mtu_bytes, mtu_buffers;
/** Vector of tap interfaces */
- tapcli_interface_t * tapcli_interfaces;
+ tapcli_interface_t *tapcli_interfaces;
/** Vector of deleted tap interfaces */
- u32 * tapcli_inactive_interfaces;
+ u32 *tapcli_inactive_interfaces;
/** Bitmap of tap interfaces with pending reads */
- uword * pending_read_bitmap;
+ uword *pending_read_bitmap;
/** Hash table to find tapcli interface given hw_if_index */
- uword * tapcli_interface_index_by_sw_if_index;
+ uword *tapcli_interface_index_by_sw_if_index;
/** Hash table to find tapcli interface given unix fd */
- uword * tapcli_interface_index_by_unix_fd;
+ uword *tapcli_interface_index_by_unix_fd;
/** renumbering table */
- u32 * show_dev_instance_by_real_dev_instance;
+ u32 *show_dev_instance_by_real_dev_instance;
/** 1 => disable CLI */
int is_disabled;
/** convenience - vlib_main_t */
- vlib_main_t * vlib_main;
+ vlib_main_t *vlib_main;
/** convenience - vnet_main_t */
- vnet_main_t * vnet_main;
+ vnet_main_t *vnet_main;
} tapcli_main_t;
static tapcli_main_t tapcli_main;
*
*/
static uword
-tapcli_tx (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame)
+tapcli_tx (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
{
- u32 * buffers = vlib_frame_args (frame);
+ u32 *buffers = vlib_frame_args (frame);
uword n_packets = frame->n_vectors;
- tapcli_main_t * tm = &tapcli_main;
- tapcli_interface_t * ti;
+ tapcli_main_t *tm = &tapcli_main;
+ tapcli_interface_t *ti;
int i;
u16 thread_index = vlib_get_thread_index ();
for (i = 0; i < n_packets; i++)
{
- struct iovec * iov;
- vlib_buffer_t * b;
+ struct iovec *iov;
+ vlib_buffer_t *b;
uword l;
- vnet_hw_interface_t * hw;
- uword * p;
+ vnet_hw_interface_t *hw;
+ uword *p;
u32 tx_sw_if_index;
b = vlib_get_buffer (vm, buffers[i]);
- tx_sw_if_index = vnet_buffer(b)->sw_if_index[VLIB_TX];
- if (tx_sw_if_index == (u32)~0)
- tx_sw_if_index = vnet_buffer(b)->sw_if_index[VLIB_RX];
-
- ASSERT(tx_sw_if_index != (u32)~0);
+ tx_sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_TX];
+ if (tx_sw_if_index == (u32) ~ 0)
+ tx_sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_RX];
+
+ ASSERT (tx_sw_if_index != (u32) ~ 0);
/* Use the sup intfc to finesse vlan subifs */
hw = vnet_get_sup_hw_interface (tm->vnet_main, tx_sw_if_index);
tx_sw_if_index = hw->sw_if_index;
- p = hash_get (tm->tapcli_interface_index_by_sw_if_index,
- tx_sw_if_index);
+ p = hash_get (tm->tapcli_interface_index_by_sw_if_index,
+ tx_sw_if_index);
if (p == 0)
- {
- clib_warning ("sw_if_index %d unknown", tx_sw_if_index);
- /* $$$ leak, but this should never happen... */
- continue;
- }
+ {
+ clib_warning ("sw_if_index %d unknown", tx_sw_if_index);
+ /* $$$ leak, but this should never happen... */
+ continue;
+ }
else
- ti = vec_elt_at_index (tm->tapcli_interfaces, p[0]);
+ ti = vec_elt_at_index (tm->tapcli_interfaces, p[0]);
/* Re-set iovecs if present. */
if (tm->threads[thread_index].iovecs)
if (PREDICT_FALSE (b->flags & VLIB_BUFFER_NEXT_PRESENT))
{
- do {
- b = vlib_get_buffer (vm, b->next_buffer);
+ do
+ {
+ b = vlib_get_buffer (vm, b->next_buffer);
- vec_add2 (tm->threads[thread_index].iovecs, iov, 1);
+ vec_add2 (tm->threads[thread_index].iovecs, iov, 1);
- iov->iov_base = b->data + b->current_data;
- iov->iov_len = b->current_length;
- l += b->current_length;
- } while (b->flags & VLIB_BUFFER_NEXT_PRESENT);
+ iov->iov_base = b->data + b->current_data;
+ iov->iov_len = b->current_length;
+ l += b->current_length;
+ }
+ while (b->flags & VLIB_BUFFER_NEXT_PRESENT);
}
if (writev (ti->unix_fd, tm->threads[thread_index].iovecs,
clib_unix_warning ("writev");
}
- vlib_buffer_free(vm, vlib_frame_vector_args(frame), frame->n_vectors);
+ vlib_buffer_free (vm, vlib_frame_vector_args (frame), frame->n_vectors);
return n_packets;
}
+/* *INDENT-OFF* */
VLIB_REGISTER_NODE (tapcli_tx_node,static) = {
.function = tapcli_tx,
.name = "tapcli-tx",
.type = VLIB_NODE_TYPE_INTERNAL,
.vector_size = 4,
};
+/* *INDENT-ON* */
/**
* @brief Dispatch tapcli RX node function for node tap_cli_rx
* @return n_packets - uword
*
*/
-static uword tapcli_rx_iface(vlib_main_t * vm,
- vlib_node_runtime_t * node,
- tapcli_interface_t * ti)
+static uword
+tapcli_rx_iface (vlib_main_t * vm,
+ vlib_node_runtime_t * node, tapcli_interface_t * ti)
{
- tapcli_main_t * tm = &tapcli_main;
+ tapcli_main_t *tm = &tapcli_main;
const uword buffer_size = VLIB_BUFFER_DATA_SIZE;
u32 n_trace = vlib_get_trace_count (vm, node);
u8 set_trace = 0;
u16 thread_index = vlib_get_thread_index ();
vnet_main_t *vnm;
- vnet_sw_interface_t * si;
+ vnet_sw_interface_t *si;
u8 admin_down;
u32 next = node->cached_next_index;
u32 n_left_to_next, next_index;
u32 *to_next;
- vnm = vnet_get_main();
+ vnm = vnet_get_main ();
si = vnet_get_sw_interface (vnm, ti->sw_if_index);
admin_down = !(si->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP);
- vlib_get_next_frame(vm, node, next, to_next, n_left_to_next);
-
- while (n_left_to_next) { // Fill at most one vector
- vlib_buffer_t *b_first, *b, *prev;
- u32 bi_first, bi;
- word n_bytes_in_packet;
- int j, n_bytes_left;
-
- if (PREDICT_FALSE(vec_len(tm->threads[thread_index].rx_buffers) <
- tm->mtu_buffers)) {
- uword len = vec_len(tm->threads[thread_index].rx_buffers);
- _vec_len(tm->threads[thread_index].rx_buffers) +=
- vlib_buffer_alloc_from_free_list(vm, &tm->threads[thread_index].rx_buffers[len],
- VLIB_FRAME_SIZE - len, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
- if (PREDICT_FALSE(vec_len(tm->threads[thread_index].rx_buffers) <
- tm->mtu_buffers)) {
- vlib_node_increment_counter(vm, tapcli_rx_node.index,
- TAPCLI_ERROR_BUFFER_ALLOC,
- tm->mtu_buffers -
- vec_len(tm->threads[thread_index].rx_buffers));
- break;
- }
- }
-
- uword i_rx = vec_len (tm->threads[thread_index].rx_buffers) - 1;
-
- /* Allocate RX buffers from end of rx_buffers.
- Turn them into iovecs to pass to readv. */
- vec_validate (tm->threads[thread_index].iovecs, tm->mtu_buffers - 1);
- for (j = 0; j < tm->mtu_buffers; j++) {
- b = vlib_get_buffer (vm, tm->threads[thread_index].rx_buffers[i_rx - j]);
- tm->threads[thread_index].iovecs[j].iov_base = b->data;
- tm->threads[thread_index].iovecs[j].iov_len = buffer_size;
- }
+ vlib_get_next_frame (vm, node, next, to_next, n_left_to_next);
- n_bytes_left = readv (ti->unix_fd, tm->threads[thread_index].iovecs,
- tm->mtu_buffers);
- n_bytes_in_packet = n_bytes_left;
- if (n_bytes_left <= 0) {
- if (errno != EAGAIN) {
- vlib_node_increment_counter(vm, tapcli_rx_node.index,
- TAPCLI_ERROR_READ, 1);
- }
- break;
- }
+ while (n_left_to_next)
+ { // Fill at most one vector
+ vlib_buffer_t *b_first, *b, *prev;
+ u32 bi_first, bi;
+ word n_bytes_in_packet;
+ int j, n_bytes_left;
- bi_first = tm->threads[thread_index].rx_buffers[i_rx];
- b = b_first = vlib_get_buffer (vm,
- tm->threads[thread_index].rx_buffers[i_rx]);
- prev = NULL;
+ if (PREDICT_FALSE (vec_len (tm->threads[thread_index].rx_buffers) <
+ tm->mtu_buffers))
+ {
+ uword len = vec_len (tm->threads[thread_index].rx_buffers);
+ _vec_len (tm->threads[thread_index].rx_buffers) +=
+ vlib_buffer_alloc_from_free_list (vm,
+ &tm->threads[thread_index].
+ rx_buffers[len],
+ VLIB_FRAME_SIZE - len,
+ VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
+ if (PREDICT_FALSE
+ (vec_len (tm->threads[thread_index].rx_buffers) <
+ tm->mtu_buffers))
+ {
+ vlib_node_increment_counter (vm, tapcli_rx_node.index,
+ TAPCLI_ERROR_BUFFER_ALLOC,
+ tm->mtu_buffers -
+ vec_len (tm->threads
+ [thread_index].
+ rx_buffers));
+ break;
+ }
+ }
- while (1) {
- b->current_length = n_bytes_left < buffer_size ? n_bytes_left : buffer_size;
- n_bytes_left -= buffer_size;
+ uword i_rx = vec_len (tm->threads[thread_index].rx_buffers) - 1;
- if (prev) {
- prev->next_buffer = bi;
- prev->flags |= VLIB_BUFFER_NEXT_PRESENT;
- }
- prev = b;
+ /* Allocate RX buffers from end of rx_buffers.
+ Turn them into iovecs to pass to readv. */
+ vec_validate (tm->threads[thread_index].iovecs, tm->mtu_buffers - 1);
+ for (j = 0; j < tm->mtu_buffers; j++)
+ {
+ b =
+ vlib_get_buffer (vm,
+ tm->threads[thread_index].rx_buffers[i_rx - j]);
+ tm->threads[thread_index].iovecs[j].iov_base = b->data;
+ tm->threads[thread_index].iovecs[j].iov_len = buffer_size;
+ }
- /* last segment */
+ n_bytes_left = readv (ti->unix_fd, tm->threads[thread_index].iovecs,
+ tm->mtu_buffers);
+ n_bytes_in_packet = n_bytes_left;
if (n_bytes_left <= 0)
- break;
+ {
+ if (errno != EAGAIN)
+ {
+ vlib_node_increment_counter (vm, tapcli_rx_node.index,
+ TAPCLI_ERROR_READ, 1);
+ }
+ break;
+ }
- i_rx--;
- bi = tm->threads[thread_index].rx_buffers[i_rx];
- b = vlib_get_buffer (vm, bi);
- }
+ bi_first = tm->threads[thread_index].rx_buffers[i_rx];
+ b = b_first = vlib_get_buffer (vm,
+ tm->threads[thread_index].
+ rx_buffers[i_rx]);
+ prev = NULL;
- _vec_len (tm->threads[thread_index].rx_buffers) = i_rx;
+ while (1)
+ {
+ b->current_length =
+ n_bytes_left < buffer_size ? n_bytes_left : buffer_size;
+ n_bytes_left -= buffer_size;
+
+ if (prev)
+ {
+ prev->next_buffer = bi;
+ prev->flags |= VLIB_BUFFER_NEXT_PRESENT;
+ }
+ prev = b;
+
+ /* last segment */
+ if (n_bytes_left <= 0)
+ break;
+
+ i_rx--;
+ bi = tm->threads[thread_index].rx_buffers[i_rx];
+ b = vlib_get_buffer (vm, bi);
+ }
- b_first->total_length_not_including_first_buffer =
- (n_bytes_in_packet > buffer_size) ? n_bytes_in_packet - buffer_size : 0;
- b_first->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
+ _vec_len (tm->threads[thread_index].rx_buffers) = i_rx;
- VLIB_BUFFER_TRACE_TRAJECTORY_INIT(b_first);
+ b_first->total_length_not_including_first_buffer =
+ (n_bytes_in_packet >
+ buffer_size) ? n_bytes_in_packet - buffer_size : 0;
+ b_first->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
- vnet_buffer (b_first)->sw_if_index[VLIB_RX] = ti->sw_if_index;
- vnet_buffer (b_first)->sw_if_index[VLIB_TX] = (u32)~0;
+ VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b_first);
- b_first->error = node->errors[TAPCLI_ERROR_NONE];
- next_index = VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
- next_index = (ti->per_interface_next_index != ~0) ?
- ti->per_interface_next_index : next_index;
- next_index = admin_down ? VNET_DEVICE_INPUT_NEXT_DROP : next_index;
+ vnet_buffer (b_first)->sw_if_index[VLIB_RX] = ti->sw_if_index;
+ vnet_buffer (b_first)->sw_if_index[VLIB_TX] = (u32) ~ 0;
- to_next[0] = bi_first;
- to_next++;
- n_left_to_next--;
+ b_first->error = node->errors[TAPCLI_ERROR_NONE];
+ next_index = VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
+ next_index = (ti->per_interface_next_index != ~0) ?
+ ti->per_interface_next_index : next_index;
+ next_index = admin_down ? VNET_DEVICE_INPUT_NEXT_DROP : next_index;
- vnet_feature_start_device_input_x1 (ti->sw_if_index, &next_index, b_first);
+ to_next[0] = bi_first;
+ to_next++;
+ n_left_to_next--;
- vlib_validate_buffer_enqueue_x1 (vm, node, next,
- to_next, n_left_to_next,
- bi_first, next_index);
+ vnet_feature_start_device_input_x1 (ti->sw_if_index, &next_index,
+ b_first);
- /* Interface counters for tapcli interface. */
- if (PREDICT_TRUE(!admin_down)) {
- vlib_increment_combined_counter (
- vnet_main.interface_main.combined_sw_if_counters
- + VNET_INTERFACE_COUNTER_RX,
- thread_index, ti->sw_if_index,
- 1, n_bytes_in_packet);
+ vlib_validate_buffer_enqueue_x1 (vm, node, next,
+ to_next, n_left_to_next,
+ bi_first, next_index);
- if (PREDICT_FALSE(n_trace > 0)) {
- vlib_trace_buffer (vm, node, next_index,
- b_first, /* follow_chain */ 1);
- n_trace--;
- set_trace = 1;
- tapcli_rx_trace_t *t0 = vlib_add_trace (vm, node, b_first, sizeof (*t0));
- t0->sw_if_index = si->sw_if_index;
- }
+ /* Interface counters for tapcli interface. */
+ if (PREDICT_TRUE (!admin_down))
+ {
+ vlib_increment_combined_counter (vnet_main.interface_main.
+ combined_sw_if_counters +
+ VNET_INTERFACE_COUNTER_RX,
+ thread_index, ti->sw_if_index, 1,
+ n_bytes_in_packet);
+
+ if (PREDICT_FALSE (n_trace > 0))
+ {
+ vlib_trace_buffer (vm, node, next_index,
+ b_first, /* follow_chain */ 1);
+ n_trace--;
+ set_trace = 1;
+ tapcli_rx_trace_t *t0 =
+ vlib_add_trace (vm, node, b_first, sizeof (*t0));
+ t0->sw_if_index = si->sw_if_index;
+ }
+ }
}
- }
vlib_put_next_frame (vm, node, next, n_left_to_next);
if (set_trace)
vlib_set_trace_count (vm, node, n_trace);
*
*/
static uword
-tapcli_rx (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame)
+tapcli_rx (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
{
- tapcli_main_t * tm = &tapcli_main;
- static u32 * ready_interface_indices;
- tapcli_interface_t * ti;
+ tapcli_main_t *tm = &tapcli_main;
+ static u32 *ready_interface_indices;
+ tapcli_interface_t *ti;
int i;
u32 total_count = 0;
vec_reset_length (ready_interface_indices);
+ /* *INDENT-OFF* */
clib_bitmap_foreach (i, tm->pending_read_bitmap,
({
vec_add1 (ready_interface_indices, i);
}));
+ /* *INDENT-ON* */
if (vec_len (ready_interface_indices) == 0)
return 0;
- for (i = 0; i < vec_len(ready_interface_indices); i++)
- {
- tm->pending_read_bitmap =
- clib_bitmap_set (tm->pending_read_bitmap,
- ready_interface_indices[i], 0);
+ for (i = 0; i < vec_len (ready_interface_indices); i++)
+ {
+ tm->pending_read_bitmap =
+ clib_bitmap_set (tm->pending_read_bitmap,
+ ready_interface_indices[i], 0);
- ti = vec_elt_at_index (tm->tapcli_interfaces, ready_interface_indices[i]);
- total_count += tapcli_rx_iface(vm, node, ti);
- }
- return total_count; //This might return more than 256.
+ ti =
+ vec_elt_at_index (tm->tapcli_interfaces, ready_interface_indices[i]);
+ total_count += tapcli_rx_iface (vm, node, ti);
+ }
+ return total_count; //This might return more than 256.
}
/** TAPCLI error strings */
-static char * tapcli_rx_error_strings[] = {
+static char *tapcli_rx_error_strings[] = {
#define _(sym,string) string,
foreach_tapcli_error
#undef _
};
+/* *INDENT-OFF* */
VLIB_REGISTER_NODE (tapcli_rx_node, static) = {
.function = tapcli_rx,
.name = "tapcli-rx",
.error_strings = tapcli_rx_error_strings,
.format_trace = format_tapcli_rx_trace,
};
+/* *INDENT-ON* */
/**
* @return error - clib_error_t
*
*/
-static clib_error_t * tapcli_read_ready (clib_file_t * uf)
+static clib_error_t *
+tapcli_read_ready (clib_file_t * uf)
{
- vlib_main_t * vm = vlib_get_main();
- tapcli_main_t * tm = &tapcli_main;
- uword * p;
+ vlib_main_t *vm = vlib_get_main ();
+ tapcli_main_t *tm = &tapcli_main;
+ uword *p;
/** Schedule the rx node */
vlib_node_set_interrupt_pending (vm, tapcli_rx_node.index);
/** Mark the specific tap interface ready-to-read */
if (p)
tm->pending_read_bitmap = clib_bitmap_set (tm->pending_read_bitmap,
- p[0], 1);
+ p[0], 1);
else
clib_warning ("fd %d not in hash table", uf->file_descriptor);
if (unformat (input, "mtu %d", &tm->mtu_bytes))
;
else if (unformat (input, "disable"))
- tm->is_disabled = 1;
+ tm->is_disabled = 1;
else
- return clib_error_return (0, "unknown input `%U'",
- format_unformat_error, input);
+ return clib_error_return (0, "unknown input `%U'",
+ format_unformat_error, input);
}
if (tm->is_disabled)
return 0;
- if (geteuid())
+ if (geteuid ())
{
clib_warning ("tapcli disabled: must be superuser");
tm->is_disabled = 1;
* @return rc - int
*
*/
-static int tap_name_renumber (vnet_hw_interface_t * hi,
- u32 new_dev_instance)
+static int
+tap_name_renumber (vnet_hw_interface_t * hi, u32 new_dev_instance)
{
tapcli_main_t *tm = &tapcli_main;
vec_validate_init_empty (tm->show_dev_instance_by_real_dev_instance,
- hi->dev_instance, ~0);
+ hi->dev_instance, ~0);
- tm->show_dev_instance_by_real_dev_instance [hi->dev_instance] =
+ tm->show_dev_instance_by_real_dev_instance[hi->dev_instance] =
new_dev_instance;
return 0;
*/
static void
tapcli_nopunt_frame (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame)
+ vlib_node_runtime_t * node, vlib_frame_t * frame)
{
- u32 * buffers = vlib_frame_args (frame);
+ u32 *buffers = vlib_frame_args (frame);
uword n_packets = frame->n_vectors;
vlib_buffer_free (vm, buffers, n_packets);
vlib_frame_free (vm, node, frame);
}
+/* *INDENT-OFF* */
VNET_HW_INTERFACE_CLASS (tapcli_interface_class,static) = {
.name = "tapcli",
.flags = VNET_HW_INTERFACE_CLASS_FLAG_P2P,
};
+/* *INDENT-ON* */
/**
* @brief Formatter for TAPCLI interface name
* @return *s - formatted string
*
*/
-static u8 * format_tapcli_interface_name (u8 * s, va_list * args)
+static u8 *
+format_tapcli_interface_name (u8 * s, va_list * args)
{
u32 i = va_arg (*args, u32);
u32 show_dev_instance = ~0;
- tapcli_main_t * tm = &tapcli_main;
+ tapcli_main_t *tm = &tapcli_main;
if (i < vec_len (tm->show_dev_instance_by_real_dev_instance))
show_dev_instance = tm->show_dev_instance_by_real_dev_instance[i];
* @return rc - u32
*
*/
-static u32 tapcli_flag_change (vnet_main_t * vnm,
- vnet_hw_interface_t * hw,
- u32 flags)
+static u32
+tapcli_flag_change (vnet_main_t * vnm, vnet_hw_interface_t * hw, u32 flags)
{
tapcli_main_t *tm = &tapcli_main;
tapcli_interface_t *ti;
- ti = vec_elt_at_index (tm->tapcli_interfaces, hw->dev_instance);
+ ti = vec_elt_at_index (tm->tapcli_interfaces, hw->dev_instance);
if (flags & ETHERNET_INTERFACE_FLAG_MTU)
{
tm->mtu_bytes = hw->max_packet_bytes;
tm->mtu_buffers = (tm->mtu_bytes + (buffer_size - 1)) / buffer_size;
}
- else
+ else
{
struct ifreq ifr;
u32 want_promisc;
/* get flags, modify to bring up interface... */
if (ioctl (ti->provision_fd, SIOCGIFFLAGS, &ifr) < 0)
- {
- clib_unix_warning ("Couldn't get interface flags for %s", hw->name);
- return 0;
- }
+ {
+ clib_unix_warning ("Couldn't get interface flags for %s", hw->name);
+ return 0;
+ }
want_promisc = (flags & ETHERNET_INTERFACE_FLAG_ACCEPT_ALL) != 0;
if (want_promisc == ti->is_promisc)
- return 0;
+ return 0;
if (flags & ETHERNET_INTERFACE_FLAG_ACCEPT_ALL)
- ifr.ifr_flags |= IFF_PROMISC;
+ ifr.ifr_flags |= IFF_PROMISC;
else
- ifr.ifr_flags &= ~(IFF_PROMISC);
+ ifr.ifr_flags &= ~(IFF_PROMISC);
/* get flags, modify to bring up interface... */
if (ioctl (ti->provision_fd, SIOCSIFFLAGS, &ifr) < 0)
- {
- clib_unix_warning ("Couldn't set interface flags for %s", hw->name);
- return 0;
- }
+ {
+ clib_unix_warning ("Couldn't set interface flags for %s", hw->name);
+ return 0;
+ }
ti->is_promisc = want_promisc;
}
* @param node_index - u32
*
*/
-static void tapcli_set_interface_next_node (vnet_main_t *vnm,
- u32 hw_if_index,
- u32 node_index)
+static void
+tapcli_set_interface_next_node (vnet_main_t * vnm,
+ u32 hw_if_index, u32 node_index)
{
tapcli_main_t *tm = &tapcli_main;
tapcli_interface_t *ti;
return 0;
}
+/* *INDENT-OFF* */
VNET_DEVICE_CLASS (tapcli_dev_class,static) = {
.name = "tapcli",
.tx_function = tapcli_tx,
.name_renumber = tap_name_renumber,
.admin_up_down_function = tapcli_interface_admin_up_down,
};
+/* *INDENT-ON* */
/**
* @brief Dump TAP interfaces
* @return rc - int
*
*/
-int vnet_tap_dump_ifs (tapcli_interface_details_t **out_tapids)
+int
+vnet_tap_dump_ifs (tapcli_interface_details_t ** out_tapids)
{
- tapcli_main_t * tm = &tapcli_main;
- tapcli_interface_t * ti;
+ tapcli_main_t *tm = &tapcli_main;
+ tapcli_interface_t *ti;
- tapcli_interface_details_t * r_tapids = NULL;
- tapcli_interface_details_t * tapid = NULL;
+ tapcli_interface_details_t *r_tapids = NULL;
+ tapcli_interface_details_t *tapid = NULL;
- vec_foreach (ti, tm->tapcli_interfaces) {
+ vec_foreach (ti, tm->tapcli_interfaces)
+ {
if (!ti->active)
- continue;
- vec_add2(r_tapids, tapid, 1);
+ continue;
+ vec_add2 (r_tapids, tapid, 1);
tapid->sw_if_index = ti->sw_if_index;
- strncpy((char *)tapid->dev_name, ti->ifr.ifr_name, sizeof (ti->ifr.ifr_name)-1);
+ strncpy ((char *) tapid->dev_name, ti->ifr.ifr_name,
+ sizeof (ti->ifr.ifr_name) - 1);
}
*out_tapids = r_tapids;
* @return interface - tapcli_interface_t
*
*/
-static tapcli_interface_t *tapcli_get_new_tapif()
+static tapcli_interface_t *
+tapcli_get_new_tapif ()
{
- tapcli_main_t * tm = &tapcli_main;
+ tapcli_main_t *tm = &tapcli_main;
tapcli_interface_t *ti = NULL;
- int inactive_cnt = vec_len(tm->tapcli_inactive_interfaces);
+ int inactive_cnt = vec_len (tm->tapcli_inactive_interfaces);
// if there are any inactive ifaces
- if (inactive_cnt > 0) {
- // take last
- u32 ti_idx = tm->tapcli_inactive_interfaces[inactive_cnt - 1];
- if (vec_len(tm->tapcli_interfaces) > ti_idx) {
- ti = vec_elt_at_index (tm->tapcli_interfaces, ti_idx);
- clib_warning("reusing tap interface");
+ if (inactive_cnt > 0)
+ {
+ // take last
+ u32 ti_idx = tm->tapcli_inactive_interfaces[inactive_cnt - 1];
+ if (vec_len (tm->tapcli_interfaces) > ti_idx)
+ {
+ ti = vec_elt_at_index (tm->tapcli_interfaces, ti_idx);
+ clib_warning ("reusing tap interface");
+ }
+ // "remove" from inactive list
+ _vec_len (tm->tapcli_inactive_interfaces) -= 1;
}
- // "remove" from inactive list
- _vec_len(tm->tapcli_inactive_interfaces) -= 1;
- }
// ti was not retrieved from inactive ifaces - create new
if (!ti)
return ti;
}
-typedef struct
+typedef struct
{
- ip6_address_t addr;
- u32 mask_width;
- unsigned int ifindex;
+ ip6_address_t addr;
+ u32 mask_width;
+ unsigned int ifindex;
} ip6_ifreq_t;
/**
* @brief Connect a TAP interface
*
* @param vm - vlib_main_t
- * @param ap - vnet_tap_connect_args_t
+ * @param ap - vnet_tap_connect_args_t
*
* @return rc - int
*
*/
-int vnet_tap_connect (vlib_main_t * vm, vnet_tap_connect_args_t *ap)
+int
+vnet_tap_connect (vlib_main_t * vm, vnet_tap_connect_args_t * ap)
{
- tapcli_main_t * tm = &tapcli_main;
- tapcli_interface_t * ti = NULL;
+ tapcli_main_t *tm = &tapcli_main;
+ tapcli_interface_t *ti = NULL;
struct ifreq ifr;
int flags;
int dev_net_tun_fd;
int dev_tap_fd = -1;
- clib_error_t * error;
- u8 hwaddr [6];
+ clib_error_t *error;
+ u8 hwaddr[6];
int rv = 0;
if (tm->is_disabled)
return VNET_API_ERROR_SYSCALL_ERROR_1;
memset (&ifr, 0, sizeof (ifr));
- strncpy(ifr.ifr_name, (char *) ap->intfc_name, sizeof (ifr.ifr_name)-1);
+ strncpy (ifr.ifr_name, (char *) ap->intfc_name, sizeof (ifr.ifr_name) - 1);
ifr.ifr_flags = flags;
- if (ioctl (dev_net_tun_fd, TUNSETIFF, (void *)&ifr) < 0)
+ if (ioctl (dev_net_tun_fd, TUNSETIFF, (void *) &ifr) < 0)
{
rv = VNET_API_ERROR_SYSCALL_ERROR_2;
goto error;
}
-
+
/* Open a provisioning socket */
- if ((dev_tap_fd = socket(PF_PACKET, SOCK_RAW,
- htons(ETH_P_ALL))) < 0 )
+ if ((dev_tap_fd = socket (PF_PACKET, SOCK_RAW, htons (ETH_P_ALL))) < 0)
{
rv = VNET_API_ERROR_SYSCALL_ERROR_3;
goto error;
struct ifreq ifr;
struct sockaddr_ll sll;
- memset (&ifr, 0, sizeof(ifr));
- strncpy (ifr.ifr_name, (char *) ap->intfc_name, sizeof (ifr.ifr_name)-1);
- if (ioctl (dev_tap_fd, SIOCGIFINDEX, &ifr) < 0 )
+ memset (&ifr, 0, sizeof (ifr));
+ strncpy (ifr.ifr_name, (char *) ap->intfc_name,
+ sizeof (ifr.ifr_name) - 1);
+ if (ioctl (dev_tap_fd, SIOCGIFINDEX, &ifr) < 0)
{
- rv = VNET_API_ERROR_SYSCALL_ERROR_4;
- goto error;
+ rv = VNET_API_ERROR_SYSCALL_ERROR_4;
+ goto error;
}
/* Bind the provisioning socket to the interface. */
- memset(&sll, 0, sizeof(sll));
- sll.sll_family = AF_PACKET;
- sll.sll_ifindex = ifr.ifr_ifindex;
- sll.sll_protocol = htons(ETH_P_ALL);
+ memset (&sll, 0, sizeof (sll));
+ sll.sll_family = AF_PACKET;
+ sll.sll_ifindex = ifr.ifr_ifindex;
+ sll.sll_protocol = htons (ETH_P_ALL);
- if (bind(dev_tap_fd, (struct sockaddr*) &sll, sizeof(sll)) < 0)
+ if (bind (dev_tap_fd, (struct sockaddr *) &sll, sizeof (sll)) < 0)
{
- rv = VNET_API_ERROR_SYSCALL_ERROR_5;
- goto error;
+ rv = VNET_API_ERROR_SYSCALL_ERROR_5;
+ goto error;
}
}
int one = 1;
if (ioctl (dev_net_tun_fd, FIONBIO, &one) < 0)
{
- rv = VNET_API_ERROR_SYSCALL_ERROR_6;
+ rv = VNET_API_ERROR_SYSCALL_ERROR_6;
goto error;
}
}
/* ip4: mask defaults to /24 */
u32 mask = clib_host_to_net_u32 (0xFFFFFF00);
- memset(&sin, 0, sizeof(sin));
+ memset (&sin, 0, sizeof (sin));
sin.sin_family = AF_INET;
/* sin.sin_port = 0; */
sin.sin_addr.s_addr = ap->ip4_address->as_u32;
memcpy (&ifr.ifr_ifru.ifru_addr, &sin, sizeof (sin));
if (ioctl (dev_tap_fd, SIOCSIFADDR, &ifr) < 0)
- {
- rv = VNET_API_ERROR_SYSCALL_ERROR_10;
- goto error;
- }
+ {
+ rv = VNET_API_ERROR_SYSCALL_ERROR_10;
+ goto error;
+ }
if (ap->ip4_mask_width > 0 && ap->ip4_mask_width < 33)
- {
- mask = ~0;
- mask <<= (32 - ap->ip4_mask_width);
- }
+ {
+ mask = ~0;
+ mask <<= (32 - ap->ip4_mask_width);
+ }
- mask = clib_host_to_net_u32(mask);
+ mask = clib_host_to_net_u32 (mask);
sin.sin_family = AF_INET;
sin.sin_port = 0;
sin.sin_addr.s_addr = mask;
memcpy (&ifr.ifr_ifru.ifru_addr, &sin, sizeof (sin));
if (ioctl (dev_tap_fd, SIOCSIFNETMASK, &ifr) < 0)
- {
- rv = VNET_API_ERROR_SYSCALL_ERROR_10;
- goto error;
- }
+ {
+ rv = VNET_API_ERROR_SYSCALL_ERROR_10;
+ goto error;
+ }
}
if (ap->ip6_address_set)
ip6_ifreq_t ifr6;
int sockfd6;
- sockfd6 = socket(AF_INET6, SOCK_DGRAM, IPPROTO_IP);
+ sockfd6 = socket (AF_INET6, SOCK_DGRAM, IPPROTO_IP);
if (sockfd6 < 0)
- {
- rv = VNET_API_ERROR_SYSCALL_ERROR_10;
- goto error;
- }
-
- memset (&ifr2, 0, sizeof(ifr));
- strncpy (ifr2.ifr_name, (char *) ap->intfc_name,
- sizeof (ifr2.ifr_name)-1);
- if (ioctl (sockfd6, SIOCGIFINDEX, &ifr2) < 0 )
- {
- close (sockfd6);
- rv = VNET_API_ERROR_SYSCALL_ERROR_4;
- goto error;
- }
-
+ {
+ rv = VNET_API_ERROR_SYSCALL_ERROR_10;
+ goto error;
+ }
+
+ memset (&ifr2, 0, sizeof (ifr));
+ strncpy (ifr2.ifr_name, (char *) ap->intfc_name,
+ sizeof (ifr2.ifr_name) - 1);
+ if (ioctl (sockfd6, SIOCGIFINDEX, &ifr2) < 0)
+ {
+ close (sockfd6);
+ rv = VNET_API_ERROR_SYSCALL_ERROR_4;
+ goto error;
+ }
+
memcpy (&ifr6.addr, ap->ip6_address, sizeof (ip6_address_t));
ifr6.mask_width = ap->ip6_mask_width;
ifr6.ifindex = ifr2.ifr_ifindex;
-
+
if (ioctl (sockfd6, SIOCSIFADDR, &ifr6) < 0)
- {
- close (sockfd6);
- clib_unix_warning ("ifr6");
- rv = VNET_API_ERROR_SYSCALL_ERROR_10;
- goto error;
- }
+ {
+ close (sockfd6);
+ clib_unix_warning ("ifr6");
+ rv = VNET_API_ERROR_SYSCALL_ERROR_10;
+ goto error;
+ }
close (sockfd6);
}
- ti = tapcli_get_new_tapif();
+ ti = tapcli_get_new_tapif ();
ti->per_interface_next_index = ~0;
if (ap->hwaddr_arg != 0)
- clib_memcpy(hwaddr, ap->hwaddr_arg, 6);
+ clib_memcpy (hwaddr, ap->hwaddr_arg, 6);
else
{
- f64 now = vlib_time_now(vm);
+ f64 now = vlib_time_now (vm);
u32 rnd;
rnd = (u32) (now * 1e6);
rnd = random_u32 (&rnd);
- memcpy (hwaddr+2, &rnd, sizeof(rnd));
+ memcpy (hwaddr + 2, &rnd, sizeof (rnd));
hwaddr[0] = 2;
hwaddr[1] = 0xfe;
}
error = ethernet_register_interface
- (tm->vnet_main,
- tapcli_dev_class.index,
- ti - tm->tapcli_interfaces /* device instance */,
- hwaddr /* ethernet address */,
- &ti->hw_if_index,
- tapcli_flag_change);
+ (tm->vnet_main,
+ tapcli_dev_class.index,
+ ti - tm->tapcli_interfaces /* device instance */ ,
+ hwaddr /* ethernet address */ ,
+ &ti->hw_if_index, tapcli_flag_change);
if (error)
{
}
{
- clib_file_t template = {0};
+ clib_file_t template = { 0 };
template.read_function = tapcli_read_ready;
template.file_descriptor = dev_net_tun_fd;
ti->clib_file_index = clib_file_add (&file_main, &template);
ti->provision_fd = dev_tap_fd;
clib_memcpy (&ti->ifr, &ifr, sizeof (ifr));
}
-
+
{
- vnet_hw_interface_t * hw;
+ vnet_hw_interface_t *hw;
hw = vnet_get_hw_interface (tm->vnet_main, ti->hw_if_index);
hw->min_supported_packet_bytes = TAP_MTU_MIN;
hw->max_supported_packet_bytes = TAP_MTU_MAX;
- hw->max_l3_packet_bytes[VLIB_RX] = hw->max_l3_packet_bytes[VLIB_TX] = hw->max_supported_packet_bytes - sizeof(ethernet_header_t);
+ hw->max_l3_packet_bytes[VLIB_RX] = hw->max_l3_packet_bytes[VLIB_TX] =
+ hw->max_supported_packet_bytes - sizeof (ethernet_header_t);
ti->sw_if_index = hw->sw_if_index;
if (ap->sw_if_indexp)
*(ap->sw_if_indexp) = hw->sw_if_index;
}
ti->active = 1;
-
+
hash_set (tm->tapcli_interface_index_by_sw_if_index, ti->sw_if_index,
- ti - tm->tapcli_interfaces);
-
+ ti - tm->tapcli_interfaces);
+
hash_set (tm->tapcli_interface_index_by_unix_fd, ti->unix_fd,
- ti - tm->tapcli_interfaces);
-
+ ti - tm->tapcli_interfaces);
+
return rv;
- error:
+error:
close (dev_net_tun_fd);
if (dev_tap_fd >= 0)
- close (dev_tap_fd);
+ close (dev_tap_fd);
return rv;
}
* @return rc - int
*
*/
-int vnet_tap_connect_renumber (vlib_main_t * vm,
- vnet_tap_connect_args_t *ap)
+int
+vnet_tap_connect_renumber (vlib_main_t * vm, vnet_tap_connect_args_t * ap)
{
- int rv = vnet_tap_connect(vm, ap);
+ int rv = vnet_tap_connect (vm, ap);
if (!rv && ap->renumber)
- vnet_interface_name_renumber (*(ap->sw_if_indexp), ap->custom_dev_instance);
+ vnet_interface_name_renumber (*(ap->sw_if_indexp),
+ ap->custom_dev_instance);
return rv;
}
* @return rc - int
*
*/
-static int tapcli_tap_disconnect (tapcli_interface_t *ti)
+static int
+tapcli_tap_disconnect (tapcli_interface_t * ti)
{
int rv = 0;
- vnet_main_t * vnm = vnet_get_main();
- tapcli_main_t * tm = &tapcli_main;
+ vnet_main_t *vnm = vnet_get_main ();
+ tapcli_main_t *tm = &tapcli_main;
u32 sw_if_index = ti->sw_if_index;
// bring interface down
vnet_sw_interface_set_flags (vnm, sw_if_index, 0);
- if (ti->clib_file_index != ~0) {
- clib_file_del (&file_main, file_main.file_pool + ti->clib_file_index);
- ti->clib_file_index = ~0;
- }
+ if (ti->clib_file_index != ~0)
+ {
+ clib_file_del (&file_main, file_main.file_pool + ti->clib_file_index);
+ ti->clib_file_index = ~0;
+ }
else
- close(ti->unix_fd);
+ close (ti->unix_fd);
hash_unset (tm->tapcli_interface_index_by_unix_fd, ti->unix_fd);
hash_unset (tm->tapcli_interface_index_by_sw_if_index, ti->sw_if_index);
- close(ti->provision_fd);
+ close (ti->provision_fd);
ti->unix_fd = -1;
ti->provision_fd = -1;
* @return rc - int
*
*/
-int vnet_tap_delete(vlib_main_t *vm, u32 sw_if_index)
+int
+vnet_tap_delete (vlib_main_t * vm, u32 sw_if_index)
{
int rv = 0;
- tapcli_main_t * tm = &tapcli_main;
+ tapcli_main_t *tm = &tapcli_main;
tapcli_interface_t *ti;
uword *p = NULL;
- p = hash_get (tm->tapcli_interface_index_by_sw_if_index,
- sw_if_index);
- if (p == 0) {
- clib_warning ("sw_if_index %d unknown", sw_if_index);
- return VNET_API_ERROR_INVALID_SW_IF_INDEX;
- }
+ p = hash_get (tm->tapcli_interface_index_by_sw_if_index, sw_if_index);
+ if (p == 0)
+ {
+ clib_warning ("sw_if_index %d unknown", sw_if_index);
+ return VNET_API_ERROR_INVALID_SW_IF_INDEX;
+ }
ti = vec_elt_at_index (tm->tapcli_interfaces, p[0]);
// inactive
ti->active = 0;
- tapcli_tap_disconnect(ti);
+ tapcli_tap_disconnect (ti);
// add to inactive list
- vec_add1(tm->tapcli_inactive_interfaces, ti - tm->tapcli_interfaces);
+ vec_add1 (tm->tapcli_inactive_interfaces, ti - tm->tapcli_interfaces);
// reset renumbered iface
if (p[0] < vec_len (tm->show_dev_instance_by_real_dev_instance))
*/
static clib_error_t *
tap_delete_command_fn (vlib_main_t * vm,
- unformat_input_t * input,
- vlib_cli_command_t * cmd)
+ unformat_input_t * input, vlib_cli_command_t * cmd)
{
- tapcli_main_t * tm = &tapcli_main;
+ tapcli_main_t *tm = &tapcli_main;
u32 sw_if_index = ~0;
if (tm->is_disabled)
}
if (unformat (input, "%U", unformat_vnet_sw_interface, tm->vnet_main,
- &sw_if_index))
- ;
+ &sw_if_index))
+ ;
else
return clib_error_return (0, "unknown input `%U'",
- format_unformat_error, input);
+ format_unformat_error, input);
int rc = vnet_tap_delete (vm, sw_if_index);
- if (!rc) {
- vlib_cli_output (vm, "Deleted.");
- } else {
- vlib_cli_output (vm, "Error during deletion of tap interface. (rc: %d)", rc);
- }
+ if (!rc)
+ {
+ vlib_cli_output (vm, "Deleted.");
+ }
+ else
+ {
+ vlib_cli_output (vm, "Error during deletion of tap interface. (rc: %d)",
+ rc);
+ }
return 0;
}
+/* *INDENT-OFF* */
VLIB_CLI_COMMAND (tap_delete_command, static) = {
.path = "tap delete",
.short_help = "tap delete <vpp-tap-intfc-name>",
.function = tap_delete_command_fn,
};
+/* *INDENT-ON* */
/**
* @brief Modifies tap interface - can result in new interface being created
* @return rc - int
*
*/
-int vnet_tap_modify (vlib_main_t * vm, vnet_tap_connect_args_t *ap)
+int
+vnet_tap_modify (vlib_main_t * vm, vnet_tap_connect_args_t * ap)
{
- int rv = vnet_tap_delete (vm, ap->orig_sw_if_index);
+ int rv = vnet_tap_delete (vm, ap->orig_sw_if_index);
- if (rv)
- return rv;
+ if (rv)
+ return rv;
- rv = vnet_tap_connect_renumber(vm, ap);
+ rv = vnet_tap_connect_renumber (vm, ap);
- return rv;
+ return rv;
}
/**
*/
static clib_error_t *
tap_modify_command_fn (vlib_main_t * vm,
- unformat_input_t * input,
- vlib_cli_command_t * cmd)
+ unformat_input_t * input, vlib_cli_command_t * cmd)
{
- u8 * intfc_name;
- tapcli_main_t * tm = &tapcli_main;
+ u8 *intfc_name;
+ tapcli_main_t *tm = &tapcli_main;
u32 sw_if_index = ~0;
u32 new_sw_if_index = ~0;
int user_hwaddr = 0;
u8 hwaddr[6];
- vnet_tap_connect_args_t _a, *ap= &_a;
+ vnet_tap_connect_args_t _a, *ap = &_a;
if (tm->is_disabled)
{
}
if (unformat (input, "%U", unformat_vnet_sw_interface, tm->vnet_main,
- &sw_if_index))
- ;
+ &sw_if_index))
+ ;
else
return clib_error_return (0, "unknown input `%U'",
- format_unformat_error, input);
+ format_unformat_error, input);
if (unformat (input, "%s", &intfc_name))
;
else
return clib_error_return (0, "unknown input `%U'",
- format_unformat_error, input);
+ format_unformat_error, input);
- if (unformat(input, "hwaddr %U", unformat_ethernet_address,
- &hwaddr))
+ if (unformat (input, "hwaddr %U", unformat_ethernet_address, &hwaddr))
user_hwaddr = 1;
- memset (ap, 0, sizeof(*ap));
+ memset (ap, 0, sizeof (*ap));
ap->orig_sw_if_index = sw_if_index;
ap->intfc_name = intfc_name;
ap->sw_if_indexp = &new_sw_if_index;
int rc = vnet_tap_modify (vm, ap);
- if (!rc) {
- vlib_cli_output (vm, "Modified %U for Linux tap '%s'",
- format_vnet_sw_if_index_name, tm->vnet_main,
- *(ap->sw_if_indexp), ap->intfc_name);
- } else {
- vlib_cli_output (vm, "Error during modification of tap interface. (rc: %d)", rc);
- }
+ if (!rc)
+ {
+ vlib_cli_output (vm, "Modified %U for Linux tap '%s'",
+ format_vnet_sw_if_index_name, tm->vnet_main,
+ *(ap->sw_if_indexp), ap->intfc_name);
+ }
+ else
+ {
+ vlib_cli_output (vm,
+ "Error during modification of tap interface. (rc: %d)",
+ rc);
+ }
return 0;
}
+/* *INDENT-OFF* */
VLIB_CLI_COMMAND (tap_modify_command, static) = {
.path = "tap modify",
.short_help = "tap modify <vpp-tap-intfc-name> <linux-intfc-name> [hwaddr <addr>]",
.function = tap_modify_command_fn,
};
+/* *INDENT-ON* */
/**
* @brief CLI function to connect TAP interface
*/
static clib_error_t *
tap_connect_command_fn (vlib_main_t * vm,
- unformat_input_t * input,
- vlib_cli_command_t * cmd)
+ unformat_input_t * input, vlib_cli_command_t * cmd)
{
- u8 * intfc_name = 0;
+ u8 *intfc_name = 0;
unformat_input_t _line_input, *line_input = &_line_input;
- vnet_tap_connect_args_t _a, *ap= &_a;
- tapcli_main_t * tm = &tapcli_main;
+ vnet_tap_connect_args_t _a, *ap = &_a;
+ tapcli_main_t *tm = &tapcli_main;
u8 hwaddr[6];
u8 *hwaddr_arg = 0;
u32 sw_if_index;
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
- if (unformat(line_input, "hwaddr %U", unformat_ethernet_address,
- &hwaddr))
- hwaddr_arg = hwaddr;
-
+ if (unformat (line_input, "hwaddr %U", unformat_ethernet_address,
+ &hwaddr))
+ hwaddr_arg = hwaddr;
+
/* It is here for backward compatibility */
- else if (unformat(line_input, "hwaddr random"))
- ;
-
+ else if (unformat (line_input, "hwaddr random"))
+ ;
+
else if (unformat (line_input, "address %U/%d",
- unformat_ip4_address, &ip4_address, &ip4_mask_width))
- ip4_address_set = 1;
-
+ unformat_ip4_address, &ip4_address, &ip4_mask_width))
+ ip4_address_set = 1;
+
else if (unformat (line_input, "address %U/%d",
- unformat_ip6_address, &ip6_address, &ip6_mask_width))
- ip6_address_set = 1;
-
+ unformat_ip6_address, &ip6_address, &ip6_mask_width))
+ ip6_address_set = 1;
+
else if (unformat (line_input, "%s", &intfc_name))
- ;
+ ;
else
- {
- error = clib_error_return (0, "unknown input `%U'",
- format_unformat_error, line_input);
- goto done;
- }
+ {
+ error = clib_error_return (0, "unknown input `%U'",
+ format_unformat_error, line_input);
+ goto done;
+ }
}
-
+
if (intfc_name == 0)
{
error = clib_error_return (0, "interface name must be specified");
ap->sw_if_indexp = &sw_if_index;
- int rv = vnet_tap_connect(vm, ap);
+ int rv = vnet_tap_connect (vm, ap);
- switch (rv)
+ switch (rv)
{
case VNET_API_ERROR_SYSCALL_ERROR_1:
error = clib_error_return (0, "Couldn't open /dev/net/tun");
goto done;
-
+
case VNET_API_ERROR_SYSCALL_ERROR_2:
- error = clib_error_return (0, "Error setting flags on '%s'", intfc_name);
+ error =
+ clib_error_return (0, "Error setting flags on '%s'", intfc_name);
goto done;
case VNET_API_ERROR_SYSCALL_ERROR_3:
- error = clib_error_return (0, "Couldn't open provisioning socket");
+ error = clib_error_return (0, "Couldn't open provisioning socket");
goto done;
case VNET_API_ERROR_SYSCALL_ERROR_4:
- error = clib_error_return (0, "Couldn't get if_index");
+ error = clib_error_return (0, "Couldn't get if_index");
goto done;
-
+
case VNET_API_ERROR_SYSCALL_ERROR_5:
- error = clib_error_return (0, "Couldn't bind provisioning socket");
+ error = clib_error_return (0, "Couldn't bind provisioning socket");
goto done;
case VNET_API_ERROR_SYSCALL_ERROR_6:
- error = clib_error_return (0, "Couldn't set device non-blocking flag");
+ error = clib_error_return (0, "Couldn't set device non-blocking flag");
goto done;
case VNET_API_ERROR_SYSCALL_ERROR_7:
- error = clib_error_return (0, "Couldn't set device MTU");
+ error = clib_error_return (0, "Couldn't set device MTU");
goto done;
case VNET_API_ERROR_SYSCALL_ERROR_8:
- error = clib_error_return (0, "Couldn't get interface flags");
+ error = clib_error_return (0, "Couldn't get interface flags");
goto done;
case VNET_API_ERROR_SYSCALL_ERROR_9:
- error = clib_error_return (0, "Couldn't set intfc admin state up");
+ error = clib_error_return (0, "Couldn't set intfc admin state up");
goto done;
case VNET_API_ERROR_SYSCALL_ERROR_10:
- error = clib_error_return (0, "Couldn't set intfc address/mask");
+ error = clib_error_return (0, "Couldn't set intfc address/mask");
goto done;
case VNET_API_ERROR_INVALID_REGISTRATION:
- error = clib_error_return (0, "Invalid registration");
+ error = clib_error_return (0, "Invalid registration");
goto done;
case 0:
break;
default:
- error = clib_error_return (0, "Unknown error: %d", rv);
+ error = clib_error_return (0, "Unknown error: %d", rv);
goto done;
}
- vlib_cli_output(vm, "%U\n", format_vnet_sw_if_index_name,
- vnet_get_main(), sw_if_index);
+ vlib_cli_output (vm, "%U\n", format_vnet_sw_if_index_name,
+ vnet_get_main (), sw_if_index);
done:
unformat_free (line_input);
return error;
}
+/* *INDENT-OFF* */
VLIB_CLI_COMMAND (tap_connect_command, static) = {
.path = "tap connect",
.short_help =
- "tap connect <intfc-name> [address <ip-addr>/mw] [hwaddr <addr>]",
+
"tap connect <intfc-name> [address <ip-addr>/mw] [hwaddr <addr>]",
.function = tap_connect_command_fn,
};
+/* *INDENT-ON* */
/**
* @brief TAPCLI main init
clib_error_t *
tapcli_init (vlib_main_t * vm)
{
- tapcli_main_t * tm = &tapcli_main;
- vlib_thread_main_t * m = vlib_get_thread_main ();
- tapcli_per_thread_t * thread;
+ tapcli_main_t *tm = &tapcli_main;
+ vlib_thread_main_t *m = vlib_get_thread_main ();
+ tapcli_per_thread_t *thread;
tm->vlib_main = vm;
- tm->vnet_main = vnet_get_main();
+ tm->vnet_main = vnet_get_main ();
tm->mtu_bytes = TAP_MTU_DEFAULT;
- tm->tapcli_interface_index_by_sw_if_index = hash_create (0, sizeof(uword));
+ tm->tapcli_interface_index_by_sw_if_index = hash_create (0, sizeof (uword));
tm->tapcli_interface_index_by_unix_fd = hash_create (0, sizeof (uword));
vm->os_punt_frame = tapcli_nopunt_frame;
vec_validate_aligned (tm->threads, m->n_vlib_mains - 1,
CLIB_CACHE_LINE_BYTES);
vec_foreach (thread, tm->threads)
- {
- thread->iovecs = 0;
- thread->rx_buffers = 0;
- vec_alloc(thread->rx_buffers, VLIB_FRAME_SIZE);
- vec_reset_length(thread->rx_buffers);
- }
+ {
+ thread->iovecs = 0;
+ thread->rx_buffers = 0;
+ vec_alloc (thread->rx_buffers, VLIB_FRAME_SIZE);
+ vec_reset_length (thread->rx_buffers);
+ }
return 0;
}
VLIB_INIT_FUNCTION (tapcli_init);
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
-/*
+/*
*------------------------------------------------------------------
* tuntap.c - kernel stack (reverse) punt/inject path
*
static vnet_hw_interface_class_t tuntap_interface_class;
static void tuntap_punt_frame (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame);
+ vlib_node_runtime_t * node,
+ vlib_frame_t * frame);
static void tuntap_nopunt_frame (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame);
+ vlib_node_runtime_t * node,
+ vlib_frame_t * frame);
-typedef struct {
+typedef struct
+{
u32 sw_if_index;
u8 is_v6;
u8 addr[16];
{
/** Vector of VLIB rx buffers to use. We allocate them in blocks
of VLIB_FRAME_SIZE (256). */
- u32 * rx_buffers;
+ u32 *rx_buffers;
/** Vector of iovecs for readv/writev calls. */
- struct iovec * iovecs;
+ struct iovec *iovecs;
} tuntap_per_thread_t;
/**
* @brief TUNTAP node main state
*/
-typedef struct {
+typedef struct
+{
/** per thread variables */
- tuntap_per_thread_t * threads;
+ tuntap_per_thread_t *threads;
/** File descriptors for /dev/net/tun and provisioning socket. */
int dev_net_tun_fd, dev_tap_fd;
u32 mtu_bytes, mtu_buffers;
/** Linux interface name for tun device. */
- char * tun_name;
+ char *tun_name;
/** Pool of subinterface addresses */
subif_address_t *subifs;
*
*/
static uword
-tuntap_tx (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame)
+tuntap_tx (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
{
- u32 * buffers = vlib_frame_args (frame);
+ u32 *buffers = vlib_frame_args (frame);
uword n_packets = frame->n_vectors;
- tuntap_main_t * tm = &tuntap_main;
+ tuntap_main_t *tm = &tuntap_main;
vnet_main_t *vnm = vnet_get_main ();
vnet_interface_main_t *im = &vnm->interface_main;
u32 n_bytes = 0;
for (i = 0; i < n_packets; i++)
{
- struct iovec * iov;
- vlib_buffer_t * b;
+ struct iovec *iov;
+ vlib_buffer_t *b;
uword l;
b = vlib_get_buffer (vm, buffers[i]);
if (tm->is_ether && (!tm->have_normal_interface))
- {
- vlib_buffer_reset(b);
- clib_memcpy (vlib_buffer_get_current (b), tm->ether_dst_mac, 6);
- }
+ {
+ vlib_buffer_reset (b);
+ clib_memcpy (vlib_buffer_get_current (b), tm->ether_dst_mac, 6);
+ }
/* Re-set iovecs if present. */
if (tm->threads[thread_index].iovecs)
if (PREDICT_FALSE (b->flags & VLIB_BUFFER_NEXT_PRESENT))
{
- do {
- b = vlib_get_buffer (vm, b->next_buffer);
+ do
+ {
+ b = vlib_get_buffer (vm, b->next_buffer);
- vec_add2 (tm->threads[thread_index].iovecs, iov, 1);
+ vec_add2 (tm->threads[thread_index].iovecs, iov, 1);
- iov->iov_base = b->data + b->current_data;
- iov->iov_len = b->current_length;
- l += b->current_length;
- } while (b->flags & VLIB_BUFFER_NEXT_PRESENT);
+ iov->iov_base = b->data + b->current_data;
+ iov->iov_len = b->current_length;
+ l += b->current_length;
+ }
+ while (b->flags & VLIB_BUFFER_NEXT_PRESENT);
}
if (writev (tm->dev_net_tun_fd, tm->threads[thread_index].iovecs,
return n_packets;
}
+/* *INDENT-OFF* */
VLIB_REGISTER_NODE (tuntap_tx_node,static) = {
.function = tuntap_tx,
.name = "tuntap-tx",
.type = VLIB_NODE_TYPE_INTERNAL,
.vector_size = 4,
};
+/* *INDENT-ON* */
/**
* @brief TUNTAP receive node
*
*/
static uword
-tuntap_rx (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame)
+tuntap_rx (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
{
- tuntap_main_t * tm = &tuntap_main;
- vlib_buffer_t * b;
+ tuntap_main_t *tm = &tuntap_main;
+ vlib_buffer_t *b;
u32 bi;
const uword buffer_size = VLIB_BUFFER_DATA_SIZE;
u16 thread_index = vlib_get_thread_index ();
if (n_left < VLIB_FRAME_SIZE / 2)
{
- if (! tm->threads[thread_index].rx_buffers)
+ if (!tm->threads[thread_index].rx_buffers)
vec_alloc (tm->threads[thread_index].rx_buffers, VLIB_FRAME_SIZE);
- n_alloc = vlib_buffer_alloc (vm, tm->threads[thread_index].rx_buffers + n_left, VLIB_FRAME_SIZE - n_left);
+ n_alloc =
+ vlib_buffer_alloc (vm,
+ tm->threads[thread_index].rx_buffers + n_left,
+ VLIB_FRAME_SIZE - n_left);
_vec_len (tm->threads[thread_index].rx_buffers) = n_left + n_alloc;
}
}
Turn them into iovecs to pass to readv. */
{
uword i_rx = vec_len (tm->threads[thread_index].rx_buffers) - 1;
- vlib_buffer_t * b;
+ vlib_buffer_t *b;
word i, n_bytes_left, n_bytes_in_packet;
/** We should have enough buffers left for an MTU sized packet. */
- ASSERT (vec_len (tm->threads[thread_index].rx_buffers) >= tm->mtu_buffers);
+ ASSERT (vec_len (tm->threads[thread_index].rx_buffers) >=
+ tm->mtu_buffers);
vec_validate (tm->threads[thread_index].iovecs, tm->mtu_buffers - 1);
for (i = 0; i < tm->mtu_buffers; i++)
{
- b = vlib_get_buffer (vm, tm->threads[thread_index].rx_buffers[i_rx - i]);
+ b =
+ vlib_get_buffer (vm,
+ tm->threads[thread_index].rx_buffers[i_rx - i]);
tm->threads[thread_index].iovecs[i].iov_base = b->data;
tm->threads[thread_index].iovecs[i].iov_len = buffer_size;
}
- n_bytes_left = readv (tm->dev_net_tun_fd, tm->threads[thread_index].iovecs,
- tm->mtu_buffers);
+ n_bytes_left =
+ readv (tm->dev_net_tun_fd, tm->threads[thread_index].iovecs,
+ tm->mtu_buffers);
n_bytes_in_packet = n_bytes_left;
if (n_bytes_left <= 0)
{
- if (errno != EAGAIN)
- clib_unix_warning ("readv %d", n_bytes_left);
+ if (errno != EAGAIN)
+ clib_unix_warning ("readv %d", n_bytes_left);
return 0;
}
b = vlib_get_buffer (vm, tm->threads[thread_index].rx_buffers[i_rx]);
b->flags = 0;
b->current_data = 0;
- b->current_length = n_bytes_left < buffer_size ? n_bytes_left : buffer_size;
+ b->current_length =
+ n_bytes_left < buffer_size ? n_bytes_left : buffer_size;
n_bytes_left -= buffer_size;
if (n_bytes_left <= 0)
- {
- break;
- }
+ {
+ break;
+ }
i_rx--;
b->flags |= VLIB_BUFFER_NEXT_PRESENT;
/** Interface counters for tuntap interface. */
vlib_increment_combined_counter
- (vnet_main.interface_main.combined_sw_if_counters
- + VNET_INTERFACE_COUNTER_RX,
- thread_index,
- tm->sw_if_index,
- 1, n_bytes_in_packet);
+ (vnet_main.interface_main.combined_sw_if_counters
+ + VNET_INTERFACE_COUNTER_RX,
+ thread_index, tm->sw_if_index, 1, n_bytes_in_packet);
_vec_len (tm->threads[thread_index].rx_buffers) = i_rx;
}
uword n_trace = vlib_get_trace_count (vm, node);
vnet_buffer (b)->sw_if_index[VLIB_RX] = tm->sw_if_index;
- vnet_buffer (b)->sw_if_index[VLIB_TX] = (u32)~0;
+ vnet_buffer (b)->sw_if_index[VLIB_TX] = (u32) ~ 0;
/*
* Turn this on if you run into
* which nodes they've visited...
*/
if (VLIB_BUFFER_TRACE_TRAJECTORY)
- b->pre_data[0] = 0;
+ b->pre_data[0] = 0;
b->error = node->errors[0];
}
else
switch (b->data[0] & 0xf0)
- {
- case 0x40:
- next_index = VNET_DEVICE_INPUT_NEXT_IP4_INPUT;
- break;
- case 0x60:
- next_index = VNET_DEVICE_INPUT_NEXT_IP6_INPUT;
- break;
- default:
- next_index = VNET_DEVICE_INPUT_NEXT_DROP;
- break;
- }
+ {
+ case 0x40:
+ next_index = VNET_DEVICE_INPUT_NEXT_IP4_INPUT;
+ break;
+ case 0x60:
+ next_index = VNET_DEVICE_INPUT_NEXT_IP6_INPUT;
+ break;
+ default:
+ next_index = VNET_DEVICE_INPUT_NEXT_DROP;
+ break;
+ }
/* The linux kernel couldn't care less if our interface is up */
if (tm->have_normal_interface)
{
- vnet_main_t *vnm = vnet_get_main();
- vnet_sw_interface_t * si;
- si = vnet_get_sw_interface (vnm, tm->sw_if_index);
- if (!(si->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP))
- next_index = VNET_DEVICE_INPUT_NEXT_DROP;
+ vnet_main_t *vnm = vnet_get_main ();
+ vnet_sw_interface_t *si;
+ si = vnet_get_sw_interface (vnm, tm->sw_if_index);
+ if (!(si->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP))
+ next_index = VNET_DEVICE_INPUT_NEXT_DROP;
}
vnet_feature_start_device_input_x1 (tm->sw_if_index, &next_index, b);
if (n_trace > 0)
{
- vlib_trace_buffer (vm, node, next_index,
- b, /* follow_chain */ 1);
- vlib_set_trace_count (vm, node, n_trace - 1);
+ vlib_trace_buffer (vm, node, next_index, b, /* follow_chain */ 1);
+ vlib_set_trace_count (vm, node, n_trace - 1);
}
}
/**
* @brief TUNTAP_RX error strings
*/
-static char * tuntap_rx_error_strings[] = {
+static char *tuntap_rx_error_strings[] = {
"unknown packet type",
};
+/* *INDENT-OFF* */
VLIB_REGISTER_NODE (tuntap_rx_node,static) = {
.function = tuntap_rx,
.name = "tuntap-rx",
.n_errors = 1,
.error_strings = tuntap_rx_error_strings,
};
+/* *INDENT-ON* */
/**
* @brief Gets called when file descriptor is ready from epoll.
*
* @return error - clib_error_t
*/
-static clib_error_t * tuntap_read_ready (clib_file_t * uf)
+static clib_error_t *
+tuntap_read_ready (clib_file_t * uf)
{
- vlib_main_t * vm = vlib_get_main();
+ vlib_main_t *vm = vlib_get_main ();
vlib_node_set_interrupt_pending (vm, tuntap_rx_node.index);
return 0;
}
int sfd;
/* Not present. */
- if (! tm->dev_net_tun_fd || tm->dev_net_tun_fd < 0)
+ if (!tm->dev_net_tun_fd || tm->dev_net_tun_fd < 0)
return 0;
sfd = socket (AF_INET, SOCK_STREAM, 0);
if (sfd < 0)
- clib_unix_warning("provisioning socket");
+ clib_unix_warning ("provisioning socket");
- memset(&ifr, 0, sizeof (ifr));
- strncpy (ifr.ifr_name, tm->tun_name, sizeof (ifr.ifr_name)-1);
+ memset (&ifr, 0, sizeof (ifr));
+ strncpy (ifr.ifr_name, tm->tun_name, sizeof (ifr.ifr_name) - 1);
/* get flags, modify to bring down interface... */
if (ioctl (sfd, SIOCGIFFLAGS, &ifr) < 0)
/* Turn off persistence */
if (ioctl (tm->dev_net_tun_fd, TUNSETPERSIST, 0) < 0)
clib_unix_warning ("TUNSETPERSIST");
- close(tm->dev_tap_fd);
+ close (tm->dev_tap_fd);
if (tm->dev_net_tun_fd >= 0)
- close(tm->dev_net_tun_fd);
+ close (tm->dev_net_tun_fd);
if (sfd >= 0)
close (sfd);
tuntap_config (vlib_main_t * vm, unformat_input_t * input)
{
tuntap_main_t *tm = &tuntap_main;
- clib_error_t * error = 0;
+ clib_error_t *error = 0;
struct ifreq ifr;
- u8 * name;
+ u8 *name;
int flags = IFF_TUN | IFF_NO_PI;
int is_enabled = 0, is_ether = 0, have_normal_interface = 0;
const uword buffer_size = VLIB_BUFFER_DATA_SIZE;
if (unformat (input, "mtu %d", &tm->mtu_bytes))
;
else if (unformat (input, "enable"))
- is_enabled = 1;
+ is_enabled = 1;
else if (unformat (input, "disable"))
- is_enabled = 0;
- else if (unformat (input, "ethernet") ||
- unformat (input, "ether"))
- is_ether = 1;
+ is_enabled = 0;
+ else if (unformat (input, "ethernet") || unformat (input, "ether"))
+ is_ether = 1;
else if (unformat (input, "have-normal-interface") ||
- unformat (input, "have-normal"))
- have_normal_interface = 1;
+ unformat (input, "have-normal"))
+ have_normal_interface = 1;
else if (unformat (input, "name %s", &name))
tm->tun_name = (char *) name;
else
if (is_enabled == 0)
return 0;
- if (geteuid())
+ if (geteuid ())
{
clib_warning ("tuntap disabled: must be superuser");
return 0;
- }
+ }
tm->is_ether = is_ether;
tm->have_normal_interface = have_normal_interface;
}
memset (&ifr, 0, sizeof (ifr));
- strncpy(ifr.ifr_name, tm->tun_name, sizeof(ifr.ifr_name)-1);
+ strncpy (ifr.ifr_name, tm->tun_name, sizeof (ifr.ifr_name) - 1);
ifr.ifr_flags = flags;
- if (ioctl (tm->dev_net_tun_fd, TUNSETIFF, (void *)&ifr) < 0)
+ if (ioctl (tm->dev_net_tun_fd, TUNSETIFF, (void *) &ifr) < 0)
{
error = clib_error_return_unix (0, "ioctl TUNSETIFF");
goto done;
}
-
+
/* Make it persistent, at least until we split. */
if (ioctl (tm->dev_net_tun_fd, TUNSETPERSIST, 1) < 0)
{
}
/* Open a provisioning socket */
- if ((tm->dev_tap_fd = socket(PF_PACKET, SOCK_RAW,
- htons(ETH_P_ALL))) < 0 )
+ if ((tm->dev_tap_fd = socket (PF_PACKET, SOCK_RAW, htons (ETH_P_ALL))) < 0)
{
error = clib_error_return_unix (0, "socket");
goto done;
struct ifreq ifr;
struct sockaddr_ll sll;
- memset (&ifr, 0, sizeof(ifr));
- strncpy (ifr.ifr_name, tm->tun_name, sizeof(ifr.ifr_name)-1);
- if (ioctl (tm->dev_tap_fd, SIOCGIFINDEX, &ifr) < 0 )
+ memset (&ifr, 0, sizeof (ifr));
+ strncpy (ifr.ifr_name, tm->tun_name, sizeof (ifr.ifr_name) - 1);
+ if (ioctl (tm->dev_tap_fd, SIOCGIFINDEX, &ifr) < 0)
{
error = clib_error_return_unix (0, "ioctl SIOCGIFINDEX");
goto done;
}
/* Bind the provisioning socket to the interface. */
- memset(&sll, 0, sizeof(sll));
- sll.sll_family = AF_PACKET;
- sll.sll_ifindex = ifr.ifr_ifindex;
- sll.sll_protocol = htons(ETH_P_ALL);
+ memset (&sll, 0, sizeof (sll));
+ sll.sll_family = AF_PACKET;
+ sll.sll_ifindex = ifr.ifr_ifindex;
+ sll.sll_protocol = htons (ETH_P_ALL);
- if (bind(tm->dev_tap_fd, (struct sockaddr*) &sll, sizeof(sll)) < 0)
+ if (bind (tm->dev_tap_fd, (struct sockaddr *) &sll, sizeof (sll)) < 0)
{
error = clib_error_return_unix (0, "bind");
goto done;
if (is_ether)
{
if (ioctl (tm->dev_tap_fd, SIOCGIFHWADDR, &ifr) < 0)
- {
- error = clib_error_return_unix (0, "ioctl SIOCGIFHWADDR");
- goto done;
- }
+ {
+ error = clib_error_return_unix (0, "ioctl SIOCGIFHWADDR");
+ goto done;
+ }
else
- clib_memcpy (tm->ether_dst_mac, ifr.ifr_hwaddr.sa_data, 6);
+ clib_memcpy (tm->ether_dst_mac, ifr.ifr_hwaddr.sa_data, 6);
}
if (have_normal_interface)
{
- vnet_main_t *vnm = vnet_get_main();
+ vnet_main_t *vnm = vnet_get_main ();
error = ethernet_register_interface
- (vnm,
- tuntap_dev_class.index,
- 0 /* device instance */,
- tm->ether_dst_mac /* ethernet address */,
- &tm->hw_if_index,
- 0 /* flag change */);
+ (vnm, tuntap_dev_class.index, 0 /* device instance */ ,
+ tm->ether_dst_mac /* ethernet address */ ,
+ &tm->hw_if_index, 0 /* flag change */ );
if (error)
- clib_error_report (error);
+ clib_error_report (error);
tm->sw_if_index = tm->hw_if_index;
vm->os_punt_frame = tuntap_nopunt_frame;
}
else
{
- vnet_main_t *vnm = vnet_get_main();
- vnet_hw_interface_t * hi;
-
+ vnet_main_t *vnm = vnet_get_main ();
+ vnet_hw_interface_t *hi;
+
vm->os_punt_frame = tuntap_punt_frame;
-
+
tm->hw_if_index = vnet_register_interface
- (vnm,
- tuntap_dev_class.index, 0 /* device instance */,
- tuntap_interface_class.index, 0);
+ (vnm, tuntap_dev_class.index, 0 /* device instance */ ,
+ tuntap_interface_class.index, 0);
hi = vnet_get_hw_interface (vnm, tm->hw_if_index);
tm->sw_if_index = hi->sw_if_index;
-
+
/* Interface is always up. */
- vnet_hw_interface_set_flags (vnm, tm->hw_if_index,
- VNET_HW_INTERFACE_FLAG_LINK_UP);
- vnet_sw_interface_set_flags (vnm, tm->sw_if_index,
- VNET_SW_INTERFACE_FLAG_ADMIN_UP);
+ vnet_hw_interface_set_flags (vnm, tm->hw_if_index,
+ VNET_HW_INTERFACE_FLAG_LINK_UP);
+ vnet_sw_interface_set_flags (vnm, tm->sw_if_index,
+ VNET_SW_INTERFACE_FLAG_ADMIN_UP);
}
{
- clib_file_t template = {0};
+ clib_file_t template = { 0 };
template.read_function = tuntap_read_ready;
template.file_descriptor = tm->dev_net_tun_fd;
tm->clib_file_index = clib_file_add (&file_main, &template);
}
- done:
+done:
if (error)
{
if (tm->dev_net_tun_fd >= 0)
u32 sw_if_index,
ip4_address_t * address,
u32 address_length,
- u32 if_address_index,
- u32 is_delete)
+ u32 if_address_index, u32 is_delete)
{
- tuntap_main_t * tm = &tuntap_main;
+ tuntap_main_t *tm = &tuntap_main;
struct ifreq ifr;
- subif_address_t subif_addr, * ap;
- uword * p;
+ subif_address_t subif_addr, *ap;
+ uword *p;
/** Tuntap disabled, or using a "normal" interface. */
- if (tm->have_normal_interface || tm->dev_tap_fd < 0)
+ if (tm->have_normal_interface || tm->dev_tap_fd < 0)
return;
/* if the address is being applied to an interface that is not in
* the same table/VRF as this tap, then ignore it.
* If we don't do this overlapping address spaces in the diferent tables
* breaks the linux host's routing tables */
- if (fib_table_get_index_for_sw_if_index(FIB_PROTOCOL_IP4,
- sw_if_index) !=
- fib_table_get_index_for_sw_if_index(FIB_PROTOCOL_IP4,
- tm->sw_if_index))
- return;
+ if (fib_table_get_index_for_sw_if_index (FIB_PROTOCOL_IP4,
+ sw_if_index) !=
+ fib_table_get_index_for_sw_if_index (FIB_PROTOCOL_IP4, tm->sw_if_index))
+ return;
/** See if we already know about this subif */
memset (&subif_addr, 0, sizeof (subif_addr));
/* Use subif pool index to select alias device. */
memset (&ifr, 0, sizeof (ifr));
- snprintf (ifr.ifr_name, sizeof(ifr.ifr_name),
- "%s:%d", tm->tun_name, (int)(ap - tm->subifs));
+ snprintf (ifr.ifr_name, sizeof (ifr.ifr_name),
+ "%s:%d", tm->tun_name, (int) (ap - tm->subifs));
/* the tuntap punt/inject is enabled for IPv4 RX so long as
* any vpp interface has an IPv4 address.
*/
ip4_sw_interface_enable_disable (tm->sw_if_index, !is_delete);
- if (! is_delete)
+ if (!is_delete)
{
- struct sockaddr_in * sin;
+ struct sockaddr_in *sin;
- sin = (struct sockaddr_in *)&ifr.ifr_addr;
+ sin = (struct sockaddr_in *) &ifr.ifr_addr;
/* Set ipv4 address, netmask. */
sin->sin_family = AF_INET;
clib_memcpy (&sin->sin_addr.s_addr, address, 4);
if (ioctl (tm->dev_tap_fd, SIOCSIFADDR, &ifr) < 0)
clib_unix_warning ("ioctl SIOCSIFADDR");
-
+
sin->sin_addr.s_addr = im->fib_masks[address_length];
if (ioctl (tm->dev_tap_fd, SIOCSIFNETMASK, &ifr) < 0)
clib_unix_warning ("ioctl SIOCSIFNETMASK");
}
else
{
- mhash_unset (&tm->subif_mhash, &subif_addr, 0 /* old value ptr */);
+ mhash_unset (&tm->subif_mhash, &subif_addr, 0 /* old value ptr */ );
pool_put (tm->subifs, ap);
}
* including @c <linux/ipv6.h> causes multiple definitions if
* @c <netinet/in.h is also included.
*/
-struct in6_ifreq {
- struct in6_addr ifr6_addr;
- u32 ifr6_prefixlen;
- int ifr6_ifindex;
+struct in6_ifreq
+{
+ struct in6_addr ifr6_addr;
+ u32 ifr6_prefixlen;
+ int ifr6_ifindex;
};
/**
u32 sw_if_index,
ip6_address_t * address,
u32 address_length,
- u32 if_address_index,
- u32 is_delete)
+ u32 if_address_index, u32 is_delete)
{
- tuntap_main_t * tm = &tuntap_main;
+ tuntap_main_t *tm = &tuntap_main;
struct ifreq ifr;
struct in6_ifreq ifr6;
- subif_address_t subif_addr, * ap;
- uword * p;
+ subif_address_t subif_addr, *ap;
+ uword *p;
/* Tuntap disabled, or using a "normal" interface. */
- if (tm->have_normal_interface || tm->dev_tap_fd < 0)
+ if (tm->have_normal_interface || tm->dev_tap_fd < 0)
return;
/* if the address is being applied to an interface that is not in
* the same table/VRF as this tap, then ignore it.
* If we don't do this overlapping address spaces in the diferent tables
* breaks the linux host's routing tables */
- if (fib_table_get_index_for_sw_if_index(FIB_PROTOCOL_IP6,
- sw_if_index) !=
- fib_table_get_index_for_sw_if_index(FIB_PROTOCOL_IP6,
- tm->sw_if_index))
- return;
+ if (fib_table_get_index_for_sw_if_index (FIB_PROTOCOL_IP6,
+ sw_if_index) !=
+ fib_table_get_index_for_sw_if_index (FIB_PROTOCOL_IP6, tm->sw_if_index))
+ return;
/* See if we already know about this subif */
memset (&subif_addr, 0, sizeof (subif_addr));
/* Use subif pool index to select alias device. */
memset (&ifr, 0, sizeof (ifr));
memset (&ifr6, 0, sizeof (ifr6));
- snprintf (ifr.ifr_name, sizeof(ifr.ifr_name),
- "%s:%d", tm->tun_name, (int)(ap - tm->subifs));
+ snprintf (ifr.ifr_name, sizeof (ifr.ifr_name),
+ "%s:%d", tm->tun_name, (int) (ap - tm->subifs));
/* the tuntap punt/inject is enabled for IPv6 RX so long as
* any vpp interface has an IPv6 address.
*/
ip6_sw_interface_enable_disable (tm->sw_if_index, !is_delete);
- if (! is_delete)
+ if (!is_delete)
{
int sockfd = socket (AF_INET6, SOCK_STREAM, 0);
if (sockfd < 0)
- clib_unix_warning ("get ifindex socket");
+ clib_unix_warning ("get ifindex socket");
if (ioctl (sockfd, SIOGIFINDEX, &ifr) < 0)
- clib_unix_warning ("get ifindex");
+ clib_unix_warning ("get ifindex");
ifr6.ifr6_ifindex = ifr.ifr_ifindex;
ifr6.ifr6_prefixlen = address_length;
clib_memcpy (&ifr6.ifr6_addr, address, 16);
if (ioctl (sockfd, SIOCSIFADDR, &ifr6) < 0)
- clib_unix_warning ("set address");
+ clib_unix_warning ("set address");
if (sockfd >= 0)
- close (sockfd);
+ close (sockfd);
}
else
{
int sockfd = socket (AF_INET6, SOCK_STREAM, 0);
if (sockfd < 0)
- clib_unix_warning ("get ifindex socket");
+ clib_unix_warning ("get ifindex socket");
if (ioctl (sockfd, SIOGIFINDEX, &ifr) < 0)
- clib_unix_warning ("get ifindex");
+ clib_unix_warning ("get ifindex");
ifr6.ifr6_ifindex = ifr.ifr_ifindex;
ifr6.ifr6_prefixlen = address_length;
clib_memcpy (&ifr6.ifr6_addr, address, 16);
if (ioctl (sockfd, SIOCDIFADDR, &ifr6) < 0)
- clib_unix_warning ("del address");
+ clib_unix_warning ("del address");
if (sockfd >= 0)
- close (sockfd);
+ close (sockfd);
- mhash_unset (&tm->subif_mhash, &subif_addr, 0 /* old value ptr */);
+ mhash_unset (&tm->subif_mhash, &subif_addr, 0 /* old value ptr */ );
pool_put (tm->subifs, ap);
}
}
*/
static void
tuntap_punt_frame (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame)
+ vlib_node_runtime_t * node, vlib_frame_t * frame)
{
tuntap_tx (vm, node, frame);
vlib_frame_free (vm, node, frame);
*/
static void
tuntap_nopunt_frame (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame)
+ vlib_node_runtime_t * node, vlib_frame_t * frame)
{
- u32 * buffers = vlib_frame_args (frame);
+ u32 *buffers = vlib_frame_args (frame);
uword n_packets = frame->n_vectors;
vlib_buffer_free (vm, buffers, n_packets);
vlib_frame_free (vm, node, frame);
}
+/* *INDENT-OFF* */
VNET_HW_INTERFACE_CLASS (tuntap_interface_class,static) = {
.name = "tuntap",
.flags = VNET_HW_INTERFACE_CLASS_FLAG_P2P,
};
+/* *INDENT-ON* */
/**
* @brief Format tun/tap interface name
* @return *s - u8 - formatted string
*
*/
-static u8 * format_tuntap_interface_name (u8 * s, va_list * args)
+static u8 *
+format_tuntap_interface_name (u8 * s, va_list * args)
{
u32 i = va_arg (*args, u32);
*/
static uword
tuntap_intfc_tx (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame)
+ vlib_node_runtime_t * node, vlib_frame_t * frame)
{
- tuntap_main_t * tm = &tuntap_main;
- u32 * buffers = vlib_frame_args (frame);
+ tuntap_main_t *tm = &tuntap_main;
+ u32 *buffers = vlib_frame_args (frame);
uword n_buffers = frame->n_vectors;
/* Normal interface transmit happens only on the normal interface... */
return n_buffers;
}
+/* *INDENT-OFF* */
VNET_DEVICE_CLASS (tuntap_dev_class,static) = {
.name = "tuntap",
.tx_function = tuntap_intfc_tx,
.format_device_name = format_tuntap_interface_name,
};
+/* *INDENT-ON* */
/**
* @brief tun/tap node init
static clib_error_t *
tuntap_init (vlib_main_t * vm)
{
- clib_error_t * error;
- ip4_main_t * im4 = &ip4_main;
- ip6_main_t * im6 = &ip6_main;
+ clib_error_t *error;
+ ip4_main_t *im4 = &ip4_main;
+ ip6_main_t *im6 = &ip6_main;
ip4_add_del_interface_address_callback_t cb4;
ip6_add_del_interface_address_callback_t cb6;
- tuntap_main_t * tm = &tuntap_main;
- vlib_thread_main_t * m = vlib_get_thread_main ();
+ tuntap_main_t *tm = &tuntap_main;
+ vlib_thread_main_t *m = vlib_get_thread_main ();
error = vlib_call_init_function (vm, ip4_init);
if (error)
return error;
- mhash_init (&tm->subif_mhash, sizeof (u32), sizeof(subif_address_t));
+ mhash_init (&tm->subif_mhash, sizeof (u32), sizeof (subif_address_t));
cb4.function = tuntap_ip4_add_del_interface_address;
cb4.function_opaque = 0;
}
VLIB_INIT_FUNCTION (tuntap_init);
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
Code Review / vpp.git / commitdiff