Open vSwitch之连接管理

连接管理模块是Open vSwitch中非常重要的模块，如果能够熟悉掌握其中的关联结构，对于开发Open vSwitch起到事半功倍的效果。写这篇博客是比较难写的，因为里面涉及层次比较多，生怕梳理不到位，反而误导大家。
Open vSwitch中虽然注释不多，但是它的层次结构非常好而且函数也非常短小。如果阅读过此套代码的人会有比较深入的感触。通过阅读代码可知道，在Open vSwitch中所有函数名、结构体名字定义在头文件中都是接口类，相应的定义到源文件中函数、结构体都是内部类，而且函数都是静态函数。这里需要澄清一下概念，此处提到类并非是C++中的类，而是广义的概念，也就是说Open vSwitch是采用面向对象思想，采用C语言实现的一套软件。
一、结构体
我们还是从结构体入手把，因为结构体是软件的灵魂和桥梁。只有将结构体分析透彻才能梳理出整个软件的架构层次。

外部流结构(外部接口)：

C

1 2 3 4 5 6 7 8 9 10 11

/* Active stream connection. 主动 流连接*/   /* Active stream connection. * * This structure should be treated as opaque by implementation. */ struct stream {      const struct stream_class * class ; /* 实际 流对象 */      int state ; /* 连接状态 取值为SCS_CONNECTING等枚举 */      int error ; /* 错误码 */      char * name ; /* 形式hostIP:port 例如name = "127.0.0.1:6653"  */ } ;

流对象（外部接口）:

C

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

struct stream_class {      /* Prefix for connection names, e.g. "tcp", "ssl", "unix". */      const char * name ;        /* True if this stream needs periodic probes to verify connectivity.  For      * streams which need probes, it can take a long time to notice the      * connection was dropped. */      bool needs_probes ;        /* Attempts to connect to a peer.  'name' is the full connection name      * provided by the user, e.g. "tcp:1.2.3.4".  This name is useful for error      * messages but must not be modified.      *      * 'suffix' is a copy of 'name' following the colon and may be modified.      * 'dscp' is the DSCP value that the new connection should use in the IP      * packets it sends.      *      * Returns 0 if successful, otherwise a positive errno value.  If      * successful, stores a pointer to the new connection in '*streamp'.      *      * The open function must not block waiting for a connection to complete.      * If the connection cannot be completed immediately, it should return      * EAGAIN (not EINPROGRESS, as returned by the connect system call) and      * continue the connection in the background. */      int ( * open ) ( const char * name , char * suffix , struct stream * * streamp ,                  uint8_t dscp ) ;        /* Closes 'stream' and frees associated memory. */      void ( * close ) ( struct stream * stream ) ;        /* Tries to complete the connection on 'stream'.  If 'stream''s connection      * is complete, returns 0 if the connection was successful or a positive      * errno value if it failed.  If the connection is still in progress,      * returns EAGAIN.      *      * The connect function must not block waiting for the connection to      * complete; instead, it should return EAGAIN immediately. */      int ( * connect ) ( struct stream * stream ) ;        /* Tries to receive up to 'n' bytes from 'stream' into 'buffer', and      * returns:      *      *     - If successful, the number of bytes received (between 1 and 'n').      *      *     - On error, a negative errno value.      *      *     - 0, if the connection has been closed in the normal fashion.      *      * The recv function will not be passed a zero 'n'.      *      * The recv function must not block waiting for data to arrive.  If no data      * have been received, it should return -EAGAIN immediately. */      ssize_t ( * recv ) ( struct stream * stream , void * buffer , size _t n ) ;        /* Tries to send up to 'n' bytes of 'buffer' on 'stream', and returns:      *      *     - If successful, the number of bytes sent (between 1 and 'n').      *      *     - On error, a negative errno value.      *      *     - Never returns 0.      *      * The send function will not be passed a zero 'n'.      *      * The send function must not block.  If no bytes can be immediately      * accepted for transmission, it should return -EAGAIN immediately. */      ssize_t ( * send ) ( struct stream * stream , const void * buffer , size _t n ) ;        /* Allows 'stream' to perform maintenance activities, such as flushing      * output buffers.      *      * May be null if 'stream' doesn't have anything to do here. */      void ( * run ) ( struct stream * stream ) ;        /* Arranges for the poll loop to wake up when 'stream' needs to perform      * maintenance activities.      *      * May be null if 'stream' doesn't have anything to do here. */      void ( * run_wait ) ( struct stream * stream ) ;        /* Arranges for the poll loop to wake up when 'stream' is ready to take an      * action of the given 'type'. */      void ( * wait ) ( struct stream * stream , enum stream_wait_type type ) ; } ;

内部流结构(内部管理接口)：

C

1 2 3 4 5 6 7

/* Active file descriptor stream. */ /* 主动接受连接                   */ struct stream_fd {      struct stream stream ; /* 流管理对象 */      int fd ; /* socket套接字描述符 */ } ;

从上面可知，前两个是对外接口 (定义在头文件中)，最后一个是内部接口，用于实际管理。其中第二个结构的成员机会都是函数指针，从面向对象的角度来说，这个结构对应着抽象类 (或者接口) ，主要目的是实现多态。三者是如何管理是如何关联起来的呢？ 是通过一个非常短的函数 new_fd_stream，如下所示：

C

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

/* Creates a new stream named 'name' that will send and receive data on 'fd' * and stores a pointer to the stream in '*streamp'.  Initial connection status * 'connect_status' is interpreted as described for stream_init(). * * Returns 0 if successful, otherwise a positive errno value.  (The current * implementation never fails.) * name = "127.0.0.1:6653" */ int new_fd_stream ( const char * name , int fd , int connect_status ,                struct stream * * streamp ) {      struct stream_fd * s ;        s = xmalloc ( sizeof * s ) ; /* 分配内部流管理 */      /* 关联stream_fd_class */      stream_init ( & s -> stream , & stream_fd_class , connect_status , name ) ;      s -> fd = fd ;      * streamp = & s -> stream ; /* 返回外部流对象 这点很重要 */      return 0 ; } /* Initializes 'stream' as a new stream named 'name', implemented via 'class'. * The initial connection status, supplied as 'connect_status', is interpreted * as follows: * *      - 0: 'stream' is connected.  Its 'send' and 'recv' functions may be *        called in the normal fashion. * *      - EAGAIN: 'stream' is trying to complete a connection.  Its 'connect' *        function should be called to complete the connection. * *      - Other positive errno values indicate that the connection failed with *        the specified error. * * After calling this function, stream_close() must be used to destroy * 'stream', otherwise resources will be leaked. * * The caller retains ownership of 'name'. */ void stream_init ( struct stream * stream , const struct stream_class * class ,              int connect_status , const char * name ) {      memset ( stream , 0 , sizeof * stream ) ;      stream -> class = class ;      stream -> state = ( connect_status == EAGAIN ? SCS_CONNECTING                      : ! connect _status ? SCS_CONNECTED                      : SCS_DISCONNECTED ) ;      stream -> error = connect_status ;      stream -> name = xstrdup ( name ) ;      ovs_assert ( stream -> state != SCS_CONNECTING || class -> connect ) ; }

针对上面两个函数需要说明三点：
1、stream_fd_class 是内部静态全局常量，类型是 stream_class。通过定义可知，内部函数指针实际指向的是流操作相关函数，例如： send，recv ，close等。换句话说，当进行真正的 socket数据传输过程中主要是通过下面的函数。函数指针 open为什么NULL?? 没有open函数怎么可能连接起来呢？？

C

1 2 3 4 5 6 7 8 9 10 11 12

static const struct stream_class stream_fd_class = {      "fd" ,                        /* name */      false ,                        /* needs_probes */      NULL ,                        /* open */      fd_close ,                    /* close */      fd_connect ,                  /* connect */      fd_recv ,                      /* recv */      fd_send ,                      /* send */      NULL ,                        /* run */      NULL ,                        /* run_wait */      fd_wait ,                      /* wait */ } ;

2、连接socket套接字保存在内部流管理fd中并非在外部流管理中。
3、函数返回并非是内部流管理而是外部流管理。当进行最底层数据处理时候，在转换成内部流管理，可以参考一下fd_send函数。

这个在介绍一个全局stream管理结构，用面向对象思想这个结构体是抽象类(接口)的实现。此结构体是也静态局部常量，主要用于连接方式管理，例如tcp连接，unix连接，ssl方式连接，甚至跨平台window方式连接。

C

1 2 3 4 5 6 7 8 9 10 11

static const struct stream_class * stream_classes [ ] = {      & tcp_stream_class , #ifndef _WIN32      & unix_stream_class , /* unix域 相同主机不同进程间通信 */ #else      & windows_stream_class , #endif #ifdef HAVE_OPENSSL      & ssl_stream_class , #endif } ;

这里我们在讲tcp_stream_class展开看一下内部结构：

C

1 2 3 4 5 6 7 8 9 10 11 12

const struct stream_class tcp_stream_class = {      "tcp" ,                        /* name */      true ,                        /* needs_probes */      tcp_open ,                    /* open */      NULL ,                        /* close */      NULL ,                        /* connect */      NULL ,                        /* recv */      NULL ,                        /* send */      NULL ,                        /* run */      NULL ,                        /* run_wait */      NULL ,                        /* wait */ } ;

当我看到tcp_stream_class定义的时候，也是很奇怪，为什么tcp_stream_class只定义了open，定义没有其他函数呢？？
但是当tcp_stream_class和stream_fd_class整合到一起，除了run和run_wait外其他函数指针都定义了，貌似这两者存在着某种关联？？我只能深入梳理代码，去验证我的猜测。

二、连接创建
上面数据结构主要是用于Open vSwitch交换机与控制器连接(Socket连接)，下面我们来分析一下，Open vSwitch是如何一步一步与控制器建立起来的socket连接。

下图是我通过Source Insight截取出来的函数调用关系。函数层次比较深入，有些地方讲解可能不够深入或者层次不清晰，因此对于这部读者需要自己深入看一下代码加深理解。

第一部分讲解是Open vSwitch中最底层socket连接管理层次，对于上层应用来说这个层次是不可见的。也就是说Open vSwitch不是直接操作stream类的，而是通过ofconn管理，或者在深一层是通过vconn管理。下面是函数流程图，针对此流程图有两点说明：
1）红色线代表返回上层函数，蓝色线表示回到最顶层函数。
2）由于函数层次较深，图中会有向右走向的函数，纯粹是为了节省篇幅

对于SDN 来说，理论上一个控制器可以管理多个交换机，一个交换机也可以被多个控制器管理。因此Open vSwitch在启动过程中，根据配置会主动连接每个控制器。

ofproto_set_controllers à add_controller 创建rconn 和ofcon，并且将 rconn挂在ofconn 中 à rconn_connect àreconnect à vconn_open 这个函数中会根据连接类型 (tcp连接，unix 连接等)在抽象类 vconn_classes中查找对应的实例。找到实例之后调用对应的 open函数，开始创建socket以及出事 tream流对象等一系列动作，最后返回到函数 connmgr_set_controller判断是否还有其他的控制器需要连接，如果有则再次执行此流程，如果没有则结束。

上面的流程比较复杂，需要我们认真去看一下代码，此处只是起到“抛砖引玉”的效果。最后展示一下数据结构关系图：

在ovs数据结构中，有很多这样的数据结构，比如说有结构 A，B ，结构B包含在结构 A中，对外使用的是结构B。类似代码中 struct vconn_stream，struct vconn 对外使用的是 struct vconn。至于ovs 为什么要这样设计的原因，我不是很清楚，只能猜测是为了封装和抽象。

• 声明：本文来自 SDNLAB