VPP启动流程分析

今天我们介绍一下VPP的启动流程。如果把vpp看成一个应用程序，那么他是怎么工作的呢：
首先，vpp有许多插件so，每个插件下面有许多node,比如我们如果要新加一个功能为ip地址过滤，那么我们其实就是加一个node,当数据经过node时，调用我们提前注册的function函数就实现了我们的功能。接下来就理一下vpp从启动后到node生效的过程是怎样的。
开始之前先说下DPDK是怎么和vpp交互的。从vpp看来，dpdk就是一个插件，只不过这个插件运行得比较靠前，当数据包到来之后，dpdk将其收到rte_mbuf中，后面再将rte_mbuf转化为vlib_buf，后面的node就是从vlib_buf中取出数据再来处理，简单讲下rte_mbuf和vlib_buf的关系，以及他们是如何转化的：

#define rte_mbuf_from_vlib_buffer(x) (((struct rte_mbuf *)x) - 1)
#define vlib_buffer_from_rte_mbuf(x) ((vlib_buffer_t *)(x+1))
这两个宏定义用于在vlib buffer和DPDK的rte_mbuf之间进行转换。rte_mbuf 是DPDK中用于表示数据包的结构体，而 vlib_buffer_t 是VPP中用于表示数据包的结构体。以下是对这两个宏的解释：

rte_mbuf_from_vlib_buffer(x): 这个宏将一个 vlib_buffer_t 转换成对应的 rte_mbuf。vlib_buffer_t 中的数据的指针指向 rte_mbuf 的后一个字节，所以通过将 x 强制转换为 struct rte_mbuf *，然后减去1，就可以得到对应的 rte_mbuf。

vlib_buffer_from_rte_mbuf(x): 这个宏将一个 rte_mbuf 转换成对应的 vlib_buffer_t。由于上面的宏中的指针偏移关系，将 x 强制转换为 vlib_buffer_t * 之后，可以得到指向 vlib_buffer_t 数据部分的指针

VPP 初始化

初始化里面主要做了四件事
1、load so //加载静态库
2、register node //注册处理节点
3、function init (cmd init,feture init) //注册处理函数

先上个伪代码简单看下流程

int main(){

	//VPP 程序的入口函数，它初始化全局状态、配置、插件以及其他运行时环境，并最终进入主循环以运行网络处理和其他功能
	vlib_unix_main();
	
		//执行了插件的早期初始化，设置了插件路径、日志等，并准备加载新的插件
		vlib_plugin_early_init();
		
			//加载新插件，并进行相应的管理和处理，确保只加载有效的插件，并进行了排序、覆盖等操作
			vlib_load_new_plugins();
			
				//加载插件并进行一系列的检查，确保插件可以正确加载和初始化
				load_one_plugin();

		//通过协程跳转到thread0执行
		clib_calljmp();
		
			//线程函数，作为独立线程的入口点
			thread0();
			
				//各种初始化操作，调用初始化函数、配置函数、主循环函数、以及一系列的清理操作
				vlib_main();
				
					//调用所有初始化函数
					vlib_call_all_init_functions();
					
						vlib_call_init_exit_functions
					
					//遍历所有的节点注册（node_registrations 链表），并将这些注册的节点全部注册到 VLIB 中
					vlib_register_all_static_nodes();		
						
					//
					 vlib_main_loop (vm);
					 
						//VLIB 主循环或工作线程循环的核心部分。它处理节点的调度和执行，以及一些循环计数和时间间隔的计算
						vlib_main_or_worker_loop (vm, /* is_main */ 1);
						
							//负责管理进程的调度、执行和暂停等。根据进程的状态和标志，它会判断是否继续执行进程，
							//启动定时器等。执行完毕后，会更新性能计数器、事件日志以及进程的统计信息
							dispatch_process();
							
								//责将进程切换到新的堆栈并执行其启动函数
								vlib_process_startup
								
									//进程启动的具体逻辑，包括在进程的堆栈上调用进程函数并处理返回值
									vlib_process_bootstrap
									
										// 这里就调用到了我们注册一个node之后，真正的处理函数
										n = node->function (vm, node, f);
							
}

接下来对上面伪代码中的函数进行详细分析下：
从main函数开始，main函数中其实都是配置和初始化VPP环境的相关东西，大概就是下面这样：

int main(){
	//创建主堆，使用了之前设置的 main_heap_size 和 main_heap_log2_page_sz
	main_heap = clib_mem_init_with_page_size(main_heap_size, main_heap_log2_page_sz);
	//初始化VLIB库,初始化VPE（VPP Environment）库
	//将一个VLIB主要实例传递给了 vpe_main_init() 函数，以便VPE库能够与VLIB库进行集成
	vlib_main_init();
	vpe_main_init(vlib_get_first_main());
	//进入VLIB的主循环并开始执行网络处理程序。这是整个程序的核心部分，处理数据包、事件和各种网络功能
	return vlib_unix_main(argc, argv);
}

vlib_unix_main函数解析：

int
vlib_unix_main (int argc, char *argv[])
{
  
	//初始化时间库
	clib_time_init (&vm->clib_time);

	//初始化并启用事件日志，用于记录系统中的事件
	elog_init (vlib_get_elog_main (), vgm->configured_elog_ring_size);
	elog_enable_disable (vlib_get_elog_main (), 1);

	//初始化插件的配置，通过调用插件的配置函数来加载和处理插件特定的配置信息
	if ((e = vlib_plugin_config (vm, &input)))
	{
	  clib_error_report (e);
	  return 1;
	}
	unformat_free (&input);

	//这里是各种so插件初始化的地方
	i = vlib_plugin_early_init (vm);
	if (i)
	return i;

	//调用注册的配置函数，这些函数在插件中注册，用于配置程序的各种功能
	e = vlib_call_all_config_functions (vm, &input, 1 /* early */ );
	if (e != 0)
	{
	  clib_error_report (e);
	  return 1;
	}
	unformat_free (&input);

	//加载 ELF 格式文件的符号，用于处理信号处理程序和内存分配追踪
	clib_elf_main_init (vgm->exec_path);

	vec_validate (vlib_thread_stacks, 0);
	vlib_thread_stack_init (0);

	__os_thread_index = 0;
	vm->thread_index = 0;

	//启动主循环，将堆栈切换到主线程的堆栈，然后使用 clib_calljmp 调用主循环
	vlib_process_start_switch_stack (vm, 0);
	i = clib_calljmp (thread0, (uword) vm,
			(void *) (vlib_thread_stacks[0] +
				  VLIB_THREAD_STACK_SIZE));
	return i;
}

这里我们再看看插件是如何被加载的，通过vlib_plugin_early_init

int
vlib_plugin_early_init (vlib_main_t * vm)
{
	plugin_main_t *pm = &vlib_plugin_main;

	pm->logger =
	vlib_log_register_class_rate_limit ("plugin", "load",
					0x7FFFFFFF /* aka no rate limit */ );

	//如果插件路径未设置，则使用默认的插件路径 vlib_plugin_path		
	if (pm->plugin_path == 0)
	pm->plugin_path = format (0, "%s", vlib_plugin_path);

	//如果有额外的插件路径附加，将其添加到插件路径中
	if (pm->plugin_path_add)
	pm->plugin_path = format (pm->plugin_path, ":%s", pm->plugin_path_add);

	//在插件路径的末尾添加一个 null 字节，以便可以在字符串中找到插件路径的终止
	pm->plugin_path = format (pm->plugin_path, "%c", 0);

	PLUGIN_LOG_DBG ("plugin path %s", pm->plugin_path);

	//创建两个哈希表，用于存储插件的信息和覆盖信息
	pm->plugin_by_name_hash = hash_create_string (0, sizeof (uword));
	pm->plugin_overrides_by_name_hash = hash_create_string (0, sizeof (uword));
	//设置插件主结构体的 vlib_main 字段，以指向 VLIB 主结构体
	pm->vlib_main = vm;

	//加载新的插件
	return vlib_load_new_plugins (pm, 1 /* from_early_init */ );
}

插件的加载就是vlib_load_new_plugins 函数，它做了哪些事呢：加载新插件，并进行相应的管理和处理，确保只加载有效的插件，并进行了排序、覆盖等操作。我们如果自己新定制了plugin插件，也是在这里处理

int
vlib_load_new_plugins (plugin_main_t * pm, int from_early_init)
{
	DIR *dp;
	struct dirent *entry;
	struct stat statb;
	uword *p;
	plugin_info_t *pi;
	u8 **plugin_path;
	uword *not_loaded_indices = 0;
	int i;

	//根据插件路径字符串生成一个字符串数组，每个元素表示一个路径
	plugin_path = split_plugin_path (pm);

	for (i = 0; i < vec_len (plugin_path); i++)
	{
	  dp = opendir ((char *) plugin_path[i]);

	  if (dp == 0)
	continue;

	//遍历插件路径数组，打开每个路径对应的目录，并遍历目录中的每个文件项
	while ((entry = readdir (dp)))
	{
	  u8 *plugin_name;
	  u8 *filename;

	  //如果设置了插件名过滤，将会检查文件名是否满足过滤条件。如果不满足，则跳过当前文件项
	  if (pm->plugin_name_filter)
		{
		  int j;
		  for (j = 0; j < vec_len (pm->plugin_name_filter); j++)
		if (entry->d_name[j] != pm->plugin_name_filter[j])
		  goto next;
		}

	  //检查文件的扩展名是否是 .so，并且通过 stat 函数检查文件是否可读
	  filename = format (0, "%s/%s%c", plugin_path[i], entry->d_name, 0);
	  char *ext = strrchr ((const char *) filename, '.');
	  /* unreadable */
	  if (!ext || (strcmp (ext, ".so") != 0) ||
		  stat ((char *) filename, &statb) < 0)
		{
		ignore:
		  vec_free (filename);
		  continue;
		}

	  /* 检查文件是否是一个常规文件，即普通文件，而不是目录或其他类型的文件 */
	  if (!S_ISREG (statb.st_mode))
		goto ignore;

		//如果文件是有效的插件文件，将其信息添加到插件信息数组中，并在哈希表中建立插件名称到插件信息的映射
	  plugin_name = format (0, "%s%c", entry->d_name, 0);
	  p = hash_get_mem (pm->plugin_by_name_hash, plugin_name);
	  if (p == 0)
		{
		  /* No, add it to the plugin vector */
		  vec_add2 (pm->plugin_info, pi, 1);
		  pi->name = plugin_name;
		  pi->filename = filename;
		  pi->file_info = statb;
		  pi->handle = 0;
		  hash_set_mem (pm->plugin_by_name_hash, plugin_name,
				pi - pm->plugin_info);
		}
	next:
	  ;
	}
	  closedir (dp);
	  vec_free (plugin_path[i]);
	}
	vec_free (plugin_path);


	/*
	根据插件名称对插件信息数组进行排序，确保插件按照名称的字典顺序排列
	*/
	vec_sort_with_function (pm->plugin_info, plugin_name_sort_cmp);

	/*
	遍历插件信息数组，并尝试加载每个插件，如果加载失败，则记录下来
	*/
	for (i = 0; i < vec_len (pm->plugin_info); i++)
	{
	  pi = vec_elt_at_index (pm->plugin_info, i);

	  if (load_one_plugin (pm, pi, from_early_init))
	{
	  /* Make a note of any which fail to load */
	  vec_add1 (not_loaded_indices, i);
	}
	}

	/*
	处理未能成功加载的插件，以及通过覆盖列表进行覆盖的插件
	*/
	for (i = 0; i < vec_len (pm->plugin_info); i++)
	{
	  uword *p;

	  pi = vec_elt_at_index (pm->plugin_info, i);

	  p = hash_get_mem (pm->plugin_overrides_by_name_hash, pi->name);

	  /* Plugin overridden? */
	  if (p)
	{
	  PLUGIN_LOG_NOTICE ("Plugin '%s' overridden by '%s'", pi->name,
				 p[0]);
	  vec_add1 (not_loaded_indices, i);
	}
	}

	/*
	删除未加载的插件信息，并对插件信息数组进行调整
	*/
	vec_sort_with_function (not_loaded_indices, index_cmp);
	for (i = 0; i < vec_len (not_loaded_indices); i++)
	{
	  if (i < vec_len (not_loaded_indices) - 1)
	{
	  if (not_loaded_indices[i + 1] == not_loaded_indices[i])
		{
		  vec_delete (not_loaded_indices, 1, i);
		  i--;
		}
	}
	}

	/* Remove plugin info vector elements corresponding to load failures */
	if (vec_len (not_loaded_indices) > 0)
	{
	
	  for (i = vec_len (not_loaded_indices) - 1; i >= 0; i--)
	{
	  pi = vec_elt_at_index (pm->plugin_info, not_loaded_indices[i]);
	  hash_unset_mem (pm->plugin_by_name_hash, pi->name);
	  if (pi->handle)
		{
		  dlclose (pi->handle);
		  PLUGIN_LOG_NOTICE ("Unloaded plugin: %s", pi->name);
		}
	  vec_free (pi->name);
	  vec_free (pi->filename);
	  vec_delete (pm->plugin_info, 1, not_loaded_indices[i]);
	}
	  vec_free (not_loaded_indices);
	}

	/* Recreate the plugin name hash */
	hash_free (pm->plugin_by_name_hash);
	pm->plugin_by_name_hash = hash_create_string (0, sizeof (uword));

	重新创建插件名称哈希表，以反映加载成功的插件信息
	for (i = 0; i < vec_len (pm->plugin_info); i++)
	{
	  pi = vec_elt_at_index (pm->plugin_info, i);
	  hash_set_mem (pm->plugin_by_name_hash, pi->name, pi - pm->plugin_info);
	}

	return 0;
}

接下来看是怎么加载一个插件的load_one_plugin

static int
load_one_plugin (plugin_main_t * pm, plugin_info_t * pi, int from_early_init)
{
  void *handle;
  int reread_reg = 1;
  clib_error_t *error;
  elf_main_t em = { 0 };
  elf_section_t *section;
  u8 *data;
  char *version_required;
  vlib_plugin_registration_t *reg;
  vlib_plugin_r2_t *r2;
  plugin_config_t *pc = 0;
  uword *p;

  //使用 ELF 解析库读取插件文件，将文件内容解析为 ELF 结构
  if (elf_read_file (&em, (char *) pi->filename))
    return -1;

  检查是否存在新的插件注册结构，如果存在，将解析该结构并进行处理
  error = elf_get_section_by_name (&em, ".vlib_plugin_r2", &section);
  if (error == 0)
    {
      data = elf_get_section_contents (&em, section->index, 1);
      r2 = (vlib_plugin_r2_t *) data;
      reg = clib_mem_alloc (sizeof (*reg));
      memset (reg, 0, sizeof (*reg));

      reg->default_disabled = r2->default_disabled != 0;
      error = r2_to_reg (&em, r2, reg);
      if (error)
	{
	  PLUGIN_LOG_ERR ("Bad r2 registration: %s\n", (char *) pi->name);
	  return -1;
	}
      if (pm->plugins_default_disable)
	reg->default_disabled = 1;
      reread_reg = 0;
      goto process_reg;
    }
  else
    clib_error_free (error);

	//检查是否存在老版本的插件注册结构，如果不存在，则表示不是一个有效的插件
  error = elf_get_section_by_name (&em, ".vlib_plugin_registration",
				   &section);
  if (error)
    {
      PLUGIN_LOG_ERR ("Not a plugin: %s\n", (char *) pi->name);
      return -1;
    }
  //处理插件注册结构，检查大小是否匹配，并根据需要进行默认禁用
  data = elf_get_section_contents (&em, section->index, 1);
  reg = (vlib_plugin_registration_t *) data;

  if (vec_len (data) != sizeof (*reg))
    {
      PLUGIN_LOG_ERR ("vlib_plugin_registration size mismatch in plugin %s\n",
		      (char *) pi->name);
      goto error;
    }

  if (pm->plugins_default_disable)
    reg->default_disabled = 1;

process_reg:
	//根据插件名称在配置信息中查找是否需要禁用插
  p = hash_get_mem (pm->config_index_by_name, pi->name);
  if (p)
    {
      pc = vec_elt_at_index (pm->configs, p[0]);
      if (pc->is_disabled)
	{
	  PLUGIN_LOG_NOTICE ("Plugin disabled: %s", pi->name);
	  goto error;
	}
      if (reg->default_disabled && pc->is_enabled == 0)
	{
	  PLUGIN_LOG_NOTICE ("Plugin disabled (default): %s", pi->name);
	  goto error;
	}
    }
  else if (reg->default_disabled)
    {
      PLUGIN_LOG_NOTICE ("Plugin disabled (default): %s", pi->name);
      goto error;
    }
	//检查插件所需的版本是否与应用版本匹配
  version_required = str_array_to_vec ((char *) &reg->version_required,
				       sizeof (reg->version_required));

  if ((strlen (version_required) > 0) &&
      (strncmp (vlib_plugin_app_version, version_required,
		strlen (version_required))))
    {
      PLUGIN_LOG_ERR ("Plugin %s version mismatch: %s != %s",
		      pi->name, vlib_plugin_app_version,
		      reg->version_required);
      if (!(pc && pc->skip_version_check == 1))
	{
	  vec_free (version_required);
	  goto error;
	}
    }

  处理当前插件覆盖的其他插件，记录覆盖关系
  if (reg->overrides[0])
    {
      const char *overrides = reg->overrides;
      u8 *override_name_copy, *overridden_by_name_copy;
      u8 *sp, *ep;
      uword *p;

      sp = ep = (u8 *) overrides;

      while (1)
	{
	  if (*sp == 0
	      || (sp >= (u8 *) overrides + ARRAY_LEN (reg->overrides)))
	    break;
	  if (*sp == ' ' || *sp == ',')
	    {
	      sp++;
	      continue;
	    }
	  ep = sp;
	  while (*ep && *ep != ' ' && *ep != ',' &&
		 ep < (u8 *) overrides + ARRAY_LEN (reg->overrides))
	    ep++;
	  if (*ep == ' ' || *ep == ',')
	    ep--;

	  override_name_copy = extract (sp, ep);


	  p = hash_get_mem (pm->plugin_overrides_by_name_hash,
			    override_name_copy);
	  /* Already overridden... */
	  if (p)
	    vec_free (override_name_copy);
	  else
	    {
	      overridden_by_name_copy = format (0, "%s%c", pi->name, 0);
	      hash_set_mem (pm->plugin_overrides_by_name_hash,
			    override_name_copy, overridden_by_name_copy);
	    }
	  sp = *ep ? ep + 1 : ep;
	}
    }
  vec_free (version_required);
//使用 dlopen 函数加载插件的动态库，返回句柄
  handle = dlopen ((char *) pi->filename,
		   RTLD_LAZY | (reg->deep_bind ? RTLD_DEEPBIND : 0));

  if (handle == 0)
    {
      PLUGIN_LOG_ERR ("%s", dlerror ());
      PLUGIN_LOG_ERR ("Failed to load plugin '%s'", pi->name);
      goto error;
    }

  pi->handle = handle;

/*dlsym 函数用于从已加载的共享库中获取一个符号的地址,该符号代表了一个结构体，
其中包含了插件的注册信息。插件在加载时，通常会在共享库中定义一个名为 
"vlib_plugin_registration" 的全局变量，该变量包含了插件的配置和信息*/
  if (reread_reg)
    reg = dlsym (pi->handle, "vlib_plugin_registration");

  pi->reg = reg;
  pi->version = str_array_to_vec ((char *) &reg->version,
				  sizeof (reg->version));
	//如果插件指定了早期初始化函数，调用该函数进行初始化
  if (reg->early_init)
    {
      clib_error_t *(*ei) (vlib_main_t *);
      void *h;

      h = dlsym (pi->handle, reg->early_init);
      if (h)
	{
	  ei = h;
	  error = (*ei) (pm->vlib_main);
	  if (error)
	    {
	      u8 *err = format (0, "%s: %U%c", pi->name,
				format_clib_error, error, 0);
	      PLUGIN_LOG_ERR ((char *) err);
	      clib_error_free (error);
	      dlclose (pi->handle);
	      pi->handle = 0;
	      goto error;
	    }
	}
      else
	PLUGIN_LOG_ERR ("Plugin %s: early init function %s set but not found",
			(char *) pi->name, reg->early_init);
    }
	
	//记录插件加载成功的信息
  if (reg->description)
    PLUGIN_LOG_NOTICE ("Loaded plugin: %s (%s)", pi->name, reg->description);
  else
    PLUGIN_LOG_NOTICE ("Loaded plugin: %s", pi->name);

	//释放临时分配的内存，并返回成功加载的状态
  vec_free (data);
  elf_main_free (&em);
  return 0;

  //在加载失败的情况下，释放资源并返回失败的状态
error:
  vec_free (data);
  elf_main_free (&em);
  return -1;
}

线程函数，作为独立线程的入口点 thread0

/**
 * 线程函数，作为独立线程的入口点。
 *
 * @param arg 传递给线程函数的参数。在这个上下文中，应该是一个指向 vlib_main_t 结构的指针。
 * @return vlib_main 函数的返回值。
 */
static uword thread0(uword arg) {
  // 将参数转换为 vlib_main_t 指针
  vlib_main_t *vm = (vlib_main_t *)arg;

  // 获取全局 VLIB 主结构
  vlib_global_main_t *vgm = vlib_get_global_main();

  // 初始化一个用于命令行解析的输入结构
  unformat_input_t input;

  // 用于存储 vlib_main 函数的返回值
  int i;

  // 通知 VLIB 线程已完成切换到其堆栈
  vlib_process_finish_switch_stack(vm);

  // 使用全局 argv 初始化命令行输入
  unformat_init_command_line(&input, (char **)vgm->argv);

  // 调用 VLIB 主循环函数并存储其返回值
  i = vlib_main(vm, &input);

  // 释放命令行输入结构使用的资源
  unformat_free(&input);

  // 返回 vlib_main 函数的返回值
  return i;
}

各种初始化操作，调用初始化函数、配置函数、主循环函数、以及一系列的清理操作vlib_main

/* 主函数 */
int vlib_main(vlib_main_t *volatile vm, unformat_input_t *input) {
  vlib_global_main_t *vgm = vlib_get_global_main();
  clib_error_t *volatile error;
  vlib_node_main_t *nm = &vm->node_main;

  // 设置队列信号回调为占位符函数
  vm->queue_signal_callback = placeholder_queue_signal_callback;

  /* 重新配置事件日志，这个日志在非常早期就被启用 */
  if (vgm->configured_elog_ring_size &&
      vgm->configured_elog_ring_size != vgm->elog_main.event_ring_size)
    elog_resize(&vgm->elog_main, vgm->configured_elog_ring_size);
  vl_api_set_elog_main(vlib_get_elog_main());
  (void)vl_api_set_elog_trace_api_messages(1);

  /* 默认名称 */
  if (!vgm->name)
    vgm->name = "VLIB";

  if ((error = vlib_physmem_init(vm))) {
    clib_error_report(error);
    goto done;
  }

  if ((error = vlib_log_init(vm))) {
    clib_error_report(error);
    goto done;
  }

  if ((error = vlib_stats_init(vm))) {
    clib_error_report(error);
    goto done;
  }

  if ((error = vlib_buffer_main_init(vm))) {
    clib_error_report(error);
    goto done;
  }

  if ((error = vlib_thread_init(vm))) {
    clib_error_report(error);
    goto done;
  }

  // 注册节点 ifunction 变体
  vlib_register_all_node_march_variants(vm);

  // 注册静态节点以便初始化函数可以使用它们
  vlib_register_all_static_nodes(vm);

  // 设置随机数生成器的种子
  if (!unformat(input, "seed %wd", &vm->random_seed))
    vm->random_seed = clib_cpu_time_now();
  clib_random_buffer_init(&vm->random_buffer, vm->random_seed);

  // 初始化节点图
  if ((error = vlib_node_main_init(vm))) {
    // 在调试模式下，将图连接错误设置为非致命错误
    if (CLIB_DEBUG > 0)
      clib_error_report(error);
    else
      goto done;
  }

  // 初始化 vpe_api
  if ((error = vpe_api_init(vm))) {
    clib_error_report(error);
    goto done;
  }

  if ((error = vlibmemory_init(vm))) {
    clib_error_report(error);
    goto done;
  }

  if ((error = map_api_segment_init(vm))) {
    clib_error_report(error);
    goto done;
  }

  // 检查 init_functions_called 是否为 0，如果是则创建哈希表
  if (vgm->init_functions_called == 0)
    vgm->init_functions_called = hash_create(0, /* value bytes */ 0);

  // 调用所有的 init 函数
  if ((error = vlib_call_all_init_functions(vm)))
    goto done;

  // 分配节点主循环的定时轮数据结构
  nm->timing_wheel = clib_mem_alloc_aligned(sizeof(TWT(tw_timer_wheel)),
                                            CLIB_CACHE_LINE_BYTES);

  vec_validate(nm->data_from_advancing_timing_wheel, 10);
  vec_set_len(nm->data_from_advancing_timing_wheel, 0);

  // 创建进程定时轮
  TW(tw_timer_wheel_init)((TWT(tw_timer_wheel) *)nm->timing_wheel,
                          0 /* no callback */,
                          10e-6 /* timer period 10us */,
                          ~0 /* max expirations per call */);

  vec_validate(vm->pending_rpc_requests, 0);
  vec_set_len(vm->pending_rpc_requests, 0);
  vec_validate(vm->processing_rpc_requests, 0);
  vec_set_len(vm->processing_rpc_requests, 0);

  // 如果配置了缓冲区分配错误注入，则设置默认参数
  if (VLIB_BUFFER_ALLOC_FAULT_INJECTOR > 0) {
    vm->buffer_alloc_success_seed = 0xdeaddabe;
    vm->buffer_alloc_success_rate = 0.80;
  }

  // 调用所有的配置函数
  if ((error = vlib_call_all_config_functions(vm, input, 0 /* is_early */)))
    goto done;

  /*
   * 使用指数平滑法，半衰期为 1 秒
   * reported_rate(t) = reported_rate(t-1) * K + rate(t)*(1-K)
   *
   * 每 20ms 进行一次采样，即每秒 50 个样本
   * K = exp (-1.0/20.0);
   * K = 0.95
   */
  vm->damping_constant = exp(-1.0 / 20.0);

  // 对 per-thread init 函数进行排序，然后启动线程
  vlib_sort_init_exit_functions(&vgm->worker_init_function_registrations);

  // 调用所有的 main loop enter 函数
  {
    clib_error_t *sub_error;
    sub_error = vlib_call_all_main_loop_enter_functions(vm);
    if (sub_error)
      clib_error_report(sub_error);
  }

  switch (clib_setjmp(&vm->main_loop_exit, VLIB_MAIN_LOOP_EXIT_NONE)) {
  case VLIB_MAIN_LOOP_EXIT_NONE:
    vm->main_loop_exit_set = 1;
    break;

  case VLIB_MAIN_LOOP_EXIT_CLI:
    goto done;

  default:
    error = vm->main_loop_error;
    goto done;
  }

  // 开始主循环
  vlib_main_loop(vm);

done:
  vlib_worker_thread_barrier_sync(vm);
  /* 调用所有的 exit 函数 */
  {
    clib_error_t *sub_error;
    sub_error = vlib_call_all_main_loop_exit_functions(vm);
    if (sub_error)
      clib_error_report(sub_error);
  }
  vlib_worker_thread_barrier_release(vm);

  // 如果有错误，报告错误
  if (error)
    clib_error_report(error);

  return vm->main_loop_exit_status;
}

调用所有初始化函数vlib_call_all_init_functions

/**
 * 调用所有初始化函数
 *
 * @param vm VLIB 主数据结构的指针
 * @return clib_error_t 指向错误对象的指针，如果没有错误则为 NULL
 */
clib_error_t *
vlib_call_all_init_functions(vlib_main_t *vm) {
  vlib_global_main_t *vgm = vlib_get_global_main();

  // 调用占位符函数，确保纯静态模块被连接
  // 这里使用 foreach_vlib_module_reference 宏来展开对各个模块的引用
#define _(f) vlib_##f##_reference();
  foreach_vlib_module_reference;
#undef _

  // 调用初始化/退出函数
  return vlib_call_init_exit_functions(vm, &vgm->init_function_registrations,
                                        1 /* call_once */, 1 /* is_global */);
}

初始化/退出/主循环进入函数的内部实现：实现了一个通用的函数调用机制，用于调用一组初始化、退出或者主循环进入函数。这个机制可以根据需要对函数链表进行排序，并且支持设置仅调用一次的标志。在遍历函数链表时，会检查是否已经调用过函数，如果设置为仅调用一次，并且函数未被调用过，则调用该函数。这样的机制可以方便地调用一组函数来完成初始化、退出或者进入主循环等操作。call_init_exit_functions_internal

/**
 * @brief 调用一组初始化/退出/主循环进入函数
 *
 * @param vm vlib_main_t 结构体的指针
 * @param headp 指向函数链表头指针的指针
 * @param call_once 标志，指示是否仅调用一次
 * @param do_sort 标志，指示是否对函数链表进行排序
 * @param is_global 标志，指示是否为全局函数
 * @return clib_error_t 指向错误对象的指针，如果没有错误则为 NULL
 */
static inline clib_error_t *
call_init_exit_functions_internal(vlib_main_t *vm,
                                  _vlib_init_function_list_elt_t **headp,
                                  int call_once, int do_sort, int is_global) {
  vlib_global_main_t *vgm = vlib_get_global_main();
  clib_error_t *error = 0;
  _vlib_init_function_list_elt_t *i;

  // 如果需要排序，进行排序操作
  if (do_sort && (error = vlib_sort_init_exit_functions(headp)))
    return (error);

  i = *headp;
  while (i) {
    uword *h;

    // 检查是否已经调用过这个函数
    if (is_global)
      h = hash_get(vgm->init_functions_called, i->f);
    else
      h = hash_get(vm->worker_init_functions_called, i->f);

    // 如果设置为仅调用一次，并且函数未被调用过，则调用函数
    if (call_once && !h) {
      if (call_once) {
        if (is_global)
          hash_set1(vgm->init_functions_called, i->f);
        else
          hash_set1(vm->worker_init_functions_called, i->f);
      }
      error = i->f(vm);
      if (error)
        return error;
    }
    i = i->next_init_function;
  }
  return error;
}

注册所有静态节点（static nodes）的函数。静态节点是预定义的节点，其功能在整个系统的生命周期中保持不变vlib_register_all_static_nodes

void vlib_register_all_static_nodes(vlib_main_t *vm) {
  vlib_global_main_t *vgm = vlib_get_global_main();
  vlib_node_registration_t *r;

  static char *null_node_error_strings[] = {
    "blackholed packets",
  };

  static vlib_node_registration_t null_node_reg = {
    .function = null_node_fn,  // 空节点的处理函数
    .vector_size = sizeof(u32),
    .n_errors = 1,
    .error_strings = null_node_error_strings,
  };

  // 注册一个名为 "null-node" 的节点
  // 这是一个特殊的节点，用于处理被黑洞的数据包
  vlib_register_node(vm, &null_node_reg, "null-node");

  // 遍历所有节点注册
  r = vgm->node_registrations;
  while (r) {
    // 注册每个节点
    vlib_register_node(vm, r, "%s", r->name);
    r = r->next_registration;
  }
}

VLIB 主循环或工作线程循环的核心部分。它处理节点的调度和执行，以及一些循环计数和时间间隔的计算vlib_main_or_worker_loop：

static_always_inline void vlib_main_or_worker_loop(vlib_main_t * vm, int is_main) {
  // 获取主循环的相关数据结构
  vlib_node_main_t *nm = &vm->node_main;
  vlib_thread_main_t *tm = vlib_get_thread_main();
  uword i;
  u64 cpu_time_now;
  f64 now;
  vlib_frame_queue_main_t *fqm;
  u32 frame_queue_check_counter = 0;

  // 初始化 pending_frames 数组，用于存储待处理的帧
  if (is_main) {
    vec_resize(nm->pending_frames, 32);
    vec_set_len(nm->pending_frames, 0);
  }

  // 标记主循环开始的时间
  if (is_main) {
    cpu_time_now = vm->clib_time.last_cpu_time;
    vm->cpu_time_main_loop_start = cpu_time_now;
  } else
    cpu_time_now = clib_cpu_time_now();

  // 预分配中断运行时索引和锁
  vec_alloc_aligned(nm->pending_interrupts, 1, CLIB_CACHE_LINE_BYTES);

  // 预分配过期节点
  if (!nm->polling_threshold_vector_length)
    nm->polling_threshold_vector_length = 10;
  if (!nm->interrupt_threshold_vector_length)
    nm->interrupt_threshold_vector_length = 5;

  // 获取当前 CPU ID 和 NUMA 节点信息
  vm->cpu_id = clib_get_current_cpu_id();
  vm->numa_node = clib_get_current_numa_node();
  os_set_numa_index(vm->numa_node);

  // 启动所有进程
  if (is_main) {
    uword i;

    // 执行初始的屏障同步
    vlib_worker_thread_initial_barrier_sync_and_release(vm);

    nm->current_process_index = ~0;
    for (i = 0; i < vec_len(nm->processes); i++)
      cpu_time_now = dispatch_process(vm, nm->processes[i], /* frame */ 0, cpu_time_now);
  }

  while (1) {
    vlib_node_runtime_t *n;

    // 处理 RPC 请求
    if (PREDICT_FALSE(_vec_len(vm->pending_rpc_requests) > 0)) {
      if (!is_main)
        vl_api_send_pending_rpc_requests(vm);
    }

    // 检查 worker 线程屏障
    if (!is_main)
      vlib_worker_thread_barrier_check();

    // 检查帧队列是否有工作
    if (PREDICT_FALSE(vm->check_frame_queues + frame_queue_check_counter)) {
      u32 processed = 0;
      vlib_frame_queue_dequeue_fn_t *fn;

      if (vm->check_frame_queues) {
        frame_queue_check_counter = 100;
        vm->check_frame_queues = 0;
      }

      vec_foreach(fqm, tm->frame_queue_mains) {
        fn = fqm->frame_queue_dequeue_fn;
        processed += (fn)(vm, fqm);
      }

      // 没有找到帧队列的工作？
      if (processed)
        frame_queue_check_counter = 100;
      else
        frame_queue_check_counter--;
    }

    // 执行 worker 线程主循环回调函数
    if (PREDICT_FALSE(vec_len(vm->worker_thread_main_loop_callbacks)))
      clib_call_callbacks(vm->worker_thread_main_loop_callbacks, vm, cpu_time_now);

    // 处理 pre-input 节点
    cpu_time_now = clib_cpu_time_now();
    vec_foreach(n, nm->nodes_by_type[VLIB_NODE_TYPE_PRE_INPUT])
      cpu_time_now = dispatch_node(vm, n, VLIB_NODE_TYPE_PRE_INPUT, VLIB_NODE_STATE_POLLING, /* frame */ 0, cpu_time_now);

    // 处理 input 节点
    vec_foreach(n, nm->nodes_by_type[VLIB_NODE_TYPE_INPUT])
      cpu_time_now = dispatch_node(vm, n, VLIB_NODE_TYPE_INPUT, VLIB_NODE_STATE_POLLING, /* frame */ 0, cpu_time_now);

    // 如果是主循环且队列信号挂起，触发队列信号回调
    if (PREDICT_TRUE(is_main && vm->queue_signal_pending == 0))
      vm->queue_signal_callback(vm);

    // 处理挂起的中断事件
    if (__atomic_load_n(nm->pending_interrupts, __ATOMIC_ACQUIRE)) {
      int int_num = -1;
      *nm->pending_interrupts = 0;

      while ((int_num = clib_interrupt_get_next(nm->interrupts, int_num)) != -1) {
        vlib_node_runtime_t *n;
        clib_interrupt_clear(nm->interrupts, int_num);
        n = vec_elt_at_index(nm->nodes_by_type[VLIB_NODE_TYPE_INPUT], int_num);
        cpu_time_now = dispatch_node(vm, n, VLIB_NODE_TYPE_INPUT, VLIB_NODE_STATE_INTERRUPT, /* frame */ 0, cpu_time_now);
      }
    }

        // 处理 input 节点可能已经添加到 pending_frames 数组中的工作
    for (i = 0; i < _vec_len(nm->pending_frames); i++)
      cpu_time_now = dispatch_pending_node(vm, i, cpu_time_now);
    // 重置 pending_frames 数组，准备下一轮迭代
    vec_set_len(nm->pending_frames, 0);

    if (is_main) {
      // ELOG_TYPE_DECLARE 定义用于事件日志记录
      ELOG_TYPE_DECLARE(es) = {
        .format = "process tw start",
        .format_args = "",
      };
      ELOG_TYPE_DECLARE(ee) = {
        .format = "process tw end: %d",
        .format_args = "i4",
      };

      struct {
        int nready_procs;
      } *ed;

      // 检查是否有节点从定时轮中过期
      ASSERT(nm->data_from_advancing_timing_wheel != 0);

      if (PREDICT_FALSE(vm->elog_trace_graph_dispatch))
        ed = ELOG_DATA(&vlib_global_main.elog_main, es);

      nm->data_from_advancing_timing_wheel =
        TW(tw_timer_expire_timers_vec)
        ((TWT(tw_timer_wheel) *)nm->timing_wheel, vlib_time_now(vm),
         nm->data_from_advancing_timing_wheel);

      ASSERT(nm->data_from_advancing_timing_wheel != 0);

      if (PREDICT_FALSE(vm->elog_trace_graph_dispatch)) {
        ed = ELOG_DATA(&vlib_global_main.elog_main, ee);
        ed->nready_procs = _vec_len(nm->data_from_advancing_timing_wheel);
      }

      if (PREDICT_FALSE(_vec_len(nm->data_from_advancing_timing_wheel) > 0)) {
        uword i;

        for (i = 0; i < _vec_len(nm->data_from_advancing_timing_wheel); i++) {
          u32 d = nm->data_from_advancing_timing_wheel[i];
          u32 di = vlib_timing_wheel_data_get_index(d);

          if (vlib_timing_wheel_data_is_timed_event(d)) {
            vlib_signal_timed_event_data_t *te =
              pool_elt_at_index(nm->signal_timed_event_data_pool, di);
            vlib_node_t *n = vlib_get_node(vm, te->process_node_index);
            vlib_process_t *p = vec_elt(nm->processes, n->runtime_index);
            void *data;
            data = vlib_process_signal_event_helper(nm, n, p,
                                                    te->event_type_index,
                                                    te->n_data_elts,
                                                    te->n_data_elt_bytes);
            if (te->n_data_bytes < sizeof(te->inline_event_data))
              clib_memcpy_fast(data, te->inline_event_data,
                                te->n_data_bytes);
            else {
              clib_memcpy_fast(data, te->event_data_as_vector,
                                te->n_data_bytes);
              vec_free(te->event_data_as_vector);
            }
            pool_put(nm->signal_timed_event_data_pool, te);
          } else {
            cpu_time_now = clib_cpu_time_now();
            cpu_time_now = dispatch_suspended_process(vm, di, cpu_time_now);
          }
        }
        vec_set_len(nm->data_from_advancing_timing_wheel, 0);
      }
    }
    
    // 增加主循环计数
    vlib_increment_main_loop_counter(vm);
    // 记录时间戳，以防没有启用的节点和上述调用未更新时间戳
    cpu_time_now = clib_cpu_time_now();
    vm->loops_this_reporting_interval++;
    now = clib_time_now_internal(&vm->clib_time, cpu_time_now);
    // 是否需要更新 loops_per_second？
    if (PREDICT_FALSE(now >= vm->loop_interval_end)) {
      // 下一次采样在 20 毫秒后结束
      if (vm->loop_interval_start) {
        f64 this_loops_per_second;

        this_loops_per_second =
          ((f64)vm->loops_this_reporting_interval) / (now - vm->loop_interval_start);

        vm->loops_per_second =
          vm->loops_per_second * vm->damping_constant +
          (1.0 - vm->damping_constant) * this_loops_per_second;
        if (vm->loops_per_second != 0.0)
          vm->seconds_per_loop = 1.0 / vm->loops_per_second;
        else
          vm->seconds_per_loop = 0.0;
      }
      // 新的间隔从现在开始，20 毫秒后结束
      vm->loop_interval_start = now;
      vm->loop_interval_end = now + 2e-4;
      vm->loops_this_reporting_interval = 0;
    }
  }
}

负责管理进程的调度、执行和暂停等。根据进程的状态和标志，它会判断是否继续执行进程，启动定时器等。执行完毕后，会更新性能计数器、事件日志以及进程的统计信息 dispatch_process：

static u64
dispatch_process(vlib_main_t *vm,
                 vlib_process_t *p, vlib_frame_t *f, u64 last_time_stamp)
{
  vlib_node_main_t *nm = &vm->node_main;
  vlib_node_runtime_t *node_runtime = &p->node_runtime;
  vlib_node_t *node = vlib_get_node(vm, node_runtime->node_index);
  u32 old_process_index;
  u64 t;
  uword n_vectors, is_suspend;

  // 检查节点状态和进程标志，判断是否可以继续执行
  if (node->state != VLIB_NODE_STATE_POLLING ||
      (p->flags & (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK |
                   VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT)))
    return last_time_stamp;

  // 设置进程标志，表示进程正在运行
  p->flags |= VLIB_PROCESS_IS_RUNNING;

  t = last_time_stamp;
  // 记录事件日志，表示节点即将执行
  vlib_elog_main_loop_event(vm, node_runtime->node_index, t,
                            f ? f->n_vectors : 0, /* is_after */ 0);

  // 保存当前进程索引，以便在之后恢复
  old_process_index = nm->current_process_index;
  nm->current_process_index = node->runtime_index;

  // 在进程启动之前更新性能计数器
  vlib_node_runtime_perf_counter(vm, node_runtime, f, 0, last_time_stamp,
                                 VLIB_NODE_RUNTIME_PERF_BEFORE);

  // 调用进程的启动函数，获取处理的向量数目
  n_vectors = vlib_process_startup(vm, p, f);

  // 恢复之前的进程索引
  nm->current_process_index = old_process_index;

  // 判断进程的处理结果，可能是继续运行、暂停等
  ASSERT(n_vectors != VLIB_PROCESS_RETURN_LONGJMP_RETURN);
  is_suspend = n_vectors == VLIB_PROCESS_RETURN_LONGJMP_SUSPEND;

  if (is_suspend) {
    // 进程被暂停，处理暂停逻辑
    vlib_pending_frame_t *pf;
    n_vectors = 0;

    // 从进程的暂停帧池中获取帧
    pool_get(nm->suspended_process_frames, pf);
    pf->node_runtime_index = node->runtime_index;
    pf->frame = f;
    pf->next_frame_index = ~0;

    p->n_suspends += 1;
    p->suspended_process_frame_index = pf - nm->suspended_process_frames;

    if (p->flags & VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK) {
      // 如果进程等待时钟，则启动定时器
      TWT(tw_timer_wheel) *tw = (TWT(tw_timer_wheel) *)nm->timing_wheel;
      p->stop_timer_handle =
        TW(tw_timer_start)(tw,
                           vlib_timing_wheel_data_set_suspended_process
                           (node->runtime_index) /* [sic] pool idex */,
                           0 /* timer_id */, p->resume_clock_interval);
    }
  } else {
    // 进程未被暂停，清除运行标志
    p->flags &= ~VLIB_PROCESS_IS_RUNNING;
  }

  t = clib_cpu_time_now();

  // 记录事件日志，表示节点执行结束
  vlib_elog_main_loop_event(vm, node_runtime->node_index, t, is_suspend,
                            /* is_after */ 1);

  // 更新节点运行时的性能计数器
  vlib_node_runtime_perf_counter(vm, node_runtime, f, n_vectors, t,
                                 VLIB_NODE_RUNTIME_PERF_AFTER);

  // 更新进程的统计信息
  vlib_process_update_stats(vm, p,
                            /* n_calls */ !is_suspend,
                            /* n_vectors */ n_vectors,
                            /* n_clocks */ t - last_time_stamp);

  return t;
}

通过调用 clib_setjmp 设置了一个返回点，然后通过条件判断选择不同的执行路径。如果返回值 r 是 VLIB_PROCESS_RETURN_LONGJMP_RETURN，说明进程还没有启动，那么会通过 vlib_process_start_switch_stack 切换到进程的新堆栈，然后调用 vlib_process_bootstrap 函数来执行进程的启动逻辑。如果 r 不是 VLIB_PROCESS_RETURN_LONGJMP_RETURN，说明进程已经启动过，此时会调用 vlib_process_finish_switch_stack 完成堆栈切换，然后返回 r。这样，通过 setjmp 和长跳转，进程可以在不同的堆栈上运行，实现了进程的启动与切换 vlib_process_startup：

/* 在主堆栈中调用。 */
static_always_inline uword
vlib_process_startup(vlib_main_t *vm, vlib_process_t *p, vlib_frame_t *f)
{
  vlib_process_bootstrap_args_t a;
  uword r;

  // 设置参数
  a.vm = vm;
  a.process = p;
  a.frame = f;

  // 使用 setjmp 保存上下文，以便进行长跳转
  r = clib_setjmp(&p->return_longjmp, VLIB_PROCESS_RETURN_LONGJMP_RETURN);
  
  if (r == VLIB_PROCESS_RETURN_LONGJMP_RETURN) {
    // 切换到进程的新堆栈，然后调用 vlib_process_bootstrap 函数
    vlib_process_start_switch_stack(vm, p);
    r = clib_calljmp(vlib_process_bootstrap, pointer_to_uword(&a),
                     (void *)p->stack + (1 << p->log2_n_stack_bytes));
  } else {
    // 完成堆栈切换
    vlib_process_finish_switch_stack(vm);
  }

  return r;
}

从参数 _a 中还原了一个结构体 vlib_process_bootstrap_args_t，其中包含了所需的参数。然后，获取了进程的主要信息，如 vm、p（进程对象）、f（帧对象）、node（进程节点运行时对象）。接着，通过调用 node->function 来执行进程的主要逻辑，返回值 n 将用于表示进程的执行结果。

在进程函数执行完成后，代码通过 vlib_process_stack_is_valid 确保进程的堆栈仍然是有效的。然后，通过调用 vlib_process_start_switch_stack 切换回主堆栈，并使用 clib_longjmp 进行长跳转，将执行结果 n 返回给调用者，也就是 vlib_process_startup 函数。

总之，这段代码负责在进程的堆栈上执行进程函数，然后将执行结果返回给调用者。这种跳转和切换堆栈的方式使得进程能够在独立的堆栈上运行，实现了并发执行 vlib_process_bootstrap：

/* 在进程堆栈中调用。 */
static uword
vlib_process_bootstrap(uword _a)
{
  vlib_process_bootstrap_args_t *a;
  vlib_main_t *vm;
  vlib_node_runtime_t *node;
  vlib_frame_t *f;
  vlib_process_t *p;
  uword n;

  // 从参数 _a 中还原参数结构体
  a = uword_to_pointer(_a, vlib_process_bootstrap_args_t *);

  // 获取参数
  vm = a->vm;
  p = a->process;

  // 完成堆栈切换
  vlib_process_finish_switch_stack(vm);

  f = a->frame;
  node = &p->node_runtime;

  // 调用进程函数并获取返回值
  n = node->function(vm, node, f);

  // 确保进程堆栈是有效的
  ASSERT(vlib_process_stack_is_valid(p));

  // 切换回主堆栈，使用 clib_longjmp 返回结果
  vlib_process_start_switch_stack(vm, 0);
  clib_longjmp(&p->return_longjmp, n);

  return n;
}

可以看到，这里就调用到了我们注册一个node之后，真正的处理函数，也就是我们新加node生效的地方。