【ceph】ceph通信 message的数据结构

网络通信的接口

在src/msg 的目录里，定义了网络模块的接口。
在源代码src/msg 里实现了ceph 的网络通信模块。在msg目录下，定义了网络通信的抽象接口。

msg/Message.cc
msg/Message.h    定义了message

msg/Connection.h  关于connection 的接口定义
msg/Dispatcher.h   关于Dispatcher

msg/Messenger.cc  定义了Messenger
msg/Messenger.h

msg/msg_types.cc   定义了消息的类型
msg/msg_types.h

message数据格式

通信的双方需要约定数据格式，这是很明显的。否则收到对方发送的数据，不知道如何解析。这应该是通信的首先要解决的问题。

Message 是所有消息的基类，任何要发送的消息，都要继承该类。对于消息，其发送格式如下：

header   +　user_data  +  footer

header是消息头，类似一个消息的信封(envelope)，保存消息的一些描述信息。user_data 是用于要发送的实际数据, footer是一个消息尾，保存了消息的效验信息和结束标志。

user_data

 payload  + middle  +　data

用户数据在Message里 有三部分组成： payload， 一般保存ceph操作的元数据；middle 预留，目前没有使用到；data 一般为读写的数据。

其对应的数据结构如下：

ceph_msg_header

struct ceph_msg_header {
	__le64 seq;       /* message seq# for this session */
	__le64 tid;       /* transaction id */
	__le16 type;      /* message type */
	__le16 priority;  /* priority.  higher value == higher priority */
	__le16 version;   /* version of message encoding */
 
	__le32 front_len; /* bytes in main payload */
	__le32 middle_len;/* bytes in middle payload */
	__le32 data_len;  /* bytes of data payload */
	__le16 data_off;  /* sender: include full offset;
			     receiver: mask against ~PAGE_MASK */
 
	struct ceph_entity_name src;
 
	/* oldest code we think can decode this.  unknown if zero. */
	__le16 compat_version;
	__le16 reserved;
	__le32 crc;       /* header crc32c */
} __attribute__ ((packed));

因为payload／middle／data大小一般是变长，因此，为了能正确地解析三者，header中纪录了三者的长度：

• front_len
• middle_len
• data_len

其中data _off含义我尚不明确，后面解决 ⚠️。

接下来看footer的数据结构：ceph_msg_footer

struct ceph_msg_footer {
	__le32 front_crc, middle_crc, data_crc;
	// sig holds the 64 bits of the digital signature for the message PLR
	__le64  sig;
	__u8 flags;
} __attribute__ ((packed));

在footer中会计算payload／middle／data的crc，填入front_crc middle_crc和data_crc

Message

class Message : public RefCountedObject {
protected:
  ceph_msg_header  header;      // headerelope
  ceph_msg_footer  footer;
  bufferlist       payload;  // "front" unaligned blob
  bufferlist       middle;   // "middle" unaligned blob
  bufferlist       data;     // data payload (page-alignment will be preserved where possible)
 
  ...
};

Connection

类Connection 就对应的一个链接，它是socket的port 对port 链接的封装。其最重要的接口，就是可以发送消息

 1 struct Connection : public RefCountedObject {
 2   mutable Mutex lock;    //锁包括 Connection的所有字段
 3   Messenger *msgr;     
 4   RefCountedObject *priv;  //私有数据
 5   int peer_type;             //链接的类型
 6   entity_addr_t peer_addr;    //对方的地址
 7   utime_t last_keepalive, last_keepalive_ack;  //最后一次发送keeplive的时间 和最后一次接受keepalive的时间
 8 private:
 9   uint64_t features;           //一些feature的标志位
10 public:
11   bool failed;       // true if we are a lossy connection that has failed.
12   int rx_buffers_version;  //接收缓存区的版本
13   map<ceph_tid_t,pair<bufferlist,int> > rx_buffers;  //接收缓冲区
14          ceph_tid --> (buffer, rx_buffers_version)
15 }

其最重要的功能，就是发送消息的接口

  virtual int send_message(Message *m) = 0;

Dispatcher

类Dispatcher 是接收消息的接口。 其接收消息的接口为：

1 virtual bool ms_dispatch(Message *m) = 0;
2 virtual void ms_fast_dispatch(Message *m);

无论是Server端，还是Client 端， 都需要实现一个Dispatcher 函数，对于Server 来接收请求，对应client 端，来接收ack应答。

Messenger

Messenger 是整个网络模块功能类的抽象。其定义了网络模块的基本功能接口。网络模块对外提供的基本的功能，就是能在节点之间发送消息。

向一个节点发送消息

virtual int send_message(Message *m, const entity_inst_t& dest) = 0;

注册一个，用来接收消息

void add_dispatcher_head(Dispatcher *d)

网络模块的使用

通过下面的最基本的服务器和客户端的程序的展示，了解如何调用网络通信来完成收发请求的功能。

Server 程序

其源代码在 test/simple_server.cc里，这里只展示有关网络部分的核心流程。

1.调用 Messenger的函数create 创建一个Messenger的实例，g_conf->ms_type为实现的类型，目前有三种方式，simple，async，xio.

1  messenger = Messenger::create(g_ceph_context, g_conf->ms_type,
2                   entity_name_t::MON(-1),
3                   "simple_server",
4                   0 /* nonce */);

2.设置 messenger 的属性

1 messenger->set_magic(MSG_MAGIC_TRACE_CTR);
2 messenger->set_default_policy(
3   Messenger::Policy::stateless_server(CEPH_FEATURES_ALL, 0));

3.对于 server，需要bind 服务端地址

r = messenger->bind(bind_addr);
if (r < 0)
     goto out;
common_init_finish(g_ceph_context);

4.创建一个Dispatcher，并添加到Messenger

dispatcher = new SimpleDispatcher(messenger);
messenger->add_dispatcher_head(dispatcher); 

5.启动messenger

messenger->start();
messenger->wait(); // can't be called until ready()

SimpleDispatcher 函数里实现了ms_dispatch，用于处理接收到的各种请求消息。

Client 程序分析

1.调用 Messenger的函数create 创建一个Messenger的实例

messenger = Messenger::create(g_ceph_context, g_conf->ms_type,
                          entity_name_t::MON(-1),
                          "client",
                           getpid());

messenger->set_magic(MSG_MAGIC_TRACE_CTR);
messenger->set_default_policy(Messenger::Policy::lossy_client(0, 0));

3.创建Dispatcher 类并添加，用于接收消息

dispatcher = new SimpleDispatcher(messenger);
messenger->add_dispatcher_head(dispatcher);
dispatcher->set_active(); // this side is the pinger

4.启动消息

r = messenger->start();
 if (r < 0)
    goto out;

5.下面开始发送请求，先获取目标server 的链接

1 conn = messenger->get_connection(dest_server);

6.通过Connection来发送请求消息。需要注意的是，这里的消息发送都是异步发送，请求的ack应对消息回来后在Dispatcher的 ms_dispatch或者ms_fast_dispatch里处理。

 1 Message *m;
 2 for (msg_ix = 0; msg_ix < n_msgs; ++msg_ix) {
 3   /* add a data payload if asked */
 4   if (! n_dsize) {
 5     m = new MPing();
 6   } else {
 7     m = new_simple_ping_with_data("simple_client", n_dsize);
 8   }
 9   conn->send_message(m);
10 }

Simple

（很老了，不研究了，最新ceph已经默认async）

Accepter

类Accepter 用来在server端监听，接受链接。其继承了Thread类，本身是一个线程，可以不断的监听server 的端口。

DispatchQueue

DispatchQueue 类用于把接收到的请求保存在内部， 通过其内部的线程，调用SimpleMessenger 类注册的 Dispatch 类的处理函数来处理相应的消息。

class DispatchQueue {
  ......
  mutable Mutex lock;
  Cond cond;
  class QueueItem {
    int type;
    ConnectionRef con;
MessageRef m;
......
  }；
  PrioritizedQueue<QueueItem, uint64_t> mqueue;    //基于优先级的 优先队列
  set<pair<double, Message*> > marrival;  
     集合 (recv_time, message) 
  map<Message *, set<pair<double, Message*> >::iterator> marrival_map;
    消息 到  所在集合位置的 映射
}；

其内部的mqueue 为优先级队列，用来保存消息， marriaval 保存了接收到的消息。marrival_map 保存消息在 集合中的位置。

函数DispatchQueue::enqueue 用来把接收到的消息添加到 队列中,函数DispatchQueue::entry 为线程的处理函数，用于调用用户注册的Dispatcher类相应的处理函数来处理消息 。

Pipe

类Pipe 是PipeConnection的具体实现类。其实现了两个端口之间类似管道的通信接口。

对于每一个pipe，内部有一个Reader线程 和 一个Writer 线程，分别用来处理有关这个Pipe的消息接收和发送。线程DelayedDelivery用于故障注入测试使用。

类Pipe的数据结构介绍如下：

 1 SimpleMessenger *msgr;   //   msgr的指针
 2 uint64_t conn_id;     //分配给Pipe 自己唯一的id
 3 char *recv_buf;         //接收缓存区
 4 int recv_max_prefetch;   //接收缓冲区一次预期的最大值
 5 int recv_ofs;            //接收的偏移量
 6 int recv_len;            //接收的长度
 7 int sd;               //pipe 对应的 socked fd
 8 struct iovec msgvec[IOV_MAX];   //发送消息的 iovec 结构
 9 int port;       //链接短裤
10 int peer_type;  //链接对方的类型
11 entity_addr_t peer_addr;  //对方地址
12 Messenger::Policy policy;   //策略
13 Mutex pipe_lock;
14 int state;            //当前链接的状态
15 atomic_t state_closed;    // non-zero iff state = STATE_CLOSED
16 PipeConnectionRef connection_state;   //PipeConnection 的引用
17 utime_t backoff;         // backoff time
18 bool reader_running, reader_needs_join;
19 bool reader_dispatching;    /// reader thread is dispatching without pipe_lock
20 bool notify_on_dispatch_done;   /// something wants a signal when dispatch done
21 bool writer_running;
22 map<int, list<Message*> > out_q;  // priority queue for outbound msgs
23    准备发送的消息 优先队列
24 DispatchQueue *in_q;   //接收消息的DispatchQueue
25 list<Message*> sent;   //要发送的消息
26 Cond cond;
27 bool send_keepalive;
28 bool send_keepalive_ack;
29 utime_t keepalive_ack_stamp;
30 bool halt_delivery;     //if a pipe's queue is destroyed, stop adding to it
31 __u32 connect_seq, peer_global_seq;
32 uint64_t out_seq;      发送消息的序列号 
33 uint64_t in_seq, in_seq_acked;  接收到消息序号和 应对的序号

消息的发送

1．当发送一个消息时，首先要通过Messenger类，获取对应的 Connection
  conn = messenger->get_connection(dest_server);

具体到 SimpleMessenger的实现：

首先比较，如果dest.addr 是my_inst.addr，就直接返回 local_connection
调用函数_lookup_pipe 在已经存在的Pipe中查找，如果找到，就直接返回pipe->connection_state，否则调用函数connect_rank 创建一个Pipe，并加入到msgr的register_pipe 里

2．当获得一个Connection之后，就可以调用 Connection 的 发送函数，发送消息
      conn->send_message(m);

其最终调用了SimpleMessenger::submit_message 函数

如果Pipe 不为空，并且状态不是Pipe::STATE_CLOSED 状态，调用函数pipe->_send 把发送的消息添加到out_q 发送队列里，触发发送线程
如果Pipe 为空，就调用connect_rank 创建Pipe，并把消息添加到out_q 中

3．发送线程writer把消息发送出去
通过步骤2，要发送的消息Messae已经保存在相应Pipe的out_q队列里。并触发了发送线程。每个Pipe的Writer 线程负责发送out_q 的消息，其线程入口函数为Pipe::writer, 实现功能：

调用函数_get_next_outgoing 从out_q 中获取消息
调用函数 write_message(header, footer, blist) 把消息的header，footer，数据blist 发送出去

消息的接收

1.接收消息,每个Pipe对应的线程 Reader 用于接收消息

  其入口函数为  Pipe::reader， 其功能如下：

       1)判断当前的state，如果为STATE_ACCEPTING， 就调用函数Pipe::accept 来接受连接，如果不是STATE_CLOSED，并且不是     STATE_CONNECTING 状态，就接收消息
       2)先调用函数tcp_read 来接收一个tag
       3)根据tag ，来接收不同类型的消息

1 CEPH_MSGR_TAG_KEEPALIVE 消
2 CEPH_MSGR_TAG_KEEPALIVE2， 在CEPH_MSGR_TAG_KEEPALIVE的基础上，添加了时间
3 CEPH_MSGR_TAG_KEEPALIVE2_ACK
4 CEPH_MSGR_TAG_ACK
5 CEPH_MSGR_TAG_MSG   这里才是接收的消息
6 CEPH_MSGR_TAG_CLOSE

2.调用函数read_message 来接收消息, 当本函数返回后，接完成了接收消息。

3.调用函数in_q->fast_preprocess(m) 预处理消息
4.调用函数in_q->can_fast_dispatch(m)，如果可以fast dispatch,  就in_q->fast_dispatch(m)处理。 特别注意的是，fast_dispatch 并不把消息加入到 mqueue里，而是直接调用msgr->ms_fast_dispatch 函数，并最终调用注册的fast_dispatcher 函数处理。
5.否则调用函数in_q->enqueue(m, m->get_priority(), conn_id) ， 本函数把接收到的消息加入到DispatchQueue的mqueue 队列里， 由DispatchQueue的线程调用ms_dispatch处理。

在这里，需要注意的是 ms_fast_dispath 和 ms_dispatch 两种处理的区别。ms_dispatch 是由DispatchQueue的线程处理的，它是一个单线程；ms_fast_dispatch的调用是由Pipe的接收线程直接处理的，因此性能比前者要好。

错误处理

网络模块，最重要的是如何处理网络错误。无论是在接收消息还是发送消息的过程中，都会出现各种异常错误，包括返回异常错误码，接收数据的magic验证不一致，接收的数据的效验验证不一致等等。 错误的原因主要是网络本身的错误（物理链路等），或者字节跳变引起的。

处理的方法比较简单：

• 关闭连接
• 重新建立连接
• 重新发送没有接受到ack应对的消息

函数 Pipe::fault 用来处理错误

1. 调用shutdown_socket 关闭Pipe 的socket
2. 调用函数requeue_sent  把没有收到ack的消息重新加入发送队列，当发送队列有请求时，发送线程会不断的尝试重新连接

原文：https://blog.csdn.net/changtao381/article/details/50915328
版权声明：本文为博主原创文章，转载请附上博文链接！