mirror of https://gerrit.osmocom.org/libosmocore
391 lines
10 KiB
C
391 lines
10 KiB
C
/*! \file utils.c
|
|
* Utility routines for printing common objects in the Osmocom world. */
|
|
/*
|
|
* (C) 2009-2010 by Harald Welte <laforge@gnumonks.org>
|
|
* (C) 2013,2015 by sysmocom - s.f.m.c. GmbH
|
|
*
|
|
* All Rights Reserved
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0+
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
*/
|
|
|
|
#include <stdint.h>
|
|
#include <inttypes.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include <limits.h>
|
|
|
|
#include <osmocom/core/linuxlist.h>
|
|
#include <osmocom/core/talloc.h>
|
|
#include <osmocom/core/timer.h>
|
|
#include <osmocom/core/rate_ctr.h>
|
|
#include <osmocom/core/stat_item.h>
|
|
#include <osmocom/core/utils.h>
|
|
#include <osmocom/core/counter.h>
|
|
|
|
#include <osmocom/vty/vty.h>
|
|
|
|
/*! \addtogroup rate_ctr
|
|
* @{
|
|
*/
|
|
|
|
struct vty_out_context {
|
|
struct vty *vty;
|
|
const char *prefix;
|
|
int max_level;
|
|
};
|
|
|
|
static int rate_ctr_handler(
|
|
struct rate_ctr_group *ctrg, struct rate_ctr *ctr,
|
|
const struct rate_ctr_desc *desc, void *vctx_)
|
|
{
|
|
struct vty_out_context *vctx = vctx_;
|
|
struct vty *vty = vctx->vty;
|
|
|
|
vty_out(vty, " %s%s: %8" PRIu64 " "
|
|
"(%" PRIu64 "/s %" PRIu64 "/m %" PRIu64 "/h %" PRIu64 "/d)%s",
|
|
vctx->prefix, desc->description, ctr->current,
|
|
ctr->intv[RATE_CTR_INTV_SEC].rate,
|
|
ctr->intv[RATE_CTR_INTV_MIN].rate,
|
|
ctr->intv[RATE_CTR_INTV_HOUR].rate,
|
|
ctr->intv[RATE_CTR_INTV_DAY].rate,
|
|
VTY_NEWLINE);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*! print a rate counter group to given VTY
|
|
* \param[in] vty The VTY to which it should be printed
|
|
* \param[in] prefix Any additional log prefix ahead of each line
|
|
* \param[in] ctrg Rate counter group to be printed
|
|
*/
|
|
void vty_out_rate_ctr_group(struct vty *vty, const char *prefix,
|
|
struct rate_ctr_group *ctrg)
|
|
{
|
|
struct vty_out_context vctx = {vty, prefix};
|
|
|
|
vty_out(vty, "%s%s:%s", prefix, ctrg->desc->group_description, VTY_NEWLINE);
|
|
|
|
rate_ctr_for_each_counter(ctrg, rate_ctr_handler, &vctx);
|
|
}
|
|
|
|
static char *
|
|
pad_append_str(char *s, const char *a, int minwidth)
|
|
{
|
|
s = talloc_asprintf_append(s, "%*s", minwidth, a);
|
|
OSMO_ASSERT(s);
|
|
return s;
|
|
}
|
|
|
|
static char *
|
|
pad_append_ctr(char *s, uint64_t ctr, int minwidth)
|
|
{
|
|
s = talloc_asprintf_append(s, "%*" PRIu64, minwidth, ctr);
|
|
OSMO_ASSERT(s);
|
|
return s;
|
|
}
|
|
|
|
static int rate_ctr_handler_fmt(
|
|
struct rate_ctr_group *ctrg, struct rate_ctr *ctr,
|
|
const struct rate_ctr_desc *desc, void *vctx_)
|
|
{
|
|
struct vty_out_context *vctx = vctx_;
|
|
struct vty *vty = vctx->vty;
|
|
const char *fmt = vctx->prefix;
|
|
char *s = talloc_strdup(vty, "");
|
|
OSMO_ASSERT(s);
|
|
|
|
while (*fmt) {
|
|
int ch, minwidth = 0, sign = 1;
|
|
char *p = strchr(fmt, '%');
|
|
|
|
if (p == NULL) {
|
|
/* No further % directives in format string. Copy rest verbatim and exit. */
|
|
s = talloc_strdup_append_buffer(s, fmt);
|
|
OSMO_ASSERT(s);
|
|
break;
|
|
} else {
|
|
ptrdiff_t len;
|
|
|
|
OSMO_ASSERT(p >= fmt);
|
|
len = p - fmt;
|
|
if (len) {
|
|
/* Copy bytes verbatim until next '%' byte. */
|
|
s = talloc_strndup_append_buffer(s, fmt, len);
|
|
OSMO_ASSERT(s);
|
|
}
|
|
fmt = (const char *)(p + 1); /* skip past '%' */
|
|
if (*fmt == '\0')
|
|
break;
|
|
}
|
|
|
|
ch = *fmt++;
|
|
if (ch == '-' && isdigit(*fmt)) {
|
|
sign = -1;
|
|
ch = *fmt++;
|
|
}
|
|
while (isdigit(ch) && *fmt != '\0') {
|
|
minwidth *= 10;
|
|
minwidth += (ch - '0');
|
|
ch = *fmt++;
|
|
}
|
|
minwidth *= sign;
|
|
|
|
switch (ch) {
|
|
case '%':
|
|
s = talloc_asprintf_append(s, "%c", ch);
|
|
OSMO_ASSERT(s);
|
|
break;
|
|
case 'd':
|
|
s = pad_append_str(s, desc->description, minwidth);
|
|
break;
|
|
case 'n':
|
|
s = pad_append_str(s, desc->name, minwidth);
|
|
break;
|
|
case 'c':
|
|
s = pad_append_ctr(s, ctr->current, minwidth);
|
|
break;
|
|
case 'p':
|
|
s = pad_append_ctr(s, ctr->previous, minwidth);
|
|
break;
|
|
case 'S':
|
|
s = pad_append_ctr(s, ctr->intv[RATE_CTR_INTV_SEC].rate, minwidth);
|
|
break;
|
|
case 'M':
|
|
s = pad_append_ctr(s, ctr->intv[RATE_CTR_INTV_MIN].rate, minwidth);
|
|
break;
|
|
case 'H':
|
|
s = pad_append_ctr(s, ctr->intv[RATE_CTR_INTV_HOUR].rate, minwidth);
|
|
break;
|
|
case 'D':
|
|
s = pad_append_ctr(s, ctr->intv[RATE_CTR_INTV_DAY].rate, minwidth);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
vty_out(vty, "%s%s", s, VTY_NEWLINE);
|
|
talloc_free(s);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*! print a rate counter group to given VTY, formatting the line for each counter according to a format string.
|
|
*
|
|
* The following format string directives are supported:
|
|
* - %d: The description of the counter
|
|
* - %n: The name of the counter
|
|
* - %c: The current value of the counter
|
|
* - %p: The previous value of the counter
|
|
* - %S: The interval of the counter in seconds
|
|
* - %M: The interval of the counter in minutes
|
|
* - %H: The interval of the counter in hours
|
|
* - %D: The interval of the counter in days
|
|
* - %%: Print a literal %.
|
|
*
|
|
* An optional number between % and the letter in a format directive may be used to set a minimum field width.
|
|
* If the expanded format directive is smaller than this width (according to strlen()) the string will be
|
|
* left-padded (if the number is positive) or right-padded (if the number is negative) with spaces.
|
|
* For example, "%25n" prints the counter name left-padded up to a minimum width of 25 columns.
|
|
*
|
|
* VTY_NEWLINE will be appended to the format string when it is printed.
|
|
*
|
|
* \param[in] vty The VTY to which it should be printed
|
|
* \param[in] ctrg Rate counter group to be printed
|
|
* \param[in] fmt A format which may contain the above directives.
|
|
*/
|
|
void vty_out_rate_ctr_group_fmt(struct vty *vty, const char *fmt,
|
|
struct rate_ctr_group *ctrg)
|
|
{
|
|
struct vty_out_context vctx = {vty, fmt};
|
|
rate_ctr_for_each_counter(ctrg, rate_ctr_handler_fmt, &vctx);
|
|
}
|
|
|
|
static int rate_ctr_group_handler(struct rate_ctr_group *ctrg, void *vctx_)
|
|
{
|
|
struct vty_out_context *vctx = vctx_;
|
|
struct vty *vty = vctx->vty;
|
|
|
|
if (ctrg->desc->class_id > vctx->max_level)
|
|
return 0;
|
|
|
|
if (ctrg->idx)
|
|
vty_out(vty, "%s%s (%d):%s", vctx->prefix,
|
|
ctrg->desc->group_description, ctrg->idx, VTY_NEWLINE);
|
|
else
|
|
vty_out(vty, "%s%s:%s", vctx->prefix,
|
|
ctrg->desc->group_description, VTY_NEWLINE);
|
|
|
|
rate_ctr_for_each_counter(ctrg, rate_ctr_handler, vctx);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*! @} */
|
|
|
|
|
|
/*! \addtogroup stats
|
|
* @{
|
|
*/
|
|
|
|
static int osmo_stat_item_handler(
|
|
struct osmo_stat_item_group *statg, struct osmo_stat_item *item, void *vctx_)
|
|
{
|
|
struct vty_out_context *vctx = vctx_;
|
|
struct vty *vty = vctx->vty;
|
|
const char *unit =
|
|
item->desc->unit != OSMO_STAT_ITEM_NO_UNIT ?
|
|
item->desc->unit : "";
|
|
|
|
vty_out(vty, " %s%s: %8" PRIi32 " %s%s",
|
|
vctx->prefix, item->desc->description,
|
|
osmo_stat_item_get_last(item),
|
|
unit, VTY_NEWLINE);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*! print a stat item group to given VTY
|
|
* \param[in] vty The VTY to which it should be printed
|
|
* \param[in] prefix Any additional log prefix ahead of each line
|
|
* \param[in] statg Stat item group to be printed
|
|
*/
|
|
void vty_out_stat_item_group(struct vty *vty, const char *prefix,
|
|
struct osmo_stat_item_group *statg)
|
|
{
|
|
struct vty_out_context vctx = {vty, prefix};
|
|
|
|
vty_out(vty, "%s%s:%s", prefix, statg->desc->group_description,
|
|
VTY_NEWLINE);
|
|
osmo_stat_item_for_each_item(statg, osmo_stat_item_handler, &vctx);
|
|
}
|
|
|
|
static int osmo_stat_item_group_handler(struct osmo_stat_item_group *statg, void *vctx_)
|
|
{
|
|
struct vty_out_context *vctx = vctx_;
|
|
struct vty *vty = vctx->vty;
|
|
|
|
if (statg->desc->class_id > vctx->max_level)
|
|
return 0;
|
|
|
|
if (statg->idx)
|
|
vty_out(vty, "%s%s (%d):%s", vctx->prefix,
|
|
statg->desc->group_description, statg->idx,
|
|
VTY_NEWLINE);
|
|
else
|
|
vty_out(vty, "%s%s:%s", vctx->prefix,
|
|
statg->desc->group_description, VTY_NEWLINE);
|
|
|
|
osmo_stat_item_for_each_item(statg, osmo_stat_item_handler, vctx);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*! @} */
|
|
|
|
/*! \addtogroup vty
|
|
* @{
|
|
*/
|
|
|
|
static int handle_counter(struct osmo_counter *counter, void *vctx_)
|
|
{
|
|
struct vty_out_context *vctx = vctx_;
|
|
struct vty *vty = vctx->vty;
|
|
const char *description = counter->description;
|
|
|
|
if (!counter->description)
|
|
description = counter->name;
|
|
|
|
vty_out(vty, " %s%s: %8lu%s",
|
|
vctx->prefix, description,
|
|
osmo_counter_get(counter), VTY_NEWLINE);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void vty_out_statistics_partial(struct vty *vty, const char *prefix,
|
|
int max_level)
|
|
{
|
|
struct vty_out_context vctx = {vty, prefix, max_level};
|
|
|
|
vty_out(vty, "%sUngrouped counters:%s", prefix, VTY_NEWLINE);
|
|
osmo_counters_for_each(handle_counter, &vctx);
|
|
rate_ctr_for_each_group(rate_ctr_group_handler, &vctx);
|
|
osmo_stat_item_for_each_group(osmo_stat_item_group_handler, &vctx);
|
|
}
|
|
|
|
void vty_out_statistics_full(struct vty *vty, const char *prefix)
|
|
{
|
|
vty_out_statistics_partial(vty, prefix, INT_MAX);
|
|
}
|
|
|
|
/*! Generate a VTY command string from value_string */
|
|
char *vty_cmd_string_from_valstr(void *ctx, const struct value_string *vals,
|
|
const char *prefix, const char *sep,
|
|
const char *end, int do_lower)
|
|
{
|
|
int len = 0, offset = 0, ret, rem;
|
|
int size = strlen(prefix) + strlen(end);
|
|
int sep_len = strlen(sep);
|
|
const struct value_string *vs;
|
|
char *str;
|
|
|
|
for (vs = vals; vs->value || vs->str; vs++)
|
|
size += strlen(vs->str) + sep_len;
|
|
|
|
rem = size;
|
|
str = talloc_zero_size(ctx, size);
|
|
if (!str)
|
|
return NULL;
|
|
|
|
ret = snprintf(str + offset, rem, "%s", prefix);
|
|
if (ret < 0)
|
|
goto err;
|
|
OSMO_SNPRINTF_RET(ret, rem, offset, len);
|
|
|
|
for (vs = vals; vs->value || vs->str; vs++) {
|
|
if (vs->str) {
|
|
int j, name_len = strlen(vs->str)+1;
|
|
char name[name_len];
|
|
|
|
for (j = 0; j < name_len; j++)
|
|
name[j] = do_lower ?
|
|
tolower(vs->str[j]) : vs->str[j];
|
|
|
|
name[name_len-1] = '\0';
|
|
ret = snprintf(str + offset, rem, "%s%s", name, sep);
|
|
if (ret < 0)
|
|
goto err;
|
|
OSMO_SNPRINTF_RET(ret, rem, offset, len);
|
|
}
|
|
}
|
|
offset -= sep_len; /* to remove the trailing sep */
|
|
rem += sep_len;
|
|
|
|
ret = snprintf(str + offset, rem, "%s", end);
|
|
if (ret < 0)
|
|
goto err;
|
|
OSMO_SNPRINTF_RET(ret, rem, offset, len);
|
|
err:
|
|
str[size-1] = '\0';
|
|
return str;
|
|
}
|
|
|
|
/*! @} */
|