static void _init_supported(void)
{
- string str = g_conf.auth_supported;
+ string str = g_conf->auth_supported;
list<string> sup_list;
get_str_list(str, sup_list);
for (list<string>::iterator iter = sup_list.begin(); iter != sup_list.end(); ++iter) {
return true;
}
void get_master(CryptoKey& dest) const {
- get_secret(g_conf.name, dest);
+ get_secret(g_conf->name, dest);
}
// modifiers
if (added) {
data.rotating_ver++;
//data.next_rotating_time = g_clock.now();
- //data.next_rotating_time += MIN(g_conf.auth_mon_ticket_ttl, g_conf.auth_service_ticket_ttl);
+ //data.next_rotating_time += MIN(g_conf->auth_mon_ticket_ttl, g_conf->auth_service_ticket_ttl);
_dump_rotating_secrets();
return true;
}
RotatingSecrets& r = data.rotating_secrets[service_id];
int added = 0;
utime_t now = g_clock.now();
- double ttl = service_id == CEPH_ENTITY_TYPE_AUTH ? g_conf.auth_mon_ticket_ttl : g_conf.auth_service_ticket_ttl;
+ double ttl = service_id == CEPH_ENTITY_TYPE_AUTH ? g_conf->auth_mon_ticket_ttl : g_conf->auth_service_ticket_ttl;
while (r.need_new_secrets(now)) {
ExpiringCryptoKey ek;
{
info.service_id = service_id;
info.ticket = auth_ticket_info.ticket;
- info.ticket.init_timestamps(g_clock.now(), g_conf.auth_service_ticket_ttl);
+ info.ticket.init_timestamps(g_clock.now(), g_conf->auth_service_ticket_ttl);
generate_secret(info.session_key);
}
if (secret_id == (uint64_t)-1) {
- if (!keys->get_secret(g_conf.name, service_secret)) {
+ if (!keys->get_secret(g_conf->name, service_secret)) {
dout(0) << "ceph_decode_ticket could not get general service secret for service_id="
<< ceph_entity_type_name(service_id) << " secret_id=" << secret_id << dendl;
return false;
should_enc_ticket = true;
}
- info.ticket.init_timestamps(g_clock.now(), g_conf.auth_mon_ticket_ttl);
+ info.ticket.init_timestamps(g_clock.now(), g_conf->auth_mon_ticket_ttl);
info.ticket.name = entity_name;
info.ticket.global_id = global_id;
info.ticket.auid = eauth.auid;
- info.validity += g_conf.auth_mon_ticket_ttl;
+ info.validity += g_conf->auth_mon_ticket_ttl;
if (auid) *auid = eauth.auid;
ret = r;
break;
}
- info.validity += g_conf.auth_service_ticket_ttl;
+ info.validity += g_conf->auth_service_ticket_ttl;
info_vec.push_back(info);
}
}
bool build_authorizer(uint64_t global_id) {
__u8 struct_v = 1;
::encode(struct_v, bl);
- ::encode(g_conf.name, bl);
+ ::encode(g_conf->name, bl);
::encode(global_id, bl);
return 0;
}
common_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
common_init_finish(&g_ceph_context);
- EntityName ename(g_conf.name);
+ EntityName ename(g_conf->name);
const char *me = argv[0];
static int list_sections(const std::string &prefix)
{
std::vector <std::string> sections;
- int ret = g_conf.get_all_sections(sections);
+ int ret = g_conf->get_all_sections(sections);
if (ret)
return 2;
for (std::vector<std::string>::const_iterator p = sections.begin();
for (deque<string>::const_iterator s = sections.begin(); s != sections.end(); ++s) {
my_sections.push_back(*s);
}
- g_conf.get_my_sections(my_sections);
+ g_conf->get_my_sections(my_sections);
std::string val;
- int ret = g_conf.get_val_from_conf_file(my_sections, key.c_str(), val, true);
+ int ret = g_conf->get_val_from_conf_file(my_sections, key.c_str(), val, true);
if (ret == -ENOENT)
return 1;
else if (ret == 0) {
vec_to_argv(nargs, argc, argv);
// FUSE will chdir("/"); be ready.
- g_conf.chdir = "/";
+ g_conf->chdir = "/";
// check for 32-bit arch
if (sizeof(long) == 4) {
// we need to handle the forking ourselves.
int fd[2] = {0, 0}; // parent's, child's
pid_t childpid = 0;
- if (g_conf.daemonize) {
+ if (g_conf->daemonize) {
int r = socketpair(AF_UNIX, SOCK_STREAM, 0, fd);
if (r < 0) {
cerr << "cfuse[" << getpid() << "]: unable to create socketpair: " << strerror(errno) << std::endl;
// start up fuse
// use my argc, argv (make sure you pass a mount point!)
- int r = client->mount(g_conf.client_mountpoint.c_str());
+ int r = client->mount(g_conf->client_mountpoint.c_str());
if (r < 0) {
cerr << "cfuse[" << getpid() << "]: ceph mount failed with " << strerror(-r) << std::endl;
goto out_shutdown;
// wait for messenger to finish
messenger->wait();
- if (g_conf.daemonize) {
+ if (g_conf->daemonize) {
//cout << "child signalling parent with " << r << std::endl;
::write(fd[1], &r, sizeof(r));
}
#undef dout_prefix
#define dout_prefix *_dout << "client" << whoami << " "
-#define tout if (!g_conf.client_trace.empty()) traceout
+#define tout if (!g_conf->client_trace.empty()) traceout
// static logger
num_flushing_caps = 0;
- lru.lru_set_max(g_conf.client_cache_size);
- lru.lru_set_midpoint(g_conf.client_cache_mid);
+ lru.lru_set_max(g_conf->client_cache_size);
+ lru.lru_set_midpoint(g_conf->client_cache_mid);
// file handles
free_fd_set.insert(10, 1<<30);
<< truncate_size << dendl;
in->truncate_size = truncate_size;
in->oset.truncate_size = truncate_size;
- if (g_conf.client_oc && prior_size > truncate_size) { //do actual in-memory truncation
+ if (g_conf->client_oc && prior_size > truncate_size) { //do actual in-memory truncation
vector<ObjectExtent> ls;
filer->file_to_extents(in->ino, &in->layout,
truncate_size, prior_size - truncate_size,
goto out;
}
- if (g_conf.client_use_random_mds)
+ if (g_conf->client_use_random_mds)
goto random_mds;
if (req->inode) {
}
client_lock.Unlock();
- int r = monclient->authenticate(g_conf.client_mount_timeout);
+ int r = monclient->authenticate(g_conf->client_mount_timeout);
client_lock.Lock();
if (r < 0)
return r;
_ll_get(root);
// trace?
- if (!g_conf.client_trace.empty()) {
- traceout.open(g_conf.client_trace.c_str());
+ if (!g_conf->client_trace.empty()) {
+ traceout.open(g_conf->client_trace.c_str());
if (traceout.is_open()) {
- dout(1) << "opened trace file '" << g_conf.client_trace << "'" << dendl;
+ dout(1) << "opened trace file '" << g_conf->client_trace << "'" << dendl;
} else {
- dout(1) << "FAILED to open trace file '" << g_conf.client_trace << "'" << dendl;
+ dout(1) << "FAILED to open trace file '" << g_conf->client_trace << "'" << dendl;
}
}
lru.lru_set_max(0);
trim_cache();
- if (g_conf.client_oc) {
+ if (g_conf->client_oc) {
// flush/release all buffered data
hash_map<vinodeno_t, Inode*>::iterator next;
for (hash_map<vinodeno_t, Inode*>::iterator p = inode_map.begin();
//}
// unsafe writes
- if (!g_conf.client_oc) {
+ if (!g_conf->client_oc) {
while (unsafe_sync_write > 0) {
dout(0) << unsafe_sync_write << " unsafe_sync_writes, waiting"
<< dendl;
}
// stop tracing
- if (!g_conf.client_trace.empty()) {
- dout(1) << "closing trace file '" << g_conf.client_trace << "'" << dendl;
+ if (!g_conf->client_trace.empty()) {
+ dout(1) << "closing trace file '" << g_conf->client_trace << "'" << dendl;
traceout.close();
}
{
dout(21) << "tick" << dendl;
tick_event = new C_C_Tick(this);
- timer.add_event_after(g_conf.client_tick_interval, tick_event);
+ timer.add_event_after(g_conf->client_tick_interval, tick_event);
utime_t now = g_clock.now();
goto done;
}
- if (dname == g_conf.client_snapdir &&
+ if (dname == g_conf->client_snapdir &&
dir->snapid == CEPH_NOSNAP) {
*target = open_snapdir(dir);
goto done;
in->get_cap_ref(CEPH_CAP_FILE_CACHE);
dout(10) << "readahead=" << readahead << " nr_consec=" << f->nr_consec_read
- << " max_byes=" << g_conf.client_readahead_max_bytes
- << " max_periods=" << g_conf.client_readahead_max_periods << dendl;
+ << " max_byes=" << g_conf->client_readahead_max_bytes
+ << " max_periods=" << g_conf->client_readahead_max_periods << dendl;
// readahead?
if (readahead &&
f->nr_consec_read &&
- (g_conf.client_readahead_max_bytes ||
- g_conf.client_readahead_max_periods)) {
+ (g_conf->client_readahead_max_bytes ||
+ g_conf->client_readahead_max_periods)) {
loff_t l = f->consec_read_bytes * 2;
- if (g_conf.client_readahead_min)
- l = MAX(l, g_conf.client_readahead_min);
- if (g_conf.client_readahead_max_bytes)
- l = MIN(l, g_conf.client_readahead_max_bytes);
+ if (g_conf->client_readahead_min)
+ l = MAX(l, g_conf->client_readahead_min);
+ if (g_conf->client_readahead_max_bytes)
+ l = MIN(l, g_conf->client_readahead_max_bytes);
loff_t p = in->layout.fl_stripe_count * in->layout.fl_object_size;
- if (g_conf.client_readahead_max_periods)
- l = MIN(l, g_conf.client_readahead_max_periods * p);
+ if (g_conf->client_readahead_max_periods)
+ l = MIN(l, g_conf->client_readahead_max_periods * p);
if (l >= 2*p)
// align large readahead with period
dout(10) << " snaprealm " << *in->snaprealm << dendl;
- if (g_conf.client_oc && (got & CEPH_CAP_FILE_BUFFER)) {
+ if (g_conf->client_oc && (got & CEPH_CAP_FILE_BUFFER)) {
// do buffered write
if (!in->oset.dirty_tx && in->oset.uncommitted.empty())
get_cap_ref(in, CEPH_CAP_FILE_BUFFER);
dout(3) << "_fsync(" << f << ", " << (syncdataonly ? "dataonly)":"data+metadata)") << dendl;
- if (g_conf.client_oc)
+ if (g_conf->client_oc)
_flush(in);
if (!syncdataonly && (in->dirty_caps & ~CEPH_CAP_ANY_FILE_WR)) {
int SyntheticClient::create_objects(int nobj, int osize, int inflight)
{
// divy up
- int numc = g_conf.num_client ? g_conf.num_client : 1;
+ int numc = g_conf->num_client ? g_conf->num_client : 1;
int start, inc, end;
if (sp < 0) dirnum++;
//dout(0) << "leading dir " << filename << " " << dirnum << dendl;
- if (dirnum % g_conf.num_client != client->get_nodeid()) {
+ if (dirnum % g_conf->num_client != client->get_nodeid()) {
dout(20) << "skipping leading dir " << dirnum << " " << filename << dendl;
continue;
}
}
dout(0) << "requesting oneshot_replay for mds" << r << dendl;
shadow = MDSMap::STATE_ONESHOT_REPLAY;
- g_conf.mds_standby_for_rank = r;
+ g_conf->mds_standby_for_rank = r;
}
else if (ceph_argparse_witharg(args, i, &val, "--hot-standby", (char*)NULL)) {
int r = parse_rank("hot-standby", val);
}
dout(0) << "requesting standby_replay for mds" << r << dendl;
shadow = MDSMap::STATE_STANDBY_REPLAY;
- g_conf.mds_standby_for_rank = r;
+ g_conf->mds_standby_for_rank = r;
}
else {
derr << "Error: can't understand argument: " << *i << "\n" << dendl;
}
// Normal startup
- if (g_conf.name.has_default_id()) {
+ if (g_conf->name.has_default_id()) {
derr << "must specify '-i name' with the cmds instance name" << dendl;
usage();
}
SimpleMessenger *messenger = new SimpleMessenger();
messenger->bind(getpid());
- cout << "starting " << g_conf.name << " at " << messenger->get_ms_addr()
+ cout << "starting " << g_conf->name << " at " << messenger->get_ms_addr()
<< std::endl;
messenger->register_entity(entity_name_t::MDS(-1));
uint64_t supported =
messenger->start();
// start mds
- MDS *mds = new MDS(g_conf.name.get_id().c_str(), messenger, &mc);
+ MDS *mds = new MDS(g_conf->name.get_id().c_str(), messenger, &mc);
// in case we have to respawn...
mds->orig_argc = argc;
usage();
}
- if (g_conf.mon_data.empty()) {
+ if (g_conf->mon_data.empty()) {
cerr << "must specify '--mon-data=foo' data path" << std::endl;
usage();
}
// -- mkfs --
if (mkfs) {
common_init_finish(&g_ceph_context);
- if (g_conf.monmap.empty() || !osdmapfn)
+ if (g_conf->monmap.empty() || !osdmapfn)
usage();
// make sure it doesn't already exist
/*
struct stat st;
- if (::lstat(g_conf.mon_data.c_str(), &st) == 0) {
- cerr << "monfs dir " << g_conf.mon_data << " already exists; remove it first" << std::endl;
+ if (::lstat(g_conf->mon_data.c_str(), &st) == 0) {
+ cerr << "monfs dir " << g_conf->mon_data << " already exists; remove it first" << std::endl;
usage();
}
*/
// load monmap
bufferlist monmapbl, osdmapbl;
- int err = monmapbl.read_file(g_conf.monmap.c_str());
+ int err = monmapbl.read_file(g_conf->monmap.c_str());
if (err < 0)
exit(1);
MonMap monmap;
exit(1);
// go
- MonitorStore store(g_conf.mon_data);
- Monitor mon(g_conf.name.get_id(), &store, 0, &monmap);
+ MonitorStore store(g_conf->mon_data);
+ Monitor mon(g_conf->name.get_id(), &store, 0, &monmap);
mon.mkfs(osdmapbl);
- cout << argv[0] << ": created monfs at " << g_conf.mon_data
- << " for " << g_conf.name << std::endl;
+ cout << argv[0] << ": created monfs at " << g_conf->mon_data
+ << " for " << g_conf->name << std::endl;
return 0;
}
ceph_mon_feature_incompat);
CompatSet ondisk_features;
- MonitorStore store(g_conf.mon_data);
+ MonitorStore store(g_conf->mon_data);
err = store.mount();
if (err < 0) {
char buf[80];
- cerr << "problem opening monitor store in " << g_conf.mon_data << ": " << strerror_r(-err, buf, sizeof(buf)) << std::endl;
+ cerr << "problem opening monitor store in " << g_conf->mon_data << ": " << strerror_r(-err, buf, sizeof(buf)) << std::endl;
exit(1);
}
assert(v == monmap.get_epoch());
}
- if (!monmap.contains(g_conf.name.get_id())) {
- cerr << g_conf.name << " does not exist in monmap" << std::endl;
+ if (!monmap.contains(g_conf->name.get_id())) {
+ cerr << g_conf->name << " does not exist in monmap" << std::endl;
exit(1);
}
- entity_addr_t ipaddr = monmap.get_addr(g_conf.name.get_id());
+ entity_addr_t ipaddr = monmap.get_addr(g_conf->name.get_id());
entity_addr_t conf_addr;
std::vector <std::string> my_sections;
- g_conf.get_my_sections(my_sections);
+ g_conf->get_my_sections(my_sections);
std::string mon_addr_str;
- if (g_conf.get_val_from_conf_file(my_sections, "mon addr",
+ if (g_conf->get_val_from_conf_file(my_sections, "mon addr",
mon_addr_str, true) == 0)
{
if (conf_addr.parse(mon_addr_str.c_str()) && (ipaddr != conf_addr)) {
// bind
SimpleMessenger *messenger = new SimpleMessenger();
- int rank = monmap.get_rank(g_conf.name.get_id());
+ int rank = monmap.get_rank(g_conf->name.get_id());
- cout << "starting " << g_conf.name << " rank " << rank
- << " at " << monmap.get_addr(g_conf.name.get_id())
- << " mon_data " << g_conf.mon_data
+ cout << "starting " << g_conf->name << " rank " << rank
+ << " at " << monmap.get_addr(g_conf->name.get_id())
+ << " mon_data " << g_conf->mon_data
<< " fsid " << monmap.get_fsid()
<< std::endl;
- err = messenger->bind(monmap.get_addr(g_conf.name.get_id()), 0);
+ err = messenger->bind(monmap.get_addr(g_conf->name.get_id()), 0);
if (err < 0)
return 1;
// start monitor
messenger->register_entity(entity_name_t::MON(rank));
messenger->set_default_send_priority(CEPH_MSG_PRIO_HIGH);
- Monitor *mon = new Monitor(g_conf.name.get_id(), &store, messenger, &monmap);
+ Monitor *mon = new Monitor(g_conf->name.get_id(), &store, messenger, &monmap);
common_init_daemonize(&g_ceph_context, 0);
common_init_finish(&g_ceph_context);
struct timeval tv;
gettimeofday(&tv, NULL);
utime_t n(&tv);
- n += g_conf.clock_offset;
+ n += g_conf->clock_offset;
if (n < last) {
//derr << "WARNING: clock jumped backwards from " << last << " to " << n << dendl;
n = last; // clock jumped backwards!
if ((changed.count("log_to_syslog") || changed.count("name")) &&
(g_code_env == CODE_ENVIRONMENT_DAEMON)) {
closelog();
- openlog(g_conf.name.to_cstr(), LOG_ODELAY | LOG_PID, LOG_USER);
+ openlog(g_conf->name.to_cstr(), LOG_ODELAY | LOG_PID, LOG_USER);
}
flags |= DOUTSB_FLAG_SYSLOG;
}
e.msg = s;
// log to syslog?
- if (g_conf.clog_to_syslog) {
+ if (g_conf->clog_to_syslog) {
ostringstream oss;
oss << e;
string str(oss.str());
}
// log to monitor?
- if (g_conf.clog_to_monitors) {
+ if (g_conf->clog_to_monitors) {
log_queue.push_back(e);
// if we are a monitor, queue for ourselves, synchronously
#undef dout
#undef derr
-#define dout(l) if (l<=g_conf.debug_lockdep) *_dout << g_clock.now() << " " << std::hex << pthread_self() << std::dec << " lockdep: "
-#define derr(l) if (l<=g_conf.debug_lockdep) *_derr << g_clock.now() << " " << std::hex << pthread_self() << std::dec << " lockdep: "
+#define dout(l) if (l<=g_conf->debug_lockdep) *_dout << g_clock.now() << " " << std::hex << pthread_self() << std::dec << " lockdep: "
+#define derr(l) if (l<=g_conf->debug_lockdep) *_derr << g_clock.now() << " " << std::hex << pthread_self() << std::dec << " lockdep: "
pthread_mutex_t lockdep_mutex = PTHREAD_MUTEX_INITIALIZER;
{
generic_dout(20) << "flush_all_loggers" << dendl;
- if (!g_conf.profiling_logger)
+ if (!g_conf->profiling_logger)
return;
utime_t now = g_clock.now();
int now_sec = fromstart.sec();
// do any catching up we need to
- bool twice = now_sec - last_flush >= 2 * g_conf.profiling_logger_interval;
+ bool twice = now_sec - last_flush >= 2 * g_conf->profiling_logger_interval;
again:
generic_dout(20) << "fromstart " << fromstart << " last_flush " << last_flush << " flushing" << dendl;
if (reset && logger_need_reset)
logger_need_reset = false;
- last_flush = now_sec - (now_sec % g_conf.profiling_logger_interval);
+ last_flush = now_sec - (now_sec % g_conf->profiling_logger_interval);
if (twice) {
twice = false;
goto again;
// schedule next flush event
utime_t next;
- next.sec_ref() = start.sec() + last_flush + g_conf.profiling_logger_interval;
+ next.sec_ref() = start.sec() + last_flush + g_conf->profiling_logger_interval;
next.nsec_ref() = start.nsec();
generic_dout(20) << "logger now=" << now
<< " start=" << start
struct stat st;
filename = "";
- if ((!g_conf.chdir.empty()) &&
- (g_conf.profiling_logger_dir.substr(0,1) != "/")) {
+ if ((!g_conf->chdir.empty()) &&
+ (g_conf->profiling_logger_dir.substr(0,1) != "/")) {
char cwd[PATH_MAX];
char *c = getcwd(cwd, sizeof(cwd));
assert(c);
filename += "/";
}
- filename = g_conf.profiling_logger_dir;
+ filename = g_conf->profiling_logger_dir;
// make (feeble) attempt to create logger_dir
if (::stat(filename.c_str(), &st))
::mkdir(filename.c_str(), 0750);
filename += "/";
- if (!g_conf.profiling_logger_subdir.empty()) {
- filename += g_conf.profiling_logger_subdir;
+ if (!g_conf->profiling_logger_subdir.empty()) {
+ filename += g_conf->profiling_logger_subdir;
::mkdir( filename.c_str(), 0755 ); // make sure dir exists
filename += "/";
}
if (vals[i] > 0) {
double avg = (fvals[i] / (double)vals[i]);
double var = 0.0;
- if (g_conf.profiling_logger_calc_variance &&
+ if (g_conf->profiling_logger_calc_variance &&
(unsigned)vals[i] == vals_to_avg[i].size()) {
for (vector<double>::iterator p = vals_to_avg[i].begin(); p != vals_to_avg[i].end(); ++p)
var += (avg - *p) * (avg - *p);
int64_t ProfLogger::inc(int key, int64_t v)
{
- if (!g_conf.profiling_logger)
+ if (!g_conf->profiling_logger)
return 0;
prof_logger_lock.Lock();
int i = type->lookup_key(key);
double ProfLogger::finc(int key, double v)
{
- if (!g_conf.profiling_logger)
+ if (!g_conf->profiling_logger)
return 0;
prof_logger_lock.Lock();
int i = type->lookup_key(key);
int64_t ProfLogger::set(int key, int64_t v)
{
- if (!g_conf.profiling_logger)
+ if (!g_conf->profiling_logger)
return 0;
prof_logger_lock.Lock();
int i = type->lookup_key(key);
double ProfLogger::fset(int key, double v)
{
- if (!g_conf.profiling_logger)
+ if (!g_conf->profiling_logger)
return 0;
prof_logger_lock.Lock();
int i = type->lookup_key(key);
double ProfLogger::favg(int key, double v)
{
- if (!g_conf.profiling_logger)
+ if (!g_conf->profiling_logger)
return 0;
prof_logger_lock.Lock();
int i = type->lookup_key(key);
vals[i]++;
double r = fvals[i] += v;
- if (g_conf.profiling_logger_calc_variance)
+ if (g_conf->profiling_logger_calc_variance)
vals_to_avg[i].push_back(v);
prof_logger_lock.Unlock();
return r;
int64_t ProfLogger::get(int key)
{
- if (!g_conf.profiling_logger)
+ if (!g_conf->profiling_logger)
return 0;
prof_logger_lock.Lock();
int i = type->lookup_key(key);
// FIXME
// These variables are here temporarily to make the transition easier.
CephContext g_ceph_context __attribute__((init_priority(103)));
-md_config_t &g_conf(*g_ceph_context._conf);
+md_config_t *g_conf(g_ceph_context._conf);
std::ostream *_dout(&g_ceph_context._dout);
DoutStreambuf <char, std::basic_string<char>::traits_type> *_doss(g_ceph_context._doss);
/* Globals (FIXME: remove) */
extern CephContext g_ceph_context;
-extern md_config_t &g_conf;
+extern md_config_t *g_conf;
extern std::ostream *_dout;
extern DoutStreambuf <char, std::basic_string<char>::traits_type> *_doss;
exit(1);
}
}
- pidfile_write(&g_conf);
- ret = g_ceph_context._doss->handle_pid_change(&g_conf);
+ pidfile_write(g_conf);
+ ret = g_ceph_context._doss->handle_pid_change(g_conf);
if (ret) {
derr << "common_init_daemonize: _doss->handle_pid_change failed with "
<< "error code " << ret << dendl;
#define TYCHECK(x, ty) STATIC_ASSERT(sizeof(x) == sizeof(ty))
#define OPTION_OPT_STR(name, def_val) \
- { STRINGIFY(name) + TYCHECK(g_conf.name, std::string), \
+ { STRINGIFY(name) + TYCHECK(g_conf->name, std::string), \
OPT_STR, offsetof(struct md_config_t, name), def_val, 0, 0 }
#define OPTION_OPT_ADDR(name, def_val) \
- { STRINGIFY(name) + TYCHECK(g_conf.name, entity_addr_t), \
+ { STRINGIFY(name) + TYCHECK(g_conf->name, entity_addr_t), \
OPT_ADDR, offsetof(struct md_config_t, name), def_val, 0, 0 }
#define OPTION_OPT_LONGLONG(name, def_val) \
- { STRINGIFY(name) + TYCHECK(g_conf.name, long long), \
+ { STRINGIFY(name) + TYCHECK(g_conf->name, long long), \
OPT_LONGLONG, offsetof(struct md_config_t, name), 0, def_val, 0 }
#define OPTION_OPT_INT(name, def_val) \
- { STRINGIFY(name) + TYCHECK(g_conf.name, int), \
+ { STRINGIFY(name) + TYCHECK(g_conf->name, int), \
OPT_INT, offsetof(struct md_config_t, name), 0, def_val, 0 }
#define OPTION_OPT_BOOL(name, def_val) \
- { STRINGIFY(name) + TYCHECK(g_conf.name, bool), \
+ { STRINGIFY(name) + TYCHECK(g_conf->name, bool), \
OPT_BOOL, offsetof(struct md_config_t, name), 0, def_val, 0 }
#define OPTION_OPT_U32(name, def_val) \
- { STRINGIFY(name) + TYCHECK(g_conf.name, uint32_t), \
+ { STRINGIFY(name) + TYCHECK(g_conf->name, uint32_t), \
OPT_U32, offsetof(struct md_config_t, name), 0, def_val, 0 }
#define OPTION_OPT_U64(name, def_val) \
- { STRINGIFY(name) + TYCHECK(g_conf.name, uint64_t), \
+ { STRINGIFY(name) + TYCHECK(g_conf->name, uint64_t), \
OPT_U64, offsetof(struct md_config_t, name), 0, def_val, 0 }
#define OPTION_OPT_DOUBLE(name, def_val) \
- { STRINGIFY(name) + TYCHECK(g_conf.name, double), \
+ { STRINGIFY(name) + TYCHECK(g_conf->name, double), \
OPT_DOUBLE, offsetof(struct md_config_t, name), 0, 0, def_val }
#define OPTION_OPT_FLOAT(name, def_val) \
- { STRINGIFY(name) + TYCHECK(g_conf.name, float), \
+ { STRINGIFY(name) + TYCHECK(g_conf->name, float), \
OPT_FLOAT, offsetof(struct md_config_t, name), 0, 0, def_val }
#define OPTION(name, type, def_val) OPTION_##type(name, def_val)
// generic macros
#define debug_DOUT_SUBSYS debug
#define dout_prefix *_dout
-#define DOUT_CONDVAR(x) g_conf.debug_ ## x
+#define DOUT_CONDVAR(x) g_conf->debug_ ## x
#define XDOUT_CONDVAR(x) DOUT_CONDVAR(x)
#define DOUT_COND(l) l <= XDOUT_CONDVAR(DOUT_SUBSYS)
*_dout
#define generic_dout(v) \
- pdout(v, g_conf.debug)
+ pdout(v, g_conf->debug)
#define dendl std::endl; } } while (0)
// whoami
char *end;
- const char *id = g_conf.name.get_id().c_str();
+ const char *id = g_conf->name.get_id().c_str();
int whoami = strtol(id, &end, 10);
if (*end || end == id || whoami < 0) {
derr << "must specify '-i #' where # is the osd number" << dendl;
usage();
}
- if (g_conf.osd_data.empty()) {
+ if (g_conf->osd_data.empty()) {
derr << "must specify '--osd-data=foo' data path" << dendl;
usage();
}
if (mc.get_monmap_privately() < 0)
return -1;
- int err = OSD::mkfs(g_conf.osd_data, g_conf.osd_journal, mc.monmap.fsid, whoami);
+ int err = OSD::mkfs(g_conf->osd_data, g_conf->osd_journal, mc.monmap.fsid, whoami);
if (err < 0) {
derr << TEXT_RED << " ** ERROR: error creating empty object store in "
- << g_conf.osd_data << ": " << cpp_strerror(-err) << TEXT_NORMAL << dendl;
+ << g_conf->osd_data << ": " << cpp_strerror(-err) << TEXT_NORMAL << dendl;
exit(1);
}
- derr << "created object store " << g_conf.osd_data;
- if (!g_conf.osd_journal.empty())
- *_dout << " journal " << g_conf.osd_journal;
+ derr << "created object store " << g_conf->osd_data;
+ if (!g_conf->osd_journal.empty())
+ *_dout << " journal " << g_conf->osd_journal;
*_dout << " for osd" << whoami << " fsid " << mc.monmap.fsid << dendl;
}
if (mkkey) {
derr << "Unable to get a Ceph keyring." << dendl;
return 1;
}
- EntityName ename(g_conf.name);
+ EntityName ename(g_conf->name);
EntityAuth eauth;
eauth.key.create(CEPH_CRYPTO_AES);
keyring->add(ename, eauth);
bufferlist bl;
keyring->encode_plaintext(bl);
- int r = bl.write_file(g_conf.keyring.c_str(), 0600);
+ int r = bl.write_file(g_conf->keyring.c_str(), 0600);
if (r)
- derr << TEXT_RED << " ** ERROR: writing new keyring to " << g_conf.keyring
+ derr << TEXT_RED << " ** ERROR: writing new keyring to " << g_conf->keyring
<< ": " << cpp_strerror(r) << TEXT_NORMAL << dendl;
else
- derr << "created new key in keyring " << g_conf.keyring << dendl;
+ derr << "created new key in keyring " << g_conf->keyring << dendl;
}
if (mkfs || mkkey)
exit(0);
if (mkjournal) {
common_init_finish(&g_ceph_context);
- int err = OSD::mkjournal(g_conf.osd_data, g_conf.osd_journal);
+ int err = OSD::mkjournal(g_conf->osd_data, g_conf->osd_journal);
if (err < 0) {
- derr << TEXT_RED << " ** ERROR: error creating fresh journal " << g_conf.osd_journal
- << " for object store " << g_conf.osd_data
+ derr << TEXT_RED << " ** ERROR: error creating fresh journal " << g_conf->osd_journal
+ << " for object store " << g_conf->osd_data
<< ": " << cpp_strerror(-err) << TEXT_NORMAL << dendl;
exit(1);
}
- derr << "created new journal " << g_conf.osd_journal
- << " for object store " << g_conf.osd_data << dendl;
+ derr << "created new journal " << g_conf->osd_journal
+ << " for object store " << g_conf->osd_data << dendl;
exit(0);
}
if (flushjournal) {
common_init_finish(&g_ceph_context);
- int err = OSD::flushjournal(g_conf.osd_data, g_conf.osd_journal);
+ int err = OSD::flushjournal(g_conf->osd_data, g_conf->osd_journal);
if (err < 0) {
- derr << TEXT_RED << " ** ERROR: error flushing journal " << g_conf.osd_journal
- << " for object store " << g_conf.osd_data
+ derr << TEXT_RED << " ** ERROR: error flushing journal " << g_conf->osd_journal
+ << " for object store " << g_conf->osd_data
<< ": " << cpp_strerror(-err) << TEXT_NORMAL << dendl;
exit(1);
}
- derr << "flushed journal " << g_conf.osd_journal
- << " for object store " << g_conf.osd_data
+ derr << "flushed journal " << g_conf->osd_journal
+ << " for object store " << g_conf->osd_data
<< dendl;
exit(0);
}
string magic;
ceph_fsid_t fsid;
int w;
- int r = OSD::peek_meta(g_conf.osd_data, magic, fsid, w);
+ int r = OSD::peek_meta(g_conf->osd_data, magic, fsid, w);
if (r < 0) {
derr << TEXT_RED << " ** ERROR: unable to open OSD superblock on "
- << g_conf.osd_data << ": " << cpp_strerror(-r)
+ << g_conf->osd_data << ": " << cpp_strerror(-r)
<< TEXT_NORMAL << dendl;
if (r == -ENOTSUP) {
derr << TEXT_RED << " ** please verify that underlying storage "
exit(1);
}
- bool client_addr_set = !g_conf.public_addr.is_blank_addr();
- bool cluster_addr_set = !g_conf.cluster_addr.is_blank_addr();
+ bool client_addr_set = !g_conf->public_addr.is_blank_addr();
+ bool cluster_addr_set = !g_conf->cluster_addr.is_blank_addr();
if (cluster_addr_set && !client_addr_set) {
derr << TEXT_RED << " ** "
<< "WARNING: set cluster address but not client address!" << " **\n"
<< "using cluster address for clients" << TEXT_NORMAL << dendl;
- g_conf.public_addr = g_conf.cluster_addr;
+ g_conf->public_addr = g_conf->cluster_addr;
client_addr_set = true;
cluster_addr_set = false;
}
SimpleMessenger *cluster_messenger = new SimpleMessenger();
SimpleMessenger *messenger_hb = new SimpleMessenger();
- client_messenger->bind(g_conf.public_addr, getpid());
- cluster_messenger->bind(g_conf.cluster_addr, getpid());
+ client_messenger->bind(g_conf->public_addr, getpid());
+ cluster_messenger->bind(g_conf->cluster_addr, getpid());
// hb should bind to same ip as cluster_addr (if specified)
- entity_addr_t hb_addr = g_conf.cluster_addr;
+ entity_addr_t hb_addr = g_conf->cluster_addr;
if (!hb_addr.is_blank_addr())
hb_addr.set_port(0);
messenger_hb->bind(hb_addr, getpid());
cout << "starting osd" << whoami
<< " at " << client_messenger->get_ms_addr()
- << " osd_data " << g_conf.osd_data
- << " " << ((g_conf.osd_journal.empty()) ?
- "(no journal)" : g_conf.osd_journal)
+ << " osd_data " << g_conf->osd_data
+ << " " << ((g_conf->osd_journal.empty()) ?
+ "(no journal)" : g_conf->osd_journal)
<< std::endl;
client_messenger->register_entity(entity_name_t::OSD(whoami));
cluster_messenger->register_entity(entity_name_t::OSD(whoami));
messenger_hb->register_entity(entity_name_t::OSD(whoami));
- Throttle client_throttler(g_conf.osd_client_message_size_cap);
+ Throttle client_throttler(g_conf->osd_client_message_size_cap);
uint64_t supported =
CEPH_FEATURE_UID |
common_init_chdir(&g_ceph_context);
OSD *osd = new OSD(whoami, cluster_messenger, client_messenger, messenger_hb, &mc,
- g_conf.osd_data, g_conf.osd_journal);
+ g_conf->osd_data, g_conf->osd_journal);
int err = osd->pre_init();
if (err < 0) {
derr << TEXT_RED << " ** ERROR: initializing osd failed: " << cpp_strerror(-err)
list<Client*> clients;
list<SyntheticClient*> synclients;
- SimpleMessenger* messengers[g_conf.num_client];
- MonClient* mclients[g_conf.num_client];
+ SimpleMessenger* messengers[g_conf->num_client];
+ MonClient* mclients[g_conf->num_client];
- cout << "csyn: starting " << g_conf.num_client << " syn client(s)" << std::endl;
- for (int i=0; i<g_conf.num_client; i++) {
+ cout << "csyn: starting " << g_conf->num_client << " syn client(s)" << std::endl;
+ for (int i=0; i<g_conf->num_client; i++) {
messengers[i] = new SimpleMessenger();
messengers[i]->register_entity(entity_name_t(entity_name_t::TYPE_CLIENT,-1));
messengers[i]->bind(i * 1000000 + getpid());
delete client;
}
- for (int i = 0; i < g_conf.num_client; ++i) {
+ for (int i = 0; i < g_conf->num_client; ++i) {
// wait for messenger to finish
delete mclients[i];
messengers[i]->wait();
IoCtxImpl(RadosClient *c, int pid, const char *pool_name_, snapid_t s) :
ref_cnt(0), client(c), poolid(pid),
pool_name(pool_name_), snap_seq(s), assert_ver(0),
- notify_timeout(g_conf.client_notify_timeout), oloc(pid),
+ notify_timeout(g_conf->client_notify_timeout), oloc(pid),
aio_write_list_lock("librados::IoCtxImpl::aio_write_list_lock"), aio_write_seq(0) {}
void dup(const IoCtxImpl& rhs) {
out << " " << dir.fnode.fragstat;
if (!(dir.fnode.fragstat == dir.fnode.accounted_fragstat))
out << "/" << dir.fnode.accounted_fragstat;
- if (g_conf.mds_debug_scatterstat && dir.is_projected()) {
+ if (g_conf->mds_debug_scatterstat && dir.is_projected()) {
fnode_t *pf = dir.get_projected_fnode();
out << "->" << pf->fragstat;
if (!(pf->fragstat == pf->accounted_fragstat))
out << " " << dir.fnode.rstat;
if (!(dir.fnode.rstat == dir.fnode.accounted_rstat))
out << "/" << dir.fnode.accounted_rstat;
- if (g_conf.mds_debug_scatterstat && dir.is_projected()) {
+ if (g_conf->mds_debug_scatterstat && dir.is_projected()) {
fnode_t *pf = dir.get_projected_fnode();
out << "->" << pf->rstat;
if (!(pf->rstat == pf->accounted_rstat))
//if (i->second->get_linkage()->is_primary())
dout(1) << *(i->second) << dendl;
}
- assert(!g_conf.mds_debug_scatterstat ||
+ assert(!g_conf->mds_debug_scatterstat ||
(get_num_head_items() ==
(fnode.fragstat.nfiles + fnode.fragstat.nsubdirs)));
} else {
dout(25) << "my rstats: " << fnode.rstat << dendl;
}
- assert(!g_conf.mds_debug_scatterstat || sub_info.rbytes == fnode.rstat.rbytes);
- assert(!g_conf.mds_debug_scatterstat || sub_info.rfiles == fnode.rstat.rfiles);
- assert(!g_conf.mds_debug_scatterstat || sub_info.rsubdirs == fnode.rstat.rsubdirs);
+ assert(!g_conf->mds_debug_scatterstat || sub_info.rbytes == fnode.rstat.rbytes);
+ assert(!g_conf->mds_debug_scatterstat || sub_info.rfiles == fnode.rstat.rfiles);
+ assert(!g_conf->mds_debug_scatterstat || sub_info.rsubdirs == fnode.rstat.rsubdirs);
dout(10) << "check_rstats complete on " << this << dendl;
return true;
}
}
// complete first? (only if we're not using TMAPUP osd op)
- if (!g_conf.mds_use_tmap && !is_complete()) {
+ if (!g_conf->mds_use_tmap && !is_complete()) {
dout(7) << "commit not complete, fetching first" << dendl;
if (cache->mds->logger) cache->mds->logger->inc(l_mds_dir_ffc);
fetch(new C_Dir_RetryCommit(this, want));
max_write_size -= inode->encode_parent_mutation(m);
if (is_complete() &&
- (num_dirty > (num_head_items*g_conf.mds_dir_commit_ratio))) {
+ (num_dirty > (num_head_items*g_conf->mds_dir_commit_ratio))) {
fnode.snap_purged_thru = realm->get_last_destroyed();
committed_dn = _commit_full(m, snaps, max_write_size);
} else {
void merge(list<CDir*>& subs, list<Context*>& waiters, bool replay);
bool should_split() {
- return (int)get_num_head_items() > g_conf.mds_bal_split_size;
+ return (int)get_num_head_items() > g_conf->mds_bal_split_size;
}
bool should_merge() {
- return (int)get_num_head_items() < g_conf.mds_bal_merge_size;
+ return (int)get_num_head_items() < g_conf->mds_bal_merge_size;
}
private:
if (in.inode.is_dir()) {
out << " " << in.inode.dirstat;
- if (g_conf.mds_debug_scatterstat && in.is_projected()) {
+ if (g_conf->mds_debug_scatterstat && in.is_projected()) {
inode_t *pi = in.get_projected_inode();
out << "->" << pi->dirstat;
}
out << " " << in.inode.rstat;
if (!(in.inode.rstat == in.inode.accounted_rstat))
out << "/" << in.inode.accounted_rstat;
- if (g_conf.mds_debug_scatterstat && in.is_projected()) {
+ if (g_conf->mds_debug_scatterstat && in.is_projected()) {
inode_t *pi = in.get_projected_inode();
out << "->" << pi->rstat;
if (!(pi->rstat == pi->accounted_rstat))
dirfragtree.force_to_leaf(p->first);
}
}
- if (g_conf.mds_debug_frag)
+ if (g_conf->mds_debug_frag)
verify_dirfrags();
}
break;
if (pf->fragstat.nsubdirs < 0)
pf->fragstat.nsubdirs = 0;
- assert(!"bad/negative frag size" == g_conf.mds_verify_scatter);
+ assert(!"bad/negative frag size" == g_conf->mds_verify_scatter);
}
if (update) {
pi->dirstat = pf->fragstat;
pi->dirstat.version = v;
- assert(!"unmatched fragstat size" == g_conf.mds_verify_scatter);
+ assert(!"unmatched fragstat size" == g_conf->mds_verify_scatter);
}
}
}
if (pi->dirstat.nsubdirs < 0)
pi->dirstat.nsubdirs = 0;
- assert(!"bad/negative dir size" == g_conf.mds_verify_scatter);
+ assert(!"bad/negative dir size" == g_conf->mds_verify_scatter);
}
}
break;
pi->rstat = pf->rstat;
pi->rstat.version = v;
- assert(!"unmatched rstat rbytes" == g_conf.mds_verify_scatter);
+ assert(!"unmatched rstat rbytes" == g_conf->mds_verify_scatter);
}
}
if (update)
<< dendl;
assert(nested_auth_pins >= 0);
- if (g_conf.mds_debug_auth_pins) {
+ if (g_conf->mds_debug_auth_pins) {
// audit
int s = 0;
for (map<frag_t,CDir*>::iterator p = dirfrags.begin();
bool has_dirfrags() { return !dirfrags.empty(); }
CDir* get_dirfrag(frag_t fg) {
if (dirfrags.count(fg)) {
- //assert(g_conf.debug_mds < 2 || dirfragtree.is_leaf(fg)); // performance hack FIXME
+ //assert(g_conf->debug_mds < 2 || dirfragtree.is_leaf(fg)); // performance hack FIXME
return dirfrags[fg];
} else
return 0;
{
bool done = false;
Cond cond;
- int rank = strtol(g_conf.name.get_id().c_str(), 0, 0);
+ int rank = strtol(g_conf->name.get_id().c_str(), 0, 0);
inodeno_t ino = MDS_INO_LOG_OFFSET + rank;
lock.Lock();
<< *lock << " " << *lock->get_parent() << dendl;
continue;
}
- if (now - lock->get_update_stamp() < g_conf.mds_scatter_nudge_interval)
+ if (now - lock->get_update_stamp() < g_conf->mds_scatter_nudge_interval)
break;
updated_scatterlocks.pop_front();
scatter_nudge(lock, 0);
#define DOUT_SUBSYS mds
#undef DOUT_COND
-#define DOUT_COND(l) l<=g_conf.debug_mds || l <= g_conf.debug_mds_balancer
+#define DOUT_COND(l) l<=g_conf->debug_mds || l <= g_conf->debug_mds_balancer
#undef dout_prefix
#define dout_prefix *_dout << "mds" << mds->get_nodeid() << ".bal "
void MDBalancer::tick()
{
- static int num_bal_times = g_conf.mds_bal_max;
+ static int num_bal_times = g_conf->mds_bal_max;
static utime_t first = g_clock.now();
utime_t now = g_clock.now();
utime_t elapsed = now;
elapsed -= first;
// sample?
- if ((double)now - (double)last_sample > g_conf.mds_bal_sample_interval) {
+ if ((double)now - (double)last_sample > g_conf->mds_bal_sample_interval) {
dout(15) << "tick last_sample now " << now << dendl;
last_sample = now;
}
if (last_heartbeat == utime_t())
last_heartbeat = now;
if (mds->get_nodeid() == 0 &&
- g_conf.mds_bal_interval > 0 &&
+ g_conf->mds_bal_interval > 0 &&
(num_bal_times ||
- (g_conf.mds_bal_max_until >= 0 &&
- elapsed.sec() > g_conf.mds_bal_max_until)) &&
+ (g_conf->mds_bal_max_until >= 0 &&
+ elapsed.sec() > g_conf->mds_bal_max_until)) &&
mds->is_active() &&
- now.sec() - last_heartbeat.sec() >= g_conf.mds_bal_interval) {
+ now.sec() - last_heartbeat.sec() >= g_conf->mds_bal_interval) {
last_heartbeat = now;
send_heartbeat();
num_bal_times--;
}
// hash?
- if (g_conf.mds_bal_frag && g_conf.mds_bal_fragment_interval > 0 &&
- now.sec() - last_fragment.sec() > g_conf.mds_bal_fragment_interval) {
+ if (g_conf->mds_bal_frag && g_conf->mds_bal_fragment_interval > 0 &&
+ now.sec() - last_fragment.sec() > g_conf->mds_bal_fragment_interval) {
last_fragment = now;
do_fragmenting();
}
double mds_load_t::mds_load()
{
- switch(g_conf.mds_bal_mode) {
+ switch(g_conf->mds_bal_mode) {
case 0:
return
.8 * auth.meta_load() +
continue;
dout(0) << "do_fragmenting splitting " << *dir << dendl;
- mds->mdcache->split_dir(dir, g_conf.mds_bal_split_bits);
+ mds->mdcache->split_dir(dir, g_conf->mds_bal_split_bits);
}
}
void MDBalancer::prep_rebalance(int beat)
{
- if (g_conf.mds_thrash_exports) {
+ if (g_conf->mds_thrash_exports) {
//we're going to randomly export to all the mds in the cluster
my_targets.clear();
set<int> up_mds;
<< dendl;
// under or over?
- if (my_load < target_load * (1.0 + g_conf.mds_bal_min_rebalance)) {
+ if (my_load < target_load * (1.0 + g_conf->mds_bal_min_rebalance)) {
dout(5) << " i am underloaded or barely overloaded, doing nothing." << dendl;
last_epoch_under = beat_epoch;
show_imports();
if (!check_targets())
return;
- if (g_conf.mds_thrash_exports) {
+ if (g_conf->mds_thrash_exports) {
dout(5) << "mds_thrash is on; not performing standard rebalance operation!"
<< dendl;
return;
if (im->get_inode()->is_stray()) continue;
double pop = im->pop_auth_subtree.meta_load(rebalance_time, mds->mdcache->decayrate);
- if (g_conf.mds_bal_idle_threshold > 0 &&
- pop < g_conf.mds_bal_idle_threshold &&
+ if (g_conf->mds_bal_idle_threshold > 0 &&
+ pop < g_conf->mds_bal_idle_threshold &&
im->inode != mds->mdcache->get_root() &&
im->inode->authority().first != mds->get_nodeid()) {
dout(0) << " exporting idle (" << pop << ") import " << *im
dout(0) << " total sent is " << total_sent << " / " << total_goal << " -> fac 1/ " << fac << dendl;
if (fac > 1.0) fac = 1.0;
}
- fac = .9 - .4 * ((float)g_conf.num_mds / 128.0); // hack magic fixme
+ fac = .9 - .4 * ((float)g_conf->num_mds / 128.0); // hack magic fixme
*/
int target = (*it).first;
continue;
}
dout(20) << " target mds" << p->first << " has been non-target for " << p->second << dendl;
- if (p->second < g_conf.mds_bal_target_removal_min)
+ if (p->second < g_conf->mds_bal_target_removal_min)
want_targets.insert(p->first);
- if (p->second >= g_conf.mds_bal_target_removal_max)
+ if (p->second >= g_conf->mds_bal_target_removal_max)
send = true;
p++;
}
set<CDir*>& already_exporting)
{
double need = amount - have;
- if (need < amount * g_conf.mds_bal_min_start)
+ if (need < amount * g_conf->mds_bal_min_start)
return; // good enough!
- double needmax = need * g_conf.mds_bal_need_max;
- double needmin = need * g_conf.mds_bal_need_min;
- double midchunk = need * g_conf.mds_bal_midchunk;
- double minchunk = need * g_conf.mds_bal_minchunk;
+ double needmax = need * g_conf->mds_bal_need_max;
+ double needmin = need * g_conf->mds_bal_need_min;
+ double midchunk = need * g_conf->mds_bal_midchunk;
+ double minchunk = need * g_conf->mds_bal_minchunk;
list<CDir*> bigger_rep, bigger_unrep;
multimap<double, CDir*> smaller;
//dout(0) << "hit_dir " << type << " pop " << v << " in " << *dir << dendl;
// split/merge
- if (g_conf.mds_bal_frag && g_conf.mds_bal_fragment_interval > 0 &&
+ if (g_conf->mds_bal_frag && g_conf->mds_bal_fragment_interval > 0 &&
!dir->inode->is_base() && // not root/base (for now at least)
dir->is_auth()) {
<< " size " << dir->get_num_head_items() << dendl;
// split
- if (g_conf.mds_bal_split_size > 0 &&
- ((dir->get_num_head_items() > (unsigned)g_conf.mds_bal_split_size) ||
- (v > g_conf.mds_bal_split_rd && type == META_POP_IRD) ||
- (v > g_conf.mds_bal_split_wr && type == META_POP_IWR)) &&
+ if (g_conf->mds_bal_split_size > 0 &&
+ ((dir->get_num_head_items() > (unsigned)g_conf->mds_bal_split_size) ||
+ (v > g_conf->mds_bal_split_rd && type == META_POP_IRD) ||
+ (v > g_conf->mds_bal_split_wr && type == META_POP_IWR)) &&
split_queue.count(dir->dirfrag()) == 0) {
dout(1) << "hit_dir " << type << " pop is " << v << ", putting in split_queue: " << *dir << dendl;
split_queue.insert(dir->dirfrag());
// merge?
if (dir->get_frag() != frag_t() &&
- (dir->get_num_head_items() < (unsigned)g_conf.mds_bal_merge_size) &&
+ (dir->get_num_head_items() < (unsigned)g_conf->mds_bal_merge_size) &&
merge_queue.count(dir->dirfrag()) == 0) {
dout(1) << "hit_dir " << type << " pop is " << v << ", putting in merge_queue: " << *dir << dendl;
merge_queue.insert(dir->dirfrag());
if (dir->is_auth() && !dir->is_ambiguous_auth()) {
if (!dir->is_rep() &&
- dir_pop >= g_conf.mds_bal_replicate_threshold) {
+ dir_pop >= g_conf->mds_bal_replicate_threshold) {
// replicate
float rdp = dir->pop_me.get(META_POP_IRD).get(now, mds->mdcache->decayrate);
rd_adj = rdp / mds->get_mds_map()->get_num_mds() - rdp;
if (dir->ino() != 1 &&
dir->is_rep() &&
- dir_pop < g_conf.mds_bal_unreplicate_threshold) {
+ dir_pop < g_conf->mds_bal_unreplicate_threshold) {
// unreplicate
dout(0) << "unreplicating dir " << *dir << " pop " << dir_pop << dendl;
if (dir->is_auth()) {
if (!dir->is_rep() &&
- dir_pop >= g_conf.mds_bal_replicate_threshold) {
+ dir_pop >= g_conf->mds_bal_replicate_threshold) {
// replicate
dout(5) << "replicating dir " << *in << " pop " << dir_pop << dendl;
}
if (dir->is_rep() &&
- dir_pop < g_conf.mds_bal_unreplicate_threshold) {
+ dir_pop < g_conf->mds_bal_unreplicate_threshold) {
// unreplicate
dout(5) << "unreplicating dir " << *in << " pop " << dir_pop << dendl;
num_inodes_with_caps = 0;
num_caps = 0;
- max_dir_commit_size = g_conf.mds_dir_max_commit_size ?
- (g_conf.mds_dir_max_commit_size << 20) :
- (0.9 *(g_conf.osd_max_write_size << 20));
+ max_dir_commit_size = g_conf->mds_dir_max_commit_size ?
+ (g_conf->mds_dir_max_commit_size << 20) :
+ (0.9 *(g_conf->osd_max_write_size << 20));
discover_last_tid = 0;
find_ino_peer_last_tid = 0;
client_lease_durations[2] = 300.0;
opening_root = open = false;
- lru.lru_set_max(g_conf.mds_cache_size);
- lru.lru_set_midpoint(g_conf.mds_cache_mid);
+ lru.lru_set_max(g_conf->mds_cache_size);
+ lru.lru_set_midpoint(g_conf->mds_cache_mid);
- decayrate.set_halflife(g_conf.mds_decay_halflife);
+ decayrate.set_halflife(g_conf->mds_decay_halflife);
did_shutdown_log_cap = false;
}
void MDCache::log_stat()
{
- mds->logger->set(l_mds_imax, g_conf.mds_cache_size);
+ mds->logger->set(l_mds_imax, g_conf->mds_cache_size);
mds->logger->set(l_mds_i, lru.lru_get_size());
mds->logger->set(l_mds_ipin, lru.lru_get_num_pinned());
mds->logger->set(l_mds_itop, lru.lru_get_top());
memset(&in->inode.dir_layout, 0, sizeof(in->inode.dir_layout));
if (in->inode.is_dir()) {
memset(&in->inode.layout, 0, sizeof(in->inode.layout));
- in->inode.dir_layout.dl_dir_hash = g_conf.mds_default_dir_hash;
+ in->inode.dir_layout.dl_dir_hash = g_conf->mds_default_dir_hash;
++in->inode.rstat.rsubdirs;
} else {
in->inode.layout = default_file_layout;
dout(20) << " result [" << first << "," << last << "] " << pi->rstat << dendl;
if (pi->rstat.rbytes < 0)
- assert(!"negative rstat rbytes" == g_conf.mds_verify_scatter);
+ assert(!"negative rstat rbytes" == g_conf->mds_verify_scatter);
last = first-1;
}
// delay propagating until later?
if (!stop && !first &&
- g_conf.mds_dirstat_min_interval > 0) {
+ g_conf->mds_dirstat_min_interval > 0) {
if (pin->last_dirstat_prop.sec() > 0) {
double since_last_prop = mut->now - pin->last_dirstat_prop;
- if (since_last_prop < g_conf.mds_dirstat_min_interval) {
+ if (since_last_prop < g_conf->mds_dirstat_min_interval) {
dout(10) << "predirty_journal_parents last prop " << since_last_prop
- << " < " << g_conf.mds_dirstat_min_interval
+ << " < " << g_conf->mds_dirstat_min_interval
<< ", stopping" << dendl;
stop = true;
} else {
dout(20) << "predirty_journal_parents gives " << pi->dirstat << " on " << *pin << dendl;
if (pi->dirstat.size() < 0)
- assert(!"negative dirstat size" == g_conf.mds_verify_scatter);
+ assert(!"negative dirstat size" == g_conf->mds_verify_scatter);
if (parent->get_frag() == frag_t()) { // i.e., we are the only frag
if (pi->dirstat.size() != pf->fragstat.size()) {
mds->clog.error() << "unmatched fragstat size on single dirfrag "
// trust the dirfrag for now
pi->dirstat = pf->fragstat;
- assert(!"unmatched fragstat size" == g_conf.mds_verify_scatter);
+ assert(!"unmatched fragstat size" == g_conf->mds_verify_scatter);
}
}
}
// trust the dirfrag for now
pi->rstat = pf->rstat;
- assert(!"unmatched rstat rbytes" == g_conf.mds_verify_scatter);
+ assert(!"unmatched rstat rbytes" == g_conf->mds_verify_scatter);
}
}
}
{
// trim LRU
if (max < 0) {
- max = g_conf.mds_cache_size;
+ max = g_conf->mds_cache_size;
if (!max) return false;
}
dout(7) << "trim max=" << max << " cur=" << lru.lru_get_size() << dendl;
<< ", malloc " << last.malloc << " mmap " << last.mmap
<< ", baseline " << baseline.get_heap()
<< ", buffers " << (buffer::get_total_alloc() >> 10)
- << ", max " << g_conf.mds_mem_max
+ << ", max " << g_conf->mds_mem_max
<< ", " << num_inodes_with_caps << " / " << inode_map.size() << " inodes have caps"
<< ", " << num_caps << " caps, " << caps_per_inode << " caps per inode"
<< dendl;
mds->mlogger->set(l_mdm_malloc, last.malloc);
/*int size = last.get_total();
- if (size > g_conf.mds_mem_max * .9) {
- float ratio = (float)g_conf.mds_mem_max * .9 / (float)size;
+ if (size > g_conf->mds_mem_max * .9) {
+ float ratio = (float)g_conf->mds_mem_max * .9 / (float)size;
if (ratio < 1.0)
mds->server->recall_client_state(ratio);
} else
*/
- if (num_inodes_with_caps > g_conf.mds_cache_size) {
- float ratio = (float)g_conf.mds_cache_size * .9 / (float)num_inodes_with_caps;
+ if (num_inodes_with_caps > g_conf->mds_cache_size) {
+ float ratio = (float)g_conf->mds_cache_size * .9 / (float)num_inodes_with_caps;
if (ratio < 1.0)
mds->server->recall_client_state(ratio);
}
dout(0) << "shutdown_check at " << g_clock.now() << dendl;
// cache
- int o = g_conf.debug_mds;
- g_conf.debug_mds = 10;
+ int o = g_conf->debug_mds;
+ g_conf->debug_mds = 10;
show_cache();
- g_conf.debug_mds = o;
- mds->timer.add_event_after(g_conf.mds_shutdown_check, new C_MDC_ShutdownCheck(this));
+ g_conf->debug_mds = o;
+ mds->timer.add_event_after(g_conf->mds_shutdown_check, new C_MDC_ShutdownCheck(this));
// this
dout(0) << "lru size now " << lru.lru_get_size() << dendl;
{
dout(2) << "shutdown_start" << dendl;
- if (g_conf.mds_shutdown_check)
- mds->timer.add_event_after(g_conf.mds_shutdown_check, new C_MDC_ShutdownCheck(this));
+ if (g_conf->mds_shutdown_check)
+ mds->timer.add_event_after(g_conf->mds_shutdown_check, new C_MDC_ShutdownCheck(this));
- // g_conf.debug_mds = 10;
+ // g_conf->debug_mds = 10;
}
list<CDir*> resultfrags;
list<Context*> waiters;
adjust_dir_fragments(diri, dirs, basefrag, bits, resultfrags, waiters, false);
- if (g_conf.mds_debug_frag)
+ if (g_conf->mds_debug_frag)
diri->verify_dirfrags();
mds->queue_waiters(waiters);
list<CDir*> resultfrags;
adjust_dir_fragments(diri, base, bits,
resultfrags, waiters, false);
- if (g_conf.mds_debug_frag)
+ if (g_conf->mds_debug_frag)
diri->verify_dirfrags();
/*
list<CDir*> resultfrags;
list<Context*> waiters;
adjust_dir_fragments(diri, p->first.frag, -p->second, resultfrags, waiters, true);
- if (g_conf.mds_debug_frag)
+ if (g_conf->mds_debug_frag)
diri->verify_dirfrags();
EFragment *le = new EFragment(mds->mdlog, EFragment::OP_ROLLBACK, diri->ino(), p->first.frag, p->second);
{
//dout(10) << "show_subtrees" << dendl;
- if (dbl > g_conf.debug && dbl > g_conf.debug_mds)
+ if (dbl > g_conf->debug && dbl > g_conf->debug_mds)
return; // i won't print anything.
if (subtrees.empty()) {
#define DOUT_SUBSYS mds
#undef DOUT_COND
-#define DOUT_COND(l) l<=g_conf.debug_mds || l <= g_conf.debug_mds_log
+#define DOUT_COND(l) l<=g_conf->debug_mds || l <= g_conf->debug_mds_log
#undef dout_prefix
#define dout_prefix *_dout << "mds" << mds->get_nodeid() << ".log "
// logger
char name[80];
- snprintf(name, sizeof(name), "mds.%s.log", g_conf.name.get_id().c_str());
+ snprintf(name, sizeof(name), "mds.%s.log", g_conf->name.get_id().c_str());
logger = new ProfLogger(name, &mdlog_logtype);
logger_add(logger);
}
assert(le == cur_event);
cur_event = NULL;
- if (!g_conf.mds_log) {
+ if (!g_conf->mds_log) {
// hack: log is disabled.
if (c) {
c->finish(0);
void MDLog::wait_for_safe(Context *c)
{
- if (g_conf.mds_log) {
+ if (g_conf->mds_log) {
// wait
journaler->wait_for_flush(c);
} else {
void MDLog::trim(int m)
{
- int max_segments = g_conf.mds_log_max_segments;
- int max_events = g_conf.mds_log_max_events;
+ int max_segments = g_conf->mds_log_max_segments;
+ int max_events = g_conf->mds_log_max_events;
if (m >= 0)
max_events = m;
if (stop < g_clock.now())
break;
- if ((int)expiring_segments.size() >= g_conf.mds_log_max_expiring)
+ if ((int)expiring_segments.size() >= g_conf->mds_log_max_expiring)
break;
// look at first segment
bl.hexdump(*_dout);
*_dout << dendl;
- assert(!!"corrupt log event" == g_conf.mds_log_skip_corrupt_events);
+ assert(!!"corrupt log event" == g_conf->mds_log_skip_corrupt_events);
continue;
}
// open loggers
char name[80];
snprintf(name, sizeof(name), "mds.%s.%llu.log",
- g_conf.name.get_id().c_str(),
+ g_conf->name.get_id().c_str(),
(unsigned long long) monc->get_global_id());
logger = new ProfLogger(name, (ProfLogType*)&mds_logtype);
logger_add(logger);
snprintf(name, sizeof(name), "mds.%s.%llu.mem.log",
- g_conf.name.get_id().c_str(),
+ g_conf->name.get_id().c_str(),
(unsigned long long) monc->get_global_id());
mlogger = new ProfLogger(name, (ProfLogType*)&mdm_logtype);
logger_add(mlogger);
timer.init();
- if (wanted_state==MDSMap::STATE_BOOT && g_conf.mds_standby_replay)
+ if (wanted_state==MDSMap::STATE_BOOT && g_conf->mds_standby_replay)
wanted_state = MDSMap::STATE_STANDBY_REPLAY;
// starting beacon. this will induce an MDSMap from the monitor
want_state = wanted_state;
if (wanted_state==MDSMap::STATE_STANDBY_REPLAY ||
wanted_state==MDSMap::STATE_ONESHOT_REPLAY) {
- g_conf.mds_standby_replay = true;
+ g_conf->mds_standby_replay = true;
if ( wanted_state == MDSMap::STATE_ONESHOT_REPLAY &&
- (g_conf.mds_standby_for_rank == -1) &&
- g_conf.mds_standby_for_name.empty()) {
+ (g_conf->mds_standby_for_rank == -1) &&
+ g_conf->mds_standby_for_name.empty()) {
// uh-oh, must specify one or the other!
dout(0) << "Specified oneshot replay mode but not an MDS!" << dendl;
suicide();
standby_type = wanted_state;
}
- standby_for_rank = g_conf.mds_standby_for_rank;
- standby_for_name.assign(g_conf.mds_standby_for_name);
+ standby_for_rank = g_conf->mds_standby_for_rank;
+ standby_for_name.assign(g_conf->mds_standby_for_name);
if (wanted_state == MDSMap::STATE_STANDBY_REPLAY &&
standby_for_rank == -1) {
// schedule
tick_event = new C_MDS_Tick(this);
- timer.add_event_after(g_conf.mds_tick_interval, tick_event);
+ timer.add_event_after(g_conf->mds_tick_interval, tick_event);
}
void MDS::tick()
// schedule next sender
if (beacon_sender) timer.cancel_event(beacon_sender);
beacon_sender = new C_MDS_BeaconSender(this);
- timer.add_event_after(g_conf.mds_beacon_interval, beacon_sender);
+ timer.add_event_after(g_conf->mds_beacon_interval, beacon_sender);
}
utime_t now = g_clock.now();
utime_t since = now - beacon_last_acked_stamp;
- if (since > g_conf.mds_beacon_grace) {
- dout(5) << "is_laggy " << since << " > " << g_conf.mds_beacon_grace
+ if (since > g_conf->mds_beacon_grace) {
+ dout(5) << "is_laggy " << since << " > " << g_conf->mds_beacon_grace
<< " since last acked beacon" << dendl;
was_laggy = true;
return true;
<< " seq " << m->get_seq()
<< " rtt " << rtt << dendl;
- if (was_laggy && rtt < g_conf.mds_beacon_grace) {
+ if (was_laggy && rtt < g_conf->mds_beacon_grace) {
dout(0) << "handle_mds_beacon no longer laggy" << dendl;
was_laggy = false;
laggy_until = now;
void MDS::reset_beacon_killer()
{
utime_t when = beacon_last_acked_stamp;
- when += g_conf.mds_beacon_grace;
+ when += g_conf->mds_beacon_grace;
dout(25) << "reset_beacon_killer last_acked_stamp at " << beacon_last_acked_stamp
<< ", will die at " << when << dendl;
{
dout(10) << "handle_command args: " << m->cmd << dendl;
if (m->cmd[0] == "injectargs")
- g_conf.injectargs(m->cmd[1]);
+ g_conf->injectargs(m->cmd[1]);
else if (m->cmd[0] == "dumpcache") {
if (m->cmd.size() > 1)
mdcache->dump_cache(m->cmd[1].c_str());
objecter->set_client_incarnation(incarnation);
// for debug
- if (g_conf.mds_dump_cache_on_map)
+ if (g_conf->mds_dump_cache_on_map)
mdcache->dump_cache();
// did it change?
rejoin_joint_start();
// did we finish?
- if (g_conf.mds_dump_cache_after_rejoin &&
+ if (g_conf->mds_dump_cache_after_rejoin &&
oldmap->is_rejoining() && !mdsmap->is_rejoining())
mdcache->dump_cache(); // for DEBUG only
}
if (is_standby_replay()) {
dout(10) << "setting replay timer" << dendl;
- timer.add_event_after(g_conf.mds_replay_interval,
+ timer.add_event_after(g_conf->mds_replay_interval,
new C_MDS_StandbyReplayRestart(this));
return;
}
mdlog->get_journaler()->set_writeable();
mdlog->get_journaler()->trim_tail();
- if (g_conf.mds_wipe_sessions) {
+ if (g_conf->mds_wipe_sessions) {
dout(1) << "wiping out client sessions" << dendl;
sessionmap.wipe();
sessionmap.save(new C_NoopContext);
}
- if (g_conf.mds_wipe_ino_prealloc) {
+ if (g_conf->mds_wipe_ino_prealloc) {
dout(1) << "wiping out ino prealloc from sessions" << dendl;
sessionmap.wipe_ino_prealloc();
sessionmap.save(new C_NoopContext);
}
- if (g_conf.mds_skip_ino) {
- inodeno_t i = g_conf.mds_skip_ino;
+ if (g_conf->mds_skip_ino) {
+ inodeno_t i = g_conf->mds_skip_ino;
dout(1) << "skipping " << i << " inodes" << dendl;
inotable->skip_inos(i);
inotable->save(new C_NoopContext);
/*double el = now - start;
if (el > 30.0 &&
el < 60.0)*/
- for (int i=0; i<g_conf.mds_thrash_exports; i++) {
+ for (int i=0; i<g_conf->mds_thrash_exports; i++) {
set<int> s;
if (!is_active()) break;
mdsmap->get_mds_set(s, MDSMap::STATE_ACTIVE);
if (s.size() < 2 || mdcache->get_num_inodes() < 10)
break; // need peers for this to work.
- dout(7) << "mds thrashing exports pass " << (i+1) << "/" << g_conf.mds_thrash_exports << dendl;
+ dout(7) << "mds thrashing exports pass " << (i+1) << "/" << g_conf->mds_thrash_exports << dendl;
// pick a random dir inode
CInode *in = mdcache->hack_pick_random_inode();
mdcache->migrator->export_dir_nicely(dir,dest);
}
// hack: thrash fragments
- for (int i=0; i<g_conf.mds_thrash_fragments; i++) {
+ for (int i=0; i<g_conf->mds_thrash_fragments; i++) {
if (!is_active()) break;
- dout(7) << "mds thrashing fragments pass " << (i+1) << "/" << g_conf.mds_thrash_fragments << dendl;
+ dout(7) << "mds thrashing fragments pass " << (i+1) << "/" << g_conf->mds_thrash_fragments << dendl;
// pick a random dir inode
CInode *in = mdcache->hack_pick_random_inode();
MDSMap() : epoch(0), flags(0), last_failure(0), last_failure_osd_epoch(0), tableserver(0), root(0),
cas_pg_pool(-1), metadata_pg_pool(0) {
// hack.. this doesn't really belong here
- session_timeout = (int)g_conf.mds_session_timeout;
- session_autoclose = (int)g_conf.mds_session_autoclose;
- max_file_size = g_conf.mds_max_file_size;
+ session_timeout = (int)g_conf->mds_session_timeout;
+ session_autoclose = (int)g_conf->mds_session_autoclose;
+ max_file_size = g_conf->mds_max_file_size;
}
utime_t get_session_timeout() {
continue;
if ((p->second.standby_for_rank == MDS_NO_STANDBY_PREF ||
p->second.standby_for_rank == MDS_MATCHED_ACTIVE ||
- (p->second.standby_for_rank == MDS_STANDBY_ANY && g_conf.mon_force_standby_active))) {
+ (p->second.standby_for_rank == MDS_STANDBY_ANY && g_conf->mon_force_standby_active))) {
return p->first;
}
}
if (pending_prepare.count(reqid)) {
dout(10) << "got agree on " << reqid << " atid " << tid << dendl;
- assert(g_conf.mds_kill_mdstable_at != 3);
+ assert(g_conf->mds_kill_mdstable_at != 3);
Context *onfinish = pending_prepare[reqid].onfinish;
*pending_prepare[reqid].ptid = tid;
pending_commit[tid]->pending_commit_tids[table].count(tid)) {
dout(10) << "got ack on tid " << tid << ", logging" << dendl;
- assert(g_conf.mds_kill_mdstable_at != 7);
+ assert(g_conf->mds_kill_mdstable_at != 7);
// remove from committing list
pending_commit[tid]->pending_commit_tids[table].erase(tid);
{
dout(10) << "_logged_ack " << tid << dendl;
- assert(g_conf.mds_kill_mdstable_at != 8);
+ assert(g_conf->mds_kill_mdstable_at != 8);
// kick any waiters (LogSegment trim)
if (ack_waiters.count(tid)) {
pending_commit[tid] = ls;
ls->pending_commit_tids[table].insert(tid);
- assert(g_conf.mds_kill_mdstable_at != 4);
+ assert(g_conf->mds_kill_mdstable_at != 4);
// send message
MMDSTableRequest *req = new MMDSTableRequest(table, TABLESERVER_OP_COMMIT, 0, tid);
_prepare(req->bl, req->reqid, from);
_note_prepare(from, req->reqid);
- assert(g_conf.mds_kill_mdstable_at != 1);
+ assert(g_conf->mds_kill_mdstable_at != 1);
ETableServer *le = new ETableServer(table, TABLESERVER_OP_PREPARE, req->reqid, from, version, version);
mds->mdlog->start_entry(le);
{
dout(7) << "_create_logged " << *req << " tid " << tid << dendl;
- assert(g_conf.mds_kill_mdstable_at != 2);
+ assert(g_conf->mds_kill_mdstable_at != 2);
MMDSTableRequest *reply = new MMDSTableRequest(table, TABLESERVER_OP_AGREE, req->reqid, tid);
reply->bl = req->bl;
if (pending_for_mds.count(tid)) {
- assert(g_conf.mds_kill_mdstable_at != 5);
+ assert(g_conf->mds_kill_mdstable_at != 5);
_commit(tid);
_note_commit(tid);
{
dout(7) << "_commit_logged, sending ACK" << dendl;
- assert(g_conf.mds_kill_mdstable_at != 6);
+ assert(g_conf->mds_kill_mdstable_at != 6);
MMDSTableRequest *reply = new MMDSTableRequest(table, TABLESERVER_OP_ACK, req->reqid, req->get_tid());
mds->send_message_mds(reply, req->get_source().num());
#define DOUT_SUBSYS mds
#undef DOUT_COND
-#define DOUT_COND(l) l <= g_conf.debug_mds || l <= g_conf.debug_mds_migrator
+#define DOUT_COND(l) l <= g_conf->debug_mds || l <= g_conf->debug_mds_migrator
#undef dout_prefix
#define dout_prefix *_dout << "mds" << mds->get_nodeid() << ".migrator "
// notify them; wait in aborting state
import_notify_abort(dir, bounds);
import_state[df] = IMPORT_ABORTING;
- assert(g_conf.mds_kill_import_at != 10);
+ assert(g_conf->mds_kill_import_at != 10);
}
}
break;
void Migrator::audit()
{
- if (g_conf.debug_mds < 5) return; // hrm.
+ if (g_conf->debug_mds < 5) return; // hrm.
// import_state
show_importing();
export_peer[dir] = dest;
dir->state_set(CDir::STATE_EXPORTING);
- assert(g_conf.mds_kill_export_at != 1);
+ assert(g_conf->mds_kill_export_at != 1);
// send ExportDirDiscover (ask target)
filepath path;
dir->inode->make_path(path);
mds->send_message_mds(new MExportDirDiscover(mds->get_nodeid(), path, dir->dirfrag()), dest);
- assert(g_conf.mds_kill_export_at != 2);
+ assert(g_conf->mds_kill_export_at != 2);
// start the freeze, but hold it up with an auth_pin.
dir->auth_pin(this);
// freeze the subtree
export_state[dir] = EXPORT_FREEZING;
dir->auth_unpin(this);
- assert(g_conf.mds_kill_export_at != 3);
+ assert(g_conf->mds_kill_export_at != 3);
}
m->put(); // done
// send.
export_state[dir] = EXPORT_PREPPING;
mds->send_message_mds(prep, dest);
- assert (g_conf.mds_kill_export_at != 4);
+ assert (g_conf->mds_kill_export_at != 4);
}
/* This function DOES put the passed message before returning*/
return;
}
- assert (g_conf.mds_kill_export_at != 5);
+ assert (g_conf->mds_kill_export_at != 5);
// send warnings
int dest = export_peer[dir];
set<CDir*> bounds;
}
export_state[dir] = EXPORT_WARNING;
- assert(g_conf.mds_kill_export_at != 6);
+ assert(g_conf->mds_kill_export_at != 6);
// nobody to warn?
if (export_warning_ack_waiting.count(dir) == 0)
export_go(dir); // start export.
export_warning_ack_waiting.erase(dir);
export_state[dir] = EXPORT_EXPORTING;
- assert(g_conf.mds_kill_export_at != 7);
+ assert(g_conf->mds_kill_export_at != 7);
assert(dir->get_cum_auth_pins() == 0);
// send
mds->send_message_mds(req, dest);
- assert(g_conf.mds_kill_export_at != 8);
+ assert(g_conf->mds_kill_export_at != 8);
// stats
if (mds->logger) mds->logger->inc(l_mds_ex);
export_warning_ack_waiting.erase(dir);
export_state[dir] = EXPORT_LOGGINGFINISH;
- assert (g_conf.mds_kill_export_at != 9);
+ assert (g_conf->mds_kill_export_at != 9);
set<CDir*> bounds;
cache->get_subtree_bounds(dir, bounds);
mds->mdlog->submit_entry(le);
mds->mdlog->wait_for_safe(new C_MDS_ExportFinishLogged(this, dir));
mds->mdlog->flush();
- assert (g_conf.mds_kill_export_at != 10);
+ assert (g_conf->mds_kill_export_at != 10);
m->put();
}
// wait for notifyacks
export_state[dir] = EXPORT_NOTIFYING;
- assert (g_conf.mds_kill_export_at != 11);
+ assert (g_conf->mds_kill_export_at != 11);
// no notifies to wait for?
if (export_notify_ack_waiting[dir].empty())
{
dout(5) << "export_finish " << *dir << dendl;
- assert (g_conf.mds_kill_export_at != 12);
+ assert (g_conf->mds_kill_export_at != 12);
if (export_state.count(dir) == 0) {
dout(7) << "target must have failed, not sending final commit message. export succeeded anyway." << dendl;
return;
} else {
dout(7) << "not sending MExportDirFinish, dest has failed" << dendl;
}
- assert(g_conf.mds_kill_export_at != 13);
+ assert(g_conf->mds_kill_export_at != 13);
// finish export (adjust local cache state)
C_Contexts *fin = new C_Contexts;
return;
}
- assert (g_conf.mds_kill_import_at != 1);
+ assert (g_conf->mds_kill_import_at != 1);
// do we have it?
CInode *in = cache->get_inode(m->get_dirfrag().ino);
dout(7) << " sending export_discover_ack on " << *in << dendl;
mds->send_message_mds(new MExportDirDiscoverAck(df), import_peer[df]);
m->put();
- assert (g_conf.mds_kill_import_at != 2);
+ assert (g_conf->mds_kill_import_at != 2);
}
void Migrator::import_reverse_discovering(dirfrag_t df)
// change import state
import_state[dir->dirfrag()] = IMPORT_PREPPING;
- assert(g_conf.mds_kill_import_at != 3);
+ assert(g_conf->mds_kill_import_at != 3);
import_bound_ls[dir] = m->get_bounds();
// bystander list
// note new state
import_state[dir->dirfrag()] = IMPORT_PREPPED;
- assert(g_conf.mds_kill_import_at != 4);
+ assert(g_conf->mds_kill_import_at != 4);
// done
m->put();
/* This function DOES put the passed message before returning*/
void Migrator::handle_export_dir(MExportDir *m)
{
- assert (g_conf.mds_kill_import_at != 5);
+ assert (g_conf->mds_kill_import_at != 5);
CDir *dir = cache->get_dirfrag(m->dirfrag);
assert(dir);
// note state
import_state[dir->dirfrag()] = IMPORT_LOGGINGSTART;
- assert (g_conf.mds_kill_import_at != 6);
+ assert (g_conf->mds_kill_import_at != 6);
// some stats
if (mds->logger) {
dout(7) << "notifying bystanders of abort" << dendl;
import_notify_abort(dir, bounds);
import_state[dir->dirfrag()] = IMPORT_ABORTING;
- assert (g_conf.mds_kill_import_at != 10);
+ assert (g_conf->mds_kill_import_at != 10);
}
}
// note state
import_state[dir->dirfrag()] = IMPORT_ACKING;
- assert (g_conf.mds_kill_import_at != 7);
+ assert (g_conf->mds_kill_import_at != 7);
// force open client sessions and finish cap import
mds->server->finish_force_open_sessions(imported_client_map, sseqmap);
//assert(dir->replica_map.size() < 2 || mds->whoami != 0);
mds->send_message_mds(new MExportDirAck(dir->dirfrag()), from);
- assert (g_conf.mds_kill_import_at != 8);
+ assert (g_conf->mds_kill_import_at != 8);
cache->show_subtrees();
}
// log finish
mds->mdlog->start_submit_entry(new EImportFinish(dir, true));
- assert(g_conf.mds_kill_import_at != 9);
+ assert(g_conf->mds_kill_import_at != 9);
// clear updated scatterlocks
/*
}
char name[80];
- snprintf(name, sizeof(name), "mds.%s.server.log", g_conf.name.get_id().c_str());
+ snprintf(name, sizeof(name), "mds.%s.server.log", g_conf->name.get_id().c_str());
logger = new ProfLogger(name, &mdserver_logtype);
logger_add(logger);
}
// (caps go stale, lease die)
utime_t now = g_clock.now();
utime_t cutoff = now;
- cutoff -= g_conf.mds_session_timeout;
+ cutoff -= g_conf->mds_session_timeout;
while (1) {
Session *session = mds->sessionmap.get_oldest_session(Session::STATE_OPEN);
if (!session) break;
// autoclose
cutoff = now;
- cutoff -= g_conf.mds_session_autoclose;
+ cutoff -= g_conf->mds_session_autoclose;
// don't kick clients if we've been laggy
if (mds->laggy_until > cutoff) {
mds->clog.info() << "denied reconnect attempt (mds is "
<< ceph_mds_state_name(mds->get_state())
<< ") from " << m->get_source_inst()
- << " after " << delay << " (allowed interval " << g_conf.mds_reconnect_timeout << ")\n";
+ << " after " << delay << " (allowed interval " << g_conf->mds_reconnect_timeout << ")\n";
mds->messenger->send_message(new MClientSession(CEPH_SESSION_CLOSE), m->get_connection());
m->put();
return;
void Server::reconnect_tick()
{
utime_t reconnect_end = reconnect_start;
- reconnect_end += g_conf.mds_reconnect_timeout;
+ reconnect_end += g_conf->mds_reconnect_timeout;
if (g_clock.now() >= reconnect_end &&
!client_reconnect_gather.empty()) {
dout(10) << "reconnect timed out" << dendl;
void Server::recall_client_state(float ratio)
{
- int max_caps_per_client = (int)(g_conf.mds_cache_size * .8);
+ int max_caps_per_client = (int)(g_conf->mds_cache_size * .8);
int min_caps_per_client = 100;
dout(10) << "recall_client_state " << ratio
void Server::early_reply(MDRequest *mdr, CInode *tracei, CDentry *tracedn)
{
- if (!g_conf.mds_early_reply)
+ if (!g_conf->mds_early_reply)
return;
if (mdr->are_slaves()) {
//assert(0); // just for now.
}
- int got = g_conf.mds_client_prealloc_inos - mdr->session->get_num_projected_prealloc_inos();
+ int got = g_conf->mds_client_prealloc_inos - mdr->session->get_num_projected_prealloc_inos();
if (got > 0) {
mds->inotable->project_alloc_ids(mdr->prealloc_inos, got);
assert(mdr->prealloc_inos.size()); // or else fix projected increment semantics
memset(&in->inode.dir_layout, 0, sizeof(in->inode.dir_layout));
if (in->inode.is_dir())
- in->inode.dir_layout.dl_dir_hash = g_conf.mds_default_dir_hash;
+ in->inode.dir_layout.dl_dir_hash = g_conf->mds_default_dir_hash;
if (layout)
in->inode.layout = *layout;
return;
}
- assert(g_conf.mds_kill_rename_at != 1);
+ assert(g_conf->mds_kill_rename_at != 1);
// -- open all srcdn inode frags, if any --
// we need these open so that auth can properly delegate from inode to dirfrags
// test hack: bail after slave does prepare, so we can verify it's _live_ rollback.
if (!mdr->more()->slaves.empty() && !srci->is_dir())
- assert(g_conf.mds_kill_rename_at != 2);
+ assert(g_conf->mds_kill_rename_at != 2);
if (!mdr->more()->slaves.empty() && srci->is_dir())
- assert(g_conf.mds_kill_rename_at != 3);
+ assert(g_conf->mds_kill_rename_at != 3);
// -- prepare anchor updates --
if (!linkmerge || srcdnl->is_primary()) {
if (anchorgather)
return; // waiting for anchor prepares
- assert(g_conf.mds_kill_rename_at != 4);
+ assert(g_conf->mds_kill_rename_at != 4);
}
// -- prepare journal entry --
CDentry::linkage_t *destdnl = destdn->get_linkage();
// test hack: test slave commit
if (!mdr->more()->slaves.empty() && !destdnl->get_inode()->is_dir())
- assert(g_conf.mds_kill_rename_at != 5);
+ assert(g_conf->mds_kill_rename_at != 5);
if (!mdr->more()->slaves.empty() && destdnl->get_inode()->is_dir())
- assert(g_conf.mds_kill_rename_at != 6);
+ assert(g_conf->mds_kill_rename_at != 6);
// commit anchor updates?
if (mdr->more()->src_reanchor_atid)
#define DOUT_SUBSYS mds
#undef DOUT_COND
-#define DOUT_COND(l) l<=g_conf.debug_mds || l <= g_conf.debug_mds_log || l <= g_conf.debug_mds_log_expire
+#define DOUT_COND(l) l<=g_conf->debug_mds || l <= g_conf->debug_mds_log || l <= g_conf->debug_mds_log_expire
#undef dout_prefix
#define dout_prefix *_dout << "mds" << mds->get_nodeid() << ".journal "
#undef DOUT_COND
-#define DOUT_COND(l) l<=g_conf.debug_mds || l <= g_conf.debug_mds_log
+#define DOUT_COND(l) l<=g_conf->debug_mds || l <= g_conf->debug_mds_log
// -----------------------
break;
}
metablob.replay(mds, _segment);
- if (in && g_conf.mds_debug_frag)
+ if (in && g_conf->mds_debug_frag)
in->verify_dirfrags();
}
{
// ugliness!
utime_t now = g_clock.now();
- DecayRate rate(g_conf.mds_decay_halflife);
+ DecayRate rate(g_conf->mds_decay_halflife);
return out << "[" << dl.vec[0].get(now, rate) << "," << dl.vec[1].get(now, rate)
<< " " << dl.meta_load(now, rate)
<< "]";
if (waiting.empty())
get(PIN_WAITER);
waiting.insert(pair<uint64_t,Context*>(mask, c));
- pdout(10,g_conf.debug_mds) << (mdsco_db_line_prefix(this))
+ pdout(10,g_conf->debug_mds) << (mdsco_db_line_prefix(this))
<< "add_waiter " << hex << mask << dec << " " << c
<< " on " << *this
<< dendl;
while (it != waiting.end()) {
if (it->first & mask) {
ls.push_back(it->second);
- pdout(10,g_conf.debug_mds) << (mdsco_db_line_prefix(this))
+ pdout(10,g_conf->debug_mds) << (mdsco_db_line_prefix(this))
<< "take_waiting mask " << hex << mask << dec << " took " << it->second
<< " tag " << hex << it->first << dec
<< " on " << *this
<< dendl;
waiting.erase(it++);
} else {
- pdout(10,g_conf.debug_mds) << "take_waiting mask " << hex << mask << dec << " SKIPPING " << it->second
+ pdout(10,g_conf->debug_mds) << "take_waiting mask " << hex << mask << dec << " SKIPPING " << it->second
<< " tag " << hex << it->first << dec
<< " on " << *this
<< dendl;
dout(10) << "create_initial -- creating initial map" << dendl;
KeyRing keyring;
- if (keyring.load(g_conf.keyring) == 0) {
+ if (keyring.load(g_conf->keyring) == 0) {
import_keyring(keyring);
}
{
assert(mon->is_leader());
- max_global_id += g_conf.mon_globalid_prealloc;
+ max_global_id += g_conf->mon_globalid_prealloc;
dout(10) << "increasing max_global_id to " << max_global_id << dendl;
Incremental inc;
inc.inc_type = GLOBAL_ID;
// set the timer
cancel_timer();
expire_event = new C_ElectionExpire(this);
- mon->timer.add_event_after(g_conf.mon_lease + plus,
+ mon->timer.add_event_after(g_conf->mon_lease + plus,
expire_event);
}
void MDSMonitor::create_new_fs(MDSMap &m, int metadata_pool, int data_pool)
{
- m.max_mds = g_conf.max_mds;
+ m.max_mds = g_conf->max_mds;
m.created = g_clock.now();
m.data_pg_pools.push_back(data_pool);
m.metadata_pg_pool = metadata_pool;
uint64_t gid = pending_mdsmap.up[w];
if (pending_mdsmap.mds_info.count(gid)) {
utime_t until = g_clock.now();
- until += g_conf.mds_blacklist_interval;
+ until += g_conf->mds_blacklist_interval;
MDSMap::mds_info_t& info = pending_mdsmap.mds_info[pending_mdsmap.up[w]];
pending_mdsmap.last_failure_osd_epoch = mon->osdmon()->blacklist(info.addr, until);
mon->osdmon()->propose_pending();
if (pending_mdsmap.mds_info.size()) {
// blacklist all old mds's
utime_t until = g_clock.now();
- until += g_conf.mds_blacklist_interval;
+ until += g_conf->mds_blacklist_interval;
for (map<int32_t,uint64_t>::iterator p = pending_mdsmap.up.begin();
p != pending_mdsmap.up.end();
++p) {
// check beacon timestamps
utime_t now = g_clock.now();
utime_t cutoff = now;
- cutoff -= g_conf.mds_beacon_grace;
+ cutoff -= g_conf->mds_beacon_grace;
// make sure last_beacon is fully populated
for (map<uint64_t,MDSMap::mds_info_t>::iterator p = pending_mdsmap.mds_info.begin();
si.state == MDSMap::STATE_STARTING) {
// blacklist laggy mds
utime_t until = now;
- until += g_conf.mds_blacklist_interval;
+ until += g_conf->mds_blacklist_interval;
pending_mdsmap.last_failure_osd_epoch = mon->osdmon()->blacklist(info.addr, until);
propose_osdmap = true;
}
// BUG: hrm, if this is the case, the STOPPING guys won't be able to stop, will they?
{
utime_t until = g_clock.now();
- until += g_conf.mds_blacklist_interval;
+ until += g_conf->mds_blacklist_interval;
pending_mdsmap.last_failure_osd_epoch = mon->osdmon()->blacklist(info.addr, until);
propose_osdmap = true;
}
int MonClient::build_initial_monmap(MonMap &monmap)
{
// file?
- if (!g_conf.monmap.empty()) {
+ if (!g_conf->monmap.empty()) {
int r;
try {
- r = monmap.read(g_conf.monmap.c_str());
+ r = monmap.read(g_conf->monmap.c_str());
}
catch (const buffer::error &e) {
r = -EINVAL;
}
if (r >= 0)
return 0;
- cerr << "unable to read/decode monmap from " << g_conf.monmap
+ cerr << "unable to read/decode monmap from " << g_conf->monmap
<< ": " << cpp_strerror(-r) << std::endl;
return r;
}
// -m foo?
- if (!g_conf.mon_host.empty()) {
+ if (!g_conf->mon_host.empty()) {
vector<entity_addr_t> addrs;
- if (parse_ip_port_vec(g_conf.mon_host.c_str(), addrs)) {
+ if (parse_ip_port_vec(g_conf->mon_host.c_str(), addrs)) {
for (unsigned i=0; i<addrs.size(); i++) {
char n[2];
n[0] = 'a' + i;
return 0;
} else { //maybe they passed us a DNS-resolvable name
char *hosts = NULL;
- char *old_addrs = new char[g_conf.mon_host.size() + 1];
+ char *old_addrs = new char[g_conf->mon_host.size() + 1];
hosts = resolve_addrs(old_addrs);
delete [] old_addrs;
if (!hosts)
return 0;
} else cerr << "couldn't parse_ip_port_vec on " << hosts << std::endl;
}
- cerr << "unable to parse addrs in '" << g_conf.mon_host << "'" << std::endl;
+ cerr << "unable to parse addrs in '" << g_conf->mon_host << "'" << std::endl;
}
// What monitors are in the config file?
std::vector <std::string> sections;
- int ret = g_conf.get_all_sections(sections);
+ int ret = g_conf->get_all_sections(sections);
if (ret) {
cerr << "Unable to find any monitors in the configuration "
<< "file, because there was an error listing the sections. error "
sections.push_back("mon");
sections.push_back("global");
std::string val;
- int res = g_conf.get_val_from_conf_file(sections, "mon addr", val, true);
+ int res = g_conf->get_val_from_conf_file(sections, "mon addr", val, true);
if (res) {
cerr << "failed to get an address for mon." << *m << ": error "
<< res << std::endl;
}
rotating_secrets = new RotatingKeyRing(cct->module_type, keyring);
- entity_name = g_conf.name;
+ entity_name = g_conf->name;
Mutex::Locker l(monc_lock);
timer.init();
srand(getpid());
auth_supported.clear();
- string str = g_conf.auth_supported;
+ string str = g_conf->auth_supported;
list<string> sup_list;
get_str_list(str, sup_list);
for (list<string>::iterator iter = sup_list.begin(); iter != sup_list.end(); ++iter) {
void MonClient::schedule_tick()
{
if (hunting)
- timer.add_event_after(g_conf.mon_client_hunt_interval, new C_Tick(this));
+ timer.add_event_after(g_conf->mon_client_hunt_interval, new C_Tick(this));
else
- timer.add_event_after(g_conf.mon_client_ping_interval, new C_Tick(this));
+ timer.add_event_after(g_conf->mon_client_ping_interval, new C_Tick(this));
}
}
utime_t cutoff = g_clock.now();
- cutoff -= MIN(30.0, g_conf.auth_service_ticket_ttl / 4.0);
+ cutoff -= MIN(30.0, g_conf->auth_service_ticket_ttl / 4.0);
if (!rotating_secrets->need_new_secrets(cutoff)) {
dout(10) << "_check_auth_rotating have uptodate secrets (they expire after " << cutoff << ")" << dendl;
rotating_secrets->dump_rotating();
if (m->cmd[0] == "_injectargs") {
dout(0) << "parsing injected options '" << m->cmd[1] << "'" << dendl;
- g_conf.injectargs(m->cmd[1]);
+ g_conf->injectargs(m->cmd[1]);
return;
}
if (m->cmd[0] == "class") {
// set an initial timeout here, so we will trim this session even if they don't
// do anything.
s->until = g_clock.now();
- s->until += g_conf.mon_subscribe_interval;
+ s->until += g_conf->mon_subscribe_interval;
} else {
//give it monitor caps; the peer type has been authenticated
reuse_caps = false;
}
s->until = g_clock.now();
- s->until += g_conf.mon_subscribe_interval;
+ s->until += g_conf->mon_subscribe_interval;
for (map<string,ceph_mon_subscribe_item>::iterator p = m->what.begin();
p != m->what.end();
p++) {
// ???
if (reply)
- messenger->send_message(new MMonSubscribeAck(monmap->get_fsid(), (int)g_conf.mon_subscribe_interval),
+ messenger->send_message(new MMonSubscribeAck(monmap->get_fsid(), (int)g_conf->mon_subscribe_interval),
m->get_source_inst());
s->put();
void Monitor::new_tick()
{
C_Mon_Tick *ctx = new C_Mon_Tick(this);
- timer.add_event_after(g_conf.mon_tick_interval, ctx);
+ timer.add_event_after(g_conf->mon_tick_interval, ctx);
}
void Monitor::tick()
return -errno;
}
- if ((!g_conf.chdir.empty()) && (dir[0] != '/')) {
+ if ((!g_conf->chdir.empty()) && (dir[0] != '/')) {
// combine it with the cwd, in case fuse screws things up (i.e. fakefuse)
string old = dir;
char cwd[PATH_MAX];
}
dout(0) << "created monfs at " << dir.c_str() << " for "
- << g_conf.name.get_id() << dendl;
+ << g_conf->name.get_id() << dendl;
return 0;
}
<< " is adding failure report on osd" << target_osd << dendl;
}
- if ((reporters >= g_conf.osd_min_down_reporters) &&
- (reports >= g_conf.osd_min_down_reports)) {
+ if ((reporters >= g_conf->osd_min_down_reporters) &&
+ (reports >= g_conf->osd_min_down_reports)) {
dout(1) << "have enough reports/reporters to mark osd" << target_osd
<< " as down" << dendl;
pending_inc.new_state[target_osd] = CEPH_OSD_UP;
i++;
if (osdmap.is_down(o) && osdmap.is_in(o)) {
- if (g_conf.mon_osd_down_out_interval > 0 &&
- down.sec() >= g_conf.mon_osd_down_out_interval) {
+ if (g_conf->mon_osd_down_out_interval > 0 &&
+ down.sec() >= g_conf->mon_osd_down_out_interval) {
dout(10) << "tick marking osd" << o << " OUT after " << down
- << " sec (target " << g_conf.mon_osd_down_out_interval << ")" << dendl;
+ << " sec (target " << g_conf->mon_osd_down_out_interval << ")" << dendl;
pending_inc.new_weight[o] = CEPH_OSD_OUT;
do_propose = true;
void OSDMonitor::handle_osd_timeouts(const utime_t &now,
const std::map<int,utime_t> &last_osd_report)
{
- utime_t timeo(g_conf.mon_osd_report_timeout, 0);
+ utime_t timeo(g_conf->mon_osd_report_timeout, 0);
int max_osd = osdmap.get_max_osd();
bool new_down = false;
int pool = ++pending_inc.new_pool_max;
pending_inc.new_pools[pool].v.type = CEPH_PG_TYPE_REP;
- pending_inc.new_pools[pool].v.size = g_conf.osd_pool_default_size;
+ pending_inc.new_pools[pool].v.size = g_conf->osd_pool_default_size;
if (crush_rule >= 0)
pending_inc.new_pools[pool].v.crush_ruleset = crush_rule;
else
- pending_inc.new_pools[pool].v.crush_ruleset = g_conf.osd_pool_default_crush_rule;
+ pending_inc.new_pools[pool].v.crush_ruleset = g_conf->osd_pool_default_crush_rule;
pending_inc.new_pools[pool].v.object_hash = CEPH_STR_HASH_RJENKINS;
- pending_inc.new_pools[pool].v.pg_num = g_conf.osd_pool_default_pg_num;
- pending_inc.new_pools[pool].v.pgp_num = g_conf.osd_pool_default_pgp_num;
+ pending_inc.new_pools[pool].v.pg_num = g_conf->osd_pool_default_pg_num;
+ pending_inc.new_pools[pool].v.pgp_num = g_conf->osd_pool_default_pgp_num;
pending_inc.new_pools[pool].v.lpg_num = 0;
pending_inc.new_pools[pool].v.lpgp_num = 0;
pending_inc.new_pools[pool].v.last_change = pending_inc.epoch;
last_osdmap_epoch(0), last_pg_scan(0),
num_pg(0),
num_osd(0),
- full_ratio(((float)g_conf.mon_osd_full_ratio)/100),
- nearfull_ratio(((float)g_conf.mon_osd_nearfull_ratio)/100) {}
+ full_ratio(((float)g_conf->mon_osd_full_ratio)/100),
+ nearfull_ratio(((float)g_conf->mon_osd_nearfull_ratio)/100) {}
void encode(bufferlist &bl) {
__u8 v = 2;
: PaxosService(mn, p)
{
ratio_monitor = new RatioMonitor(this);
- g_conf.add_observer(ratio_monitor);
+ g_conf->add_observer(ratio_monitor);
}
PGMonitor::~PGMonitor()
{
- g_conf.remove_observer(ratio_monitor);
+ g_conf->remove_observer(ratio_monitor);
delete ratio_monitor;
}
if (!mon->is_leader())
return;
utime_t now(g_clock.now());
- utime_t timeo(g_conf.mon_osd_report_timeout, 0);
+ utime_t timeo(g_conf->mon_osd_report_timeout, 0);
if (now - mon->get_leader_since() < timeo) {
// We haven't been the leader for long enough to consider OSD timeouts
return;
// throttle?
if (last_sent_pg_create.count(osd) &&
- now - g_conf.mon_pg_create_interval < last_sent_pg_create[osd])
+ now - g_conf->mon_pg_create_interval < last_sent_pg_create[osd])
continue;
dout(20) << "send_pg_creates " << pgid << " -> osd" << osd
// set timeout event
collect_timeout_event = new C_CollectTimeout(this);
- mon->timer.add_event_after(g_conf.mon_accept_timeout, collect_timeout_event);
+ mon->timer.add_event_after(g_conf->mon_accept_timeout, collect_timeout_event);
}
// set timeout event
accept_timeout_event = new C_AcceptTimeout(this);
- mon->timer.add_event_after(g_conf.mon_accept_timeout, accept_timeout_event);
+ mon->timer.add_event_after(g_conf->mon_accept_timeout, accept_timeout_event);
}
// peon
assert(is_active());
lease_expire = g_clock.now();
- lease_expire += g_conf.mon_lease;
+ lease_expire += g_conf->mon_lease;
acked_lease.clear();
acked_lease.insert(mon->rank);
- dout(7) << "extend_lease now+" << g_conf.mon_lease << " (" << lease_expire << ")" << dendl;
+ dout(7) << "extend_lease now+" << g_conf->mon_lease << " (" << lease_expire << ")" << dendl;
// bcast
for (set<int>::const_iterator p = mon->get_quorum().begin();
// if old timeout is still in place, leave it.
if (!lease_ack_timeout_event) {
lease_ack_timeout_event = new C_LeaseAckTimeout(this);
- mon->timer.add_event_after(g_conf.mon_lease_ack_timeout, lease_ack_timeout_event);
+ mon->timer.add_event_after(g_conf->mon_lease_ack_timeout, lease_ack_timeout_event);
}
// set renew event
lease_renew_event = new C_LeaseRenew(this);
utime_t at = lease_expire;
- at -= g_conf.mon_lease;
- at += g_conf.mon_lease_renew_interval;
+ at -= g_conf->mon_lease;
+ at += g_conf->mon_lease_renew_interval;
mon->timer.add_event_at(at, lease_renew_event);
}
utime_t now = g_clock.now();
if (t > now) {
utime_t diff = t - now;
- if (diff > g_conf.mon_clock_drift_allowed) {
+ if (diff > g_conf->mon_clock_drift_allowed) {
utime_t warn_diff = now - last_clock_drift_warn;
if (warn_diff >
- pow(g_conf.mon_clock_drift_warn_backoff, clock_drift_warned)) {
+ pow(g_conf->mon_clock_drift_warn_backoff, clock_drift_warned)) {
mon->clog.warn() << "message from " << from << " was stamped " << diff
<< "s in the future, clocks not synchronized";
last_clock_drift_warn = g_clock.now();
if (lease_timeout_event)
mon->timer.cancel_event(lease_timeout_event);
lease_timeout_event = new C_LeaseTimeout(this);
- mon->timer.add_event_after(g_conf.mon_lease_ack_timeout, lease_timeout_event);
+ mon->timer.add_event_after(g_conf->mon_lease_ack_timeout, lease_timeout_event);
// trim?
trim_to(lease->first_committed);
}
utime_t timeout = g_clock.now();
- timeout += g_conf.paxos_observer_timeout;
+ timeout += g_conf->paxos_observer_timeout;
observer->timeout = timeout;
if (is_readable())
delay = 0.0;
else {
utime_t now = g_clock.now();
- if ((now - paxos->last_commit_time) > g_conf.paxos_propose_interval)
- delay = (double)g_conf.paxos_min_wait;
+ if ((now - paxos->last_commit_time) > g_conf->paxos_propose_interval)
+ delay = (double)g_conf->paxos_min_wait;
else
- delay = (double)(g_conf.paxos_propose_interval + paxos->last_commit_time
+ delay = (double)(g_conf->paxos_propose_interval + paxos->last_commit_time
- now);
}
return true;
encode_payload();
calc_front_crc();
- if (!g_conf.ms_nocrc)
+ if (!g_conf->ms_nocrc)
calc_data_crc();
else
footer.flags = (unsigned)footer.flags | CEPH_MSG_FOOTER_NOCRC;
bufferlist& front, bufferlist& middle, bufferlist& data)
{
// verify crc
- if (!g_conf.ms_nocrc) {
+ if (!g_conf->ms_nocrc) {
__u32 front_crc = front.crc32c(0);
__u32 middle_crc = middle.crc32c(0);
default:
dout(0) << "can't decode unknown message type " << type << " MSG_AUTH=" << CEPH_MSG_AUTH << dendl;
- if (g_conf.ms_die_on_bad_msg)
+ if (g_conf->ms_die_on_bad_msg)
assert(0);
return 0;
}
dout(0) << "failed to decode message of type " << type
<< " v" << header.version
<< ": " << e.what() << dendl;
- if (g_conf.ms_die_on_bad_msg)
+ if (g_conf->ms_die_on_bad_msg)
assert(0);
return 0;
}
// bind to a socket
dout(10) << "accepter.bind" << dendl;
- int family = g_conf.ms_bind_ipv6 ? AF_INET6 : AF_INET;
+ int family = g_conf->ms_bind_ipv6 ? AF_INET6 : AF_INET;
switch (bind_addr.get_family()) {
case AF_INET:
case AF_INET6:
dout(10) << "accepted incoming on sd " << sd << dendl;
// disable Nagle algorithm?
- if (g_conf.ms_tcp_nodelay) {
+ if (g_conf->ms_tcp_nodelay) {
int flag = 1;
int r = ::setsockopt(sd, IPPROTO_TCP, TCP_NODELAY, (char*)&flag, sizeof(flag));
if (r < 0)
}
// disable Nagle algorithm?
- if (g_conf.ms_tcp_nodelay) {
+ if (g_conf->ms_tcp_nodelay) {
int flag = 1;
int r = ::setsockopt(sd, IPPROTO_TCP, TCP_NODELAY, (char*)&flag, sizeof(flag));
if (r < 0)
} else if (backoff == utime_t()) {
if (!onconnect)
dout(0) << "fault first fault" << dendl;
- backoff.set_from_double(g_conf.ms_initial_backoff);
+ backoff.set_from_double(g_conf->ms_initial_backoff);
} else {
dout(10) << "fault waiting " << backoff << dendl;
cond.WaitInterval(pipe_lock, backoff);
backoff += backoff;
- if (backoff > g_conf.ms_max_backoff)
- backoff.set_from_double(g_conf.ms_max_backoff);
+ if (backoff > g_conf->ms_max_backoff)
+ backoff.set_from_double(g_conf->ms_max_backoff);
dout(10) << "fault done waiting or woke up" << dendl;
}
}
out_seq(0), in_seq(0), in_seq_acked(0),
reader_thread(this), writer_thread(this) {
connection_state->pipe = get();
- messenger->timeout = g_conf.ms_tcp_read_timeout * 1000; //convert to ms
+ messenger->timeout = g_conf->ms_tcp_read_timeout * 1000; //convert to ms
if (messenger->timeout == 0)
messenger->timeout = -1;
}
assert(pipe_lock.is_locked());
assert(!reader_running);
reader_running = true;
- reader_thread.create(g_conf.ms_rwthread_stack_bytes);
+ reader_thread.create(g_conf->ms_rwthread_stack_bytes);
}
void start_writer() {
assert(pipe_lock.is_locked());
assert(!writer_running);
writer_running = true;
- writer_thread.create(g_conf.ms_rwthread_stack_bytes);
+ writer_thread.create(g_conf->ms_rwthread_stack_bytes);
}
void join_reader() {
if (!reader_running)
Messenger(entity_name_t()),
accepter(this),
lock("SimpleMessenger::lock"), started(false), did_bind(false),
- dispatch_throttler(g_conf.ms_dispatch_throttle_bytes), need_addr(true),
+ dispatch_throttler(g_conf->ms_dispatch_throttle_bytes), need_addr(true),
destination_stopped(true), my_type(-1),
global_seq_lock("SimpleMessenger::global_seq_lock"), global_seq(0),
reaper_thread(this), reaper_started(false), reaper_stop(false),
int bind(entity_addr_t bind_addr, int64_t nonce);
int bind(uint64_t nonce) {
- return bind(g_conf.public_addr, nonce);
+ return bind(g_conf->public_addr, nonce);
}
int start_with_nonce(uint64_t nonce); // if we didn't bind
int start() { // if we did
while (len > 0) {
- if (g_conf.ms_inject_socket_failures && sd >= 0) {
- if (rand() % g_conf.ms_inject_socket_failures == 0) {
+ if (g_conf->ms_inject_socket_failures && sd >= 0) {
+ if (rand() % g_conf->ms_inject_socket_failures == 0) {
generic_dout(0) << "injecting socket failure" << dendl;
::shutdown(sd, SHUT_RDWR);
}
pfd.fd = sd;
pfd.events = POLLOUT | POLLHUP | POLLRDHUP | POLLNVAL | POLLERR;
- if (g_conf.ms_inject_socket_failures && sd >= 0) {
- if (rand() % g_conf.ms_inject_socket_failures == 0) {
+ if (g_conf->ms_inject_socket_failures && sd >= 0) {
+ if (rand() % g_conf->ms_inject_socket_failures == 0) {
generic_dout(0) << "injecting socket failure" << dendl;
::shutdown(sd, SHUT_RDWR);
}
return -EINVAL;
}
- int64_t conf_journal_sz(g_conf.osd_journal_size);
+ int64_t conf_journal_sz(g_conf->osd_journal_size);
conf_journal_sz <<= 20;
if (bdev_sz < conf_journal_sz) {
dout(0) << __func__ << ": you have configured a journal of size "
bool create)
{
int ret;
- int64_t conf_journal_sz(g_conf.osd_journal_size);
+ int64_t conf_journal_sz(g_conf->osd_journal_size);
conf_journal_sz <<= 20;
- if ((g_conf.osd_journal_size == 0) && (oldsize < ONE_MEG)) {
+ if ((g_conf->osd_journal_size == 0) && (oldsize < ONE_MEG)) {
derr << "I'm sorry, I don't know how large of a journal to create."
<< "Please specify a block device to use as the journal OR "
<< "set osd_journal_size in your ceph.conf" << dendl;
}
if (create && (oldsize < conf_journal_sz)) {
- uint64_t newsize(g_conf.osd_journal_size);
+ uint64_t newsize(g_conf->osd_journal_size);
newsize <<= 20;
dout(10) << "_open extending to " << newsize << " bytes" << dendl;
ret = ::ftruncate(fd, newsize);
header.fsid = fsid;
header.max_size = max_size;
header.block_size = block_size;
- if (g_conf.journal_block_align || directio)
+ if (g_conf->journal_block_align || directio)
header.alignment = block_size;
else
header.alignment = 16; // at least stay word aligned on 64bit machines...
goto free_buf;
}
- needed_space = g_conf.osd_max_write_size << 20;
+ needed_space = g_conf->osd_max_write_size << 20;
needed_space += (2 * sizeof(entry_header_t)) + get_top();
if (header.max_size - header.start < needed_space) {
derr << "FileJournal::create: OSD journal is not large enough to hold "
// gather queued writes
off64_t queue_pos = write_pos;
- int eleft = g_conf.journal_max_write_entries;
- unsigned bmax = g_conf.journal_max_write_bytes;
+ int eleft = g_conf->journal_max_write_entries;
+ unsigned bmax = g_conf->journal_max_write_bytes;
if (full_state != FULL_NOTFULL)
return -ENOSPC;
if (eleft) {
if (--eleft == 0) {
- dout(20) << "prepare_multi_write hit max events per write " << g_conf.journal_max_write_entries << dendl;
+ dout(20) << "prepare_multi_write hit max events per write " << g_conf->journal_max_write_entries << dendl;
break;
}
}
if (bmax) {
if (bl.length() >= bmax) {
- dout(20) << "prepare_multi_write hit max write size " << g_conf.journal_max_write_bytes << dendl;
+ dout(20) << "prepare_multi_write hit max write size " << g_conf->journal_max_write_bytes << dendl;
break;
}
}
void FileJournal::throttle()
{
- if (throttle_ops.wait(g_conf.journal_queue_max_ops))
+ if (throttle_ops.wait(g_conf->journal_queue_max_ops))
dout(1) << "throttle: waited for ops" << dendl;
- if (throttle_bytes.wait(g_conf.journal_queue_max_bytes))
+ if (throttle_bytes.wait(g_conf->journal_queue_max_bytes))
dout(1) << "throttle: waited for bytes" << dendl;
}
timer(sync_entry_timeo_lock),
stop(false), sync_thread(this),
op_queue_len(0), op_queue_bytes(0), next_finish(0),
- op_tp("FileStore::op_tp", g_conf.filestore_op_threads), op_wq(this, &op_tp),
+ op_tp("FileStore::op_tp", g_conf->filestore_op_threads), op_wq(this, &op_tp),
flusher_queue_len(0), flusher_thread(this),
logger(NULL)
{
{
if (journalpath.length()) {
dout(10) << "open_journal at " << journalpath << dendl;
- journal = new FileJournal(fsid, &finisher, &sync_cond, journalpath.c_str(), g_conf.journal_dio);
+ journal = new FileJournal(fsid, &finisher, &sync_cond, journalpath.c_str(), g_conf->journal_dio);
}
return 0;
}
int basedir_fd;
struct btrfs_ioctl_vol_args volargs;
- if (!g_conf.filestore_dev.empty()) {
+ if (!g_conf->filestore_dev.empty()) {
dout(0) << "mounting" << dendl;
- ret = run_cmd("mount", g_conf.filestore_dev.c_str(), (char*)NULL);
+ ret = run_cmd("mount", g_conf->filestore_dev.c_str(), (char*)NULL);
if (ret) {
- derr << "FileStore::mkfs: failed to mount g_conf.filestore_dev "
- << "'" << g_conf.filestore_dev << "'. Error code " << ret << dendl;
+ derr << "FileStore::mkfs: failed to mount g_conf->filestore_dev "
+ << "'" << g_conf->filestore_dev << "'. Error code " << ret << dendl;
goto out;
}
}
if (ret)
goto close_basedir_fd;
- if (!g_conf.filestore_dev.empty()) {
+ if (!g_conf->filestore_dev.empty()) {
dout(0) << "umounting" << dendl;
- snprintf(buf, sizeof(buf), "umount %s", g_conf.filestore_dev.c_str());
+ snprintf(buf, sizeof(buf), "umount %s", g_conf->filestore_dev.c_str());
//system(cmd);
}
char buf[80];
// fake collections?
- if (g_conf.filestore_fake_collections) {
+ if (g_conf->filestore_fake_collections) {
dout(0) << "faking collections (in memory)" << dendl;
fake_collections = true;
}
// xattrs?
- if (g_conf.filestore_fake_attrs) {
+ if (g_conf->filestore_fake_attrs) {
dout(0) << "faking xattrs (in memory)" << dendl;
fake_attrs = true;
} else {
btrfs = true;
// clone_range?
- if (g_conf.filestore_btrfs_clone_range) {
+ if (g_conf->filestore_btrfs_clone_range) {
btrfs_clone_range = true;
int r = _do_clone_range(fsid_fd, -1, 0, 1);
if (r == -EBADF) {
dout(0) << "mount btrfs SNAP_CREATE failed: " << strerror_r(-r, buf, sizeof(buf)) << dendl;
}
- if (g_conf.filestore_btrfs_snap && !btrfs_snap_destroy) {
+ if (g_conf->filestore_btrfs_snap && !btrfs_snap_destroy) {
dout(0) << "mount btrfs snaps enabled, but no SNAP_DESTROY ioctl (from kernel 2.6.32+)" << dendl;
cerr << TEXT_YELLOW
<< " ** WARNING: 'filestore btrfs snap' was enabled (for safe transactions, rollback),\n"
<< " but btrfs does not support the SNAP_DESTROY ioctl (added in\n"
<< " Linux 2.6.32). Disabling.\n"
<< TEXT_NORMAL;
- g_conf.filestore_btrfs_snap = false;
+ g_conf->filestore_btrfs_snap = false;
}
// start_sync?
}
}
- if (g_conf.filestore_btrfs_snap && !btrfs_snap_create_v2) {
+ if (g_conf->filestore_btrfs_snap && !btrfs_snap_create_v2) {
dout(0) << "mount WARNING: btrfs snaps enabled, but no SNAP_CREATE_V2 ioctl (from kernel 2.6.37+)" << dendl;
cerr << TEXT_YELLOW
<< " ** WARNING: 'filestore btrfs snap' is enabled (for safe transactions,\n"
{
// sanity check(s)
- if ((int)g_conf.filestore_journal_writeahead +
- (int)g_conf.filestore_journal_parallel +
- (int)g_conf.filestore_journal_trailing > 1) {
+ if ((int)g_conf->filestore_journal_writeahead +
+ (int)g_conf->filestore_journal_parallel +
+ (int)g_conf->filestore_journal_trailing > 1) {
dout(0) << "mount ERROR: more than one of filestore journal {writeahead,parallel,trailing} enabled" << dendl;
cerr << TEXT_RED
<< " ** WARNING: more than one of 'filestore journal {writeahead,parallel,trailing}'\n"
}
if (!btrfs) {
- if (!journal || !g_conf.filestore_journal_writeahead) {
+ if (!journal || !g_conf->filestore_journal_writeahead) {
dout(0) << "mount WARNING: no btrfs, and no journal in writeahead mode; data may be lost" << dendl;
cerr << TEXT_RED
<< " ** WARNING: no btrfs AND (no journal OR journal not in writeahead mode)\n"
uint64_t initial_op_seq;
set<string> cluster_snaps;
- if (!g_conf.filestore_dev.empty()) {
+ if (!g_conf->filestore_dev.empty()) {
dout(0) << "mounting" << dendl;
- //run_cmd("mount", g_conf.filestore_dev, (char*)NULL);
+ //run_cmd("mount", g_conf->filestore_dev, (char*)NULL);
}
dout(5) << "basedir " << basedir << " journal " << journalpath << dendl;
dout(0) << "mount found cluster snaps " << cluster_snaps << dendl;
}
- if (g_conf.osd_rollback_to_cluster_snap.length() &&
- cluster_snaps.count(g_conf.osd_rollback_to_cluster_snap) == 0) {
- derr << "rollback to cluster snapshot '" << g_conf.osd_rollback_to_cluster_snap << "': not found" << dendl;
+ if (g_conf->osd_rollback_to_cluster_snap.length() &&
+ cluster_snaps.count(g_conf->osd_rollback_to_cluster_snap) == 0) {
+ derr << "rollback to cluster snapshot '" << g_conf->osd_rollback_to_cluster_snap << "': not found" << dendl;
ret = -ENOENT;
goto close_basedir_fd;
}
- if (btrfs && g_conf.filestore_btrfs_snap) {
+ if (btrfs && g_conf->filestore_btrfs_snap) {
if (snaps.empty()) {
dout(0) << "mount WARNING: no consistent snaps found, store may be in inconsistent state" << dendl;
} else if (!btrfs) {
} else {
char s[PATH_MAX];
- if (g_conf.osd_rollback_to_cluster_snap.length()) {
+ if (g_conf->osd_rollback_to_cluster_snap.length()) {
derr << TEXT_RED
- << " ** NOTE: rolling back to cluster snapshot " << g_conf.osd_rollback_to_cluster_snap << " **"
+ << " ** NOTE: rolling back to cluster snapshot " << g_conf->osd_rollback_to_cluster_snap << " **"
<< TEXT_NORMAL
<< dendl;
- assert(cluster_snaps.count(g_conf.osd_rollback_to_cluster_snap));
+ assert(cluster_snaps.count(g_conf->osd_rollback_to_cluster_snap));
snprintf(s, sizeof(s), "%s/" CLUSTER_SNAP_ITEM, basedir.c_str(),
- g_conf.osd_rollback_to_cluster_snap.c_str());
+ g_conf->osd_rollback_to_cluster_snap.c_str());
} else {
uint64_t curr_seq;
{
dout(10) << " most recent snap from " << snaps << " is " << cp << dendl;
if (cp != curr_seq) {
- if (!g_conf.osd_use_stale_snap) {
+ if (!g_conf->osd_use_stale_snap) {
derr << TEXT_RED
<< " ** ERROR: current volume data version is not equal to snapshotted version\n"
<< " which can lead to data inconsistency. \n"
// select journal mode?
if (journal) {
- if (!g_conf.filestore_journal_writeahead &&
- !g_conf.filestore_journal_parallel &&
- !g_conf.filestore_journal_trailing) {
+ if (!g_conf->filestore_journal_writeahead &&
+ !g_conf->filestore_journal_parallel &&
+ !g_conf->filestore_journal_trailing) {
if (!btrfs) {
- g_conf.filestore_journal_writeahead = true;
+ g_conf->filestore_journal_writeahead = true;
dout(0) << "mount: enabling WRITEAHEAD journal mode: btrfs not detected" << dendl;
- } else if (!g_conf.filestore_btrfs_snap) {
- g_conf.filestore_journal_writeahead = true;
+ } else if (!g_conf->filestore_btrfs_snap) {
+ g_conf->filestore_journal_writeahead = true;
dout(0) << "mount: enabling WRITEAHEAD journal mode: 'filestore btrfs snap' mode is not enabled" << dendl;
} else if (!btrfs_snap_create_v2) {
- g_conf.filestore_journal_writeahead = true;
+ g_conf->filestore_journal_writeahead = true;
dout(0) << "mount: enabling WRITEAHEAD journal mode: btrfs SNAP_CREATE_V2 ioctl not detected (v2.6.37+)" << dendl;
} else {
- g_conf.filestore_journal_parallel = true;
+ g_conf->filestore_journal_parallel = true;
dout(0) << "mount: enabling PARALLEL journal mode: btrfs, SNAP_CREATE_V2 detected and 'filestore btrfs snap' mode is enabled" << dendl;
}
} else {
- if (g_conf.filestore_journal_writeahead)
+ if (g_conf->filestore_journal_writeahead)
dout(0) << "mount: WRITEAHEAD journal mode explicitly enabled in conf" << dendl;
- if (g_conf.filestore_journal_parallel)
+ if (g_conf->filestore_journal_parallel)
dout(0) << "mount: PARALLEL journal mode explicitly enabled in conf" << dendl;
- if (g_conf.filestore_journal_trailing)
+ if (g_conf->filestore_journal_trailing)
dout(0) << "mount: TRAILING journal mode explicitly enabled in conf" << dendl;
}
- if (g_conf.filestore_journal_writeahead)
+ if (g_conf->filestore_journal_writeahead)
journal->set_wait_on_full(true);
}
basedir_fd = -1;
}
- if (!g_conf.filestore_dev.empty()) {
+ if (!g_conf->filestore_dev.empty()) {
dout(0) << "umounting" << dendl;
- //run_cmd("umount", g_conf.filestore_dev, (char*)NULL);
+ //run_cmd("umount", g_conf->filestore_dev, (char*)NULL);
}
{
void FileStore::_op_queue_reserve_throttle(Op *o, const char *caller)
{
// Do not call while holding the journal lock!
- uint64_t max_ops = g_conf.filestore_queue_max_ops;
- uint64_t max_bytes = g_conf.filestore_queue_max_bytes;
+ uint64_t max_ops = g_conf->filestore_queue_max_ops;
+ uint64_t max_bytes = g_conf->filestore_queue_max_bytes;
if (is_committing()) {
- max_ops += g_conf.filestore_queue_committing_max_ops;
- max_bytes += g_conf.filestore_queue_committing_max_bytes;
+ max_ops += g_conf->filestore_queue_committing_max_ops;
+ max_bytes += g_conf->filestore_queue_committing_max_bytes;
}
if (logger) {
//logger->inc(l_os_in_bytes, 1);
}
- if (journal && journal->is_writeable() && !g_conf.filestore_journal_trailing) {
+ if (journal && journal->is_writeable() && !g_conf->filestore_journal_trailing) {
Op *o = build_op(tls, onreadable, onreadable_sync);
op_queue_reserve_throttle(o);
journal->throttle();
o->op = op_submit_start();
- if (g_conf.filestore_journal_parallel) {
+ if (g_conf->filestore_journal_parallel) {
dout(5) << "queue_transactions (parallel) " << o->op << " " << o->tls << dendl;
_op_journal_transactions(o->tls, o->op, ondisk);
// queue inside journal lock, to preserve ordering
queue_op(osr, o);
- } else if (g_conf.filestore_journal_writeahead) {
+ } else if (g_conf->filestore_journal_writeahead) {
dout(5) << "queue_transactions (writeahead) " << o->op << " " << o->tls << dendl;
osr->queue_journal(o->op);
return 0;
#else
if (!btrfs || !btrfs_trans_start_end ||
- !g_conf.filestore_btrfs_trans)
+ !g_conf->filestore_btrfs_trans)
return 0;
char buf[80];
return;
#else
if (!btrfs || !btrfs_trans_start_end ||
- !g_conf.filestore_btrfs_trans)
+ !g_conf->filestore_btrfs_trans)
return;
char fn[PATH_MAX];
// flush?
#ifdef HAVE_SYNC_FILE_RANGE
- if (!g_conf.filestore_flusher ||
+ if (!g_conf->filestore_flusher ||
!queue_flusher(fd, offset, len)) {
- if (g_conf.filestore_sync_flush)
+ if (g_conf->filestore_sync_flush)
::sync_file_range(fd, offset, len, SYNC_FILE_RANGE_WRITE);
::close(fd);
}
{
bool queued;
lock.Lock();
- if (flusher_queue_len < g_conf.filestore_flusher_max_fds) {
+ if (flusher_queue_len < g_conf->filestore_flusher_max_fds) {
flusher_queue.push_back(sync_epoch);
flusher_queue.push_back(fd);
flusher_queue.push_back(off);
} else {
dout(10) << "queue_flusher ep " << sync_epoch << " fd " << fd << " " << off << "~" << len
<< " qlen " << flusher_queue_len
- << " hit flusher_max_fds " << g_conf.filestore_flusher_max_fds
+ << " hit flusher_max_fds " << g_conf->filestore_flusher_max_fds
<< ", skipping async flush" << dendl;
queued = false;
}
void finish(int r) {
BackTrace *bt = new BackTrace(1);
generic_dout(-1) << "FileStore: sync_entry timed out after "
- << g_conf.filestore_commit_timeout << " seconds.\n";
+ << g_conf->filestore_commit_timeout << " seconds.\n";
bt->print(*_dout);
*_dout << dendl;
delete bt;
lock.Lock();
while (!stop) {
utime_t max_interval;
- max_interval.set_from_double(g_conf.filestore_max_sync_interval);
+ max_interval.set_from_double(g_conf->filestore_max_sync_interval);
utime_t min_interval;
- min_interval.set_from_double(g_conf.filestore_min_sync_interval);
+ min_interval.set_from_double(g_conf->filestore_min_sync_interval);
utime_t startwait = g_clock.now();
if (!force_sync) {
SyncEntryTimeout *sync_entry_timeo = new SyncEntryTimeout();
sync_entry_timeo_lock.Lock();
- timer.add_event_after(g_conf.filestore_commit_timeout, sync_entry_timeo);
+ timer.add_event_after(g_conf->filestore_commit_timeout, sync_entry_timeo);
sync_entry_timeo_lock.Unlock();
if (logger)
dout(15) << "sync_entry committing " << cp << " sync_epoch " << sync_epoch << dendl;
write_op_seq(op_fd, cp);
- bool do_snap = btrfs && g_conf.filestore_btrfs_snap;
+ bool do_snap = btrfs && g_conf->filestore_btrfs_snap;
if (do_snap) {
dout(15) << "sync_entry doing btrfs SYNC" << dendl;
// do a full btrfs commit
::ioctl(op_fd, BTRFS_IOC_SYNC);
- } else if (g_conf.filestore_fsync_flushes_journal_data) {
+ } else if (g_conf->filestore_fsync_flushes_journal_data) {
dout(15) << "sync_entry doing fsync on " << current_op_seq_fn << dendl;
// make the file system's journal commit.
// this works with ext3, but NOT ext4
{
dout(10) << "flush" << dendl;
- if (g_conf.filestore_journal_writeahead) {
+ if (g_conf->filestore_journal_writeahead) {
if (journal)
journal->flush();
dout(10) << "flush draining ondisk finisher" << dendl;
{
dout(10) << "sync_and_flush" << dendl;
- if (g_conf.filestore_journal_writeahead) {
+ if (g_conf->filestore_journal_writeahead) {
if (journal)
journal->flush();
_flush_op_queue();
- } else if (g_conf.filestore_journal_parallel) {
+ } else if (g_conf->filestore_journal_parallel) {
_flush_op_queue();
sync();
} else {
for (list<ObjectStore::Transaction*>::iterator p = tls.begin(); p != tls.end(); p++) {
ObjectStore::Transaction *t = *p;
if (t->get_data_length() > data_len &&
- (int)t->get_data_length() >= g_conf.journal_align_min_size) {
+ (int)t->get_data_length() >= g_conf->journal_align_min_size) {
data_len = t->get_data_length();
data_align = (t->get_data_alignment() - tbl.length()) & ~PAGE_MASK;
}
cls->status == ClassData::CLASS_MISSING) {
char fname[PATH_MAX];
snprintf(fname, sizeof(fname), "%s/libcls_%s.so",
- g_conf.osd_class_dir.c_str(),
+ g_conf->osd_class_dir.c_str(),
cls->name.c_str());
dout(10) << "_load_class " << cls->name << " from " << fname << dendl;
if (::stat(dev.c_str(), &st) != 0)
return 0;
- if (g_conf.filestore)
+ if (g_conf->filestore)
return new FileStore(dev, jdev);
if (S_ISDIR(st.st_mode))
}
// age?
- if (g_conf.osd_age_time != 0) {
- if (g_conf.osd_age_time >= 0) {
+ if (g_conf->osd_age_time != 0) {
+ if (g_conf->osd_age_time >= 0) {
dout(0) << "aging..." << dendl;
Ager ager(store);
- ager.age(g_conf.osd_age_time,
- g_conf.osd_age,
- g_conf.osd_age - .05,
+ ager.age(g_conf->osd_age_time,
+ g_conf->osd_age,
+ g_conf->osd_age - .05,
50000,
- g_conf.osd_age - .05);
+ g_conf->osd_age - .05);
}
}
// benchmark?
- if (g_conf.osd_auto_weight) {
+ if (g_conf->osd_auto_weight) {
bufferlist bl;
bufferptr bp(1048576);
bp.zero();
ceph_osd_feature_ro_compat,
ceph_osd_feature_incompat),
state(STATE_BOOTING), boot_epoch(0), up_epoch(0),
- op_tp("OSD::op_tp", g_conf.osd_op_threads),
- recovery_tp("OSD::recovery_tp", g_conf.osd_recovery_threads),
- disk_tp("OSD::disk_tp", g_conf.osd_disk_threads),
+ op_tp("OSD::op_tp", g_conf->osd_op_threads),
+ recovery_tp("OSD::recovery_tp", g_conf->osd_recovery_threads),
+ disk_tp("OSD::disk_tp", g_conf->osd_disk_threads),
heartbeat_lock("OSD::heartbeat_lock"),
heartbeat_stop(false), heartbeat_epoch(0),
heartbeat_messenger(hbm),
decayrate(5.0),
stat_oprate(),
peer_stat_lock("OSD::peer_stat_lock"),
- read_latency_calc(g_conf.osd_max_opq<1 ? 1:g_conf.osd_max_opq),
+ read_latency_calc(g_conf->osd_max_opq<1 ? 1:g_conf->osd_max_opq),
qlen_calc(3),
- iat_averager(g_conf.osd_flash_crowd_iat_alpha),
+ iat_averager(g_conf->osd_flash_crowd_iat_alpha),
finished_lock("OSD::finished_lock"),
op_wq(this, &op_tp),
osdmap(NULL),
heartbeat_thread.create();
// tick
- timer.add_event_after(g_conf.osd_heartbeat_interval, new C_Tick(this));
+ timer.add_event_after(g_conf->osd_heartbeat_interval, new C_Tick(this));
if (false) {
signal(SIGTERM, handle_signal);
int OSD::shutdown()
{
- g_conf.debug_osd = 100;
- g_conf.debug_journal = 100;
- g_conf.debug_filestore = 100;
- g_conf.debug_ms = 100;
+ g_conf->debug_osd = 100;
+ g_conf->debug_journal = 100;
+ g_conf->debug_filestore = 100;
+ g_conf->debug_ms = 100;
derr << "OSD::shutdown" << dendl;
assert(peer_stat_lock.is_locked());
// refresh?
- if (now - my_stat.stamp > g_conf.osd_stat_refresh_interval ||
+ if (now - my_stat.stamp > g_conf->osd_stat_refresh_interval ||
pending_ops > 2*my_stat.qlen) {
update_osd_stat();
while (!heartbeat_stop) {
heartbeat();
- double wait = .5 + ((float)(rand() % 10)/10.0) * (float)g_conf.osd_heartbeat_interval;
+ double wait = .5 + ((float)(rand() % 10)/10.0) * (float)g_conf->osd_heartbeat_interval;
utime_t w;
w.set_from_double(wait);
dout(30) << "heartbeat_entry sleeping for " << wait << dendl;
// check for incoming heartbeats (move me elsewhere?)
utime_t grace = g_clock.now();
- grace -= g_conf.osd_heartbeat_grace;
+ grace -= g_conf->osd_heartbeat_grace;
for (map<int, epoch_t>::iterator p = heartbeat_from.begin();
p != heartbeat_from.end();
p++) {
// hmm.. am i all alone?
dout(30) << "heartbeat lonely?" << dendl;
if (heartbeat_from.empty() || heartbeat_to.empty()) {
- if (now - last_mon_heartbeat > g_conf.osd_mon_heartbeat_interval) {
+ if (now - last_mon_heartbeat > g_conf->osd_mon_heartbeat_interval) {
last_mon_heartbeat = now;
dout(10) << "i have no heartbeat peers; checking mon for new map" << dendl;
monc->sub_want("osdmap", osdmap->get_epoch() + 1, CEPH_SUBSCRIBE_ONETIME);
// mon report?
utime_t now = g_clock.now();
- if (now - last_pg_stats_sent > g_conf.osd_mon_report_interval_max) {
+ if (now - last_pg_stats_sent > g_conf->osd_mon_report_interval_max) {
osd_stat_updated = true;
do_mon_report();
}
- else if (now - last_mon_report > g_conf.osd_mon_report_interval_min) {
+ else if (now - last_mon_report > g_conf->osd_mon_report_interval_min) {
do_mon_report();
}
dout(20) << "handle_command args: " << m->cmd << dendl;
if (m->cmd[0] == "injectargs")
- g_conf.injectargs(m->cmd[1]);
+ g_conf->injectargs(m->cmd[1]);
else if (m->cmd[0] == "stop") {
dout(0) << "got shutdown" << dendl;
shutdown();
fout.close();
}
else if (m->cmd.size() == 3 && m->cmd[1] == "kick_recovery_wq") {
- g_conf.osd_recovery_delay_start = atoi(m->cmd[2].c_str());
+ g_conf->osd_recovery_delay_start = atoi(m->cmd[2].c_str());
clog.info() << "kicking recovery queue. set osd_recovery_delay_start "
- << "to " << g_conf.osd_recovery_delay_start << "\n";
+ << "to " << g_conf->osd_recovery_delay_start << "\n";
defer_recovery_until = g_clock.now();
- defer_recovery_until += g_conf.osd_recovery_delay_start;
+ defer_recovery_until += g_conf->osd_recovery_delay_start;
recovery_wq.kick();
}
}
return false;
}
- if (loadavgs[0] >= g_conf.osd_scrub_load_threshold) {
+ if (loadavgs[0] >= g_conf->osd_scrub_load_threshold) {
dout(20) << "scrub_should_schedule loadavg " << loadavgs[0]
- << " >= max " << g_conf.osd_scrub_load_threshold
+ << " >= max " << g_conf->osd_scrub_load_threshold
<< " = no, load too high" << dendl;
return false;
}
bool coin_flip = (rand() % 3) == whoami % 3;
if (!coin_flip) {
dout(20) << "scrub_should_schedule loadavg " << loadavgs[0]
- << " < max " << g_conf.osd_scrub_load_threshold
+ << " < max " << g_conf->osd_scrub_load_threshold
<< " = no, randomly backing off"
<< dendl;
return false;
}
dout(20) << "scrub_should_schedule loadavg " << loadavgs[0]
- << " < max " << g_conf.osd_scrub_load_threshold
+ << " < max " << g_conf->osd_scrub_load_threshold
<< " = yes" << dendl;
- return loadavgs[0] < g_conf.osd_scrub_load_threshold;
+ return loadavgs[0] < g_conf->osd_scrub_load_threshold;
}
void OSD::sched_scrub()
pair<utime_t,pg_t> pos;
utime_t max = g_clock.now();
- max -= g_conf.osd_scrub_max_interval;
+ max -= g_conf->osd_scrub_max_interval;
sched_scrub_lock.Lock();
if (t > max) {
dout(10) << " " << pgid << " at " << t
- << " > " << max << " (" << g_conf.osd_scrub_max_interval << " seconds ago)" << dendl;
+ << " > " << max << " (" << g_conf->osd_scrub_max_interval << " seconds ago)" << dendl;
break;
}
bool result = false;
sched_scrub_lock.Lock();
- if (scrubs_pending + scrubs_active < g_conf.osd_max_scrubs) {
+ if (scrubs_pending + scrubs_active < g_conf->osd_max_scrubs) {
dout(20) << "inc_scrubs_pending " << scrubs_pending << " -> " << (scrubs_pending+1)
- << " (max " << g_conf.osd_max_scrubs << ", active " << scrubs_active << ")" << dendl;
+ << " (max " << g_conf->osd_max_scrubs << ", active " << scrubs_active << ")" << dendl;
result = true;
++scrubs_pending;
} else {
- dout(20) << "inc_scrubs_pending " << scrubs_pending << " + " << scrubs_active << " active >= max " << g_conf.osd_max_scrubs << dendl;
+ dout(20) << "inc_scrubs_pending " << scrubs_pending << " + " << scrubs_active << " active >= max " << g_conf->osd_max_scrubs << dendl;
}
sched_scrub_lock.Unlock();
{
sched_scrub_lock.Lock();
dout(20) << "dec_scrubs_pending " << scrubs_pending << " -> " << (scrubs_pending-1)
- << " (max " << g_conf.osd_max_scrubs << ", active " << scrubs_active << ")" << dendl;
+ << " (max " << g_conf->osd_max_scrubs << ", active " << scrubs_active << ")" << dendl;
--scrubs_pending;
assert(scrubs_pending >= 0);
sched_scrub_lock.Unlock();
{
sched_scrub_lock.Lock();
dout(20) << "dec_scrubs_active " << scrubs_active << " -> " << (scrubs_active-1)
- << " (max " << g_conf.osd_max_scrubs << ", pending " << scrubs_pending << ")" << dendl;
+ << " (max " << g_conf->osd_max_scrubs << ", pending " << scrubs_pending << ")" << dendl;
--scrubs_active;
sched_scrub_lock.Unlock();
}
bool OSD::_recover_now()
{
- if (recovery_ops_active >= g_conf.osd_recovery_max_active) {
+ if (recovery_ops_active >= g_conf->osd_recovery_max_active) {
dout(15) << "_recover_now active " << recovery_ops_active
- << " >= max " << g_conf.osd_recovery_max_active << dendl;
+ << " >= max " << g_conf->osd_recovery_max_active << dendl;
return false;
}
if (g_clock.now() < defer_recovery_until) {
{
// see how many we should try to start. note that this is a bit racy.
recovery_wq.lock();
- int max = g_conf.osd_recovery_max_active - recovery_ops_active;
+ int max = g_conf->osd_recovery_max_active - recovery_ops_active;
recovery_wq.unlock();
if (max == 0) {
dout(10) << "do_recovery raced and failed to start anything; requeuing " << *pg << dendl;
pg->lock();
dout(10) << "do_recovery starting " << max
- << " (" << recovery_ops_active << "/" << g_conf.osd_recovery_max_active << " rops) on "
+ << " (" << recovery_ops_active << "/" << g_conf->osd_recovery_max_active << " rops) on "
<< *pg << dendl;
#ifdef DEBUG_RECOVERY_OIDS
dout(20) << " active was " << recovery_oids[pg->info.pgid] << dendl;
int started = pg->start_recovery_ops(max);
dout(10) << "do_recovery started " << started
- << " (" << recovery_ops_active << "/" << g_conf.osd_recovery_max_active << " rops) on "
+ << " (" << recovery_ops_active << "/" << g_conf->osd_recovery_max_active << " rops) on "
<< *pg << dendl;
/*
{
recovery_wq.lock();
dout(10) << "start_recovery_op " << *pg << " " << soid
- << " (" << recovery_ops_active << "/" << g_conf.osd_recovery_max_active << " rops)"
+ << " (" << recovery_ops_active << "/" << g_conf->osd_recovery_max_active << " rops)"
<< dendl;
assert(recovery_ops_active >= 0);
recovery_ops_active++;
{
dout(10) << "finish_recovery_op " << *pg << " " << soid
<< " dequeue=" << dequeue
- << " (" << recovery_ops_active << "/" << g_conf.osd_recovery_max_active << " rops)"
+ << " (" << recovery_ops_active << "/" << g_conf->osd_recovery_max_active << " rops)"
<< dendl;
recovery_wq.lock();
return;
}
- if (g_conf.osd_max_write_size &&
- op->get_data_len() > g_conf.osd_max_write_size << 20) {
+ if (g_conf->osd_max_write_size &&
+ op->get_data_len() > g_conf->osd_max_write_size << 20) {
// journal can't hold commit!
reply_op_error(op, -OSD_WRITETOOBIG);
pg->unlock();
}
pg->get();
- if (g_conf.osd_op_threads < 1) {
+ if (g_conf->osd_op_threads < 1) {
// do it now.
if (op->get_type() == CEPH_MSG_OSD_OP)
pg->do_op((MOSDOp*)op);
return;
}
- if (g_conf.osd_op_threads < 1) {
+ if (g_conf->osd_op_threads < 1) {
pg->do_sub_op(op); // do it now
} else {
enqueue_op(pg, op); // queue for worker threads
}
PG *pg = _lookup_lock_pg(pgid);
- if (g_conf.osd_op_threads < 1) {
+ if (g_conf->osd_op_threads < 1) {
pg->do_sub_op_reply(op); // do it now
} else {
enqueue_op(pg, op); // queue for worker threads
dout(10) << "dequeue_op " << op << " finish" << dendl;
assert(pending_ops > 0);
- if (pending_ops > g_conf.osd_max_opq)
+ if (pending_ops > g_conf->osd_max_opq)
op_queue_cond.Signal();
pending_ops--;
void OSD::throttle_op_queue()
{
// throttle? FIXME PROBABLY!
- while (pending_ops > g_conf.osd_max_opq) {
+ while (pending_ops > g_conf->osd_max_opq) {
dout(10) << "enqueue_op waiting for pending_ops " << pending_ops
- << " to drop to " << g_conf.osd_max_opq << dendl;
+ << " to drop to " << g_conf->osd_max_opq << dendl;
op_queue_cond.Wait(osd_lock);
}
}
bool is_flash_crowd_candidate(const object_t& oid) const {
Mutex::Locker locker(lock);
- return get_average_iat(oid) <= g_conf.osd_flash_crowd_iat_threshold;
+ return get_average_iat(oid) <= g_conf->osd_flash_crowd_iat_threshold;
}
};
pg->get();
osd->recovery_queue.push_back(&pg->recovery_item);
- if (g_conf.osd_recovery_delay_start > 0) {
+ if (g_conf->osd_recovery_delay_start > 0) {
osd->defer_recovery_until = g_clock.now();
- osd->defer_recovery_until += g_conf.osd_recovery_delay_start;
+ osd->defer_recovery_until += g_conf->osd_recovery_delay_start;
}
return true;
}
for (map<int,const char*>::iterator p = rulesets.begin(); p != rulesets.end(); p++) {
int pool = ++pool_max;
pools[pool].v.type = CEPH_PG_TYPE_REP;
- pools[pool].v.size = g_conf.osd_pool_default_size;
+ pools[pool].v.size = g_conf->osd_pool_default_size;
pools[pool].v.crush_ruleset = p->first;
pools[pool].v.object_hash = CEPH_STR_HASH_RJENKINS;
pools[pool].v.pg_num = nosd << pg_bits;
crush.set_type_name(1, "domain");
crush.set_type_name(2, "pool");
- int minrep = g_conf.osd_min_rep;
- int maxrep = g_conf.osd_max_rep;
+ int minrep = g_conf->osd_min_rep;
+ int maxrep = g_conf->osd_max_rep;
assert(maxrep >= minrep);
if (!ndom)
- ndom = MAX(maxrep, g_conf.osd_max_raid_width);
+ ndom = MAX(maxrep, g_conf->osd_max_raid_width);
if (ndom > 1 &&
nosd >= ndom*3 &&
nosd > 8) {
// replication
for (map<int,const char*>::iterator p = rulesets.begin(); p != rulesets.end(); p++) {
int ruleset = p->first;
- crush_rule *rule = crush_make_rule(3, ruleset, CEPH_PG_TYPE_REP, g_conf.osd_min_rep, maxrep);
+ crush_rule *rule = crush_make_rule(3, ruleset, CEPH_PG_TYPE_REP, g_conf->osd_min_rep, maxrep);
crush_rule_set_step(rule, 0, CRUSH_RULE_TAKE, rootid, 0);
crush_rule_set_step(rule, 1, CRUSH_RULE_CHOOSE_FIRSTN, CRUSH_CHOOSE_N, 0);
crush_rule_set_step(rule, 2, CRUSH_RULE_EMIT, 0, 0);
ps_t pps = pool.raw_pg_to_pps(pg); // placement ps
unsigned size = pool.get_size();
- assert(g_conf.osd_pg_layout == CEPH_PG_LAYOUT_CRUSH);
+ assert(g_conf->osd_pg_layout == CEPH_PG_LAYOUT_CRUSH);
{
int preferred = pg.preferred();
if (preferred >= max_osd || preferred >= crush.get_max_devices())
// no crush, but forcefeeding?
if (pg.preferred() >= 0 &&
- g_conf.osd_pg_layout != CEPH_PG_LAYOUT_CRUSH) {
+ g_conf->osd_pg_layout != CEPH_PG_LAYOUT_CRUSH) {
int osd = pg.preferred();
// already in there?
// -- crash recovery?
if (is_crashed()) {
replay_until = g_clock.now();
- replay_until += g_conf.osd_replay_window;
- dout(10) << "crashed, allowing op replay for " << g_conf.osd_replay_window
+ replay_until += g_conf->osd_replay_window;
+ dout(10) << "crashed, allowing op replay for " << g_conf->osd_replay_window
<< " until " << replay_until << dendl;
state_set(PG_STATE_REPLAY);
osd->replay_queue_lock.Lock();
::encode(ondisklog, blb);
t.collection_setattr(coll, "ondisklog", blb);
- if (!g_conf.osd_preserve_trimmed_log)
+ if (!g_conf->osd_preserve_trimmed_log)
t.zero(coll_t::META_COLL, log_oid, 0, ondisklog.tail & ~4095);
}
}
// just scrubbed?
- if (info.history.last_scrub_stamp + g_conf.osd_scrub_min_interval > g_clock.now()) {
+ if (info.history.last_scrub_stamp + g_conf->osd_scrub_min_interval > g_clock.now()) {
dout(20) << "sched_scrub: just scrubbed, skipping" << dendl;
return true;
}
assert(pg->is_primary());
pg->check_recovery_op_pulls(pg->osd->osdmap);
- if (g_conf.osd_check_for_log_corruption)
+ if (g_conf->osd_check_for_log_corruption)
pg->check_log_for_corruption(pg->osd->store);
int unfound = pg->missing.num_missing() - pg->missing_loc.size();
if (unfound > 0 &&
pg->all_unfound_are_lost(pg->osd->osdmap)) {
- if (g_conf.osd_auto_mark_unfound_lost) {
+ if (g_conf->osd_auto_mark_unfound_lost) {
pg->osd->clog.error() << pg->info.pgid << " has " << unfound
<< " objects unfound and apparently lost, automatically marking lost\n";
pg->mark_all_unfound_as_lost(*context< RecoveryMachine >().get_cur_transaction());
/*
if (is_primary() &&
- g_conf.osd_balance_reads)
+ g_conf->osd_balance_reads)
stat_object_temp_rd[soid].hit(now, osd->decayrate); // hit temp.
*/
} else {
} catch (const buffer::error &e) {
timeout = 0;
}
- if (!timeout || timeout > (uint32_t)g_conf.osd_max_notify_timeout)
- timeout = g_conf.osd_max_notify_timeout;
+ if (!timeout || timeout > (uint32_t)g_conf->osd_max_notify_timeout)
+ timeout = g_conf->osd_max_notify_timeout;
notify_info_t n;
n.timeout = timeout;
// only pull so much at a time
interval_set<uint64_t> pullsub;
- pullsub.span_of(data_subset, 0, g_conf.osd_recovery_max_chunk);
+ pullsub.span_of(data_subset, 0, g_conf->osd_recovery_max_chunk);
// take note
assert(pulling.count(soid) == 0);
pi->data_subset = data_subset;
pi->clone_subsets = clone_subsets;
- pi->data_subset_pushing.span_of(pi->data_subset, 0, g_conf.osd_recovery_max_chunk);
+ pi->data_subset_pushing.span_of(pi->data_subset, 0, g_conf->osd_recovery_max_chunk);
bool complete = pi->data_subset_pushing == pi->data_subset;
dout(10) << "push_start " << soid << " size " << size << " data " << data_subset
if (!complete) {
// push more
uint64_t from = pi->data_subset_pushing.range_end();
- pi->data_subset_pushing.span_of(pi->data_subset, from, g_conf.osd_recovery_max_chunk);
+ pi->data_subset_pushing.span_of(pi->data_subset, from, g_conf->osd_recovery_max_chunk);
dout(10) << " pushing more, " << pi->data_subset_pushing << " of " << pi->data_subset << dendl;
complete = pi->data_subset.range_end() == pi->data_subset_pushing.range_end();
send_push_op(soid, pi->version, peer, pi->size, false, complete,
update_stats();
} else {
// pull more
- pi->data_subset_pulling.span_of(pi->data_subset, data_subset.range_end(), g_conf.osd_recovery_max_chunk);
+ pi->data_subset_pulling.span_of(pi->data_subset, data_subset.range_end(), g_conf->osd_recovery_max_chunk);
dout(10) << " pulling more, " << pi->data_subset_pulling << " of " << pi->data_subset << dendl;
send_pull_op(soid, v, false, pi->data_subset_pulling, pi->from);
}
// prefetch intelligently.
// (watch out, this is big if you use big objects or weird striping)
- uint64_t periods = g_conf.journaler_prefetch_periods;
+ uint64_t periods = g_conf->journaler_prefetch_periods;
if (periods < 2)
periods = 2; // we need at least 2 periods to make progress.
fetch_len = layout.fl_stripe_count * layout.fl_object_size * periods;
assert(!readonly);
uint32_t s = bl.length();
- if (!g_conf.journaler_allow_split_entries) {
+ if (!g_conf->journaler_allow_split_entries) {
// will we span a stripe boundary?
int p = layout.fl_stripe_unit;
if (write_pos / p != (write_pos + (int64_t)(bl.length() + sizeof(s))) / p) {
} else {
if (1) {
// maybe buffer
- if (write_buf.length() < g_conf.journaler_batch_max) {
+ if (write_buf.length() < g_conf->journaler_batch_max) {
// delay! schedule an event.
dout(20) << "flush delaying flush" << dendl;
if (delay_flush_event)
timer->cancel_event(delay_flush_event);
delay_flush_event = new C_DelayFlush(this);
- timer->add_event_after(g_conf.journaler_batch_interval, delay_flush_event);
+ timer->add_event_after(g_conf->journaler_batch_interval, delay_flush_event);
} else {
dout(20) << "flush not delaying flush" << dendl;
_do_flush();
}
// write head?
- if (last_wrote_head.sec() + g_conf.journaler_write_head_interval < g_clock.now().sec()) {
+ if (last_wrote_head.sec() + g_conf->journaler_write_head_interval < g_clock.now().sec()) {
write_head();
}
}
// we need to zero at least two periods, minimum, to ensure that we have a full
// empty object/period in front of us.
- uint64_t num_periods = MAX(2, g_conf.journaler_prezero_periods);
+ uint64_t num_periods = MAX(2, g_conf->journaler_prezero_periods);
/*
* issue zero requests based on write_pos, even though the invariant
void ObjectCacher::flush(loff_t amount)
{
utime_t cutoff = g_clock.now();
- //cutoff.sec_ref() -= g_conf.client_oc_max_dirty_age;
+ //cutoff.sec_ref() -= g_conf->client_oc_max_dirty_age;
dout(10) << "flush " << amount << dendl;
void ObjectCacher::trim(loff_t max)
{
if (max < 0)
- max = g_conf.client_oc_size;
+ max = g_conf->client_oc_size;
dout(10) << "trim start: max " << max
<< " clean " << get_stat_clean()
int blocked = 0;
// wait for writeback?
- while (get_stat_dirty() + get_stat_tx() >= g_conf.client_oc_max_dirty) {
+ while (get_stat_dirty() + get_stat_tx() >= g_conf->client_oc_max_dirty) {
dout(10) << "wait_for_write waiting on " << len << ", dirty|tx "
<< (get_stat_dirty() + get_stat_tx())
- << " >= " << g_conf.client_oc_max_dirty
+ << " >= " << g_conf->client_oc_max_dirty
<< dendl;
flusher_cond.Signal();
stat_waiter++;
}
// start writeback anyway?
- if (get_stat_dirty() > g_conf.client_oc_target_dirty) {
+ if (get_stat_dirty() > g_conf->client_oc_target_dirty) {
dout(10) << "wait_for_write " << get_stat_dirty() << " > target "
- << g_conf.client_oc_target_dirty << ", nudging flusher" << dendl;
+ << g_conf->client_oc_target_dirty << ", nudging flusher" << dendl;
flusher_cond.Signal();
}
return blocked;
while (!flusher_stop) {
loff_t all = get_stat_tx() + get_stat_rx() + get_stat_clean() + get_stat_dirty();
dout(11) << "flusher "
- << all << " / " << g_conf.client_oc_size << ": "
+ << all << " / " << g_conf->client_oc_size << ": "
<< get_stat_tx() << " tx, "
<< get_stat_rx() << " rx, "
<< get_stat_clean() << " clean, "
<< get_stat_dirty() << " dirty ("
- << g_conf.client_oc_target_dirty << " target, "
- << g_conf.client_oc_max_dirty << " max)"
+ << g_conf->client_oc_target_dirty << " target, "
+ << g_conf->client_oc_max_dirty << " max)"
<< dendl;
- if (get_stat_dirty() > g_conf.client_oc_target_dirty) {
+ if (get_stat_dirty() > g_conf->client_oc_target_dirty) {
// flush some dirty pages
dout(10) << "flusher "
<< get_stat_dirty() << " dirty > target "
- << g_conf.client_oc_target_dirty
+ << g_conf->client_oc_target_dirty
<< ", flushing some dirty bhs" << dendl;
- flush(get_stat_dirty() - g_conf.client_oc_target_dirty);
+ flush(get_stat_dirty() - g_conf->client_oc_target_dirty);
}
else {
// check tail of lru for old dirty items
<< dendl;
if (wr->extents.size() == 1 &&
- wr->extents.front().length <= g_conf.client_oc_max_sync_write) {
+ wr->extents.front().length <= g_conf->client_oc_max_sync_write) {
// single object.
// make sure we aren't already locking/locked...
void Objecter::init()
{
assert(client_lock.is_locked());
- timer.add_event_after(g_conf.objecter_tick_interval, new C_Tick(this));
+ timer.add_event_after(g_conf->objecter_tick_interval, new C_Tick(this));
maybe_request_map();
}
// look for laggy requests
utime_t cutoff = g_clock.now();
- cutoff -= g_conf.objecter_timeout; // timeout
+ cutoff -= g_conf->objecter_timeout; // timeout
for (hash_map<tid_t,Op*>::iterator p = ops.begin();
p != ops.end();
}
// reschedule
- timer.add_event_after(g_conf.objecter_tick_interval, new C_Tick(this));
+ timer.add_event_after(g_conf->objecter_tick_interval, new C_Tick(this));
}
void Objecter::resend_mon_ops()
{
utime_t cutoff = g_clock.now();
- cutoff -= g_conf.objecter_mon_retry_interval;
+ cutoff -= g_conf->objecter_mon_retry_interval;
for (map<tid_t,PoolStatOp*>::iterator p = poolstat_ops.begin(); p!=poolstat_ops.end(); ++p) {
last_seen_pgmap_version(0),
client_lock(l), timer(t),
num_homeless_ops(0),
- op_throttler(g_conf.objecter_inflight_op_bytes)
+ op_throttler(g_conf->objecter_inflight_op_bytes)
{ }
~Objecter() { }
bool tree = false;
bool createsimple = false;
int num_osd = 0, num_dom = 0;
- int pg_bits = g_conf.osd_pg_bits;
- int pgp_bits = g_conf.osd_pgp_bits;
- int lpg_bits = g_conf.osd_lpg_bits;
+ int pg_bits = g_conf->osd_pg_bits;
+ int pgp_bits = g_conf->osd_pgp_bits;
+ int lpg_bits = g_conf->osd_lpg_bits;
bool clobber = false;
bool modified = false;
const char *export_crush = 0;
{
char profile_name[PATH_MAX];
snprintf(profile_name, sizeof(profile_name),
- "%s/%s", g_conf.log_dir.c_str(), g_conf.name.to_cstr());
+ "%s/%s", g_conf->log_dir.c_str(), g_conf->name.to_cstr());
generic_dout(0) << "turning on heap profiler with prefix "
<< profile_name << dendl;
HeapProfilerStart(profile_name);
else {
char *heap_stats = new char[1024];
ceph_heap_profiler_stats(heap_stats, 1024);
- clog.info() << g_conf.name << "dumping heap profile now.\n"
+ clog.info() << g_conf->name << "dumping heap profile now.\n"
<< heap_stats << std::endl;
ceph_heap_profiler_dump("admin request");
}
} else if (cmd.size() == 2 && cmd[1] == "start_profiler") {
ceph_heap_profiler_start();
- clog.info() << g_conf.name << " started profiler \n";
+ clog.info() << g_conf->name << " started profiler \n";
} else if (cmd.size() == 2 && cmd[1] == "stop_profiler") {
ceph_heap_profiler_stop();
- clog.info() << g_conf.name << " stopped profiler\n";
+ clog.info() << g_conf->name << " stopped profiler\n";
} else if (cmd.size() == 2 && cmd[1] == "release") {
ceph_heap_release_free_memory();
- clog.info() << g_conf.name << " releasing free RAM back "
+ clog.info() << g_conf->name << " releasing free RAM back "
<< "to system.\n";
} else if (cmd.size() == 2 && cmd[1] == "stats") {
char *heap_stats = new char[1024];
ceph_heap_profiler_stats(heap_stats, 1024);
- clog.info() << g_conf.name << "tcmalloc heap stats:"
+ clog.info() << g_conf->name << "tcmalloc heap stats:"
<< heap_stats << std::endl;
} else {
clog.warn() << "unknown command " << cmd << std::endl;
#include <sstream>
#include <string.h>
-#define RGW_LOG(x) pdout(x, g_conf.rgw_log)
+#define RGW_LOG(x) pdout(x, g_conf->rgw_log)
static Mutex librgw_init_mutex("librgw_init");
static int librgw_initialized = 0;
#define RGW_MAX_CHUNK_SIZE (4*1024*1024)
#define RGW_LOG_BEGIN "RADOS S3 Gateway:"
-#define RGW_LOG(x) pdout(x, g_conf.rgw_log)
+#define RGW_LOG(x) pdout(x, g_conf->rgw_log)
#define RGW_FORMAT_XML 1
#define RGW_FORMAT_JSON 2
if (ret >= 0) {
bufferlist::iterator iter = bl.begin();
policy->decode(iter);
- if (g_conf.rgw_log >= 15) {
+ if (g_conf->rgw_log >= 15) {
RGW_LOG(15) << "Read AccessControlPolicy" << dendl;
policy->to_xml(cerr);
RGW_LOG(15) << dendl;
goto done;
}
- if (g_conf.rgw_log >= 15) {
+ if (g_conf->rgw_log >= 15) {
RGW_LOG(15) << "Old AccessControlPolicy" << dendl;
policy->to_xml(cout);
RGW_LOG(15) << dendl;
if (ret < 0)
goto done;
- if (g_conf.rgw_log >= 15) {
+ if (g_conf->rgw_log >= 15) {
RGW_LOG(15) << "New AccessControlPolicy" << dendl;
new_policy.to_xml(cout);
RGW_LOG(15) << dendl;
if (cgi_env_level != NULL) {
int level = atoi(cgi_env_level);
if (level >= 0) {
- g_conf.rgw_log = level;
+ g_conf->rgw_log = level;
}
}
const char *cgi_should_log = FCGX_GetParam("RGW_SHOULD_LOG", fcgx->envp);
s->should_log = rgw_str_to_bool(cgi_should_log, RGW_SHOULD_LOG_DEFAULT);
- if (g_conf.rgw_log >= 20) {
+ if (g_conf->rgw_log >= 20) {
char *p;
for (int i=0; (p = fcgx->envp[i]); ++i) {
RGW_LOG(20) << p << dendl;
if (attrs) {
r = state->io_ctx.getxattrs(oid, *attrs);
- if (g_conf.rgw_log >= 20) {
+ if (g_conf->rgw_log >= 20) {
for (iter = attrs->begin(); iter != attrs->end(); ++iter) {
RGW_LOG(20) << "Read xattr: " << iter->first << dendl;
}
changed.insert(*t);
}
DoutLocker _dout_locker;
- dos->handle_conf_change(&g_conf, changed);
+ dos->handle_conf_change(g_conf, changed);
}
derr << "using configuration: " << dos->config_to_str() << dendl;
// start up network
int whoami = mc.monmap.get_rank(args[0]);
assert(whoami >= 0);
- g_conf.public_addr = mc.monmap.get_addr(whoami);
+ g_conf->public_addr = mc.monmap.get_addr(whoami);
SimpleMessenger *rank = new SimpleMessenger();
int err = rank->bind(getpid());
if (err < 0)
}
registered.clear();
- float seconds = g_conf.paxos_observer_timeout/2;
+ float seconds = g_conf->paxos_observer_timeout/2;
dout(1) << " refresh after " << seconds << " with same mon" << dendl;
g.timer.add_event_after(seconds, new C_ObserverRefresh(false));
}
g.mc.init();
if (g.mc.authenticate() < 0) {
- derr << "unable to authenticate as " << g_conf.name << dendl;
+ derr << "unable to authenticate as " << g_conf->name << dendl;
ceph_tool_messenger_shutdown();
ceph_tool_common_shutdown();
return 1;
projects / ceph.git / commitdiff