1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
2 // vim: ts=8 sw=2 smarttab
4 * Ceph - scalable distributed file system
6 * Copyright (C) 2011 New Dream Network
7 * Copyright (C) 2017 OVH
9 * This is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License version 2.1, as published by the Free Software
12 * Foundation. See file COPYING.
16 #include <boost/algorithm/string.hpp>
18 #include "include/mempool.h"
19 #include "common/admin_socket.h"
20 #include "common/perf_counters.h"
21 #include "common/code_environment.h"
22 #include "common/ceph_crypto.h"
23 #include "common/HeartbeatMap.h"
24 #include "common/errno.h"
25 #include "common/Graylog.h"
26 #include "auth/Crypto.h"
27 #include "include/str_list.h"
28 #include "common/PluginRegistry.h"
30 using ceph::bufferlist;
31 using ceph::HeartbeatMap;
35 class LockdepObs : public md_config_obs_t {
37 explicit LockdepObs(CephContext *cct) : m_cct(cct), m_registered(false) {
39 ~LockdepObs() override {
41 lockdep_unregister_ceph_context(m_cct);
45 const char** get_tracked_conf_keys() const override {
46 static const char *KEYS[] = {"lockdep", NULL};
50 void handle_conf_change(const md_config_t *conf,
51 const std::set <std::string> &changed) override {
52 if (conf->lockdep && !m_registered) {
53 lockdep_register_ceph_context(m_cct);
55 } else if (!conf->lockdep && m_registered) {
56 lockdep_unregister_ceph_context(m_cct);
65 class MempoolObs : public md_config_obs_t,
66 public AdminSocketHook {
70 explicit MempoolObs(CephContext *cct) : cct(cct) {
71 cct->_conf->add_observer(this);
72 int r = cct->get_admin_socket()->register_command(
79 ~MempoolObs() override {
80 cct->_conf->remove_observer(this);
81 cct->get_admin_socket()->unregister_command("dump_mempools");
85 const char** get_tracked_conf_keys() const override {
86 static const char *KEYS[] = {
93 void handle_conf_change(const md_config_t *conf,
94 const std::set <std::string> &changed) override {
95 if (changed.count("mempool_debug")) {
96 mempool::set_debug_mode(cct->_conf->mempool_debug);
101 bool call(std::string command, cmdmap_t& cmdmap, std::string format,
102 bufferlist& out) override {
103 if (command == "dump_mempools") {
104 std::unique_ptr<Formatter> f(Formatter::create(format));
105 f->open_object_section("mempools");
106 mempool::dump(f.get());
115 } // anonymous namespace
117 class CephContextServiceThread : public Thread
120 explicit CephContextServiceThread(CephContext *cct)
121 : _lock("CephContextServiceThread::_lock"),
122 _reopen_logs(false), _exit_thread(false), _cct(cct)
126 ~CephContextServiceThread() override {}
128 void *entry() override
131 Mutex::Locker l(_lock);
133 if (_cct->_conf->heartbeat_interval) {
134 utime_t interval(_cct->_conf->heartbeat_interval, 0);
135 _cond.WaitInterval(_lock, interval);
144 _cct->_log->reopen_log_file();
145 _reopen_logs = false;
147 _cct->_heartbeat_map->check_touch_file();
149 // refresh the perf coutners
150 _cct->refresh_perf_values();
157 Mutex::Locker l(_lock);
164 Mutex::Locker l(_lock);
179 * observe logging config changes
181 * The logging subsystem sits below most of the ceph code, including
182 * the config subsystem, to keep it simple and self-contained. Feed
183 * logging-related config changes to the log.
185 class LogObs : public md_config_obs_t {
186 ceph::logging::Log *log;
189 explicit LogObs(ceph::logging::Log *l) : log(l) {}
191 const char** get_tracked_conf_keys() const override {
192 static const char *KEYS[] = {
211 void handle_conf_change(const md_config_t *conf,
212 const std::set <std::string> &changed) override {
214 if (changed.count("log_to_stderr") || changed.count("err_to_stderr")) {
215 int l = conf->log_to_stderr ? 99 : (conf->err_to_stderr ? -1 : -2);
216 log->set_stderr_level(l, l);
220 if (changed.count("log_to_syslog")) {
221 int l = conf->log_to_syslog ? 99 : (conf->err_to_syslog ? -1 : -2);
222 log->set_syslog_level(l, l);
226 if (changed.count("log_file")) {
227 log->set_log_file(conf->log_file);
228 log->reopen_log_file();
231 if (changed.count("log_max_new")) {
233 log->set_max_new(conf->log_max_new);
236 if (changed.count("log_max_recent")) {
237 log->set_max_recent(conf->log_max_recent);
241 if (changed.count("log_to_graylog") || changed.count("err_to_graylog")) {
242 int l = conf->log_to_graylog ? 99 : (conf->err_to_graylog ? -1 : -2);
243 log->set_graylog_level(l, l);
245 if (conf->log_to_graylog || conf->err_to_graylog) {
246 log->start_graylog();
247 } else if (! (conf->log_to_graylog && conf->err_to_graylog)) {
252 if (log->graylog() && (changed.count("log_graylog_host") || changed.count("log_graylog_port"))) {
253 log->graylog()->set_destination(conf->log_graylog_host, conf->log_graylog_port);
257 if (log->graylog() && changed.count("host")) {
258 log->graylog()->set_hostname(conf->host);
261 if (log->graylog() && changed.count("fsid")) {
262 log->graylog()->set_fsid(conf->get_val<uuid_d>("fsid"));
268 // cct config watcher
269 class CephContextObs : public md_config_obs_t {
273 explicit CephContextObs(CephContext *cct) : cct(cct) {}
275 const char** get_tracked_conf_keys() const override {
276 static const char *KEYS[] = {
277 "enable_experimental_unrecoverable_data_corrupting_features",
284 void handle_conf_change(const md_config_t *conf,
285 const std::set <std::string> &changed) override {
287 "enable_experimental_unrecoverable_data_corrupting_features")) {
288 ceph_spin_lock(&cct->_feature_lock);
290 conf->enable_experimental_unrecoverable_data_corrupting_features,
291 cct->_experimental_features);
292 ceph_spin_unlock(&cct->_feature_lock);
293 if (getenv("CEPH_DEV") == NULL) {
294 if (!cct->_experimental_features.empty()) {
295 if (cct->_experimental_features.count("*")) {
296 lderr(cct) << "WARNING: all dangerous and experimental features are enabled." << dendl;
298 lderr(cct) << "WARNING: the following dangerous and experimental features are enabled: "
299 << cct->_experimental_features << dendl;
305 if (changed.count("crush_location")) {
306 cct->crush_location.update_from_conf();
311 bool CephContext::check_experimental_feature_enabled(const std::string& feat)
313 stringstream message;
314 bool enabled = check_experimental_feature_enabled(feat, &message);
315 lderr(this) << message.str() << dendl;
319 bool CephContext::check_experimental_feature_enabled(const std::string& feat,
320 std::ostream *message)
322 ceph_spin_lock(&_feature_lock);
323 bool enabled = (_experimental_features.count(feat) ||
324 _experimental_features.count("*"));
325 ceph_spin_unlock(&_feature_lock);
328 (*message) << "WARNING: experimental feature '" << feat << "' is enabled\n";
329 (*message) << "Please be aware that this feature is experimental, untested,\n";
330 (*message) << "unsupported, and may result in data corruption, data loss,\n";
331 (*message) << "and/or irreparable damage to your cluster. Do not use\n";
332 (*message) << "feature with important data.\n";
334 (*message) << "*** experimental feature '" << feat << "' is not enabled ***\n";
335 (*message) << "This feature is marked as experimental, which means it\n";
336 (*message) << " - is untested\n";
337 (*message) << " - is unsupported\n";
338 (*message) << " - may corrupt your data\n";
339 (*message) << " - may break your cluster is an unrecoverable fashion\n";
340 (*message) << "To enable this feature, add this to your ceph.conf:\n";
341 (*message) << " enable experimental unrecoverable data corrupting features = " << feat << "\n";
348 class CephContextHook : public AdminSocketHook {
352 explicit CephContextHook(CephContext *cct) : m_cct(cct) {}
354 bool call(std::string command, cmdmap_t& cmdmap, std::string format,
355 bufferlist& out) override {
356 m_cct->do_command(command, cmdmap, format, &out);
361 void CephContext::do_command(std::string command, cmdmap_t& cmdmap,
362 std::string format, bufferlist *out)
364 Formatter *f = Formatter::create(format, "json-pretty", "json-pretty");
366 for (cmdmap_t::iterator it = cmdmap.begin(); it != cmdmap.end(); ++it) {
367 if (it->first != "prefix") {
368 ss << it->first << ":" << cmd_vartype_stringify(it->second) << " ";
371 lgeneric_dout(this, 1) << "do_command '" << command << "' '"
372 << ss.str() << dendl;
373 if (command == "perfcounters_dump" || command == "1" ||
374 command == "perf dump") {
377 cmd_getval(this, cmdmap, "logger", logger);
378 cmd_getval(this, cmdmap, "counter", counter);
379 _perf_counters_collection->dump_formatted(f, false, logger, counter);
381 else if (command == "perfcounters_schema" || command == "2" ||
382 command == "perf schema") {
383 _perf_counters_collection->dump_formatted(f, true);
385 else if (command == "perf histogram dump") {
388 cmd_getval(this, cmdmap, "logger", logger);
389 cmd_getval(this, cmdmap, "counter", counter);
390 _perf_counters_collection->dump_formatted_histograms(f, false, logger,
393 else if (command == "perf histogram schema") {
394 _perf_counters_collection->dump_formatted_histograms(f, true);
396 else if (command == "perf reset") {
398 string section = command;
399 f->open_object_section(section.c_str());
400 if (!cmd_getval(this, cmdmap, "var", var)) {
401 f->dump_string("error", "syntax error: 'perf reset <var>'");
403 if(!_perf_counters_collection->reset(var))
404 f->dump_stream("error") << "Not find: " << var;
406 f->dump_string("success", command + ' ' + var);
411 string section = command;
412 boost::replace_all(section, " ", "_");
413 f->open_object_section(section.c_str());
414 if (command == "config show") {
415 _conf->show_config(f);
417 else if (command == "config set") {
419 std::vector<std::string> val;
421 if (!(cmd_getval(this, cmdmap, "var", var)) ||
422 !(cmd_getval(this, cmdmap, "val", val))) {
423 f->dump_string("error", "syntax error: 'config set <var> <value>'");
425 // val may be multiple words
426 string valstr = str_join(val, " ");
427 int r = _conf->set_val(var.c_str(), valstr.c_str());
429 f->dump_stream("error") << "error setting '" << var << "' to '" << valstr << "': " << cpp_strerror(r);
432 _conf->apply_changes(&ss);
433 f->dump_string("success", ss.str());
436 } else if (command == "config get") {
438 if (!cmd_getval(this, cmdmap, "var", var)) {
439 f->dump_string("error", "syntax error: 'config get <var>'");
442 memset(buf, 0, sizeof(buf));
444 int r = _conf->get_val(var.c_str(), &tmp, sizeof(buf));
446 f->dump_stream("error") << "error getting '" << var << "': " << cpp_strerror(r);
448 f->dump_string(var.c_str(), buf);
451 } else if (command == "config help") {
453 if (cmd_getval(this, cmdmap, "var", var)) {
454 // Output a single one
455 std::string key = ConfFile::normalize_key_name(var);
456 const auto &i = _conf->schema.find(key);
457 if (i == _conf->schema.end()) {
458 std::ostringstream msg;
459 msg << "Setting not found: '" << key << "'";
460 f->dump_string("error", msg.str());
466 f->open_array_section("options");
467 for (const auto &option : ceph_options) {
472 } else if (command == "config diff") {
473 md_config_t def_conf;
474 def_conf.set_val("cluster", _conf->cluster);
475 def_conf.name = _conf->name;
476 def_conf.set_val("host", _conf->host);
477 def_conf.apply_changes(NULL);
479 map<string,pair<string,string> > diff;
481 def_conf.diff(_conf, &diff, &unknown);
482 f->open_object_section("diff");
484 f->open_object_section("current");
485 for (map<string,pair<string,string> >::iterator p = diff.begin();
486 p != diff.end(); ++p) {
487 f->dump_string(p->first.c_str(), p->second.second);
489 f->close_section(); // current
490 f->open_object_section("defaults");
491 for (map<string,pair<string,string> >::iterator p = diff.begin();
492 p != diff.end(); ++p) {
493 f->dump_string(p->first.c_str(), p->second.first);
495 f->close_section(); // defaults
496 f->close_section(); // diff
498 f->open_array_section("unknown");
499 for (set<string>::iterator p = unknown.begin();
500 p != unknown.end(); ++p) {
501 f->dump_string("option", *p);
503 f->close_section(); // unknown
504 } else if (command == "config diff get") {
506 if (!cmd_getval(this, cmdmap, "var", setting)) {
507 f->dump_string("error", "syntax error: 'config diff get <var>'");
509 md_config_t def_conf;
510 def_conf.set_val("cluster", _conf->cluster);
511 def_conf.name = _conf->name;
512 def_conf.set_val("host", _conf->host);
513 def_conf.apply_changes(NULL);
515 map<string, pair<string, string>> diff;
517 def_conf.diff(_conf, &diff, &unknown, setting);
518 f->open_object_section("diff");
519 f->open_object_section("current");
521 for (const auto& p : diff) {
522 f->dump_string(p.first.c_str(), p.second.second);
524 f->close_section(); //-- current
526 f->open_object_section("defaults");
527 for (const auto& p : diff) {
528 f->dump_string(p.first.c_str(), p.second.first);
530 f->close_section(); //-- defaults
531 f->close_section(); //-- diff
533 } else if (command == "log flush") {
536 else if (command == "log dump") {
539 else if (command == "log reopen") {
540 _log->reopen_log_file();
543 assert(0 == "registered under wrong command?");
549 lgeneric_dout(this, 1) << "do_command '" << command << "' '" << ss.str()
550 << "result is " << out->length() << " bytes" << dendl;
553 CephContext::CephContext(uint32_t module_type_,
554 enum code_environment_t code_env,
557 _conf(new md_config_t(code_env == CODE_ENVIRONMENT_DAEMON)),
559 _module_type(module_type_),
560 _init_flags(init_flags_),
565 _crypto_inited(false),
566 _service_thread(NULL),
569 _perf_counters_collection(NULL),
570 _perf_counters_conf_obs(NULL),
571 _heartbeat_map(NULL),
574 _plugin_registry(NULL),
576 crush_location(this),
579 ceph_spin_init(&_service_thread_lock);
580 ceph_spin_init(&_associated_objs_lock);
581 ceph_spin_init(&_fork_watchers_lock);
582 ceph_spin_init(&_feature_lock);
583 ceph_spin_init(&_cct_perf_lock);
585 _log = new ceph::logging::Log(&_conf->subsys);
588 _log_obs = new LogObs(_log);
589 _conf->add_observer(_log_obs);
591 _cct_obs = new CephContextObs(this);
592 _conf->add_observer(_cct_obs);
594 _lockdep_obs = new LockdepObs(this);
595 _conf->add_observer(_lockdep_obs);
597 _perf_counters_collection = new PerfCountersCollection(this);
599 _admin_socket = new AdminSocket(this);
600 _heartbeat_map = new HeartbeatMap(this);
602 _plugin_registry = new PluginRegistry(this);
604 _admin_hook = new CephContextHook(this);
605 _admin_socket->register_command("perfcounters_dump", "perfcounters_dump", _admin_hook, "");
606 _admin_socket->register_command("1", "1", _admin_hook, "");
607 _admin_socket->register_command("perf dump", "perf dump name=logger,type=CephString,req=false name=counter,type=CephString,req=false", _admin_hook, "dump perfcounters value");
608 _admin_socket->register_command("perfcounters_schema", "perfcounters_schema", _admin_hook, "");
609 _admin_socket->register_command("perf histogram dump", "perf histogram dump name=logger,type=CephString,req=false name=counter,type=CephString,req=false", _admin_hook, "dump perf histogram values");
610 _admin_socket->register_command("2", "2", _admin_hook, "");
611 _admin_socket->register_command("perf schema", "perf schema", _admin_hook, "dump perfcounters schema");
612 _admin_socket->register_command("perf histogram schema", "perf histogram schema", _admin_hook, "dump perf histogram schema");
613 _admin_socket->register_command("perf reset", "perf reset name=var,type=CephString", _admin_hook, "perf reset <name>: perf reset all or one perfcounter name");
614 _admin_socket->register_command("config show", "config show", _admin_hook, "dump current config settings");
615 _admin_socket->register_command("config help", "config help name=var,type=CephString,req=false", _admin_hook, "get config setting schema and descriptions");
616 _admin_socket->register_command("config set", "config set name=var,type=CephString name=val,type=CephString,n=N", _admin_hook, "config set <field> <val> [<val> ...]: set a config variable");
617 _admin_socket->register_command("config get", "config get name=var,type=CephString", _admin_hook, "config get <field>: get the config value");
618 _admin_socket->register_command("config diff",
619 "config diff", _admin_hook,
620 "dump diff of current config and default config");
621 _admin_socket->register_command("config diff get",
622 "config diff get name=var,type=CephString", _admin_hook,
623 "dump diff get <field>: dump diff of current and default config setting <field>");
624 _admin_socket->register_command("log flush", "log flush", _admin_hook, "flush log entries to log file");
625 _admin_socket->register_command("log dump", "log dump", _admin_hook, "dump recent log entries to log file");
626 _admin_socket->register_command("log reopen", "log reopen", _admin_hook, "reopen log file");
628 _crypto_none = CryptoHandler::create(CEPH_CRYPTO_NONE);
629 _crypto_aes = CryptoHandler::create(CEPH_CRYPTO_AES);
631 MempoolObs *mempool_obs = 0;
632 lookup_or_create_singleton_object(mempool_obs, "mempool_obs");
635 CephContext::~CephContext()
637 join_service_thread();
639 for (map<string, SingletonWrapper*>::iterator it = _associated_objs.begin();
640 it != _associated_objs.end(); ++it)
644 _perf_counters_collection->remove(_cct_perf);
649 delete _plugin_registry;
651 _admin_socket->unregister_command("perfcounters_dump");
652 _admin_socket->unregister_command("1");
653 _admin_socket->unregister_command("perf dump");
654 _admin_socket->unregister_command("perfcounters_schema");
655 _admin_socket->unregister_command("perf histogram dump");
656 _admin_socket->unregister_command("2");
657 _admin_socket->unregister_command("perf schema");
658 _admin_socket->unregister_command("perf histogram schema");
659 _admin_socket->unregister_command("perf reset");
660 _admin_socket->unregister_command("config show");
661 _admin_socket->unregister_command("config set");
662 _admin_socket->unregister_command("config get");
663 _admin_socket->unregister_command("config help");
664 _admin_socket->unregister_command("config diff");
665 _admin_socket->unregister_command("config diff get");
666 _admin_socket->unregister_command("log flush");
667 _admin_socket->unregister_command("log dump");
668 _admin_socket->unregister_command("log reopen");
670 delete _admin_socket;
672 delete _heartbeat_map;
674 delete _perf_counters_collection;
675 _perf_counters_collection = NULL;
677 delete _perf_counters_conf_obs;
678 _perf_counters_conf_obs = NULL;
680 _conf->remove_observer(_log_obs);
684 _conf->remove_observer(_cct_obs);
688 _conf->remove_observer(_lockdep_obs);
697 ceph_spin_destroy(&_service_thread_lock);
698 ceph_spin_destroy(&_fork_watchers_lock);
699 ceph_spin_destroy(&_associated_objs_lock);
700 ceph_spin_destroy(&_feature_lock);
701 ceph_spin_destroy(&_cct_perf_lock);
706 ceph::crypto::shutdown(g_code_env == CODE_ENVIRONMENT_LIBRARY);
709 void CephContext::put() {
711 ANNOTATE_HAPPENS_AFTER(&nref);
712 ANNOTATE_HAPPENS_BEFORE_FORGET_ALL(&nref);
715 ANNOTATE_HAPPENS_BEFORE(&nref);
719 void CephContext::init_crypto()
721 if (!_crypto_inited) {
722 ceph::crypto::init(this);
723 _crypto_inited = true;
727 void CephContext::start_service_thread()
729 ceph_spin_lock(&_service_thread_lock);
730 if (_service_thread) {
731 ceph_spin_unlock(&_service_thread_lock);
734 _service_thread = new CephContextServiceThread(this);
735 _service_thread->create("service");
736 ceph_spin_unlock(&_service_thread_lock);
738 // make logs flush on_exit()
739 if (_conf->log_flush_on_exit)
740 _log->set_flush_on_exit();
742 // Trigger callbacks on any config observers that were waiting for
743 // it to become safe to start threads.
744 _conf->set_val("internal_safe_to_start_threads", "true");
745 _conf->call_all_observers();
747 // start admin socket
748 if (_conf->admin_socket.length())
749 _admin_socket->init(_conf->admin_socket);
752 void CephContext::reopen_logs()
754 ceph_spin_lock(&_service_thread_lock);
756 _service_thread->reopen_logs();
757 ceph_spin_unlock(&_service_thread_lock);
760 void CephContext::join_service_thread()
762 ceph_spin_lock(&_service_thread_lock);
763 CephContextServiceThread *thread = _service_thread;
765 ceph_spin_unlock(&_service_thread_lock);
768 _service_thread = NULL;
769 ceph_spin_unlock(&_service_thread_lock);
771 thread->exit_thread();
776 uint32_t CephContext::get_module_type() const
781 void CephContext::set_init_flags(int flags)
786 int CephContext::get_init_flags() const
791 PerfCountersCollection *CephContext::get_perfcounters_collection()
793 return _perf_counters_collection;
796 void CephContext::enable_perf_counter()
798 PerfCountersBuilder plb(this, "cct", l_cct_first, l_cct_last);
799 plb.add_u64(l_cct_total_workers, "total_workers", "Total workers");
800 plb.add_u64(l_cct_unhealthy_workers, "unhealthy_workers", "Unhealthy workers");
801 PerfCounters *perf_tmp = plb.create_perf_counters();
803 ceph_spin_lock(&_cct_perf_lock);
804 assert(_cct_perf == NULL);
805 _cct_perf = perf_tmp;
806 ceph_spin_unlock(&_cct_perf_lock);
808 _perf_counters_collection->add(_cct_perf);
811 void CephContext::disable_perf_counter()
813 _perf_counters_collection->remove(_cct_perf);
815 ceph_spin_lock(&_cct_perf_lock);
818 ceph_spin_unlock(&_cct_perf_lock);
821 void CephContext::refresh_perf_values()
823 ceph_spin_lock(&_cct_perf_lock);
825 _cct_perf->set(l_cct_total_workers, _heartbeat_map->get_total_workers());
826 _cct_perf->set(l_cct_unhealthy_workers, _heartbeat_map->get_unhealthy_workers());
828 ceph_spin_unlock(&_cct_perf_lock);
831 AdminSocket *CephContext::get_admin_socket()
833 return _admin_socket;
836 CryptoHandler *CephContext::get_crypto_handler(int type)
839 case CEPH_CRYPTO_NONE:
841 case CEPH_CRYPTO_AES: