OSDService是否共享osdmap

最新推荐文章于 2023-08-28 14:41:57 发布
最新推荐文章于 2023-08-28 14:41:57 发布
阅读量1.5k 收藏
点赞数
分类专栏： ceph 文章标签： OSDService
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/litianze99/article/details/76043401
版权

OSDService比对当前所持有的osdmap版本与请求所携带的osdmap版本，如果请求携带的osdmap版本低则与请求端共享新的osdmap。

1.是否与请求端共享osdmap
//与请求端对比是否需要共享osdmap，如需要则，共享服务端的osdmap与请求端。
void OSD::maybe_share_map(
  Session *session,
  OpRequestRef op,
  OSDMapRef osdmap)
{
  if (!op->check_send_map) {
  ¦ return;
  }                                                                                                                                                                                          
  epoch_t last_sent_epoch = 0;

  session->sent_epoch_lock.lock();
  last_sent_epoch = session->last_sent_epoch;
  session->sent_epoch_lock.unlock();

  const Message *m = op->get_req();
  service.share_map(
  ¦ m->get_source(),
  ¦ m->get_connection().get(),
  ¦ op->sent_epoch,
  ¦ osdmap,
  ¦ session ? &last_sent_epoch : NULL);

  session->sent_epoch_lock.lock();
  if (session->last_sent_epoch < last_sent_epoch) {
  ¦ session->last_sent_epoch = last_sent_epoch;
  }
  session->sent_epoch_lock.unlock();

  op->check_send_map = false;
}
2.共享osdmap
//将服务端的osdmap与请求端共享（将所持有的最新osdmap，发送给请求端）。
void OSDService::share_map(                                                                                                                                       
  ¦ entity_name_t name,                                                                                                                                           
  ¦ Connection *con,                                                                                                                                              
  ¦ epoch_t epoch,                                                                                                                                                
  ¦ OSDMapRef& osdmap,                                                                                                                                            
  ¦ epoch_t *sent_epoch_p)                                                                                                                                        
{                                                                                                                                                                 
  dout(20) << "share_map "                                                                                                                                        
         ¦ << name << " " << con->get_peer_addr()                                                                                                                 
         ¦ << " " << epoch << dendl;                                                                                                                              

  if (!osd->is_active()) {                                                                                                                                        
  ¦ /*It is safe not to proceed as OSD is not in healthy state*/                                                                                                  
  ¦ return;                                                                                                                                                       
  }                                                                                                                                                                                          
  //判断是否需要分享osdmap                                                                                                                                                                
  bool want_shared = should_share_map(name, con, epoch,                                                                                                           
  ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦                 osdmap, sent_epoch_p);                                                                                                      

  if (want_shared){  
//如果请求端是client，则更新与其相关的session中的epoch，并发送给请求端。  
  ¦ if (name.is_client()) {                                                                                                                                       
  ¦ ¦ dout(10) << name << " has old map " << epoch                                                                                                                
  ¦ ¦ ¦ ¦ << " < " << osdmap->get_epoch() << dendl;                                                                                                               
  ¦ ¦ // we know the Session is valid or we wouldn't be sending                                                                                                   
  ¦ ¦ if (sent_epoch_p) {                                                                                                                                         
        *sent_epoch_p = osdmap->get_epoch();                                                                                                                      
  ¦ ¦ }                                                                                                                                                           
  ¦ ¦ send_incremental_map(epoch, con, osdmap);                                                                                                                   
  ¦ } else if (con->get_messenger() == osd->cluster_messenger &&                                                                                                  
  ¦ ¦ ¦ osdmap->is_up(name.num()) &&                                                                                                                              
  ¦ ¦ ¦ (osdmap->get_cluster_addr(name.num()) == con->get_peer_addr() ||                                                                                          
  ¦ ¦ ¦ ¦ ¦ osdmap->get_hb_back_addr(name.num()) == con->get_peer_addr())) {                                                                                      
  ¦ ¦ dout(10) << name << " " << con->get_peer_addr()                                                                                                             
         ¦ ¦ ¦ ¦ ¦ ¦ ¦ << " has old map " << epoch << " < "                                                                                                       
         ¦ ¦ ¦ ¦ ¦ ¦ ¦ << osdmap->get_epoch() << dendl;
//如果请求端是peer，则记录该peer与epoch的映射，并把所持有的最新的osdmap发送给peer。       
  ¦ ¦ note_peer_epoch(name.num(), osdmap->get_epoch());                                                                                                           
  ¦ ¦ send_incremental_map(epoch, con, osdmap);                                                                                                                   
  ¦ }                                                                                                                                                             
  }
3.判断是否共享osdmap
//判断是否要与请求端共享当前的osdmap，需要就返回true，否则就返回false，
bool OSDService::should_share_map(entity_name_t name, Connection *con,
  ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦             epoch_t epoch, const OSDMapRef& osdmap,
  ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦             const epoch_t *sent_epoch_p)
{
  dout(20) << "should_share_map "
  ¦ ¦ ¦ ¦ ¦<< name << " " << con->get_peer_addr()
  ¦ ¦ ¦ ¦ ¦<< " " << epoch << dendl;
//请求端可能是client和peer，如果是client这op中的osdmap的epoch小于服务端的PG osdmap则返回true。
  // does client have old map?
  if (name.is_client()) {
  ¦ bool message_sendmap = epoch < osdmap->get_epoch();
  ¦ if (message_sendmap && sent_epoch_p) {
  ¦ ¦ dout(20) << "client session last_sent_epoch: "
  ¦ ¦ ¦ ¦ ¦ ¦ ¦<< *sent_epoch_p
  ¦ ¦ ¦ ¦ ¦ ¦ ¦<< " versus osdmap epoch " << osdmap->get_epoch() << dendl;
  ¦ ¦ if (*sent_epoch_p < osdmap->get_epoch()) {
  ¦ ¦ ¦ return true;
  ¦ ¦ } // else we don't need to send it out again
  ¦ }
  }
//请求时peer，如果pg osdmap中的epoch大于session中和op中携带的epoch，则返回true。
  if (con->get_messenger() == osd->cluster_messenger &&
  ¦ ¦ con != osd->cluster_messenger->get_loopback_connection() &&
  ¦ ¦ osdmap->is_up(name.num()) &&
  ¦ ¦ (osdmap->get_cluster_addr(name.num()) == con->get_peer_addr() ||
  ¦ ¦ ¦osdmap->get_hb_back_addr(name.num()) == con->get_peer_addr())) {
  ¦ // remember
  ¦ epoch_t has = MAX(get_peer_epoch(name.num()), epoch);

  ¦ // share?
  ¦ if (has < osdmap->get_epoch()) {
  ¦ ¦ dout(10) << name << " " << con->get_peer_addr()
  ¦ ¦ ¦ ¦ ¦ ¦ ¦<< " has old map " << epoch << " < "
  ¦ ¦ ¦ ¦ ¦ ¦ ¦<< osdmap->get_epoch() << dendl;
  ¦ ¦ return true;
  ¦ }
  }

  return false;
}
4.记录peer epoch映射
//在osd内部维护peer_map_epoch，记录peer与osdmap epoch映射。
epoch_t OSDService::note_peer_epoch(int peer, epoch_t e)
{
  Mutex::Locker l(peer_map_epoch_lock);
  map<int,epoch_t>::iterator p = peer_map_epoch.find(peer);
  if (p != peer_map_epoch.end()) {
  ¦ if (p->second < e) {
  ¦ ¦ dout(10) << "note_peer_epoch osd." << peer << " has " << e << dendl;
  ¦ ¦ p->second = e;
  ¦ } else {
  ¦ ¦ dout(30) << "note_peer_epoch osd." << peer << " has " << p->second << " >= " << e << dendl;
  ¦ }
  ¦ return p->second;
  } else {
  ¦ dout(10) << "note_peer_epoch osd." << peer << " now has " << e << dendl;
  ¦ peer_map_epoch[peer] = e;
  ¦ return e;
  }
}
5.发送osdmap消息
void OSDService::send_incremental_map(epoch_t since, Connection *con,
  ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦                 OSDMapRef& osdmap)
{
  epoch_t to = osdmap->get_epoch();
  dout(10) << "send_incremental_map " << since << " -> " << to
  ¦ ¦ ¦ ¦ ¦<< " to " << con << " " << con->get_peer_addr() << dendl;

  MOSDMap *m = NULL;
  while (!m) {
  ¦ OSDSuperblock sblock(get_superblock());
  ¦ if (since < sblock.oldest_map) {
  ¦ ¦ // just send latest full map
  ¦ ¦ MOSDMap *m = new MOSDMap(monc->get_fsid());
  ¦ ¦ m->oldest_map = max_oldest_map;
  ¦ ¦ m->newest_map = sblock.newest_map;
  ¦ ¦ get_map_bl(to, m->maps[to]);
  ¦ ¦ send_map(m, con);
  ¦ ¦ return;
  ¦ }

  ¦ if (to > since && (int64_t)(to - since) > cct->_conf->osd_map_share_max_epochs) {
  ¦ ¦ dout(10) << "  " << (to - since) << " > max " << cct->_conf->osd_map_share_max_epochs
         ¦ ¦ ¦ << ", only sending most recent" << dendl;
  ¦ ¦ since = to - cct->_conf->osd_map_share_max_epochs;
  ¦ }

  ¦ if (to - since > (epoch_t)cct->_conf->osd_map_message_max)
  ¦ ¦ to = since + cct->_conf->osd_map_message_max;
  ¦ m = build_incremental_map_msg(since, to, sblock);
  }
  send_map(m, con);
}   


//从OSDService::map_bl_cache中找出指定epoch的osdmap（bl），如果没有命中就重新加载（磁盘中读取）
bool OSDService::_get_map_bl(epoch_t e, bufferlist& bl)
{
  bool found = map_bl_cache.lookup(e, &bl);
  if (found) {
  ¦ if (logger)
  ¦ ¦ logger->inc(l_osd_map_bl_cache_hit);
  ¦ return true;
  }
  if (logger)
  ¦ logger->inc(l_osd_map_bl_cache_miss);
  found = store->read(coll_t::meta(),
                ¦ ¦ ¦ OSD::get_osdmap_pobject_name(e), 0, 0, bl,
                ¦ ¦ ¦ CEPH_OSD_OP_FLAG_FADVISE_WILLNEED) >= 0;
  if (found) {
  ¦ _add_map_bl(e, bl);
  }                                                                                                                                                                                          
  return found;
}

//构造osdmap消息，并发送到请求端。
void OSDService::send_incremental_map(epoch_t since, Connection *con,
  ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦                 OSDMapRef& osdmap)
{
  epoch_t to = osdmap->get_epoch();
  dout(10) << "send_incremental_map " << since << " -> " << to
  ¦ ¦ ¦ ¦ ¦<< " to " << con << " " << con->get_peer_addr() << dendl;

  MOSDMap *m = NULL;
  while (!m) {
  ¦ OSDSuperblock sblock(get_superblock());
  ¦ if (since < sblock.oldest_map) {
  ¦ ¦ // just send latest full map
  ¦ ¦ MOSDMap *m = new MOSDMap(monc->get_fsid());
  ¦ ¦ m->oldest_map = max_oldest_map;                                                                                                                                                        
  ¦ ¦ m->newest_map = sblock.newest_map;
  ¦ ¦ get_map_bl(to, m->maps[to]);
  ¦ ¦ send_map(m, con);
  ¦ ¦ return;
  ¦ }

  ¦ if (to > since && (int64_t)(to - since) > cct->_conf->osd_map_share_max_epochs) {
  ¦ ¦ dout(10) << "  " << (to - since) << " > max " << cct->_conf->osd_map_share_max_epochs
         ¦ ¦ ¦ << ", only sending most recent" << dendl;
  ¦ ¦ since = to - cct->_conf->osd_map_share_max_epochs;
  ¦ }

  ¦ if (to - since > (epoch_t)cct->_conf->osd_map_message_max)
  ¦ ¦ to = since + cct->_conf->osd_map_message_max;
  ¦ m = build_incremental_map_msg(since, to, sblock);
  }
  send_map(m, con);
}
李艳坤
关注
专栏目录
ceph osdmap crush 分析
周健华的专栏
06-02 1万+
1 maps 更新1.1 更新规则 Because cluster map changes may be frequent, as in a very large system where OSDs failures and recoveries are the norm, updates are distributed as incremental maps(增量更新): small mes
【ceph】ceph osd启动及peering过程中osdmap相关加载和更新流程
小鱼菜鸟的博客
07-22 725
OSD启动过程中osdmap加载流程 OSD启动入口是ceph_osd.cc的main函数，他会调用osd->init()进行osd启动前的初始化工作。 int OSD::init() { ......//检查osd目录相关持久化数据，以及文件系统属性等，加载FileStore驱动。 int r = store->mount()...
解析 Ceph : OSD , OSDMap 和 PG, PGMap
chenzhigui2178的博客
02-13 937
在 2014 年 01 月 25 日 上公布 作者为 麦子迈 文章分类 Ceph 图A Ceph致力于提供PB级的集群存储能力，并且提供自动故障恢复，方便的扩容和缩容能力，这些能力在典型的分布式存储系统就需要 Metadata ...
Ceph OSDMap 机制浅析
weixin_44389885的博客
11-13 1102
OSDMap 机制是 Ceph 架构中非常重要的部分，PG 在 OSD 上的分布和监控由 OSDMap 机制执行。OSDMap 机制和 CRUSH 算法一起构成了 Ceph 分布式架构的基石。 OSDMap 机制主要包括如下3个方面： 1、Monitor 监控 OSDMap 数据，包括 Pool 集合，副本数，PG 数量，OSD 集合和 OSD 状态。 2...
【ceph】Ceph 存储中 PGMap、OSDMap 和xxMap
bandaoyu的note
02-23 3013
目录 简介 OSDMap PG 和 PGMap OSDMap 机制浅析 OSDMap 代码浅析 二、OSDMap模块数据结构 1.osd_info_t 2.osd_xinfo_t 3.OSDMap 4.Incremental 三、MOSDMap消息 四、OSDMap更新机制 五、OSDMap要点分析 六、获取OSDMap 1.查看当前集群最新epoch的OSDMap信息 七、与OSDMap相关的参数配置 八、疑点 ...
Ceph 学习——OSD读写流程与源码分析（一）
SEU_PAN的博客
12-08 1万+
消息从客户端发送而来，之前几节介绍了 客户端下 对象存储、块存储库的实现以及他们在客户端下API请求的发送过程（Ceph学习——Librados与Osdc实现源码解析 、 Ceph学习——客户端读写操作分析 、 Ceph学习——Librbd块存储库与RBD读写流程源码分析）。当请求被封装后，通过消息发送模块（Ceph学习——Ceph网络通信机制与源码分析）将请求及其相关信息发送到服务端实现真正的
【ceph】OSD心跳检测机制（前端后端网）
小鱼菜鸟的博客
07-22 767
目录 ceph心跳机制 OSD间的心跳机制 发送 接收 超时检测 peer OSD选择 OSD和MON间的心跳机制 总结： @bandaoyu,本文随时更新,连接：https://blog.csdn.net/bandaoyu/article/details/123018441 心跳是一种用于故障检测的手段。分布式系统中，各种异常，如...
osd的多副本读写流程
chuxinxia8434的博客
05-22 700
数据结构 struct pg_pool_t{ enum { TYPE_REPLICATED = 1, // 多副本 //TYPE_RAID4 = 2, // raid4 (never implemented) TYPE_ERASURE =...
集群ceph df中pool 与 global不一致问题
zlarm的专栏
03-13 1784
一 引言 某地存储项目中由于每天都需要统计存储使用量及业务量，在某一日统计存储使用量时发现global中容量与各池的可用容量不一致，由此产生疑问。 二 Global &amp; Pool统计 分析代码，发现ceph df在monitor中的处理逻辑是monito.cc handle_command： 这部分代码里主要分为两部分：一部分是对于Global输出的统计，另外一部分是对于各池的统计。 { ...
ceph-osd无法获取osd map导致osd down掉的解决办法
天行健，地势坤
03-28 2423
环境：ceph-12.2.1 3节点测试性能集群 60块osd 最近ceph集群中有两个osd在重启之后遇到如下问题,osd获取不到集群osdmap产生coredump： ceph version 12.2.1.06 (3e7492b9ada8bdc9a5cd0feafd42fbca27f9c38e) luminous (stable) 1: (()+0xa2bf21) [0x7fcd9162...
Ceph源码解析：PG peering
最新发布
大隐隐于野
08-28 827
从以上分析来看，整个peering过程主要分为三个阶段，GetInfo -> GetLog -> GetMissing，首先向prior set、acting set、up set中的每个osd请求pg infos, 选出authoritative log对应的pg；其次向authoritative log所在的osd请求authoritative log；最后获取recovery过程需要的missing set；peering时间的长短并不可控，主要是在于请求的osd是否能够及时响应；
ceph——三副本读写——2
w007d的专栏
07-01 2008
处理线程 void OSD::ShardedOpWQ::_process(uint32_t thread_index, heartbeat_handle_d *hb) |---auto&amp; sdata = osd-&gt;shards[shard_index]; //vector&lt;OSDShard*&gt; shards; |---if (sdata-&gt;pqueue-&gt...
linux下的osd服务,重启osd服务失败：Start request repeated too quickly
weixin_39542710的博客
05-03 1248
背景OS：Ubuntu 16.04修改了osd的一些配置，修改后，需要重启osd服务才能生效。第一次重启后，配置立刻生效。再改了一些配置，重启osd服务后，配置却不再生效了。ps命令查看进程，发现osd进程都没有启动。分析osd进程未启动，第一直觉就是配置出错，osd进程启动后又挂掉。于是，进入/var/log/ceph目录，查看ceph-osd.0.log，发现日志末尾只有关闭进程的相关日志，并...
执行增量(Incremental )Map-Reduce
zxwjx的专栏
05-22 429
目录1 数据设置2 当前集合的初始Map-Reduce3 后续的增量Map-Reduce4 聚合替代 进入MongoDB中文手册（4.2版本）专栏 聚合管道作为替代 聚合管道比map-reduce提供更好的性能和更一致的接口。 各种map-reduce操作可以使用聚合管道操作符重写，诸如$group， $merge等。下面的例子包括聚合管道的替代方案。 为了执行map-reduce操作，MongoDB提供了mapReduce命令，并在mongo shell中提供了封装方法db.collection.ma
Ceph各个版本之间参数变化分析
HHFQ的博客
03-11 2760
Ceph各个版本之间参数变化分析 原文：https://www.cnblogs.com/zphj1987/p/13671961.html 前言 本篇主要是分析ceph的版本之间参数的变化，参数变化意味着功能的变化，通过参数来分析增加，删除，修改了哪些功能，以及版本之间的变化，本篇主要通过导出参数，然后通过脚本去比对不同的版本的参数变化 14版本之前安装一个ceph-common,然后touch一个空配置文件就可以通过ceph --show-config拿到版本的配置文件 14版本之后需要安装好mon，并且这
Ceph操作——监视OSD和PG
AK48的专栏
11-18 1万+
MONITORING OSDS AND PGS——监视OSDS和PGS 高可用性和高可靠性要求的容错方法来管理硬件和软件问题。Ceph的具有不存在单点故障，并可以以一个“退化”模式服务于一个数据请求。Ceph的数据放置 引入了一个间接层，以确保数据不直接绑定到特定的OSD地址。这意味着，追查系统故障，需要找到问题的根源安置组和相关的OSD。 注：  在一个集群的一部分故障可能会阻止你
osd的原理
热门推荐
follow_blast的博客
03-05 1万+
OSD（On Screen Display）是屏幕显示技术的一种，用于在显示终端上显示字符、图形和图像。 显存，也被叫做帧缓存，它的作用是用来存储显卡芯片处理过或者即将提取的渲染数据。如同计算机的内存一样，显存是用来存储要处理的图形信息的部件。我们在显示屏上看到的画面是由一个个的像素点构成的，而每个像素点都以4至32甚至64位的数据来控制它的亮度和色彩，这些数据必须通过显存来保存，再交由显示芯片
ceph修改osd服务器IP,ceph增加osd流程
weixin_39808877的博客
08-12 570
假如需要新增一个主机名：osd4ip:192.168.0.110的OSD1.在osd4创建挂载目录及放置配置文件的目录ssh192.168.0.110(这里是从mon主机ssh到osd4主机)mkdir/ceph/osd.4mkdir/etc/ceph2.在osd4上格式化ext4的sda3分区,挂载分区。mkfs.ext4/dev/sda3mount-ouser_xattr/d...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值