【ceph】ceph配置源码分析|common/config.*

已于 2022-06-08 16:50:50 修改
阅读量980 收藏 2
点赞数 1
分类专栏： 存储|ceph|DAOS 文章标签： 网络协议 网络
于 2022-06-02 21:43:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bandaoyu/article/details/125106623
版权

Ceph 配置参数 宏定义 md_config_t 配置文件解析
关键词由CSDN通过智能技术生成

ceph的配置项的构建思路

如果一个class中有成百上千个成员变量，有没有觉得当写类头文件都写到手痛，还要在构造函数里初始化它们，简直不敢再想下去了……

像下图这样

这只是头文件

还有实现的

接着还有get 和 set

然而，以上是最笨的方法~

那么问题来了，ceph的开发者是怎样做的呢？

利用c++的宏，在class的头文件定义成员变量前定义好要用的宏，如下

OPTION(name,ty,init)宏能根据ty，也就是成员变量的类型，在编译时生成成员变量，成员变量的最终定义是在common/config_opts.h下：

Class的构造函数初始化成员变量也是一样的手法：

只要改动common/config_opts.h下的OPTION语句就能实现增删成员变量了。

至于get 和 set 方法，用了一个巧妙的方法：直接对成员变量相对该class的偏移地址进行存取。

以下为例，如下图：

初始化全局数组config_optionsp时，每个config_option元素记录着md_config_t里的一个成员变量的名字，类型和偏移，如上图中的编号4小图。主要用的是stddef.h里的offsetof计算成员变量在class里的偏移值。

当调用get时进入到上图中小图1的函数，先找根据成员变量的名字找出config_option对象，再如小图2调用config_option的conf_ptr（小图3），其中md_conf_off是该成员变量在md_config_t类中的偏移量。这样就能直接存取成员变量，而且运行效率更高，同时又降低了开发的工作量，代码也更美观！

摘抄自：Ceph源码之 config https://blog.csdn.net/chunlu2438/article/details/100679794

代码

int main(int argc, const char **argv)

auto cct = global_init(&def_args, args,
             CEPH_ENTITY_TYPE_MON, CODE_ENVIRONMENT_DAEMON,
             flags, "mon_data");

void global_pre_init(std::vector < const char * > *alt_def_args,
             std::vector < const char* >& args,
             uint32_t module_type, code_environment_t code_env,
             int flags)

CephContext *cct = common_preinit(iparams, code_env, flags);

CephContext *cct = new CephContext(iparams.module_type, code_env, flags);

CephContext::CephContext(uint32_t module_type_,
                         enum code_environment_t code_env,
                         int init_flags_)
  : nref(1),
    _conf(new md_config_t(code_env == CODE_ENVIRONMENT_DAEMON)),
    _log(NULL),
{
}

 一，遍历ceph_options把option的name放入schema中。

二，把legacy_config_opts.h中的变量（展开）把名字和md_config_t::name结对生成map放入legacy_values中。

既：options.cc中的变量（名） 放入 schema。legacy_config_opts.h中的变量（名）放入 legacy_values。

ceph_options的来源是=build_options，build_options 就是把options.cc中的配置全部加入到 std::vector中返回给ceph_options， 见后面的代码

md_config_t::md_config_t(bool is_daemon)
{
 ……


  for (const auto &i : ceph_options) {
    if (schema.count(i.name)) {
      // We may be instantiated pre-logging so send 
      std::cerr << "Duplicate config key in schema: '" << i.name << "'"
                << std::endl;
      assert(false);
    }
    schema.insert({i.name, i});
  }

  // Populate list of legacy_values according to the OPTION() definitions
  // Note that this is just setting up our map of name->member ptr.  The
  // default values etc will get loaded in along with new-style data,
  // as all loads write to both the values map, and the legacy
  // members if present.
  legacy_values = {
#define OPTION(name, type) {std::string(STRINGIFY(name)), &md_config_t::name},
#define SAFE_OPTION(name, type) OPTION(name, type)
#include "common/legacy_config_opts.h"
#undef OPTION
#undef SAFE_OPTION
  };

  validate_schema();

……

}
 

static std::vector<Option> build_options()
{
  std::vector<Option> result = get_global_options();

  auto ingest = [&result](std::vector<Option>&& options, const char* svc) {
    for (const auto &o_in : options) {
      Option o(o_in);
      o.add_service(svc);
      result.push_back(o);
    }
  };

  ingest(get_rgw_options(), "rgw");
  ingest(get_rbd_options(), "rbd");
  ingest(get_rbd_mirror_options(), "rbd-mirror");
  ingest(get_mds_options(), "mds");
  ingest(get_mds_client_options(), "mds_client");

  return result;
}

const std::vector<Option> ceph_options = build_options();
 

  validate_schema();   

1、检查……   

2、检查确保legacy_config_opts.h中定义的变量，在options.cc中都有定义。


/**
 * Sanity check schema.  Assert out on failures, to ensure any bad changes
 * cannot possibly pass any testing and make it into a release.
 */
void md_config_t::validate_schema()
{
  for (const auto &i : schema) {
    const auto &opt = i.second;
    for (const auto &see_also_key : opt.see_also) {
      if (schema.count(see_also_key) == 0) {
        std::cerr << "Non-existent see-also key '" << see_also_key
                  << "' on option '" << opt.name << "'" << std::endl;
        assert(false);
      }
    }
  }

  for (const auto &i : legacy_values) {
    if (schema.count(i.first) == 0) {
      std::cerr << "Schema is missing legacy field '" << i.first << "'"
                << std::endl;
      assert(false);
    }
  }
}

src\common\options.cc里面还定义（实例化）一些变量，放入get_global_options、get_rgw_options、get_rbd_options、get_rbd_options……里：

std::vector<Option> get_global_options() {
  return std::vector<Option>({
    Option("host", Option::TYPE_STR, Option::LEVEL_BASIC)
    .set_description("local hostname")
    .set_long_description("if blank, ceph assumes the short hostname (hostname -s)")
    .add_service("common")
    .add_tag("network"),

    Option("fsid", Option::TYPE_UUID, Option::LEVEL_BASIC)
    .set_description("cluster fsid (uuid)")
    .add_service("common")
    .add_tag("service"),

    Option("public_addr", Option::TYPE_ADDR, Option::LEVEL_BASIC)
    .set_description("public-facing address to bind to")
    .add_service({"mon", "mds", "osd", "mgr"}),

    Option("public_bind_addr", Option::TYPE_ADDR, Option::LEVEL_ADVANCED)
    .set_default(entity_addr_t())
    .add_service("mon")
    .set_description(""),
……
}
std::vector<Option> get_rgw_options() {
  return std::vector<Option>({
    Option("rgw_acl_grants_max_num", Option::TYPE_INT, Option::LEVEL_ADVANCED)
    .set_default(100)
    .set_description("Max number of ACL grants in a single request"),

    Option("rgw_max_chunk_size", Option::TYPE_INT, Option::LEVEL_ADVANCED)
    .set_default(4_M)
    .set_description("Set RGW max chunk size")
    .set_long_description(
        "The chunk size is the size of RADOS I/O requests that RGW sends when accessing "
        "data objects. RGW read and write operation will never request more than this amount "
        "in a single request. This also defines the rgw object head size, as head operations "
        "need to be atomic, and anything larger than this would require more than a single "
        "operation."),

    Option("rgw_put_obj_min_window_size", Option::TYPE_INT, Option::LEVEL_ADVANCED)
    .set_default(16_M)
    .set_description("The minimum RADOS write window size (in bytes).")
    .set_long_description(
        "The window size determines the total concurrent RADOS writes of a single rgw object. "
        "When writing an object RGW will send multiple chunks to RADOS. The total size of the "
        "writes does not exceed the window size. The window size can be automatically "
        "in order to better utilize the pipe.")
    .add_see_also({"rgw_put_obj_max_window_size", "rgw_max_chunk_size"}),
……
}

然后都放入ceph_options 中

static std::vector<Option> build_options()
{
  std::vector<Option> result = get_global_options();

  auto ingest = [&result](std::vector<Option>&& options, const char* svc) {
    for (const auto &o_in : options) {
      Option o(o_in);
      o.add_service(svc);
      result.push_back(o);
    }
  };

  ingest(get_rgw_options(), "rgw");
  ingest(get_rbd_options(), "rbd");
  ingest(get_rbd_mirror_options(), "rbd-mirror");
  ingest(get_mds_options(), "mds");
  ingest(get_mds_client_options(), "mds_client");

  return result;
}

const std::vector<Option> ceph_options = build_options();

然后在 md_config_t中，把options.cc中定义/实例化的option的名字放入schema： schema.insert({i.name, i});

md_config_t::md_config_t(bool is_daemon)
  : cluster(""),
  lock("md_config_t", true, false)
{
  init_subsys();

  // Load the compile-time list of Option into
  // a map so that we can resolve keys quickly.
  for (const auto &i : ceph_options) {
    if (schema.count(i.name)) {
      // We may be instantiated pre-logging so send 
      std::cerr << "Duplicate config key in schema: '" << i.name << "'"
                << std::endl;
      assert(false);
    }
    schema.insert({i.name, i});
  }
……
}

 src\common\legacy_config_opts.h里面宏定义自己的变量：

/* note: no header guard */
OPTION(host, OPT_STR) // "" means that ceph will use short hostname
OPTION(public_addr, OPT_ADDR)
OPTION(public_bind_addr, OPT_ADDR)
OPTION(cluster_addr, OPT_ADDR)
OPTION(public_network, OPT_STR)
OPTION(cluster_network, OPT_STR)
OPTION(lockdep, OPT_BOOL)
OPTION(lockdep_force_backtrace, OPT_BOOL) // always gather current backtrace at every lock
OPTION(run_dir, OPT_STR)       // the "/var/run/ceph" dir, created on daemon startup
OPTION(admin_socket, OPT_STR) // default changed by common_preinit()
OPTION(admin_socket_mode, OPT_STR) // permission bits to set for admin socket file, e.g., "0775", "0755"
……

接着src\common\config.cc里面把legacy_config_opts.h里面宏定义自己的变量展开到 legacy_values里面：

#define _STR(x) #x
#define STRINGIFY(x) _STR(x)

md_config_t::md_config_t(bool is_daemon){
……

legacy_values = {
#define OPTION(name, type) \
    {std::string(STRINGIFY(name)), &md_config_t::name},
#define SAFE_OPTION(name, type) OPTION(name, type)
#include "common/legacy_config_opts.h"
#undef OPTION
#undef SAFE_OPTION
  };
……

}

ceph中的可配置参数（日志级别，缓存设置等等）都定义在http://options.cc中，可以通过ceph daemon命令来查看或者修改这些参数配置。

ceph daemon *** config show

例如："log_file"参数可以配置日志文件的路径

Option("log_file", Option::TYPE_STR, Option::LEVEL_BASIC)
    .set_default("")
    .set_daemon_default("/var/log/ceph/$cluster-$name.log")
    .set_description("path to log file")
    .add_see_also({"log_to_stderr", "err_to_stderr", "log_to_syslog", "err_to_syslog"}),

参数是以Option结构体存在，Option结构体的定义如下

struct Option {
  enum type_t {                  // 参数值的类型         
    TYPE_UINT,
    TYPE_INT,
    TYPE_STR,
    TYPE_FLOAT,
    TYPE_BOOL,
    TYPE_ADDR,
    TYPE_UUID,
  };
  enum level_t {
    LEVEL_BASIC,
    LEVEL_ADVANCED,
    LEVEL_DEV,
  };
  using value_t = boost::variant<boost::blank, std::string, uint64_t, int64_t, double, bool, entity_addr_t, uuid_d>;
  const std::string name;                   // 参数名
  const type_t type;                        // 参数类型
  const level_t level;                      // 参数级别
  std::string desc;                         // 该参数的含义
  std::string long_desc;
  value_t value;                            // 参数值
  value_t daemon_value;                     // 有daemon的参数值
  std::vector<const char*> services;        // services即服务类型，比如"mds"
  std::vector<const char*> see_also;            // 该参数对应的类似的参数
  std::vector<const char*> enum_allowed;
  bool safe;
  ...  
}

在http://options.cc中，定义的参数分为几类

std::vector<Option> get_global_options() { ... }

std::vector<Option> get_rgw_options() { ... }

static std::vector<Option> get_rbd_options() { ... } 

static std::vector<Option> get_rbd_mirror_options() { ... }

std::vector<Option> get_mds_options() { ... }

std::vector<Option> get_mds_client_options() { ... }

从函数名可以看出来：get_global_options函数中的参数是global类型的，即基本所有的模块都可以使用这些参数。get_rgw_options函数中的参数是给rgw模块使用。get_rbd_options函数和get_rbd_mirror_options函数中的参数是给rbd相关模块使用。get_mds_options函数中的参数是给mds模块使用。get_mds_client_options函数中的参数是给mds client模块使用。

全局变量ceph_options

ceph_options包含了所有的参数，

const std::vector<Option> ceph_options = build_options();

在build_options中将所有的Option类放入ceph_options这个vector里面。

static std::vector<Option> build_options()
{
  std::vector<Option> result = get_global_options();
  auto ingest = [&result](std::vector<Option>&& options, const char* svc) {
    for (auto &o : options) {
      o.add_service(svc);
      result.push_back(std::move(o));
    }
  };
  ingest(get_rgw_options(), "rgw");
  ingest(get_rbd_options(), "rbd");
  ingest(get_rbd_mirror_options(), "rbd-mirror");
  ingest(get_mds_options(), "mds");
  ingest(get_mds_client_options(), "mds_client");
  return result;
}

ceph_options = { Option{"log_file"}, Option("***")}

md_config_t

md_config_t结构体表示当前的Ceph配置，ceph_options中的参数都会存在这里。在md_config_t中有特殊的成员变量定义。

#define OPTION_OPT_INT(name) int64_t name;
#define OPTION_OPT_LONGLONG(name) int64_t name;
#define OPTION_OPT_STR(name) std::string name;
#define OPTION_OPT_DOUBLE(name) double name;
#define OPTION_OPT_FLOAT(name) double name;
#define OPTION_OPT_BOOL(name) bool name;
#define OPTION_OPT_ADDR(name) entity_addr_t name;
#define OPTION_OPT_U32(name) uint64_t name;
#define OPTION_OPT_U64(name) uint64_t name;
#define OPTION_OPT_UUID(name) uuid_d name;
#define OPTION(name, ty) \
  public:                      \
    OPTION_##ty(name)          
#define SAFE_OPTION(name, ty) \
  protected:                        \
    OPTION_##ty(name)               
#include "common/legacy_config_opts.h"
#undef OPTION_OPT_INT
#undef OPTION_OPT_LONGLONG
#undef OPTION_OPT_STR
#undef OPTION_OPT_DOUBLE
#undef OPTION_OPT_FLOAT
#undef OPTION_OPT_BOOL
#undef OPTION_OPT_ADDR
#undef OPTION_OPT_U32
#undef OPTION_OPT_U64
#undef OPTION_OPT_UUID
#undef OPTION
#undef SAFE_OPTION

common/legacy_config_opts.h中存的变量和common/http://options.cc一一对应，代码如下

/* note: no header guard */
OPTION(host, OPT_STR) // "" means that ceph will use short hostname
OPTION(public_addr, OPT_ADDR)
OPTION(public_bind_addr, OPT_ADDR)
OPTION(cluster_addr, OPT_ADDR)
OPTION(public_network, OPT_STR)
OPTION(cluster_network, OPT_STR)
OPTION(lockdep, OPT_BOOL)
OPTION(lockdep_force_backtrace, OPT_BOOL) // always gather current backtrace at every lock
OPTION(run_dir, OPT_STR)       // the "/var/run/ceph" dir, created on daemon startup
OPTION(admin_socket, OPT_STR) // default changed by common_preinit()
OPTION(admin_socket_mode, OPT_STR) // permission bits to set for admin socket file, e.g., "0775", "0755"
......

最终md_config_t结构体定义如下

struct md_config_t {
   ...
   typedef std::multimap <std::string, md_config_obs_t*> obs_map_t;
   std::map<std::string, md_config_t::member_ptr_t> legacy_values;
   std::map<std::string, const Option&> schema;
   std::map<std::string, Option::value_t> values;
private:
  ConfFile cf;
public:
  std::deque<std::string> parse_errors;
private:
  bool safe_to_start_threads = false;
  obs_map_t observers;
  changed_set_t changed;
public:
  ceph::logging::SubsystemMap subsys;
  EntityName name;
  string data_dir_option;  ///< data_dir config option, if any
  string cluster;           // cluster = "ceph"

// 下面的成员来自common/legacy_config_opts.h中
public：
   std::string host;
   entity_addr_t public_addr;
   entity_addr_t public_bind_addr;
   entity_addr_t cluster_addr;
   std::string public_network;
   std::string cluster_network;
   bool lockdep;
   bool lockdep_force_backtrace;
   std::string run_dir;
   std::string admin_socket;
   std::string admin_socket_mode;
   std::string log_file; 
   ...
protected:
   std::string ms_type; 
   std::string plugin_dir;
   ...

}

其中schema保存ceph_options中的所有Option参数，即

schema = { <"host", Options("host")>, ..., <"log_file", Option("log_file")>, ...}

legacy_values将ceph_options中的Option的name与对应的md_config_t中的成员指针作为key-value保存，即

legacy_values = {<"host", &md_config_t::host>, ... , <"log_file", &md_config_t::log_file>, ...}

values将ceph_options中的Option的name和value作为key-value保存。

libcephfs中：values = {<"host", "">, ..., <"log_file", "">, ...}

ceph-mds中：values = {<"host", "">, ..., <"log_file", "/var/log/ceph/$cluster-$name.log">, ...}

subsys用来存日志项，即

subsys = ceph::logging::SubsystemMap( m_subsys[ceph_subsys_ == 0] = Subsystem<name = "none", log_level = 0, gather_level = 5>, ... , m_subsys[ceph_subsys_crush == 3] = Subsystem<name = "crush", log_level = 1, gather_level = 1>, m_subsys[ceph_subsys_mds == 4] = Subsystem<name = "mds", log_level = 1, gather_level = 5>, ... }。

g_ceph_context和g_conf全局变量

一个模块的进程会有多个线程，比如ceph-mds，进程中有些内容需要整个进程中的所有线程都可以访问，比如参数配置和以及上下文内容，所以就有两个全局变量g_conf和g_ceph_context，在src/global/http://global_context.cc中定义如下

CephContext *g_ceph_context = NULL;
md_config_t *g_conf = NULL;

md_config_t 实例对象指针又作为CephContext 的成员，

class CephContext {
...
public:
  md_config_t *_conf;
...
}

每个模块启动时，都需要实例化CephContext，就不需要单独去实例化md_config_t。CephContext实例化函数流程如下：

在md_config_t的构造函数的入参为is_daemon，它是用来判断该模块是单独起一个守护线程，或者由别的线程去调用对外接口，不单独起线程。构造函数如下

md_config_t::md_config_t(bool is_daemon){ ... }

md_config_t的实例化处如下

 _conf(new md_config_t(code_env == CODE_ENVIRONMENT_DAEMON))

即判断code_env == CODE_ENVIRONMENT_DAEMON，在各个模块的main函数中有code_env的入参。即http://ceph_mds.cc，http://ceph_fuse.cc和http://ceph_mon.cc等中的md_config_t中is_daemon都是true，libcephfs的md_config_t中is_daemon是false。

参数配置方式

参数配置方式有两种：永久和临时。永久方式，就是在配置文件(如ceph.conf)中添加该参数的配置，重启进程后，参数就生效了。临时方式，就是通过ceph daemon命令设置内存中的参数。

修改ceph.conf中参数后怎么生效, 比如在ceph.conf中配置了

admin_socket = $rundir/$cluster-$id.$pid.asok

直接看代码，从http://ceph_mon.cc中开始看

auto cct = global_init(&def_args, args, CEPH_ENTITY_TYPE_MON, CODE_ENVIRONMENT_DAEMON,
			 flags, "mon_data")

global_init

boost::intrusive_ptr<CephContext> global_init(std::vector < const char * > *alt_def_args, std::vector < const char* >& args,
	    uint32_t module_type, code_environment_t code_env, int flags,
	    const char *data_dir_option, bool run_pre_init)
{ // module_type = CEPH_ENTITY_TYPE_MON, code_env = CODE_ENVIRONMENT_DAEMON, flags = 0
  // *data_dir_option = "mon_data", run_pre_init = true
  static bool first_run = true;
  if (run_pre_init) {
    global_pre_init(alt_def_args, args, module_type, code_env, flags);
  } else 
  ...
}

global_pre_init是关键函数：

void global_pre_init(std::vector < const char * > *alt_def_args, std::vector < const char* >& args,
		     uint32_t module_type, code_environment_t code_env, int flags)
{ // module_type = CEPH_ENTITY_TYPE_MON, code_env = CODE_ENVIRONMENT_DAEMON, flags = 0
  std::string conf_file_list;            // ceph.conf的路径
  std::string cluster = "";
  CephInitParameters iparams = ceph_argparse_early_args(args, module_type, &cluster, &conf_file_list);
  // common_preinit函数主要是去实例化CephContext
  CephContext *cct = common_preinit(iparams, code_env, flags);
  cct->_conf->cluster = cluster;         // cct->_conf->cluster = "ceph"
  global_init_set_globals(cct);
  md_config_t *conf = cct->_conf;
  if (alt_def_args)
    conf->parse_argv(*alt_def_args);  // alternative default args
  int ret = conf->parse_config_files(c_str_or_null(conf_file_list), &cerr, flags);
  ...
}

调用ceph_argparse_early_args来解析进程启动时设置的参数，比如ceph-mon启动时设置的参数如下

/usr/bin/ceph-mon -f --cluster ceph --id node1 --setuser ceph --setgroup ceph

ceph_argparse_early_args函数如下，

CephInitParameters ceph_argparse_early_args (std::vector<const char*>& args, uint32_t module_type,
	   std::string *cluster, std::string *conf_file_list)
{ //module_type = CEPH_ENTITY_TYPE_MON, *cluster = "", *conf_file_list = ""
  CephInitParameters iparams(module_type);
  // iparams里面的内容为class CephInitParameters { module_type = CEPH_ENTITY_TYPE_MON，
  //   name: struct EntityName { type = CEPH_ENTITY_TYPE_MON, id = "admin", type_id = "mon.admin" }}
  std::string val;
  vector<const char *> orig_args = args;
  for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ) {
    ...
   // 解析--conf,但是执行ceph-mon命令时，并未指定--conf，所以val为空字符串。
    else if (ceph_argparse_witharg(args, i, &val, "--conf", "-c", (char*)NULL)) {
      *conf_file_list = val;       
    }
    else if (ceph_argparse_witharg(args, i, &val, "--cluster", (char*)NULL)) {
      *cluster = val;         // *cluster = ceph
    }
    else if ((module_type != CEPH_ENTITY_TYPE_CLIENT) &&
	     (ceph_argparse_witharg(args, i, &val, "-i", (char*)NULL))) {
      iparams.name.set_id(val); 
    }
    else if (ceph_argparse_witharg(args, i, &val, "--id", "--user", (char*)NULL)) {
      iparams.name.set_id(val); // iparams.name中{_id = "node1", type_id = "mon.node1"}
    }
    ...
  return iparams;
}

common_preinit

CephContext *common_preinit(const CephInitParameters &iparams, enum code_environment_t code_env, int flags)
{ // code_env = CODE_ENVIRONMENT_DAEMON, flags = 0
  // 实例CephContext
  CephContext *cct = new CephContext(iparams.module_type, code_env, flags);
  md_config_t *conf = cct->_conf;
  conf->name = iparams.name;
  ...
  return cct;
}

最重要的就是parse_config_files

int md_config_t::parse_config_files(const char *conf_files, std::ostream *warnings, int flags)
{ // conf_files = NULL
  ...
  if (!conf_files) {
    const char *c = getenv("CEPH_CONF");       // c = NULL
    ...
    else {
      ...
      // CEPH_CONF_FILE_DEFAULT = "$data_dir/config, /etc/ceph/$cluster.conf, ~/.ceph/$cluster.conf, $cluster.conf"
      conf_files = CEPH_CONF_FILE_DEFAULT; // CEPH_CONF_FILE_DEFAULT就是配置文件的路径
    }
  }
  std::list<std::string> cfl;
  get_str_list(conf_files, cfl);     // 将conf_files中的字符串切割放在cfl中
  auto p = cfl.begin();
  while (p != cfl.end()) { ... }
  return parse_config_files_impl(cfl, warnings);
}

md_config_t::parse_config_files_impl

int md_config_t::parse_config_files_impl(const std::list<std::string> &conf_files,std::ostream *warnings)
{
  list<string>::const_iterator c;
  // 遍历conf_files，替换"$"后面的字符串，比如将$cluster替换成ceph
  for (c = conf_files.begin(); c != conf_files.end(); ++c) {
    cf.clear();
    string fn = *c;
    // 替换"$"后面的字符串
    expand_meta(fn, warnings);
    // 将ceph.conf(如/etc/ceph/ceph.conf)中的内容读上来保存在cf中
    int ret = cf.parse_file(fn.c_str(), &parse_errors, warnings);
    if (ret == 0) break;
  }

  std::vector <std::string> my_sections;
  // 获取要解析的部分，比如mon：<"mon.node1", "mon", global">, client: <"client.admin", "admin", "global">
  // 即ceph.conf中my_sections对应的部分才会解析
  _get_my_sections(my_sections);
  for (const auto &i : schema) { ... }
  //遍历subsys, 配置debug_**之类的
  for (size_t o = 0; o < subsys.get_num(); o++) { ... }
  ...
  return 0;
}

md_config_t::expand_meta函数用来替换"$"后面的字符串，比如admin_socket = $rundir/$cluster-$id.$pid.asok，调用expand_meta函数后admin_socket = /var/run/ceph/ceph-mon.node1.2093242.asok

摘抄自：ceph：可配置参数 https://zhuanlan.zhihu.com/p/110079635

1 介绍

    ceph里面的配置文件代码比较繁琐，分析清楚配置代码对未来排查问题大有益处。

2 启动分析

2.1 入口

    无论是osd、mgr还是mon等程序都需要加载配置，都有统一的入口，例如ceph-osd.cc在main函数中调用global_init--->global_pre_init函数进行配置的加载。

2.2 env_to_vec分析

ceph_mon.cc

int main(int argc, const char **argv)
{
  int err;

  bool mkfs = false;
  bool compact = false;
  bool force_sync = false;
  bool yes_really = false;
  std::string osdmapfn, inject_monmap, extract_monmap;

  vector<const char*> args;
  argv_to_vec(argc, argv, args);
  env_to_vec(args);

……
}

    split_dashdash把args根据"--"拆分成两段（注意：--不同于--param），前段为类型为vector的options， 后段为类型为vector的arguments。

（/opt/h3c/bin/ceph-mon --cluster ceph --mkfs -i rdma58 --keyring）

void env_to_vec(std::vector<const char*>& args, const char *name)
{
  if (!name)
    name = "CEPH_ARGS";

  bool dashdash = false;
  std::vector<const char*> options;
  std::vector<const char*> arguments;
  if (split_dashdash(args, options, arguments))
    dashdash = true;

  std::vector<const char*> env_options;
  std::vector<const char*> env_arguments;
  std::vector<const char*> env;

……

  g_str_vec_lock.lock();
  if (g_str_vec.empty()) {
    char *p = getenv(name);
    if (!p) {
      g_str_vec_lock.unlock();
      return;
    }
    get_str_vec(p, " ", g_str_vec);
  }

}


    get_str_vec。把环境变量值取出来：默认的环境变量是"CEPH_ARGS"，可以通过参数来指定名字。以空格“ ” 为间隔，把环境变量拆分为一个个字符串到g_str_vec中。
    g_str_vec腾挪到env 的vector<const char*>中，同args一样以“--”进行拆分。
    分别聚合env和args的options和arguments到args中， 还是以“--”来间隔，无论是options还是arguments，env的参数都在前。

2.3 ceph_argparse_early_args

void global_pre_init(std::vector < const char * > *alt_def_args,
             std::vector < const char* >& args,
             uint32_t module_type, code_environment_t code_env,
             int flags)
{
  std::string conf_file_list;
  std::string cluster = "";
  CephInitParameters iparams = ceph_argparse_early_args(args, module_type,
                            &cluster, &conf_file_list);
  CephContext *cct = common_preinit(iparams, code_env, flags);
  cct->_conf->cluster = cluster;

……

}

    解析options来获取对应的值：
         a) -v 展示version
         b) -c 配置文件
         c) --cluster cluster
         d) -i 非client实体的id （client程序通过-i指定id会无效）
         e) --id / --user 设置实体的id，会覆盖-i的选项
         f) --name/-n 通过名字来解析设置实体的id， 会覆盖-i 以及 --id/--user
         g）--show_args 显示参数 ，但是不会exit

3 配置类分析

3.1 ConfigProxy

    配置的代理类，实际是封装了:
         a) ConfigValues values;
         b) ObserverMgr<md_config_obs_t> obs_mgr;
         c) md_config_t config;

3.2 md_config_t

    主要包含了配置的元数据， 主要成员有：
         1) std::map<std::string, const Option&> schema;

        a) 构造函数中通过全局变量ceph_options=build_options()构造，在这个函数里面可以看到很多默认的值

         2) std::map<std::string, member_ptr_t> legacy_values;

3.3 Option

主要成员：

  1. name:

  2. type :参考 type_t {TYPE_UINT, TYPE_INT...}

  3. level: 参考level_t {basic, advanced, dev}

    3.1 basic: for users, configures some externally visible functional aspect

    3.2 advanced: for users, configures some internal behaviour

    3.3 Dev: not for users. May be dangerous, may not be documented.

    1. value_t value; value_t daemon_value;

3.4 ConfigValues

主要成员：

using values_t = std::map<std::string, map<int32_t,Option::value_t>>; // <name, <level, value_t>
values_t values;

3.5 类关系

通过ConfigProxy提供对外的接口：

1、如果是set类接口：先通过md_config_t获取option，通过option获取name、类型、默认值、校验等信息，解析value，最后设置到ConfigValues中。

2、如果是get类接口：

    2.1、流程也是从md_config_t到ConfigValues, 如果从ConfigValues不能获取到，则获取Option的默认值

    2.2、md_config_t::expand_meta 解析${var}到实际的值


作者：小跑001
链接：https://www.jianshu.com/p/fbfacbff1edf
 

读取和解析配置文件ceph.conf的代码

ceph_mon.cc

int main(int argc, const char **argv)

--->auto cct = global_init(&def_args, args,……）   

------>global_pre_init(alt_def_args, args, module_type, code_env, flags);

--------->ret = conf->parse_config_files(c_str_or_null(conf_file_list),

------------>parse_config_files_impl(cfl, warnings);

---------------->ret = _get_val_from_conf_file(my_sections, opt.name, val, false);

---------------->r = set_val_impl(val, opt, &error_message);

-------------------->values[opt.name] = new_value;

 auto legacy_ptr_iter = legacy_values.find(std::string(opt.name));
  if (legacy_ptr_iter != legacy_values.end()) {
    update_legacy_val(opt, legacy_ptr_iter->second);
  }

conf_file_list 由命令传入--conf 或为null，为null则读取环境变量CEPH_CONF定义路径下的ceph.conf：const char *c = getenv("CEPH_CONF");

int md_config_t::parse_config_files(const char *conf_files,
                    std::ostream *warnings,
                    int flags)
{

  if (!conf_files) {
    const char *c = getenv("CEPH_CONF");
    if (c) {
      conf_files = c;
    }
    else {
      if (flags & CINIT_FLAG_NO_DEFAULT_CONFIG_FILE)
    return 0;

// CEPH_CONF_FILE_DEFAULT = "$data_dir/config, /etc/ceph/$cluster.conf, ~/.ceph/$cluster.conf, $cluster.conf"
      conf_files = CEPH_CONF_FILE_DEFAULT; // CEPH_CONF_FILE_DEFAULT就是配置文件的路径

    }
  }



  std::list<std::string> cfl;
  get_str_list(conf_files, cfl);

 CEPH_CONF可以以；或，分割多个配置文件，get_str_list读取处理把多个配置文件放入litst cfl中：

   std::list<std::string> cfl;
  get_str_list(conf_files, cfl);

 cfl里面装的 使用变量定义的配置文件路径 翻译成真实路径？

  auto p = cfl.begin();
  while (p != cfl.end()) {
    // expand $data_dir?
    string &s = *p;
    if (s.find("$data_dir") != string::npos) {
      if (data_dir_option.length()) {
    list<const Option *> stack;
    expand_meta(s, NULL, stack, warnings);
    p++;
      } else {
    cfl.erase(p++);  // ignore this item
      }
    } else {
      ++p;
    }
  }

解析cfl里装的配置文件 

 return parse_config_files_impl(cfl, warnings);

 md_config_t::parse_config_files_impl

int md_config_t::parse_config_files_impl(const std::list<std::string> &conf_files,std::ostream *warnings)
{
  list<string>::const_iterator c;
  // 遍历conf_files，替换"$"后面的字符串，比如将$cluster替换成ceph
  for (c = conf_files.begin(); c != conf_files.end(); ++c) {
    cf.clear();
    string fn = *c;
    // 替换"$"后面的字符串
    expand_meta(fn, warnings);
    // 将ceph.conf(如/etc/ceph/ceph.conf)中的内容读上来保存在cf中
    int ret = cf.parse_file(fn.c_str(), &parse_errors, warnings);
    if (ret == 0) break;
  }

  std::vector <std::string> my_sections;
  // 获取要解析的部分，比如mon：<"mon.node1", "mon", global">, client: <"client.admin", "admin", "global">
  // 即ceph.conf中my_sections对应的部分才会解析
  _get_my_sections(my_sections);
  for (const auto &i : schema) { ... }
  //遍历subsys, 配置debug_**之类的
  for (size_t o = 0; o < subsys.get_num(); o++) { ... }
  ...
  return 0;
}

md_config_t::expand_meta函数用来替换"$"后面的字符串，比如admin_socket = $rundir/$cluster-$id.$pid.asok，调用expand_meta函数后admin_socket = /var/run/ceph/ceph-mon.node1.2093242.asok

bandaoyu
关注
专栏目录
ceph源码开发
ZHANGJNWEI的专栏
06-22 734
Ceph是分布式存储软件，参与其中的开发工作。 （1）checkout源码 git clone git://github.com/ceph/ceph （2）git submodules git submodules update --init --recursive 下载编译工具： ./install-deps.sh 构建Ceph ./do_make.sh ## -DCMAKE_BUILD_TYPE=RelWithDebInfo选项创建...
CC00237.CloudKubernetes——|KuberNetes&存储进阶.V03|——|Ceph.v02|ceph集群|部署|
yanqi_vip
03-31 126
一、部署ceph ### --- 创建crds、common、operator [root@k8s-master01 ceph]# kubectl create -f crds.yaml -f common.yaml -f operator.yaml customresourcedefinition.apiextensions.k8s.io/cephclusters.ceph.roo...
Ceph源代码分析
ws1296931325的博客
05-08 3829
2.1SDS1 2.2Disk2 2.2.1块式与流式2 2.2.2磁盘2 2.2.3固态硬盘4 2.3块存储指令与协议6 2.3.1硬盘物理接口6 2.3.2SCSI指令体系6 2.3.3块存储指令通信协议7 2.4Raid...
ceph源码调试（vstart.sh）
最新发布
分布式存储
09-01 1194
本文介绍如何调试使用vstart脚本部署的ceph集群。
ceph源码之一
weixin_34111819的博客
05-14 277
转自于：http://blog.csdn.net/changtao381/article/details/8698935 一、概述： 　其结构如下：在src 里， 　　网络通信：  msg  里面 包括了网络传输的代码， message 目录里定义了 传输的消息格式。 　　元数据服务器：       　　            mds  目录 包括了metadata server 的代码...
Ceph源码解析：读写流程
weixin_30323961的博客
06-09 5142
转载注明出处，整理也是需要功夫的，http://www.cnblogs.com/chenxianpao/p/5572859.html 一、OSD模块简介 1.1 消息封装：在OSD上发送和接收信息。 cluster_messenger -与其它OSDs和monitors沟通 client_messenger －与客户端沟通 1.2 消息调度： Dispatcher类，主要负责消息分类 ...
ceph源码分析
u013946404的博客
11-20 1615
说明 ceph版本10.2.10
CC00242.CloudKubernetes——|KuberNetes&存储进阶.V08|——|Ceph.v02|ceph集群|部署|
yanqi_vip
03-31 130
一、部署ceph ### --- 创建crds、common、operator [root@k8s-master01 ceph]# kubectl create -f crds.yaml -f common.yaml -f operator.yaml customresourcedefinition.apiextensions.k8s.io/cephclusters.ceph.r...
Docker私有仓库与Harbor部署使用
Yusheng9527的博客
03-11 643
Docker私有仓库与Harbor部署使用一、本地私有仓库1. 下载registry镜像2. 在daemon.json文件中添加私有镜像仓库地址3. 运行registry容器4. Docker容器的重启策略如下5. 为镜像打标签6. 上传到私有仓库7. 列出私有仓库的所有镜像8. 列出私有仓库的centos镜像有哪些tag9. 先删除原有的centos镜像，再测试私有仓库下载二、Harbor1. Harbor简介2. Harbor的特性3. Harbor的构成4. Harbor部署4.1 服务器设置4.2
Centos7系统安装yum遇到的问题failure: repodata/repomd.xml from base: [Errno 256] No more mirrors to try. http:
热门推荐
果冻先生的专栏
06-10 16万+
当遇到这个问题的时候，发现网上也有很多人也在问同样的问题。但是发现大家问的问题，很少有人能解释得很清楚，而且很多人的解决方法复杂且不能解决问题。我查了近二十篇博客和文章，对照做了，但是基本解决不了问题。 http://mirrors.ustc.edu.cn/help/centos.html http://mirrors.163.com/.help/centos.html https://bl...
ceph秘钥管理机制
qq_23929673的博客
01-27 2914
文章目录引言CephX 是什么？CephX 的命名规则默认用户谁才是 CephX 中的鼻祖？CephX 使用场景MONOSDClient细说 capsMON权限介绍r 权限w 权限x 权限* 权限profile osd 权限OSD丢失所有秘钥的恢复流程cephx -> nonekeyring 的分布配置只能访问一个RBD的用户权限总结 引言 这篇文章主要介绍了 Ceph 中的一个重要系统 –...
ceph源码分析--monitor leader选举
SY_Yu的博客
01-19 1217
本篇博客主要分为三个部分 1.概述 2.选举的时机 3.选举的过程 1.概述 monitor在运行的过程中，必须存在一个leader节点来。众多的更新操作都是由leader节点来完成，写的命令也会经由peon转发到leader节点进行。 leader的选择是根据rank值来的，rank值小的为leader，而rank值跟IP地址有关。 2.选举的时机 在ceph中有大致三处
【ceph】《Ceph源码分析》finisher 类
bandaoyu的note
04-06 407
转自：ceph中的finisher类：https://blog.csdn.net/tiantao2012/article/details/79419556 finisher 类是ceph中定义的专门检查操作是否结束的一个类。 《Ceph源码分析》一书中的第2章，第2.4节Finisher，作者常涛，有讲到这个类。更多章节内容可以访问云栖社区“华章计算机”公众号查看。 类Finisher用来完成回调函数Context的执行，其内部有一个FinisherThread线程来用于执行Context回调函数：.
ceph安装配置
weixin_34362875的博客
08-17 217
简介 ceph是一个开源分布式存储系统，支持PB级别的存储，支持对象存储，块存储和文件存储，高性能，高可用，可扩展。 部署网络建议架构图 部署 部署架构图，本次实验部署jewel版本 实验环境的Vagrantfile lab1节点既作admin节点又作node节点，lab2，lab3只作为node节点，lab4作为作测试使用ceph的节点 # -*- mode: ruby -*-...
ceph中的finisher类
jason的笔记
03-02 1371
finisher 类是ceph中定义的专门检查操作是否结束的一个类。 我们首先看这个类的start函数 void Finisher::start() { ldout(cct, 10) &lt;&lt; __func__ &lt;&lt; dendl; finisher_thread.create(thread_name.c_str()); } 调用finisher_thread的creat...
ceph源码分析--ceph命令解析（终端敲命令之后发生的事）
SY_Yu的博客
01-22 2497
在一次开发组内讨论中，那次是admin_socket的后台部分的课程分享。分享中同事提出了一个疑问。既然讲了admin_socket的的后台部分，那前端输入命令到底是怎么去调用的后台呢，或者前台的命令到底是怎么发送的呢？平时的ceph命令到底是怎么解析的呢？讨论会后带着这些疑问，看起了ceph代码。 在终端敲入了ceph stastus，终端就返回了集群的状态。那在这个过程中，到底是调用了什么。
《Ceph源码分析》——导读
weixin_33794672的博客
05-02 388
本节书摘来自华章出版社《Ceph源码分析》一书中的导读，作者常涛，更多章节内容可以访问云栖社区“华章计算机”公众号查看 目　　录序言第1章　Ceph整体架构1.1　Ceph的发展历程 1.2　Ceph的设计目标 1.3　Ceph基本架构图 1.4　Ceph客户端接口 1.4.1　RBD 1.4.2　CephFS ...
Ceph 网络通信源代码分析
changtao381的专栏
03-17 5241
对于一个分布式存储系统，需要一个稳定的底层网络通信模块，用于各个节点的之间的互联互通。对于一个网络通信系统，要求： 高性能 性能评价的两个指标： 带宽和延迟 稳定可靠 在网络中断时，实现重连。数据不丢包 在msg的子目录下， 分别对应三种不同的实现方式：Simple， Async， XIO Simple是相对比较简单，目前可以在生产环境中使用的模式。 它最大的特点是，每一个链接，都创建两个线程，
ceph源码分析--MonitorDB
SY_Yu的博客
02-02 570
友情链接
https://github.com/ceph/ceph/raw/v15.2.17/src/cephadm/cephadm
06-21
`https://github.com/ceph/ceph/raw/v15.2.17/src/cephadm/cephadm` 是Ceph Admin Daemon (cephadm) 的源码链接，Ceph是一个开源的分布式存储系统，而 cephadm 是一个用于部署、管理和升级 Ceph 集群的工具。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值