vpp/api/gmon.c - fdio/vpp - Gitiles

 /*
  * Copyright (c) 2012 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 <stdio.h>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <netinet/in.h>
 #include <signal.h>
 #include <pthread.h>
 #include <unistd.h>
 #include <time.h>
 #include <fcntl.h>
 #include <string.h>
 #include <vppinfra/clib.h>
 #include <vppinfra/vec.h>
 #include <vppinfra/hash.h>
 #include <vppinfra/bitmap.h>
 #include <vppinfra/fifo.h>
 #include <vppinfra/time.h>
 #include <vppinfra/mheap.h>
 #include <vppinfra/heap.h>
 #include <vppinfra/pool.h>
 #include <vppinfra/format.h>
 #include <vlibapi/api.h>
 #include <vlibmemory/api.h>

 #include <vlib/vlib.h>
 #include <vlib/unix/unix.h>
 #include <vnet/api_errno.h>

 #include <svmdb.h>

 typedef struct {
   svmdb_client_t *svmdb_client;
   f64 *vector_rate_ptr;
   f64 *input_rate_ptr;
   f64 *sig_error_rate_ptr;
   pid_t *vpef_pid_ptr;
   u64 last_sig_errors;
   u64 current_sig_errors;
   uword * sig_error_bitmap;
   vlib_main_t *vlib_main;
   vlib_main_t ** my_vlib_mains;

 } gmon_main_t;

 #if DPDK == 0
 static inline u64 vnet_get_aggregate_rx_packets (void)
 { return 0; }
 #else
 #include <vlib/vlib.h>
 #include <vnet/vnet.h>
 #include <vnet/devices/dpdk/dpdk.h>
 #endif

 gmon_main_t gmon_main;

 static u64 get_significant_errors(gmon_main_t * gm)
 {
   vlib_main_t * this_vlib_main;
   vlib_error_main_t * em;
   uword code;
   int vm_index;
   u64 significant_errors = 0;

   clib_bitmap_foreach (code, gm->sig_error_bitmap,
   ({
     for (vm_index = 0; vm_index < vec_len (gm->my_vlib_mains); vm_index++)
       {
         this_vlib_main = gm->my_vlib_mains[vm_index];
         em = &this_vlib_main->error_main;
         significant_errors += em->counters[code] -
           ((vec_len(em->counters_last_clear) > code) ?
            em->counters_last_clear[code] : 0);
       }
   }));

   return (significant_errors);
 }

 static clib_error_t *
 publish_pid (vlib_main_t *vm)
 {
   gmon_main_t *gm = &gmon_main;

   *gm->vpef_pid_ptr = getpid();

   return 0;
 }
 VLIB_API_INIT_FUNCTION(publish_pid);


 static uword
 gmon_process (vlib_main_t * vm,
               vlib_node_runtime_t * rt,
               vlib_frame_t * f)
 {
     f64 vector_rate;
     u64 input_packets, last_input_packets, new_sig_errors;
     f64 last_runtime, dt, now;
     gmon_main_t *gm = &gmon_main;
     int i;

     last_runtime = 0.0;
     last_input_packets = 0;

     last_runtime = 0.0;
     last_input_packets = 0;

     /* Initial wait for the world to settle down */
     vlib_process_suspend (vm, 5.0);

     if (vec_len(vlib_mains) == 0)
       vec_add1(gm->my_vlib_mains, &vlib_global_main);
     else
       {
         for (i = 0; i < vec_len(vlib_mains); i++)
           vec_add1 (gm->my_vlib_mains, vlib_mains[i]);
       }

     while (1) {
         vlib_process_suspend (vm, 5.0);
         vector_rate = vlib_last_vector_length_per_node (vm);
         *gm->vector_rate_ptr = vector_rate;
         now = vlib_time_now(vm);
         dt = now - last_runtime;
         input_packets =  vnet_get_aggregate_rx_packets();
         *gm->input_rate_ptr = (f64)(input_packets - last_input_packets) / dt;
         last_runtime = now;
         last_input_packets = input_packets;

         new_sig_errors = get_significant_errors(gm);
         *gm->sig_error_rate_ptr =
             ((f64)(new_sig_errors - gm->last_sig_errors)) / dt;
         gm->last_sig_errors = new_sig_errors;
     }

     return 0; /* not so much */
 }

 VLIB_REGISTER_NODE (gmon_process_node,static) = {
     .function = gmon_process,
     .type = VLIB_NODE_TYPE_PROCESS,
     .name = "gmon-process",
 };

 static clib_error_t *
 gmon_init (vlib_main_t *vm)
 {
     gmon_main_t *gm = &gmon_main;
     api_main_t * am = &api_main;
     pid_t *swp = 0;
     f64 *v = 0;
     clib_error_t * error;

     if ((error = vlib_call_init_function(vm, vpe_api_init)))
         return(error);

     /* Make sure that /global-vm is owned as directed */
     svm_region_init_chroot_uid_gid (am->root_path, am->api_uid, am->api_gid);

     gm->vlib_main = vm;
     gm->svmdb_client = svmdb_map_chroot(am->root_path);

     /* Find or create, set to zero */
     vec_add1 (v, 0.0);
     svmdb_local_set_vec_variable(gm->svmdb_client,
                                  "vpp_vector_rate",
                                  (char *)v, sizeof (*v));
     vec_free(v);
     vec_add1 (v, 0.0);
     svmdb_local_set_vec_variable(gm->svmdb_client,
                                  "vpp_input_rate",
                                  (char *)v, sizeof (*v));
     vec_free(v);
     vec_add1 (v, 0.0);
     svmdb_local_set_vec_variable(gm->svmdb_client,
                                  "vpp_sig_error_rate",
                                  (char *)v, sizeof (*v));
     vec_free(v);

     vec_add1 (swp, 0.0);
     svmdb_local_set_vec_variable(gm->svmdb_client,
                                  "vpp_pid",
                                  (char *)swp, sizeof (*swp));
     vec_free(swp);

     /* the value cells will never move, so acquire references to them */
     gm->vector_rate_ptr =
         svmdb_local_get_variable_reference (gm->svmdb_client,
                                             SVMDB_NAMESPACE_VEC,
                                             "vpp_vector_rate");
     gm->input_rate_ptr =
         svmdb_local_get_variable_reference (gm->svmdb_client,
                                             SVMDB_NAMESPACE_VEC,
                                             "vpp_input_rate");
     gm->sig_error_rate_ptr =
         svmdb_local_get_variable_reference (gm->svmdb_client,
                                             SVMDB_NAMESPACE_VEC,
                                             "vpp_sig_error_rate");
     gm->vpef_pid_ptr =
         svmdb_local_get_variable_reference (gm->svmdb_client,
                                             SVMDB_NAMESPACE_VEC,
                                             "vpp_pid");
     return 0;
 }

 VLIB_INIT_FUNCTION (gmon_init);

 static clib_error_t *gmon_exit (vlib_main_t *vm)
 {
     gmon_main_t *gm = &gmon_main;

     if (gm->vector_rate_ptr) {
         *gm->vector_rate_ptr = 0.0;
         *gm->vpef_pid_ptr = 0;
         *gm->input_rate_ptr = 0.0;
         *gm->sig_error_rate_ptr = 0.0;
         svm_region_unmap ((void *) gm->svmdb_client->db_rp);
         vec_free(gm->svmdb_client);
     }
     return 0;
 }
 VLIB_MAIN_LOOP_EXIT_FUNCTION (gmon_exit);

 static int
 significant_error_enable_disable (gmon_main_t * gm,
                                   u32 index, int enable)
 {
   vlib_main_t * vm = gm->vlib_main;
   vlib_error_main_t * em = &vm->error_main;

   if (index >= vec_len (em->counters))
     return VNET_API_ERROR_NO_SUCH_ENTRY;

   gm->sig_error_bitmap = clib_bitmap_set (gm->sig_error_bitmap, index, enable);
   return 0;
 }

 static clib_error_t *
 set_significant_error_command_fn (vlib_main_t * vm,
 		 unformat_input_t * input,
 		 vlib_cli_command_t * cmd)
 {
   u32 index;
   int enable = 1;
   int rv;
   gmon_main_t *gm = &gmon_main;

   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
     if (unformat (input, "%d", &index))
       ;
     else if (unformat (input, "disable"))
       enable = 0;
     else
       return clib_error_return (0, "unknown input `%U'",
                                 format_unformat_error, input);
   }

   rv = significant_error_enable_disable (gm, index, enable);

   switch (rv)
     {
     case 0:
       break;

     default:
       return clib_error_return
         (0, "significant_error_enable_disable returned %d", rv);
     }

   return 0;
 }

 VLIB_CLI_COMMAND (set_significant_error_command, static) = {
     .path = "set significant error",
     .short_help = "set significant error <counter-index-nnn>",
     .function = set_significant_error_command_fn,
 };
	/*
	* Copyright (c) 2012 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 <stdio.h>
	#include <stdlib.h>
	#include <sys/types.h>
	#include <sys/mman.h>
	#include <sys/stat.h>
	#include <netinet/in.h>
	#include <signal.h>
	#include <pthread.h>
	#include <unistd.h>
	#include <time.h>
	#include <fcntl.h>
	#include <string.h>
	#include <vppinfra/clib.h>
	#include <vppinfra/vec.h>
	#include <vppinfra/hash.h>
	#include <vppinfra/bitmap.h>
	#include <vppinfra/fifo.h>
	#include <vppinfra/time.h>
	#include <vppinfra/mheap.h>
	#include <vppinfra/heap.h>
	#include <vppinfra/pool.h>
	#include <vppinfra/format.h>
	#include <vlibapi/api.h>
	#include <vlibmemory/api.h>

	#include <vlib/vlib.h>
	#include <vlib/unix/unix.h>
	#include <vnet/api_errno.h>

	#include <svmdb.h>

	typedef struct {
	svmdb_client_t *svmdb_client;
	f64 *vector_rate_ptr;
	f64 *input_rate_ptr;
	f64 *sig_error_rate_ptr;
	pid_t *vpef_pid_ptr;
	u64 last_sig_errors;
	u64 current_sig_errors;
	uword * sig_error_bitmap;
	vlib_main_t *vlib_main;
	vlib_main_t ** my_vlib_mains;

	} gmon_main_t;

	#if DPDK == 0
	static inline u64 vnet_get_aggregate_rx_packets (void)
	{ return 0; }
	#else
	#include <vlib/vlib.h>
	#include <vnet/vnet.h>
	#include <vnet/devices/dpdk/dpdk.h>
	#endif

	gmon_main_t gmon_main;

	static u64 get_significant_errors(gmon_main_t * gm)
	{
	vlib_main_t * this_vlib_main;
	vlib_error_main_t * em;
	uword code;
	int vm_index;
	u64 significant_errors = 0;

	clib_bitmap_foreach (code, gm->sig_error_bitmap,
	({
	for (vm_index = 0; vm_index < vec_len (gm->my_vlib_mains); vm_index++)
	{
	this_vlib_main = gm->my_vlib_mains[vm_index];
	em = &this_vlib_main->error_main;
	significant_errors += em->counters[code] -
	((vec_len(em->counters_last_clear) > code) ?
	em->counters_last_clear[code] : 0);
	}
	}));

	return (significant_errors);
	}

	static clib_error_t *
	publish_pid (vlib_main_t *vm)
	{
	gmon_main_t *gm = &gmon_main;

	*gm->vpef_pid_ptr = getpid();

	return 0;
	}
	VLIB_API_INIT_FUNCTION(publish_pid);


	static uword
	gmon_process (vlib_main_t * vm,
	vlib_node_runtime_t * rt,
	vlib_frame_t * f)
	{
	f64 vector_rate;
	u64 input_packets, last_input_packets, new_sig_errors;
	f64 last_runtime, dt, now;
	gmon_main_t *gm = &gmon_main;
	int i;

	last_runtime = 0.0;
	last_input_packets = 0;

	last_runtime = 0.0;
	last_input_packets = 0;

	/* Initial wait for the world to settle down */
	vlib_process_suspend (vm, 5.0);

	if (vec_len(vlib_mains) == 0)
	vec_add1(gm->my_vlib_mains, &vlib_global_main);
	else
	{
	for (i = 0; i < vec_len(vlib_mains); i++)
	vec_add1 (gm->my_vlib_mains, vlib_mains[i]);
	}

	while (1) {
	vlib_process_suspend (vm, 5.0);
	vector_rate = vlib_last_vector_length_per_node (vm);
	*gm->vector_rate_ptr = vector_rate;
	now = vlib_time_now(vm);
	dt = now - last_runtime;
	input_packets = vnet_get_aggregate_rx_packets();
	*gm->input_rate_ptr = (f64)(input_packets - last_input_packets) / dt;
	last_runtime = now;
	last_input_packets = input_packets;

	new_sig_errors = get_significant_errors(gm);
	*gm->sig_error_rate_ptr =
	((f64)(new_sig_errors - gm->last_sig_errors)) / dt;
	gm->last_sig_errors = new_sig_errors;
	}

	return 0; /* not so much */
	}

	VLIB_REGISTER_NODE (gmon_process_node,static) = {
	.function = gmon_process,
	.type = VLIB_NODE_TYPE_PROCESS,
	.name = "gmon-process",
	};

	static clib_error_t *
	gmon_init (vlib_main_t *vm)
	{
	gmon_main_t *gm = &gmon_main;
	api_main_t * am = &api_main;
	pid_t *swp = 0;
	f64 *v = 0;
	clib_error_t * error;

	if ((error = vlib_call_init_function(vm, vpe_api_init)))
	return(error);

	/* Make sure that /global-vm is owned as directed */
	svm_region_init_chroot_uid_gid (am->root_path, am->api_uid, am->api_gid);

	gm->vlib_main = vm;
	gm->svmdb_client = svmdb_map_chroot(am->root_path);

	/* Find or create, set to zero */
	vec_add1 (v, 0.0);
	svmdb_local_set_vec_variable(gm->svmdb_client,
	"vpp_vector_rate",
	(char )v, sizeof (v));
	vec_free(v);
	vec_add1 (v, 0.0);
	svmdb_local_set_vec_variable(gm->svmdb_client,
	"vpp_input_rate",
	(char )v, sizeof (v));
	vec_free(v);
	vec_add1 (v, 0.0);
	svmdb_local_set_vec_variable(gm->svmdb_client,
	"vpp_sig_error_rate",
	(char )v, sizeof (v));
	vec_free(v);

	vec_add1 (swp, 0.0);
	svmdb_local_set_vec_variable(gm->svmdb_client,
	"vpp_pid",
	(char )swp, sizeof (swp));
	vec_free(swp);

	/* the value cells will never move, so acquire references to them */
	gm->vector_rate_ptr =
	svmdb_local_get_variable_reference (gm->svmdb_client,
	SVMDB_NAMESPACE_VEC,
	"vpp_vector_rate");
	gm->input_rate_ptr =
	svmdb_local_get_variable_reference (gm->svmdb_client,
	SVMDB_NAMESPACE_VEC,
	"vpp_input_rate");
	gm->sig_error_rate_ptr =
	svmdb_local_get_variable_reference (gm->svmdb_client,
	SVMDB_NAMESPACE_VEC,
	"vpp_sig_error_rate");
	gm->vpef_pid_ptr =
	svmdb_local_get_variable_reference (gm->svmdb_client,
	SVMDB_NAMESPACE_VEC,
	"vpp_pid");
	return 0;
	}

	VLIB_INIT_FUNCTION (gmon_init);

	static clib_error_t gmon_exit (vlib_main_t vm)
	{
	gmon_main_t *gm = &gmon_main;

	if (gm->vector_rate_ptr) {
	*gm->vector_rate_ptr = 0.0;
	*gm->vpef_pid_ptr = 0;
	*gm->input_rate_ptr = 0.0;
	*gm->sig_error_rate_ptr = 0.0;
	svm_region_unmap ((void *) gm->svmdb_client->db_rp);
	vec_free(gm->svmdb_client);
	}
	return 0;
	}
	VLIB_MAIN_LOOP_EXIT_FUNCTION (gmon_exit);

	static int
	significant_error_enable_disable (gmon_main_t * gm,
	u32 index, int enable)
	{
	vlib_main_t * vm = gm->vlib_main;
	vlib_error_main_t * em = &vm->error_main;

	if (index >= vec_len (em->counters))
	return VNET_API_ERROR_NO_SUCH_ENTRY;

	gm->sig_error_bitmap = clib_bitmap_set (gm->sig_error_bitmap, index, enable);
	return 0;
	}

	static clib_error_t *
	set_significant_error_command_fn (vlib_main_t * vm,
	unformat_input_t * input,
	vlib_cli_command_t * cmd)
	{
	u32 index;
	int enable = 1;
	int rv;
	gmon_main_t *gm = &gmon_main;

	while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
	if (unformat (input, "%d", &index))
	;
	else if (unformat (input, "disable"))
	enable = 0;
	else
	return clib_error_return (0, "unknown input `%U'",
	format_unformat_error, input);
	}

	rv = significant_error_enable_disable (gm, index, enable);

	switch (rv)
	{
	case 0:
	break;

	default:
	return clib_error_return
	(0, "significant_error_enable_disable returned %d", rv);
	}

	return 0;
	}

	VLIB_CLI_COMMAND (set_significant_error_command, static) = {
	.path = "set significant error",
	.short_help = "set significant error <counter-index-nnn>",
	.function = set_significant_error_command_fn,
	};