/* * Copyright (c) 2018 Cisco and/or its affiliates. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at: * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include vlib_log_main_t log_main = { .default_log_level = VLIB_LOG_LEVEL_NOTICE, .default_syslog_log_level = VLIB_LOG_LEVEL_WARNING, .unthrottle_time = 3, .size = 512, .add_to_elog = 1, .default_rate_limit = 50, }; /* *INDENT-OFF* */ VLIB_REGISTER_LOG_CLASS (log_log, static) = { .class_name = "log", }; /* *INDENT-ON* */ static const int colors[] = { [VLIB_LOG_LEVEL_EMERG] = 1, /* red */ [VLIB_LOG_LEVEL_ALERT] = 1, /* red */ [VLIB_LOG_LEVEL_CRIT] = 1, /* red */ [VLIB_LOG_LEVEL_ERR] = 1, /* red */ [VLIB_LOG_LEVEL_WARNING] = 3, /* yellow */ [VLIB_LOG_LEVEL_NOTICE] = 2, /* green */ [VLIB_LOG_LEVEL_INFO] = 4, /* blue */ [VLIB_LOG_LEVEL_DEBUG] = 6, /* cyan */ }; static const int log_level_to_syslog_priority[] = { [VLIB_LOG_LEVEL_EMERG] = LOG_EMERG, [VLIB_LOG_LEVEL_ALERT] = LOG_ALERT, [VLIB_LOG_LEVEL_CRIT] = LOG_CRIT, [VLIB_LOG_LEVEL_ERR] = LOG_ERR, [VLIB_LOG_LEVEL_WARNING] = LOG_WARNING, [VLIB_LOG_LEVEL_NOTICE] = LOG_NOTICE, [VLIB_LOG_LEVEL_INFO] = LOG_INFO, [VLIB_LOG_LEVEL_DEBUG] = LOG_DEBUG, [VLIB_LOG_LEVEL_DISABLED] = LOG_DEBUG, }; int last_log_entry () { vlib_log_main_t *lm = &log_main; int i; i = lm->next - lm->count; if (i < 0) i += lm->size; return i; } static vlib_log_class_data_t * get_class_data (vlib_log_class_t ci) { vlib_log_main_t *lm = &log_main; return vec_elt_at_index (lm->classes, (ci >> 16)); } static vlib_log_subclass_data_t * get_subclass_data (vlib_log_class_t ci) { vlib_log_class_data_t *c = get_class_data (ci); return vec_elt_at_index (c->subclasses, (ci & 0xffff)); } u8 * format_vlib_log_class (u8 * s, va_list * args) { vlib_log_class_t ci = va_arg (*args, vlib_log_class_t); vlib_log_class_data_t *c = get_class_data (ci); vlib_log_subclass_data_t *sc = get_subclass_data (ci); if (sc->name) return format (s, "%v/%v", c->name, sc->name); else return format (s, "%v", c->name, 0); } u8 * format_indent (u8 * s, va_list * args) { u8 *v = va_arg (*args, u8 *); u32 indent = va_arg (*args, u32); u8 *c; /* *INDENT-OFF* */ vec_foreach (c, v) { vec_add (s, c, 1); if (c[0] == '\n') for (u32 i = 0; i < indent; i++) vec_add1 (s, (u8) ' '); } /* *INDENT-ON* */ return s; } static int log_level_is_enabled (vlib_log_level_t level, vlib_log_level_t configured) { if (configured == VLIB_LOG_LEVEL_DISABLED) return 0; if (level > configured) return 0; return 1; } void vlib_log (vlib_log_level_t level, vlib_log_class_t class, char *fmt, ...) { vlib_main_t *vm = vlib_get_main (); vlib_log_main_t *lm = &log_main; vlib_log_entry_t *e; vlib_log_subclass_data_t *sc = get_subclass_data (class); va_list va; f64 t = vlib_time_now (vm); f64 delta = t - sc->last_event_timestamp; int log_enabled = log_level_is_enabled (level, sc->level); int syslog_enabled = log_level_is_enabled (level, sc->syslog_level); u8 *s = 0; /* make sure we are running on the main thread to avoid use in dataplane code, for dataplane logging consider use of event-logger */ ASSERT (vlib_get_thread_index () == 0); if ((log_enabled || syslog_enabled) == 0) return; vec_validate (lm->entries, lm->size); if ((delta > lm->unthrottle_time) || (sc->is_throttling == 0 && (delta > 1))) { sc->last_event_timestamp = t; sc->last_sec_count = 0; sc->is_throttling = 0; } else { sc->last_sec_count++; if (sc->last_sec_count > sc->rate_limit) return; else if (sc->last_sec_count == sc->rate_limit) { vec_reset_length (s); s = format (s, "--- message(s) throttled ---"); sc->is_throttling = 1; } } if (s == 0) { va_start (va, fmt); s = va_format (s, fmt, &va); va_end (va); } if (syslog_enabled) { u8 *l = 0; if (unix_main.flags & (UNIX_FLAG_INTERACTIVE | UNIX_FLAG_NOSYSLOG)) { int indent = 0; int with_colors = (unix_main.flags & UNIX_FLAG_NOCOLOR) == 0; u8 *fmt; if (with_colors) { l = format (l, "\x1b[%um", 90 + colors[level]); indent = vec_len (l); } fmt = format (0, "%%-%uU [%%-6U]: ", lm->max_class_name_length); vec_terminate_c_string (fmt); l = format (l, (char *) fmt, format_vlib_log_class, class, format_vlib_log_level, level); vec_free (fmt); indent = vec_len (l) - indent; if (with_colors) l = format (l, "\x1b[0m"); l = format (l, "%U", format_indent, s, indent); fformat (stderr, "%v\n", l); fflush (stderr); } else { l = format (l, "%U", format_vlib_log_class, class); int prio = log_level_to_syslog_priority[level]; int is_term = vec_c_string_is_terminated (l) ? 1 : 0; syslog (prio, "%.*s: %.*s", (int) vec_len (l), l, (int) vec_len (s) - is_term, s); } vec_free (l); } if (log_enabled) { e = vec_elt_at_index (lm->entries, lm->next); vec_free (e->string); e->level = level; e->class = class; e->string = s; e->timestamp = t; s = 0; if (lm->add_to_elog) { /* *INDENT-OFF* */ ELOG_TYPE_DECLARE(ee) = { .format = "log-%s: %s", .format_args = "t4T4", .n_enum_strings = 9, .enum_strings = { "emerg", "alert", "crit", "err", "warn", "notice", "info", "debug", "disabled", }, }; struct { u32 log_level; u32 string_index; } *ed; /* *INDENT-ON* */ ed = ELOG_DATA (&vm->elog_main, ee); ed->log_level = level; ed->string_index = elog_string (&vm->elog_main, "%v", e->string); } lm->next = (lm->next + 1) % lm->size; if (lm->size > lm->count) lm->count++; } vec_free (s); } static vlib_log_class_t vlib_log_register_class_internal (char *class, char *subclass, u32 limit) { vlib_log_main_t *lm = &log_main; vlib_log_class_data_t *c = NULL; vlib_log_subclass_data_t *s; vlib_log_class_data_t *tmp; vlib_log_class_config_t *cc = 0, *scc = 0; uword *p; u8 *str; u32 length = 0; if ((p = hash_get_mem (lm->config_index_by_name, class))) cc = vec_elt_at_index (lm->configs, p[0]); str = format (0, "%s/%s%c", class, subclass, 0); if ((p = hash_get_mem (lm->config_index_by_name, (char *) str))) scc = vec_elt_at_i
# Copyright (c) 2018 Cisco and/or its affiliates.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at:
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

find_path(IBVERBS_INCLUDE_DIR NAMES infiniband/verbs.h)

if (NOT IBVERBS_INCLUDE_DIR)
  message(WARNING "-- rdma headers not found - rdma plugin disabled")
  return()
endif()

vpp_plugin_find_library(rdma IBVERBS_LIB libibverbs.a)
vpp_plugin_find_library(rdma RDMA_UTIL_LIB librdma_util.a)
vpp_plugin_find_library(rdma MLX5_LIB libmlx5.a)

if (NOT IBVERBS_LIB OR NOT RDMA_UTIL_LIB OR NOT MLX5_LIB)
  message(WARNING "rdma plugin - ibverbs not found - rdma plugin disabled")
  return()
endif()

string_append(RDMA_LINK_FLAGS "-Wl,--whole-archive,${MLX5_LIB},--no-whole-archive")

set(CMAKE_REQUIRED_FLAGS "-fPIC -shared -pthread -Wno-unused-command-line-argument ${RDMA_LINK_FLAGS} ${IBVERBS_LIB} ${RDMA_UTIL_LIB}")
set(CMAKE_REQUIRED_INCLUDES "${IBVERBS_INCLUDE_DIR}")
set(CMAKE_REQUIRED_LIBRARIES "c") # force linkage by including libc explicitely
CHECK_C_SOURCE_COMPILES("
#include <infiniband/verbs.h>
int main(void)
{
    return 0 != ibv_get_device_list(0);
}" IBVERBS_COMPILES_CHECK)

if (NOT IBVERBS_COMPILES_CHECK)
  message(WARNING "rdma plugins - no working ibverbs found - rdma plugin disabled")
  return()
endif()

include_directories(${IBVERBS_INCLUDE_DIR})

add_vpp_plugin(rdma
  SOURCES
  api.c
  cli.c
  device.c
  format.c
  plugin.c
  unformat.c
  input.c
  output.c

  MULTIARCH_SOURCES
  input.c
  output.c

  API_FILES
  rdma.api

  API_TEST_SOURCES
  unformat.c
  test_api.c

  LINK_FLAGS
  "${RDMA_LINK_FLAGS}"

  LINK_LIBRARIES
  ${IBVERBS_LIB}
  ${RDMA_UTIL_LIB}
)
(line_input, "%U", unformat_vlib_log_subclass, class, &subclass)) { vlib_log (level, (class->index << 16) | (subclass->index), "%U", format_unformat_input, line_input); } else { return clib_error_return (0, "unknown log subclass near beginning of `%U'", format_unformat_error, line_input); } } else { return clib_error_return (0, "unknown log class near beginning of `%U'", format_unformat_error, line_input); } } else { return clib_error_return (0, "unknown log level near beginning of `%U'", format_unformat_error, line_input); } return 0; } /* *INDENT-OFF* */ VLIB_CLI_COMMAND (cli_test_log, static) = { .path = "test log", .short_help = "test log ", .function = test_log_class_subclass, }; /* *INDENT-ON* */ static clib_error_t * log_config_class (vlib_main_t * vm, char *name, unformat_input_t * input) { vlib_log_main_t *lm = &log_main; vlib_log_class_config_t *cc, tmp; uword *p; if (lm->config_index_by_name == 0) lm->config_index_by_name = hash_create_string (0, sizeof (uword)); p = hash_get_mem (lm->config_index_by_name, name); if (p) return clib_error_return (0, "logging class '%s' already configured", name); clib_memset_u8 (&tmp, 0xff, sizeof (vlib_log_class_config_t)); while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { if (unformat (input, "level %U", unformat_vlib_log_level, &tmp.level)) ; else if (unformat (input, "syslog-level %U", unformat_vlib_log_level, &tmp.syslog_level)) ; else if (unformat (input, "rate-limit %u", &tmp.rate_limit)) ; else return clib_error_return (0, "unknown input '%U'", format_unformat_error, input); } vec_add2 (lm->configs, cc, 1); clib_memcpy_fast (cc, &tmp, sizeof (vlib_log_class_config_t)); cc->name = name; hash_set_mem (lm->config_index_by_name, name, cc - lm->configs); return 0; } static clib_error_t * log_config (vlib_main_t * vm, unformat_input_t * input) { vlib_log_main_t *lm = &log_main; unformat_input_t sub_input; u8 *class = 0; while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { if (unformat (input, "size %d", &lm->size)) vec_validate (lm->entries, lm->size); else if (unformat (input, "unthrottle-time %d", &lm->unthrottle_time)) ; else if (unformat (input, "default-log-level %U", unformat_vlib_log_level, &lm->default_log_level)) ; else if (unformat (input, "default-syslog-log-level %U", unformat_vlib_log_level, &lm->default_syslog_log_level)) ; else if (unformat (input, "add-to-elog")) lm->add_to_elog = 1; else if (unformat (input, "class %s %U", &class, unformat_vlib_cli_sub_input, &sub_input)) { clib_error_t *err; err = log_config_class (vm, (char *) class, &sub_input); class = 0; unformat_free (&sub_input); if (err) return err; } else { return unformat_parse_error (input); } } return 0; } VLIB_EARLY_CONFIG_FUNCTION (log_config, "logging"); /* * fd.io coding-style-patch-verification: ON * * Local Variables: * eval: (c-set-style "gnu") * End: */