zebra 的Thread机制

最新推荐文章于 2022-08-01 23:40:48 发布
最新推荐文章于 2022-08-01 23:40:48 发布
阅读量638 收藏
点赞数
分类专栏： Zebra分析

1．thread的四种创建方法

一个新的thread可以通过如下三种方式被创建，主要是看你需要创建的thread的类型：

1， thread_add_read：添加一个thread到read queue，该thread负责通过socket接受和读取从client端来的数据。

2， thread_add_write：添加一个thread到write queue，该thread负责通过socket向client端填充和写数据。

3， thread_add_timer functioncalls：添加一个thread到timer queue,该thread负责定时一个event，例如update和redistribute一个route table.

4， thread_add_event：添加一个event thread到event queue。

上面这三个函数的处理过程都差不多：

1，创建thread。首先在unuse queue查找，如果有unuse thread，就使用它，否则重新分配空间。

2，根据参数，对thread进行赋值。

3，将该thread加入到相应的queue中。

2． thread的调用

1，bgp daemon不断地从event queue中取出thread并且执行它。一旦该thread被执行了，将该thread的type设置为unuse。并且将该thread添加到unuse queue中。

2，如果event queue为空时，bgp daemon 通过select函数监控读、写、异常三个描述符集。一旦有某个描述符准备就绪，则将该描述符所对应的thread加入ready queue.

而对于timer queue中的thread，只有当select函数超时后才会进入ready queue.

3．zebrad端的thread

zebrad启动后会，在read queue中会出现两个thread，一个是等待来自local client端bgpd的连接，另一个是等待来自vty client端的连接。

第1个thread

zebra_init ( )-> zebra_serv_un ( )中创建一个thread，加入read queue。该thread的处理函数为zebra_accept，监听内部client的socket。

zebra_client_create (client_sock);创建一个新的zebra client

/* Register myself. */

zebra_event (ZEBRA_SERV, accept_sock, NULL);继续监听server socket

puts("<-zebra_accept");

return 0;

}

vty_accept，加入read queue。作为vty server监听internet的vty socket.。

vty_create(vty_sock, &su);

根据vty_sock和ip地址信息su，创建一个新的vty。

puts("<-vty_accept");

return 0;

}

vty_flush。

vty_event (VTY_READ, vty_sock, vty);

根据new client vty的vty_sock创建新的VTY_READthread，加入read queue，该thread的处理函数为vty_read。

return vty;

}

sockunion_bind(accept_sock, &su, port,NULL);

将accept_socket文件描述符与一个特定的逻辑网络连系起来。服务器端使用su->sin.sin_addr.s_addr = htonl (INADDR_ANY);表示接受任何一个主机网络接口上的连接请求。

if (ret < 0)

{

close (accept_sock); /* Avoid sd leak. */

return;

}

/* Listen socket under queue 3. */

ret = listen (accept_sock, 3);

将accept_sock套接口设置成被动监听状态，用于接受连接，只能在服务器端使用。

if (ret < 0)

{

zlog (NULL, LOG_WARNING, "can't listen socket");

close (accept_sock); /* Avoid sd leak. */

return;

}

/* Add vty server event. */

vty_event(VTY_SERV, accept_sock, NULL);

}

sockunion_bind操作

/* Bind socket to specified address. */

intsockunion_bind (int sock,union sockunion *su, unsigned short port,

union sockunion *su_addr)

{

int size = 0;

int ret;

if (su->sa.sa_family == AF_INET)

{

size = sizeof (struct sockaddr_in);

su->sin.sin_port = htons (port);

#ifdef HAVE_SIN_LEN

su->sin.sin_len = size;

#endif /* HAVE_SIN_LEN */

if (su_addr == NULL)

su->sin.sin_addr.s_addr = htonl (INADDR_ANY);

服务器一般将sin_addr.s_addr 字段设置为INADDR_ANY表示套接字应接收任何一个主机网络接口上的连接请求。

客户端将sin_addr.s_addr字段设置为服务器主机的IP地址。

}

#ifdef HAVE_IPV6

else if (su->sa.sa_family == AF_INET6)

{

size = sizeof (struct sockaddr_in6);

su->sin6.sin6_port = htons (port);

#ifdef SIN6_LEN

su->sin6.sin6_len = size;

#endif /* SIN6_LEN */

if (su_addr == NULL)

{

#if defined(LINUX_IPV6) || defined(NRL)

bzero (&su->sin6.sin6_addr, sizeof (struct in6_addr));

#else

su->sin6.sin6_addr = in6addr_any;

#endif /* LINUX_IPV6 */

}

}

#endif /* HAVE_IPV6 */

ret = bind (sock, (struct sockaddr *)su, size);

if (ret < 0)

zlog (NULL, LOG_WARNING, "can't bind socket : %s",strerror (errno));

return ret;

}

vty_event操作

/* struct thread_master *master; */

static voidvty_event (enum eventevent, int sock, struct vty *vty)

{

struct thread *vty_serv_thread;

switch (event)

{

case VTY_SERV:

vty_serv_thread = thread_add_read (master, vty_accept, vty,sock);

vector_set_index (Vvty_serv_thread, sock, vty_serv_thread);

break;

case VTY_READ:

vty->t_read = thread_add_read (master, vty_read, vty,sock);

/* Time out treatment. */

if (vty->v_timeout)

{

if (vty->t_timeout)

thread_cancel (vty->t_timeout);

vty->t_timeout =

thread_add_timer (master, vty_timeout, vty,vty->v_timeout);

}

break;

case VTY_WRITE:

if (! vty->t_write)

vty->t_write = thread_add_write (master, vty_flush, vty,sock);

break;

case VTY_TIMEOUT_RESET:

if (vty->t_timeout)

{

thread_cancel (vty->t_timeout);

vty->t_timeout = NULL;

}

if (vty->v_timeout)

{

vty->t_timeout =

thread_add_timer (master, vty_timeout, vty,vty->v_timeout);

}

break;

}

}

第2 个thread

bgp_serv_sock( )-> bgp_serv_sock_family( )中创建一个thread，不是通过event的方式添加的。该thread的处理函数为bgp_accept。作为bgp_server，接受来自 internet上的bgp连接。

bgp_serv_sock_family操作

port = 179 family = AF_INET

/* Make bgpd's server socket. */

voidbgp_serv_sock_family(unsigned short port, int family)

{

int ret;

int bgp_sock;

union sockunion su;

bzero (&su, sizeof (union sockunion));

/* Specify address family. */

su.sa.sa_family = family;

bgp_sock = sockunion_stream_socket (&su); 产生一个BGP socket

sockopt_reuseaddr (bgp_sock);

sockopt_reuseport (bgp_sock);

ret = sockunion_bind (bgp_sock, &su, port, NULL);

ret = listen (bgp_sock, 3);

if (ret < 0)

{

zlog (NULL, LOG_INFO, "Can't listen bgp server socket :%s",

strerror (errno));

return;

}

thread_add_read (master, bgp_accept, NULL, bgp_sock); 添加一个thread 到readlist中。

}

VTY server和BGP server 在使用accept操作的方法如下：

他们均是通过创建一个THREAD_READ 类型的thread，加到Master的readlist的队列后面，thread 的处理函数会执行accept操作。

VTY accept：

vty_serv_thread = thread_add_read (master, vty_accept, vty,sock);

BGP server accept:

thread_add_read (master, bgp_accept, NULL, bgp_sock);

bgpd和zebrad间通信

bgp和zebra是通过zebra message进行通信，格式如下：

报文头3字节（前两字节length，后1字节为command type）

报文体长度不定。

/* Zebra message types. */

#define ZEBRA_INTERFACE_ADD 1

#define ZEBRA_INTERFACE_DELETE 2

#define ZEBRA_INTERFACE_ADDRESS_ADD 3

#define ZEBRA_INTERFACE_ADDRESS_DELETE 4

#define ZEBRA_INTERFACE_UP 5

#define ZEBRA_INTERFACE_DOWN 6

#define ZEBRA_IPV4_ROUTE_ADD 7

#define ZEBRA_IPV4_ROUTE_DELETE 8

#define ZEBRA_IPV6_ROUTE_ADD 9

#define ZEBRA_IPV6_ROUTE_DELETE 10

#define ZEBRA_REDISTRIBUTE_ADD 11

#define ZEBRA_REDISTRIBUTE_DELETE 12

#define ZEBRA_REDISTRIBUTE_DEFAULT_ADD 13

#define ZEBRA_REDISTRIBUTE_DEFAULT_DELETE 14

#define ZEBRA_IPV4_NEXTHOP_LOOKUP 15

#define ZEBRA_IPV6_NEXTHOP_LOOKUP 16

bgpd和zebrad之间的api接口

bgp端接受到message后，会执行相应的bgp action:

bgp action func message type

int (*interface_add) (int, struct zclient *, zebra_size_t);ZEBRA_INTERFACE_ADD

int (*interface_delete) (int, struct zclient *, zebra_size_t);ZEBRA_INTERFACE_DELETE

int (*interface_up) (int, struct zclient *, zebra_size_t);ZEBRA_INTERFACE_UP

int (*interface_down) (int, struct zclient *, zebra_size_t);ZEBRA_INTERFACE_DOWN

int (*interface_address_add) (int, struct zclient *,zebra_size_t); ZEBRA_INTERFACE_ADDRESS_ADD

int (*interface_address_delete) (int, struct zclient *,zebra_size_t); ZEBRA_INTERFACE_ADDRESS_DELETE

int (*ipv4_route_add) (int, struct zclient *, zebra_size_t);ZEBRA_IPV4_ROUTE_ADD

int (*ipv4_route_delete) (int, struct zclient *,zebra_size_t); ZEBRA_IPV4_ROUTE_DELETE

int (*ipv6_route_add) (int, struct zclient *, zebra_size_t);ZEBRA_IPV6_ROUTE_ADD

int (*ipv6_route_delete) (int, struct zclient *,zebra_size_t); ZEBRA_IPV6_ROUTE_DELETE

zebra 端接受到message后，会执行相应的zebra action:

zebra action func message type

void zread_interface_add (struct zserv *client, u_shortlength) ZEBRA_INTERFACE_ADD

void zread_interface_delete (struct zserv *client, u_shortlength) ZEBRA_INTERFACE_DELETE

void zread_ipv4_add (struct zserv *client, u_short length)ZEBRA_IPV4_ROUTE_ADD

void zread_ipv4_delete (struct zserv *client, u_short length)ZEBRA_IPV4_ROUTE_DELETE

void zread_ipv6_add (struct zserv *client, u_short length)ZEBRA_IPV6_ROUTE_ADD

void zread_ipv6_delete (struct zserv *client, u_short length)ZEBRA_IPV6_ROUTE_DELETE

void zebra_redistribute_add (int command, struct zserv*client, int length) ZEBRA_REDISTRIBUTE_ADD

void zebra_redistribute_delete (int command, struct zserv*client, int length) ZEBRA_REDISTRIBUTE_DELETE

voidzebra_redistribute_default_add (int command,

struct zserv *client, int length)ZEBRA_REDISTRIBUTE_DEFAULT_ADD

void zebra_redistribute_default_delete (int command,

struct zserv *client, int length)ZEBRA_REDISTRIBUTE_DEFAULT_DELETE

void zread_ipv4_nexthop_lookup (struct zserv *client, u_shortlength) ZEBRA_IPV4_NEXTHOP_LOOKUP

void zread_ipv6_nexthop_lookup (struct zserv *client, u_shortlength) ZEBRA_IPV6_NEXTHOP_LOOKUP

bgp action：将local_client_socket中数据，写入bgp数据库。

zebra action：将zebra数据库中的信息写入local_server_subsocket，让local client端进行读取。

bgp peer间通信

bgp_accept操作

/* Accept bgp connection. */

int bgp_accept (struct thread *thread)

{

int bgp_sock;

int accept_sock;

union sockunion su;

struct peer *peer;

struct peer *peer1;

char buf[SU_ADDRSTRLEN];

/* Regiser accept thread. */

accept_sock = THREAD_FD (thread);

printf("->bgp_accept [%d]\n",accept_sock);

thread_add_read (master, bgp_accept, NULL, accept_sock);

/* Accept client connection. */

bgp_sock = sockunion_accept (accept_sock, &su);

if (bgp_sock < 0)

{

zlog_err ("[Error] BGP socket accept failed (%s)",strerror (errno));

printf("[Error] BGP socket accept failed (%s)",strerror (errno));

puts("<-bgp_accept 2");

return -1;

}

if (BGP_DEBUG (events, EVENTS))

zlog_info ("[Event] BGP connection from host %s",inet_sutop (&su, buf));

printf("[Event] BGP connection from host %s",inet_sutop (&su, buf));

/* Check remote IP address */

peer1 = peer_lookup_by_su (&su);

if (! peer1 || peer1->status == Idle)

{

if (BGP_DEBUG (events, EVENTS))

{

if (! peer1)

zlog_info ("[Event] BGP connection IP address %s is notconfigured",

inet_sutop (&su, buf));

else

zlog_info ("[Event] BGP connection IP address %s is Idlestate",

inet_sutop (&su, buf));

}

close (bgp_sock);

puts("<-bgp_accept 2");

return -1;

}

/* Make dummy peer until read Open packet. */

if (BGP_DEBUG (events, EVENTS))

zlog_info ("[Event] Make dummy peer structure until readOpen packet");

printf("[Event] Make dummy peer structure until readOpen packet\n");

{

char buf[SU_ADDRSTRLEN + 1];

peer = peer_create_accept ();

SET_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER);

peer->su = su;

peer->fd = bgp_sock;

peer->status = Active;

/* Make peer's address string. */

sockunion2str (&su, buf, SU_ADDRSTRLEN);

peer->host = strdup (buf);

}

BGP_EVENT_ADD (peer, TCP_connection_open); 创建一个event thread执行bgp_event函数

puts("<-bgp_accept 0");

return 0;

}

bgp_event操作

/* Execute event process. */

int bgp_event (struct thread *thread)

{

int ret;

int event;

int next;

struct peer *peer;

peer = THREAD_ARG (thread); // get peer

event = THREAD_VAL (thread); // get FSM eventeg.TCP_connection_open

puts("->bgp_event");

/* Logging this event. */

next = FSM [peer->status -1][event - 1].next_state; next为下一个状态

if (BGP_DEBUG (fsm, FSM))

plog_info (peer->log, "%s [FSM] %s (%s->%s)",peer->host,

bgp_event_str[event],

LOOKUP (bgp_status_msg, peer->status),

LOOKUP (bgp_status_msg, next));

printf("%s [FSM] %s (%s->%s)", peer->host,

bgp_event_str[event],

LOOKUP (bgp_status_msg, peer->status),

LOOKUP (bgp_status_msg, next));

/* Call function. */

ret = (*(FSM [peer->status - 1][event - 1].func))(peer); 执行本状态处理函数

/* When function do not want proceed next job return -1. */

if (ret < 0)

{

puts("<-bgp_event 1");

return ret;

}

/* If status is changed. */

if (next != peer->status) 判断状态是否需要转变

fsm_change_status (peer, next);

/* Make sure timer is set. */

bgp_timer_set (peer);

puts("<-bgp_event 0");

return 0;

}

 

路由Zebra 之socket通信机制
森海的博客
03-27 1587
1 socket通信过程 1.1 socket接收端流程 图1  socket server端函数关系   图2  socket server端通信流程图 Socketserver端的数据处理是由main函数的vty_server_sock()函数实现的， （1）先建立一个AF_UNIX类型的套接字socket1，然后绑定套接字，监听该套接字。 （2）zebra通过threa
keepalived源码解析 —— vrrp_dispatcher_read_timeout
傲然君
02-12 1236
当 vrrp socket 发生 读超时时，会调用函数：vrrp_dispatcher_read_timeout()。 1、依据当前 master/back 状态，进行处理。若 back 发生读超时，则尝试将本端 vrrp 切换到 master； /* Handle dispatcher read timeout */ static int vrrp_dispatcher_read_timeout...
quagga线程机制概述
timebomb的专栏
02-20 8286
从别地转过来的，感觉挺有帮助，对自己理解系统进程线程的调用很好 原文地址：点击打开链接 A) quagga线程机制概述 quagga中的线程是分队列调度的，每个队列以一个链表的方式实现。线程队列可以分成5个队列：event、timer、ready、read、write。队列的优先级由高到低排列。但是，read和write队列并不参与到优先级的排列中，实际操作时，如果rea
zebra 的Thread机制 -- 003
~~ LINUX ~~
08-21 2617
========================================================== 一、线程机制概述 zebra这个软件包整体结构大致可分为两大块：协议模块和守护进程模块。协议模块实现各协议的功能，各协议以子模块的形式加载到zebra中；守护进程模块的功能主要是管理各协议的信令传输、表项操作、系统操作调用等事务，为各协议提供底层信息以及相关的硬件处理等功能支持...
zebra关于线程管理的相关函数的简要功能介绍
IT小小鸟
09-03 1487
下面给出了zebra关于线程管理的相关函数的简要功能介绍。 1.1.1 thread_master_create () 为创建一个新的thread_master结构体动态开辟一块内存空间。 1.1.2 thread_list_add () 在list双向链表尾部插入一个新的thread。 1.1.3 thread_list_add_before () 在函数参数point所指向的thr
Linux下中断处理程序源码分析
敏于思，慎于行
11-29 2185
下面是最近调试中断时额外研习了一下Linux的内核代码，下面就直接贴代码和注释了，大量借鉴了网上牛人的见解，还望海涵！！   int main (int argc, char **argv)    {      char *p;      int daemon_mode = 0;      char *progname;      struct th
内核定时器的使用
iczyh的专栏
11-08 4135
概要内核定时器是内核用来控制在未来某个时间点（基于jiffies）调度执行某个函数的一种机制，其实现位于 和 kernel/timer.c 文件中。被调度的函数肯定是异步执行的，它类似于一种“软件中断”，而且是处于非进程的上下文中，所以调度函数必须遵守以下规则：1) 没有 current 指针、不允许访问用户空间。因为没有进程上下文，相关代码和被中断的进程没有任何联系。2) 不能执行休眠（或可能
Zebra框架的线程调度机制详解
"Zebra框架的线程执行机制与应用" Zebra是一个开源的路由软件包，遵循GNU标准，提供多种路由协议服务，如RIPv1、RIPv2、RIPng、OSPFv2、OSPFv3、BGP-4、BGP-4+、ISIS等。它不仅涵盖IPv4协议，还支持IPv6。Zebra最新...
深入解析zebra的tread_master机制
"tread_master机制在zebra中的应用与实现" 在计算机网络和操作系统领域，线程（Thread）是程序执行的基本单元。在zebra软件中，`tread_master`机制是一个关键的设计，用于高效地管理和调度不同类型的线程，以处理...
对 zebra 的一点理解 thread+socket+read部分 (备忘)
atefrice的专栏
08-18 5613
一、主要从 socket 通信角度 及thread 分析备忘(daemonvtysh)。 1、每个daemon(e.g igmp-snooping、ring)都定义一个 master 的 全局变量； 2、master 内 有六个 struct thread_list *read、write 等六个 链表； 3、最小的 执行单元为 thread ， 必要的时候会 挂在 对应的 thread_l
Zebra框架详解：模块交互与线程机制
每个使用Zebra线程机制的任务都会有一个`thread_master`变量，它维护了不同类型的线程链表，如读取（READ）、写入（WRITE）等。任务会根据预设的优先级遍历这些链表，调度相应的线程执行。例如，当需要处理套接字读...
内核定时器的使用(好几个例子add_timer)【转】
weixin_34293902的博客
01-25 196
转自：http://blog.youkuaiyun.com/jidonghui/article/details/7449546   LINUX内核定时器是内核用来控制在未来某个时间点（基于jiffies）调度执行某个函数的一种机制，其实现位于 &lt;linux/timer.h&gt; 和 kernel/timer.c 文件中。被调度的函数肯定是异步执行的，它类似于一种“软件中断”，而且是处于非进程的...
Zebra资源
hanyingzhong的专栏
11-19 2391
http://blog.sina.com.cn/s/blog_87bbe37e01015nly.html
基于Linux系统的边界网关协议的设计与实现
lingdongdeshui的专栏
04-09 323
基于Linux系统的边界网关协议的设计与实现 3.6 BGP和RMer系统间通信 RMer系统和BGP系统之间采用的是UNIX本地的服务器客户端模式进行通信，它们创建的socket的地址格式为AF_UNIX，表示用于UNIX本地的通信。RMer系统与BGP系统之间的通信原理如图3-9所示，因为它们之间使用的是本地客户端和服务器模式进行通信，故称RMer系统为local server端，BG...
嵌入式Qt-做一个秒表
码农爱学习的博客
08-01 2217
本篇通过一个秒表的实例，介绍了如何使用Qt Creator的UI界面设计功能，进行Qt的开发，并将代码进行交叉编译，放入i.MX6ULL的Linux环境中测试运行情况。
内核定时机制API之add_timer
jason的笔记
02-09 4966
void add_timer(struct timer_list *timer)用于开始一个定时器。 这个函数在内核中用的实在是太多了。 其源码分析如下： void add_timer(struct timer_list *timer) { BUG_ON(timer_pending(timer)); mod_timer(timer, timer->expires); } 首先通过timer_p
内核定时器的使用(好几个例子add_timer)
热门推荐
jidonghui的专栏
04-11 2万+
LINUX内核定时器是内核用来控制在未来某个时间点（基于jiffies）调度执行某个函数的一种机制，其实现位于 和 kernel/timer.c 文件中。被调度的函数肯定是异步执行的，它类似于一种“软件中断”，而且是处于非进程的上下文中，所以调度函数必须遵守以下规则： 1) 没有 current 指针、不允许访问用户空间。因为没有进程上下文，相关代码和被中断的进程没有任何联系。 2)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值