summaryrefslogtreecommitdiffstats
path: root/src/vpp-api
diff options
context:
space:
mode:
authorOle Troan <ot@cisco.com>2018-10-02 22:00:29 +0200
committerDamjan Marion <dmarion@me.com>2018-10-02 21:26:28 +0000
commitbf49590c07162be44b21d0e0440e7fb96b2746d5 (patch)
tree06ba921f8f1540adc096459f30772770811c6a0c /src/vpp-api
parent94495f2a6a68ac2202b7715ce09620f1ba6fe673 (diff)
Stats: vpp_prometheus_export fixes.
- Crash on /sys/nodes if per-node-counters off - Require patterns parameters. Change-Id: If4fddefb17504a92ba462c7af91e373601b66a5c Signed-off-by: Ole Troan <ot@cisco.com>
Diffstat (limited to 'src/vpp-api')
-rw-r--r--src/vpp-api/client/stat_client.c4
1 files changed, 4 insertions, 0 deletions
diff --git a/src/vpp-api/client/stat_client.c b/src/vpp-api/client/stat_client.c
index b5aab74de8a..a539fbaa4e6 100644
--- a/src/vpp-api/client/stat_client.c
+++ b/src/vpp-api/client/stat_client.c
@@ -177,6 +177,8 @@ copy_data (stat_segment_directory_entry_t * ep)
break;
case STAT_DIR_TYPE_COUNTER_VECTOR_SIMPLE:
+ if (ep->offset == 0)
+ return result;
simple_c = stat_segment_pointer (sm->shared_header, ep->offset);
result.simple_counter_vec = vec_dup (simple_c);
offset_vector =
@@ -190,6 +192,8 @@ copy_data (stat_segment_directory_entry_t * ep)
break;
case STAT_DIR_TYPE_COUNTER_VECTOR_COMBINED:
+ if (ep->offset == 0)
+ return result;
combined_c = stat_segment_pointer (sm->shared_header, ep->offset);
result.combined_counter_vec = vec_dup (combined_c);
offset_vector =
ref='#n191'>191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 
/*
 * Copyright (c) 2015 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.
 */
/*
  Copyright (c) 2005 Eliot Dresselhaus

  Permission is hereby granted, free of charge, to any person obtaining
  a copy of this software and associated documentation files (the
  "Software"), to deal in the Software without restriction, including
  without limitation the rights to use, copy, modify, merge, publish,
  distribute, sublicense, and/or sell copies of the Software, and to
  permit persons to whom the Software is furnished to do so, subject to
  the following conditions:

  The above copyright notice and this permission notice shall be
  included in all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#include <vppinfra/elog.h>
#include <vppinfra/error.h>
#include <vppinfra/format.h>
#include <vppinfra/random.h>
#include <vppinfra/serialize.h>
#include <vppinfra/unix.h>

void
g2_test_pattern (elog_main_t * em, int g2_test, char *dump_file)
{
  int i, j;
  clib_error_t *error;
  elog_track_t *tracks = 0;

  elog_init (em, 100000);
  elog_enable_disable (em, 1 /* enable */ );

  for (i = 0; i < 100; i++)
    {
      elog_track_t *t;
      vec_validate (tracks, i);
      t = tracks + i;
      t->name = (char *) format (0, "Track %3d", i + 1);
      elog_track_register (em, t);
    }

  for (i = 0; i < 100; i++)
    {
      for (j = 0; j < 100; j++)
	{
	  ELOG_TYPE_DECLARE (e) =
	  {
	  .format = "0: t%d event %d",.format_args = "i4i4",};
	  ELOG_TYPE_DECLARE (e2) =
	  {
	  .format = "1: t%d event %d",.format_args = "i4i4",};

	  struct
	  {
	    int track, event;
	  } *ed;

	  ed = ELOG_TRACK_DATA (em, e, tracks[j]);
	  ed->track = j + 1;
	  ed->event = i;
	  ed = ELOG_TRACK_DATA (em, e2, tracks[j]);
	  ed->track = j + 1;
	  ed->event = i;
	}
    }

  if (dump_file == 0)
    dump_file = "/tmp/g2_test.elog";

  error = elog_write_file (em, dump_file, 1 /* flush ring */ );

  if (error)
    clib_error_report (error);
}


int
test_elog_main (unformat_input_t * input)
{
  clib_error_t *error = 0;
  u32 i, n_iter, seed, max_events;
  elog_main_t _em, *em = &_em;
  u32 verbose;
  f64 min_sample_time;
  char *dump_file, *load_file, *merge_file, **merge_files;
  u8 *tag, **tags;
  f64 align_tweak;
  f64 *align_tweaks;
  int g2_test;

  n_iter = 100;
  max_events = 100000;
  seed = 1;
  verbose = 0;
  dump_file = 0;
  load_file = 0;
  merge_files = 0;
  tags = 0;
  align_tweaks = 0;
  min_sample_time = 2;
  g2_test = 0;
  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
    {
      if (unformat (input, "iter %d", &n_iter))
	;
      else if (unformat (input, "seed %d", &seed))
	;
      else if (unformat (input, "dump %s", &dump_file))
	;
      else if (unformat (input, "load %s", &load_file))
	;
      else if (unformat (input, "tag %s", &tag))
	vec_add1 (tags, tag);
      else if (unformat (input, "merge %s", &merge_file))
	vec_add1 (merge_files, merge_file);

      else if (unformat (input, "verbose %=", &verbose, 1))
	;
      else if (unformat (input, "max-events %d", &max_events))
	;
      else if (unformat (input, "sample-time %f", &min_sample_time))
	;
      else if (unformat (input, "align-tweak %f", &align_tweak))
	vec_add1 (align_tweaks, align_tweak);
      else if (unformat (input, "g2-test %=", &g2_test, 1))
	;
      else
	{
	  error = clib_error_create ("unknown input `%U'\n",
				     format_unformat_error, input);
	  goto done;
	}
    }

  if (g2_test)
    {
      g2_test_pattern (em, g2_test, dump_file);
      return (0);
    }

#ifdef CLIB_UNIX
  if (load_file)
    {
      if ((error = elog_read_file (em, load_file)))
	goto done;
    }

  else if (merge_files)
    {
      uword i;
      elog_main_t *ems;
      vec_clone (ems, merge_files);

      /* Supply default tags as needed */
      if (vec_len (tags) < vec_len (ems))
	{
	  for (i = vec_len (tags); i < vec_len (ems); i++)
	    vec_add1 (tags, format (0, "F%d%c", i, 0));
	}

      elog_init (em, max_events);
      for (i = 0; i < vec_len (ems); i++)
	{
	  if ((error =
	       elog_read_file (i == 0 ? em : &ems[i], merge_files[i])))
	    goto done;
	  if (i > 0)
	    {
	      align_tweak = 0.0;
	      if (i <= vec_len (align_tweaks))
		align_tweak = align_tweaks[i - 1];
	      elog_merge (em, tags[0], &ems[i], tags[i], align_tweak);
	      tags[0] = 0;
	    }
	}
    }

  else
#endif /* CLIB_UNIX */
    {
      f64 t[2];

      elog_init (em, max_events);
      elog_enable_disable (em, 1);
      t[0] = unix_time_now ();

      for (i = 0; i < n_iter; i++)
	{
	  u32 j, n, sum;

	  n = 1 + (random_u32 (&seed) % 128);
	  sum = 0;
	  for (j = 0; j < n; j++)
	    sum += random_u32 (&seed);

	  {
	    ELOG_TYPE_XF (e);
	    ELOG (em, e, sum);
	  }

	  {
	    ELOG_TYPE_XF (e);
	    ELOG (em, e, sum + 1);
	  }

	  {
	    struct
	    {
	      u32 string_index;
	      f32 f;
	    } *d;
	    ELOG_TYPE_DECLARE (e) =
	    {
	      .format = "fumble %s %.9f",.format_args =
		"t4f4",.n_enum_strings = 4,.enum_strings =
	      {
	    "string0", "string1", "string2", "string3",},};

	    d = ELOG_DATA (em, e);

	    d->string_index = sum & 3;
	    d->f = (sum & 0xff) / 128.;
	  }

	  {
	    ELOG_TYPE_DECLARE (e) =
	    {
	    .format = "bar %d.%d.%d.%d",.format_args = "i1i1i1i1",};
	    ELOG_TRACK (my_track);
	    u8 *d = ELOG_TRACK_DATA (em, e, my_track);
	    d[0] = i + 0;
	    d[1] = i + 1;
	    d[2] = i + 2;
	    d[3] = i + 3;
	  }

	  {
	    ELOG_TYPE_DECLARE (e) =
	    {
	    .format = "bar `%s'",.format_args = "s20",};
	    struct
	    {
	      char s[20];
	    } *d;
	    u8 *v;

	    d = ELOG_DATA (em, e);
	    v = format (0, "foo %d%c", i, 0);
	    clib_memcpy (d->s, v, clib_min (vec_len (v), sizeof (d->s)));
	  }

	  {
	    ELOG_TYPE_DECLARE (e) =
	    {
	    .format = "bar `%s'",.format_args = "T4",};
	    struct
	    {
	      u32 offset;
	    } *d;

	    d = ELOG_DATA (em, e);
	    d->offset = elog_string (em, "string table %d", i);
	  }
	}

      do
	{
	  t[1] = unix_time_now ();
	}
      while (t[1] - t[0] < min_sample_time);
    }

#ifdef CLIB_UNIX
  if (dump_file)
    {
      if ((error =
	   elog_write_file (em, dump_file, 0 /* do not flush ring */ )))
	goto done;
    }
#endif

  if (verbose)
    {
      elog_event_t *e, *es;
      es = elog_get_events (em);
      vec_foreach (e, es)
      {
	clib_warning ("%18.9f: %12U %U\n", e->time,
		      format_elog_track_name, em, e, format_elog_event, em,
		      e);
      }
    }

done:
  if (error)
    clib_error_report (error);
  return 0;
}

#ifdef CLIB_UNIX
int
main (int argc, char *argv[])
{
  unformat_input_t i;
  int r;

  clib_mem_init (0, 3ULL << 30);

  unformat_init_command_line (&i, argv);
  r = test_elog_main (&i);
  unformat_free (&i);
  return r;
}
#endif

/**
 * @brief GDB callable function: vl - Return vector length of vector
 *
 * @param *p - void - address of vector
 *
 * @return length - u32
 *
 */
u32
vl (void *p)
{
  return vec_len (p);
}

/**
 * @brief GDB callable function: pe - call pool_elts - number of elements in a pool
 *
 * @param *v - void - address of pool
 *
 * @return number - uword
 *
 */
#include <vppinfra/pool.h>
uword
pe (void *v)
{
  return (pool_elts (v));
}

#include <vppinfra/hash.h>
uword
he (void *v)
{
  return (hash_elts (v));
}

/*
 * fd.io coding-style-patch-verification: ON
 *
 * Local Variables:
 * eval: (c-set-style "gnu")
 * End:
 */