global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
EntityName ename(g_conf->name);
const char *me = argv[0];
if (gen_print_key) {
CryptoKey key;
- key.create(&g_ceph_context, CEPH_CRYPTO_AES);
+ key.create(g_ceph_context, CEPH_CRYPTO_AES);
cout << key << std::endl;
return 0;
}
cout << "importing contents of " << import_keyring << " into " << fn << std::endl;
//other.print(cout);
- keyring.import(&g_ceph_context, other);
+ keyring.import(g_ceph_context, other);
modified = true;
} else {
cerr << "can't open " << import_keyring << ": " << err << std::endl;
}
if (gen_key) {
EntityAuth eauth;
- eauth.key.create(&g_ceph_context, CEPH_CRYPTO_AES);
+ eauth.key.create(g_ceph_context, CEPH_CRYPTO_AES);
keyring.add(ename, eauth);
modified = true;
}
cerr << "could not parse caps file " << caps_fn << std::endl;
exit(1);
}
- complain_about_parse_errors(&g_ceph_context, &parse_errors);
+ complain_about_parse_errors(g_ceph_context, &parse_errors);
map<string, bufferlist> caps;
const char *key_names[] = { "mon", "osd", "mds", NULL };
for (int i=0; key_names[i]; i++) {
argv_to_vec(argc, argv, args);
env_to_vec(args);
global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
std::string val;
for (std::vector<const char*>::iterator i = args.begin(); i != args.end(); ) {
}
// get monmap
- MonClient mc(&g_ceph_context);
+ MonClient mc(g_ceph_context);
int ret = mc.build_initial_monmap();
if (ret == -EINVAL)
usage();
return -1;
// start up network
- SimpleMessenger *messenger = new SimpleMessenger(&g_ceph_context);
+ SimpleMessenger *messenger = new SimpleMessenger(g_ceph_context);
messenger->register_entity(entity_name_t::CLIENT());
Client *client = new Client(messenger, &mc);
if (filer_flags) {
childpid = fork();
}
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
if (childpid == 0) {
//cout << "child, mounting" << std::endl;
char hostname[80];
gethostname(hostname, 79);
snprintf(s, sizeof(s), "clients.%s.%d", hostname, getpid());
- client_logger = new ProfLogger(&g_ceph_context, s, &client_logtype);
+ client_logger = new ProfLogger(g_ceph_context, s, &client_logtype);
}
client_logger_lock.Unlock();
}
bufferlist *pdirbl)
{
// time the call
- utime_t start = ceph_clock_now(&g_ceph_context);
+ utime_t start = ceph_clock_now(g_ceph_context);
bool nojournal = false;
int op = request->get_op();
// -- log times --
if (client_logger) {
- utime_t lat = ceph_clock_now(&g_ceph_context);
+ utime_t lat = ceph_clock_now(g_ceph_context);
lat -= request->sent_stamp;
dout(20) << "lat " << lat << dendl;
client_logger->favg(l_c_lat,(double)lat);
r->releases = request->cap_releases;
if (request->mds == -1) {
- request->sent_stamp = ceph_clock_now(&g_ceph_context);
+ request->sent_stamp = ceph_clock_now(g_ceph_context);
dout(20) << "send_request set sent_stamp to " << request->sent_stamp << dendl;
}
request->mds = mds;
dout(1) << "handle_mds_map epoch " << m->get_epoch() << dendl;
MDSMap *oldmap = mdsmap;
- mdsmap = new MDSMap(&g_ceph_context);
+ mdsmap = new MDSMap(g_ceph_context);
mdsmap->decode(m->get_encoded());
// reset session
void Client::release_lease(Inode *in, Dentry *dn, int mask)
{
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
assert(dn);
void Client::cap_delay_requeue(Inode *in)
{
dout(10) << "cap_delay_requeue on " << *in << dendl;
- in->hold_caps_until = ceph_clock_now(&g_ceph_context);
+ in->hold_caps_until = ceph_clock_now(g_ceph_context);
in->hold_caps_until += 5.0;
delayed_caps.push_back(&in->cap_item);
else
in->hold_caps_until = utime_t();
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
map<int,InodeCap*>::iterator it = in->caps.begin();
while (it != in->caps.end()) {
tick_event = new C_C_Tick(this);
timer.add_event_after(g_conf->client_tick_interval, tick_event);
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
if (mdsmap->get_epoch()) {
// renew caps?
void Client::renew_caps()
{
dout(10) << "renew_caps()" << dendl;
- last_cap_renew = ceph_clock_now(&g_ceph_context);
+ last_cap_renew = ceph_clock_now(g_ceph_context);
for (map<int,MDSSession*>::iterator p = mds_sessions.begin();
p != mds_sessions.end();
void Client::renew_caps(const int mds) {
dout(10) << "renew_caps mds" << mds << dendl;
MDSSession *session = mds_sessions[mds];
- session->last_cap_renew_request = ceph_clock_now(&g_ceph_context);
+ session->last_cap_renew_request = ceph_clock_now(g_ceph_context);
uint64_t seq = ++session->cap_renew_seq;
messenger->send_message(new MClientSession(CEPH_SESSION_REQUEST_RENEWCAPS, seq),
mdsmap->get_inst(mds));
<< dendl;
// is dn lease valid?
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
if (dn->lease_mds >= 0 &&
dn->lease_ttl > now &&
mds_sessions.count(dn->lease_mds)) {
Dentry *dn = *pdn = dir->dir->dentries[name];
// is dn lease valid?
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
if (dn->inode &&
dn->lease_mds >= 0 &&
dn->lease_ttl > now &&
if (!mask) {
// caller just needs us to bump the ctime
- in->ctime = ceph_clock_now(&g_ceph_context);
+ in->ctime = ceph_clock_now(g_ceph_context);
if (issued & CEPH_CAP_AUTH_EXCL)
mark_caps_dirty(in, CEPH_CAP_AUTH_EXCL);
else if (issued & CEPH_CAP_FILE_EXCL)
if (in->caps_issued_mask(CEPH_CAP_AUTH_EXCL)) {
if (mask & CEPH_SETATTR_MODE) {
- in->ctime = ceph_clock_now(&g_ceph_context);
+ in->ctime = ceph_clock_now(g_ceph_context);
in->mode = (in->mode & ~07777) | (attr->st_mode & 07777);
mark_caps_dirty(in, CEPH_CAP_AUTH_EXCL);
mask &= ~CEPH_SETATTR_MODE;
}
if (mask & CEPH_SETATTR_UID) {
- in->ctime = ceph_clock_now(&g_ceph_context);
+ in->ctime = ceph_clock_now(g_ceph_context);
in->uid = attr->st_uid;
mark_caps_dirty(in, CEPH_CAP_AUTH_EXCL);
mask &= ~CEPH_SETATTR_UID;
}
if (mask & CEPH_SETATTR_GID) {
- in->ctime = ceph_clock_now(&g_ceph_context);
+ in->ctime = ceph_clock_now(g_ceph_context);
in->gid = attr->st_gid;
mark_caps_dirty(in, CEPH_CAP_AUTH_EXCL);
mask &= ~CEPH_SETATTR_GID;
in->mtime = utime_t(attr->st_mtim.tv_sec, attr->st_mtim.tv_nsec);
if (mask & CEPH_SETATTR_ATIME)
in->atime = utime_t(attr->st_atim.tv_sec, attr->st_atim.tv_nsec);
- in->ctime = ceph_clock_now(&g_ceph_context);
+ in->ctime = ceph_clock_now(g_ceph_context);
in->time_warp_seq++;
mark_caps_dirty(in, CEPH_CAP_FILE_EXCL);
mask &= ~(CEPH_SETATTR_MTIME|CEPH_SETATTR_ATIME);
dout(10) << "cur file size is " << in->size << dendl;
// time it.
- utime_t start = ceph_clock_now(&g_ceph_context);
+ utime_t start = ceph_clock_now(g_ceph_context);
// copy into fresh buffer (since our write may be resub, async)
bufferptr bp;
// async, caching, non-blocking.
objectcacher->file_write(&in->oset, &in->layout, in->snaprealm->get_snap_context(),
- offset, size, bl, ceph_clock_now(&g_ceph_context), 0);
+ offset, size, bl, ceph_clock_now(g_ceph_context), 0);
put_cap_ref(in, CEPH_CAP_FILE_BUFFER);
} else {
/*
// atomic, synchronous, blocking.
objectcacher->file_atomic_sync_write(in->ino, &in->layout, in->snaprealm->get_snap_context(),
- offset, size, bl, ceph_clock_now(&g_ceph_context), 0, client_lock);
+ offset, size, bl, ceph_clock_now(g_ceph_context), 0, client_lock);
*/
// simple, non-atomic sync write
Mutex flock("Client::_write flock");
get_cap_ref(in, CEPH_CAP_FILE_BUFFER); // released by onsafe callback
filer->write_trunc(in->ino, &in->layout, in->snaprealm->get_snap_context(),
- offset, size, bl, ceph_clock_now(&g_ceph_context), filer_flags,
+ offset, size, bl, ceph_clock_now(g_ceph_context), filer_flags,
in->truncate_size, in->truncate_seq,
onfinish, onsafe);
}
// time
- utime_t lat = ceph_clock_now(&g_ceph_context);
+ utime_t lat = ceph_clock_now(g_ceph_context);
lat -= start;
if (client_logger)
client_logger->favg(l_c_wrlat,(double)lat);
}
// mtime
- in->mtime = ceph_clock_now(&g_ceph_context);
+ in->mtime = ceph_clock_now(g_ceph_context);
mark_caps_dirty(in, CEPH_CAP_FILE_WR);
put_cap_ref(in, CEPH_CAP_FILE_WR);
Inode *diri = 0;
Inode *in = 0;
int r = 0;
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
if (inode_map.count(parent) == 0) {
dout(1) << "ll_lookup " << parent << " " << name << " -> ENOENT (parent DNE... WTF)" << dendl;
/*cout << "cap_gen " << cap->session-> cap_gen << std::endl
<< "session gen " << cap->gen << std::endl
<< "cap expire " << cap->session->cap_ttl << std::endl
- << "cur time " << ceph_clock_now(&g_ceph_context) << std::endl;*/
+ << "cur time " << ceph_clock_now(g_ceph_context) << std::endl;*/
if ((cap->session->cap_gen <= cap->gen)
- && (ceph_clock_now(&g_ceph_context) < cap->session->cap_ttl)) {
+ && (ceph_clock_now(g_ceph_context) < cap->session->cap_ttl)) {
return true;
}
//if we make it here, the capabilities aren't up-to-date
this->iargs = syn_iargs;
this->sargs = syn_sargs;
- run_start = ceph_clock_now(&g_ceph_context);
+ run_start = ceph_clock_now(g_ceph_context);
}
return -1;
}
- //run_start = ceph_clock_now(&g_ceph_context);
+ //run_start = ceph_clock_now(g_ceph_context);
run_until = utime_t(0,0);
dout(5) << "run" << dendl;
iargs.pop_front();
if (iarg1 && run_me()) {
dout(2) << "sleepuntil " << iarg1 << dendl;
- utime_t at = ceph_clock_now(&g_ceph_context) - run_start;
+ utime_t at = ceph_clock_now(g_ceph_context) - run_start;
if (at.sec() < iarg1)
sleep(iarg1 - at.sec());
}
if (iarg1 == 0) iarg1 = 1; // play trace at least once!
for (int i=0; i<iarg1; i++) {
- utime_t start = ceph_clock_now(&g_ceph_context);
+ utime_t start = ceph_clock_now(g_ceph_context);
if (time_to_stop()) break;
play_trace(t, prefix, !playdata);
if (time_to_stop()) break;
if (iarg1 > 1) clean_dir(prefix); // clean only if repeat
- utime_t lat = ceph_clock_now(&g_ceph_context);
+ utime_t lat = ceph_clock_now(g_ceph_context);
lat -= start;
dout(0) << " trace " << tfile << " loop " << (i+1) << "/" << iarg1 << " done in " << (double)lat << " seconds" << dendl;
char buf[1024];
char buf2[1024];
- utime_t start = ceph_clock_now(&g_ceph_context);
+ utime_t start = ceph_clock_now(g_ceph_context);
hash_map<int64_t, int64_t> open_files;
hash_map<int64_t, dir_result_t*> open_dirs;
Cond cond;
bool ack;
bool safe;
- C_Gather *safeg = new C_Gather(&g_ceph_context, new C_SafeCond(&lock, &cond, &safe));
+ C_Gather *safeg = new C_Gather(g_ceph_context, new C_SafeCond(&lock, &cond, &safe));
Context *safegref = safeg->new_sub(); // take a ref
while (!t.end()) {
bufferlist bl;
bl.push_back(bp);
SnapContext snapc;
- client->objecter->write(oid, oloc, off, len, snapc, bl, ceph_clock_now(&g_ceph_context), 0,
+ client->objecter->write(oid, oloc, off, len, snapc, bl, ceph_clock_now(g_ceph_context), 0,
new C_SafeCond(&lock, &cond, &ack),
safeg->new_sub());
while (!ack) cond.Wait(lock);
object_locator_t oloc(CEPH_DATA_RULE);
lock.Lock();
SnapContext snapc;
- client->objecter->zero(oid, oloc, off, len, snapc, ceph_clock_now(&g_ceph_context), 0,
+ client->objecter->zero(oid, oloc, off, len, snapc, ceph_clock_now(g_ceph_context), 0,
new C_SafeCond(&lock, &cond, &ack),
safeg->new_sub());
while (!ack) cond.Wait(lock);
dout(3) << "read_dirs " << basedir << " dirs " << dirs << " files " << files << " depth " << depth << dendl;
list<string> contents;
- utime_t s = ceph_clock_now(&g_ceph_context);
+ utime_t s = ceph_clock_now(g_ceph_context);
int r = client->getdir(basedir, contents);
- utime_t e = ceph_clock_now(&g_ceph_context);
+ utime_t e = ceph_clock_now(g_ceph_context);
e -= s;
if (r < 0) {
dout(0) << "read_dirs couldn't readdir " << basedir << ", stopping" << dendl;
for (int i=0; i<files; i++) {
snprintf(d, sizeof(d), "%s/file.%d", basedir, i);
- utime_t s = ceph_clock_now(&g_ceph_context);
+ utime_t s = ceph_clock_now(g_ceph_context);
if (client->lstat(d, &st) < 0) {
dout(2) << "read_dirs failed stat on " << d << ", stopping" << dendl;
return -1;
}
- utime_t e = ceph_clock_now(&g_ceph_context);
+ utime_t e = ceph_clock_now(g_ceph_context);
e -= s;
}
// files
struct stat st;
- utime_t start = ceph_clock_now(&g_ceph_context);
+ utime_t start = ceph_clock_now(g_ceph_context);
for (int c=0; c<count; c++) {
for (int n=0; n<num; n++) {
snprintf(d, sizeof(d), "dir.%d.run%d/file.client%d.%d", priv ? whoami:0, c, whoami, n);
if (time_to_stop()) return 0;
}
}
- utime_t end = ceph_clock_now(&g_ceph_context);
+ utime_t end = ceph_clock_now(g_ceph_context);
end -= start;
dout(0) << "makefiles time is " << end << " or " << ((double)end / (double)num) <<" per file" << dendl;
client->mkdir("orig", 0755);
client->mkdir("copy", 0755);
- utime_t start = ceph_clock_now(&g_ceph_context);
+ utime_t start = ceph_clock_now(g_ceph_context);
for (int i=0; i<num; i++) {
snprintf(d, sizeof(d), "orig/file.%d", i);
client->mknod(d, 0755);
}
- utime_t end = ceph_clock_now(&g_ceph_context);
+ utime_t end = ceph_clock_now(g_ceph_context);
end -= start;
dout(0) << "orig " << end << dendl;
// link
- start = ceph_clock_now(&g_ceph_context);
+ start = ceph_clock_now(g_ceph_context);
for (int i=0; i<num; i++) {
snprintf(d, sizeof(d), "orig/file.%d", i);
snprintf(e, sizeof(e), "copy/file.%d", i);
client->link(d, e);
}
- end = ceph_clock_now(&g_ceph_context);
+ end = ceph_clock_now(g_ceph_context);
end -= start;
dout(0) << "copy " << end << dendl;
dout(5) << "writing to " << fn << " fd " << fd << dendl;
if (fd < 0) return fd;
- utime_t from = ceph_clock_now(&g_ceph_context);
+ utime_t from = ceph_clock_now(g_ceph_context);
utime_t start = from;
uint64_t bytes = 0, total = 0;
bytes += wrsize;
total += wrsize;
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
if (now - from >= 1.0) {
double el = now - from;
dout(0) << "write " << (bytes / el / 1048576.0) << " MB/sec" << dendl;
client->fsync(fd, true);
- utime_t stop = ceph_clock_now(&g_ceph_context);
+ utime_t stop = ceph_clock_now(g_ceph_context);
double el = stop - start;
dout(0) << "write total " << (total / el / 1048576.0) << " MB/sec ("
<< total << " bytes in " << el << " seconds)" << dendl;
dout(5) << "reading from " << fn << " fd " << fd << dendl;
if (fd < 0) return fd;
- utime_t from = ceph_clock_now(&g_ceph_context);
+ utime_t from = ceph_clock_now(g_ceph_context);
utime_t start = from;
uint64_t bytes = 0, total = 0;
bytes += rdsize;
total += rdsize;
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
if (now - from >= 1.0) {
double el = now - from;
dout(0) << "read " << (bytes / el / 1048576.0) << " MB/sec" << dendl;
dout(0) << " + " << (bad-1) << " other bad 16-byte bits in this block" << dendl;
}
- utime_t stop = ceph_clock_now(&g_ceph_context);
+ utime_t stop = ceph_clock_now(g_ceph_context);
double el = stop - start;
dout(0) << "read total " << (total / el / 1048576.0) << " MB/sec ("
<< total << " bytes in " << el << " seconds)" << dendl;
}
dout(10) << "writing " << oid << dendl;
- starts.push_back(ceph_clock_now(&g_ceph_context));
+ starts.push_back(ceph_clock_now(g_ceph_context));
client->client_lock.Lock();
- client->objecter->write(oid, oloc, 0, osize, snapc, bl, ceph_clock_now(&g_ceph_context), 0,
+ client->objecter->write(oid, oloc, 0, osize, snapc, bl, ceph_clock_now(g_ceph_context), 0,
new C_Ref(lock, cond, &unack),
new C_Ref(lock, cond, &unsafe));
client->client_lock.Unlock();
}
lock.Unlock();
- utime_t lat = ceph_clock_now(&g_ceph_context);
+ utime_t lat = ceph_clock_now(g_ceph_context);
lat -= starts.front();
starts.pop_front();
}
SnapContext snapc;
client->client_lock.Lock();
- utime_t start = ceph_clock_now(&g_ceph_context);
+ utime_t start = ceph_clock_now(g_ceph_context);
if (write) {
dout(10) << "write to " << oid << dendl;
op.op.op = CEPH_OSD_OP_STARTSYNC;
m.ops.push_back(op);
}
- client->objecter->mutate(oid, oloc, m, snapc, ceph_clock_now(&g_ceph_context), 0,
+ client->objecter->mutate(oid, oloc, m, snapc, ceph_clock_now(g_ceph_context), 0,
NULL, new C_Ref(lock, cond, &unack));
/*client->objecter->write(oid, layout, 0, osize, snapc, bl, 0,
new C_Ref(lock, cond, &unack),
}
lock.Unlock();
- utime_t lat = ceph_clock_now(&g_ceph_context);
+ utime_t lat = ceph_clock_now(g_ceph_context);
lat -= start;
if (client_logger) {
if (write)
}
bool time_to_stop() {
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
if (0) cout << "time_to_stop .. now " << now
<< " until " << run_until
<< " start " << run_start
static int do_cmds_special_action(const std::string &action,
const std::string &dump_file, int rank)
{
- SimpleMessenger *messenger = new SimpleMessenger(&g_ceph_context);
+ SimpleMessenger *messenger = new SimpleMessenger(g_ceph_context);
messenger->bind(getpid());
- MonClient mc(&g_ceph_context);
+ MonClient mc(g_ceph_context);
if (mc.build_initial_monmap() < 0)
return -1;
usage();
}
- SimpleMessenger *messenger = new SimpleMessenger(&g_ceph_context);
+ SimpleMessenger *messenger = new SimpleMessenger(g_ceph_context);
messenger->bind(getpid());
cout << "starting " << g_conf->name << " at " << messenger->get_ms_addr()
<< std::endl;
SimpleMessenger::Policy::stateful_server(supported, 0));
if (shadow != MDSMap::STATE_ONESHOT_REPLAY)
- global_init_daemonize(&g_ceph_context, 0);
- common_init_finish(&g_ceph_context);
+ global_init_daemonize(g_ceph_context, 0);
+ common_init_finish(g_ceph_context);
// get monmap
- MonClient mc(&g_ceph_context);
+ MonClient mc(g_ceph_context);
if (mc.build_initial_monmap() < 0)
return -1;
- global_init_chdir(&g_ceph_context);
+ global_init_chdir(g_ceph_context);
messenger->start();
// -- mkfs --
if (mkfs) {
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
if (g_conf->monmap.empty() || !osdmapfn)
usage();
<< error << std::endl;
exit(1);
}
- MonMap monmap(ceph_clock_now(&g_ceph_context));
+ MonMap monmap(ceph_clock_now(g_ceph_context));
monmap.decode(monmapbl);
err = osdmapbl.read_file(osdmapfn, &error);
// go
MonitorStore store(g_conf->mon_data);
- Monitor mon(&g_ceph_context, g_conf->name.get_id(), &store, 0, &monmap);
+ Monitor mon(g_ceph_context, 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;
v++;
// set the version
- MonMap tmp(ceph_clock_now(&g_ceph_context));
+ MonMap tmp(ceph_clock_now(g_ceph_context));
tmp.decode(bl);
if (tmp.get_epoch() != v) {
cout << "changing monmap epoch from " << tmp.get_epoch() << " to " << v << std::endl;
// monmap?
- MonMap monmap(ceph_clock_now(&g_ceph_context));
+ MonMap monmap(ceph_clock_now(g_ceph_context));
{
bufferlist latest;
store.get_bl_ss(latest, "monmap/latest", 0);
}
// bind
- SimpleMessenger *messenger = new SimpleMessenger(&g_ceph_context);
+ SimpleMessenger *messenger = new SimpleMessenger(g_ceph_context);
int rank = monmap.get_rank(g_conf->name.get_id());
cout << "starting " << g_conf->name << " rank " << rank
// start monitor
messenger->register_entity(entity_name_t::MON(rank));
messenger->set_default_send_priority(CEPH_MSG_PRIO_HIGH);
- Monitor *mon = new Monitor(&g_ceph_context, g_conf->name.get_id(), &store, messenger, &monmap);
+ Monitor *mon = new Monitor(g_ceph_context, g_conf->name.get_id(), &store, messenger, &monmap);
- global_init_daemonize(&g_ceph_context, 0);
- common_init_finish(&g_ceph_context);
- global_init_chdir(&g_ceph_context);
+ global_init_daemonize(g_ceph_context, 0);
+ common_init_finish(g_ceph_context);
+ global_init_chdir(g_ceph_context);
messenger->start();
uint64_t supported =
md_config_obs_t *_prof_logger_conf_obs;
};
-/* Globals (FIXME: remove) */
-extern CephContext g_ceph_context;
-extern md_config_t *g_conf;
-extern DoutStreambuf <char, std::basic_string<char>::traits_type> *_doss;
-
-
#endif
/* Global version of the stuff in common/dout.h
*/
-#define dout(v) ldout((&g_ceph_context), v)
+#define dout(v) ldout((g_ceph_context), v)
-#define pdout(v, p) lpdout((&g_ceph_context), v, p)
+#define pdout(v, p) lpdout((g_ceph_context), v, p)
-#define generic_dout(v) lgeneric_dout((&g_ceph_context), v)
+#define generic_dout(v) lgeneric_dout((g_ceph_context), v)
-#define derr lderr((&g_ceph_context))
+#define derr lderr((g_ceph_context))
-#define generic_derr lgeneric_derr((&g_ceph_context))
+#define generic_derr lgeneric_derr((g_ceph_context))
#endif
}
if (dump_pg_log) {
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
bufferlist bl;
std::string error;
int r = bl.read_file(dump_pg_log, &error);
}
if (mkfs) {
- common_init_finish(&g_ceph_context);
- MonClient mc(&g_ceph_context);
+ common_init_finish(g_ceph_context);
+ MonClient mc(g_ceph_context);
if (mc.build_initial_monmap() < 0)
return -1;
if (mc.get_monmap_privately() < 0)
*_dout << " for osd" << whoami << " fsid " << mc.monmap.fsid << dendl;
}
if (mkkey) {
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
KeyRing *keyring = KeyRing::create_empty();
if (!keyring) {
derr << "Unable to get a Ceph keyring." << dendl;
}
EntityName ename(g_conf->name);
EntityAuth eauth;
- eauth.key.create(&g_ceph_context, CEPH_CRYPTO_AES);
+ eauth.key.create(g_ceph_context, CEPH_CRYPTO_AES);
keyring->add(ename, eauth);
bufferlist bl;
keyring->encode_plaintext(bl);
if (mkfs || mkkey)
exit(0);
if (mkjournal) {
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
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
exit(0);
}
if (flushjournal) {
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
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
cluster_addr_set = false;
}
- SimpleMessenger *client_messenger = new SimpleMessenger(&g_ceph_context);
- SimpleMessenger *cluster_messenger = new SimpleMessenger(&g_ceph_context);
- SimpleMessenger *messenger_hb = new SimpleMessenger(&g_ceph_context);
+ SimpleMessenger *client_messenger = new SimpleMessenger(g_ceph_context);
+ SimpleMessenger *cluster_messenger = new SimpleMessenger(g_ceph_context);
+ SimpleMessenger *messenger_hb = new SimpleMessenger(g_ceph_context);
client_messenger->bind(g_conf->public_addr, getpid());
cluster_messenger->bind(g_conf->cluster_addr, getpid());
// Set up crypto, daemonize, etc.
// Leave stderr open in case we need to report errors.
- global_init_daemonize(&g_ceph_context, CINIT_FLAG_NO_CLOSE_STDERR);
- common_init_finish(&g_ceph_context);
- MonClient mc(&g_ceph_context);
+ global_init_daemonize(g_ceph_context, CINIT_FLAG_NO_CLOSE_STDERR);
+ common_init_finish(g_ceph_context);
+ MonClient mc(g_ceph_context);
if (mc.build_initial_monmap() < 0)
return -1;
- global_init_chdir(&g_ceph_context);
+ global_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);
}
// Now close the standard file descriptors
- global_init_shutdown_stderr(&g_ceph_context);
+ global_init_shutdown_stderr(g_ceph_context);
client_messenger->start();
messenger_hb->start();
argv_to_vec(argc, argv, args);
global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
parse_syn_options(args); // for SyntheticClient
vec_to_argv(args, argc, argv);
// get monmap
- MonClient mc(&g_ceph_context);
+ MonClient mc(g_ceph_context);
if (mc.build_initial_monmap() < 0)
return -1;
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(&g_ceph_context);
+ messengers[i] = new SimpleMessenger(g_ceph_context);
messengers[i]->register_entity(entity_name_t(entity_name_t::TYPE_CLIENT,-1));
messengers[i]->bind(i * 1000000 + getpid());
- mclients[i] = new MonClient(&g_ceph_context);
+ mclients[i] = new MonClient(g_ceph_context);
mclients[i]->build_initial_monmap();
Client *client = new Client(messengers[i], mclients[i]);
client->set_filer_flags(syn_filer_flags);
env_to_vec(args);
global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
// args
if (args.size() != 4)
/*
* Global variables for use from process context.
*/
-CephContext g_ceph_context __attribute__((init_priority(103))) (0);
-md_config_t *g_conf(g_ceph_context._conf);
-DoutStreambuf <char, std::basic_string<char>::traits_type> *_doss(g_ceph_context._doss);
+CephContext *g_ceph_context = new CephContext(0);
+md_config_t *g_conf(g_ceph_context->_conf);
+DoutStreambuf <char, std::basic_string<char>::traits_type> *_doss(g_ceph_context->_doss);
CephContext *get_global_context(void)
{
- return &g_ceph_context;
+ return g_ceph_context;
}
class md_config_t;
-extern CephContext g_ceph_context;
+extern CephContext *g_ceph_context;
extern md_config_t *g_conf;
extern DoutStreambuf <char, std::basic_string<char>::traits_type> *_doss;
void sighup_handler(int signum)
{
- g_ceph_context.reopen_logs();
+ g_ceph_context->reopen_logs();
}
static void reraise_fatal(int signum)
{
int ret;
libceph_init_mutex.Lock();
- CephContext *cct = &g_ceph_context;
+ CephContext *cct = g_ceph_context;
if (!libceph_initialized) {
CephInitParameters iparams(CEPH_ENTITY_TYPE_CLIENT, CEPH_CONF_FILE_DEFAULT);
iparams.conf_file = "";
}
global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
FOR_EACH_ARG(args) {
usage_exit();
++rados_initialized;
}
else {
- cct_ = &g_ceph_context;
+ cct_ = g_ceph_context;
}
rados_init_mutex.Unlock();
librados::RadosClient *radosp = new librados::RadosClient(cct_);
ostream& CDentry::print_db_line_prefix(ostream& out)
{
- return out << ceph_clock_now(&g_ceph_context) << " mds" << dir->cache->mds->get_nodeid() << ".cache.den(" << dir->ino() << " " << name << ") ";
+ return out << ceph_clock_now(g_ceph_context) << " mds" << dir->cache->mds->get_nodeid() << ".cache.den(" << dir->ino() << " " << name << ") ";
}
boost::pool<> CDentry::pool(sizeof(CDentry));
ostream& CDir::print_db_line_prefix(ostream& out)
{
- return out << ceph_clock_now(&g_ceph_context) << " mds" << cache->mds->get_nodeid() << ".cache.dir(" << this->dirfrag() << ") ";
+ return out << ceph_clock_now(g_ceph_context) << " mds" << cache->mds->get_nodeid() << ".cache.dir(" << this->dirfrag() << ") ";
}
CDir::CDir(CInode *in, frag_t fg, MDCache *mdcache, bool auth) :
dirty_rstat_inodes(member_offset(CInode, dirty_rstat_item)),
item_dirty(this), item_new(this),
- pop_me(ceph_clock_now(&g_ceph_context)),
- pop_nested(ceph_clock_now(&g_ceph_context)),
- pop_auth_subtree(ceph_clock_now(&g_ceph_context)),
- pop_auth_subtree_nested(ceph_clock_now(&g_ceph_context)),
+ pop_me(ceph_clock_now(g_ceph_context)),
+ pop_nested(ceph_clock_now(g_ceph_context)),
+ pop_auth_subtree(ceph_clock_now(g_ceph_context)),
+ pop_auth_subtree_nested(ceph_clock_now(g_ceph_context)),
bloom(NULL)
{
g_num_dir++;
list<Context*> finished;
take_waiting(mask, finished);
if (result < 0)
- finish_contexts(&g_ceph_context, finished, result);
+ finish_contexts(g_ceph_context, finished, result);
else
cache->mds->queue_waiters(finished);
}
in->mark_dirty_rstat();
//in->hack_accessed = false;
- //in->hack_load_stamp = ceph_clock_now(&g_ceph_context);
+ //in->hack_load_stamp = ceph_clock_now(g_ceph_context);
//num_new_inodes_loaded++;
}
}
m.priority = CEPH_MSG_PRIO_LOW; // set priority lower than journal!
if (committed_dn == items.end())
- cache->mds->objecter->mutate(oid, oloc, m, snapc, ceph_clock_now(&g_ceph_context), 0, NULL,
+ cache->mds->objecter->mutate(oid, oloc, m, snapc, ceph_clock_now(g_ceph_context), 0, NULL,
new C_Dir_Committed(this, get_version(),
inode->inode.last_renamed_version));
else { // send in a different Context
- C_Gather *gather = new C_Gather(&g_ceph_context, new C_Dir_Committed(this, get_version(),
+ C_Gather *gather = new C_Gather(g_ceph_context, new C_Dir_Committed(this, get_version(),
inode->inode.last_renamed_version));
while (committed_dn != items.end()) {
ObjectOperation n = ObjectOperation();
committed_dn = _commit_partial(n, snaps, max_write_size, committed_dn);
- cache->mds->objecter->mutate(oid, oloc, n, snapc, ceph_clock_now(&g_ceph_context), 0, NULL,
+ cache->mds->objecter->mutate(oid, oloc, n, snapc, ceph_clock_now(g_ceph_context), 0, NULL,
gather->new_sub());
}
/*
* we simply send the message containing the header off last, we cannot
* get our header into an incorrect state.
*/
- cache->mds->objecter->mutate(oid, oloc, m, snapc, ceph_clock_now(&g_ceph_context), 0, NULL,
+ cache->mds->objecter->mutate(oid, oloc, m, snapc, ceph_clock_now(g_ceph_context), 0, NULL,
gather->new_sub());
}
}
//int cinode_pins[CINODE_NUM_PINS]; // counts
ostream& CInode::print_db_line_prefix(ostream& out)
{
- return out << ceph_clock_now(&g_ceph_context) << " mds" << mdcache->mds->get_nodeid() << ".cache.ino(" << inode.ino << ") ";
+ return out << ceph_clock_now(g_ceph_context) << " mds" << mdcache->mds->get_nodeid() << ".cache.ino(" << inode.ino << ") ";
}
/*
object_t oid = CInode::get_object_name(ino(), frag_t(), ".inode");
object_locator_t oloc(mdcache->mds->mdsmap->get_metadata_pg_pool());
- mdcache->mds->objecter->mutate(oid, oloc, m, snapc, ceph_clock_now(&g_ceph_context), 0,
+ mdcache->mds->objecter->mutate(oid, oloc, m, snapc, ceph_clock_now(g_ceph_context), 0,
NULL, new C_Inode_Stored(this, get_version(), fin) );
}
dout(10) << "fetch" << dendl;
C_Inode_Fetched *c = new C_Inode_Fetched(this, fin);
- C_Gather *gather = new C_Gather(&g_ceph_context, c);
+ C_Gather *gather = new C_Gather(g_ceph_context, c);
object_t oid = CInode::get_object_name(ino(), frag_t(), "");
object_locator_t oloc(mdcache->mds->mdsmap->get_metadata_pg_pool());
object_t oid = get_object_name(ino(), frag_t(), "");
object_locator_t oloc(mdcache->mds->mdsmap->get_metadata_pg_pool());
- mdcache->mds->objecter->mutate(oid, oloc, m, snapc, ceph_clock_now(&g_ceph_context), 0,
+ mdcache->mds->objecter->mutate(oid, oloc, m, snapc, ceph_clock_now(g_ceph_context), 0,
NULL, new C_Inode_StoredParent(this, inode.last_renamed_version, fin) );
}
cap->issue_norevoke(issue);
issue = cap->pending();
cap->set_last_issue();
- cap->set_last_issue_stamp(ceph_clock_now(&g_ceph_context));
+ cap->set_last_issue_stamp(ceph_clock_now(g_ceph_context));
e.cap.caps = issue;
e.cap.wanted = cap->wanted();
e.cap.cap_id = cap->get_cap_id();
if (dirty)
_mark_dirty(ls);
- ::decode(pop, ceph_clock_now(&g_ceph_context), p);
+ ::decode(pop, ceph_clock_now(g_ceph_context), p);
::decode(replica_map, p);
if (!replica_map.empty())
item_dirty_dirfrag_dirfragtree(this),
auth_pins(0), nested_auth_pins(0),
nested_anchors(0),
- pop(ceph_clock_now(&g_ceph_context)),
+ pop(ceph_clock_now(g_ceph_context)),
versionlock(this, &versionlock_type),
authlock(this, &authlock_type),
linklock(this, &linklock_type),
cap->reset_seq();
}
cap->set_cap_id(icr.cap_id);
- cap->set_last_issue_stamp(ceph_clock_now(&g_ceph_context));
+ cap->set_last_issue_stamp(ceph_clock_now(g_ceph_context));
return cap;
}
void clear_client_caps_after_export() {
Cond cond;
cout << "writing header " << oid << std::endl;
- objecter->write_full(oid, oloc, snapc, hbl, ceph_clock_now(&g_ceph_context), 0,
+ objecter->write_full(oid, oloc, snapc, hbl, ceph_clock_now(g_ceph_context), 0,
NULL,
new C_SafeCond(&lock, &cond, &done));
uint64_t l = MIN(left, 1024*1024);
j.read_fd(fd, l);
cout << " writing " << pos << "~" << l << std::endl;
- filer.write(ino, &h.layout, snapc, pos, l, j, ceph_clock_now(&g_ceph_context), 0, NULL, new C_SafeCond(&lock, &cond, &done));
+ filer.write(ino, &h.layout, snapc, pos, l, j, ceph_clock_now(g_ceph_context), 0, NULL, new C_SafeCond(&lock, &cond, &done));
lock.Lock();
while (!done)
Dispatcher(messenger_->cct),
messenger(messenger_),
monc(monc_),
- lock("Dumper::lock"), timer(&g_ceph_context, lock)
+ lock("Dumper::lock"), timer(g_ceph_context, lock)
{}
virtual ~Dumper();
issue_caps(in);
}
- finish_contexts(&g_ceph_context, finishers);
+ finish_contexts(g_ceph_context, finishers);
}
void Locker::eval_scatter_gathers(CInode *in)
if (need_issue && in->is_head())
issue_caps(in);
- finish_contexts(&g_ceph_context, finishers);
+ finish_contexts(g_ceph_context, finishers);
}
void Locker::eval(SimpleLock *lock, bool *need_issue)
if (wanted != in->replica_caps_wanted) {
if (wanted == 0) {
- if (in->replica_caps_wanted_keep_until > ceph_clock_now(&g_ceph_context)) {
+ if (in->replica_caps_wanted_keep_until > ceph_clock_now(g_ceph_context)) {
// ok, release them finally!
in->replica_caps_wanted_keep_until.sec_ref() = 0;
dout(7) << "request_inode_file_caps " << ccap_string(wanted)
<< dendl;
}
else if (in->replica_caps_wanted_keep_until.sec() == 0) {
- in->replica_caps_wanted_keep_until = ceph_clock_now(&g_ceph_context);
+ in->replica_caps_wanted_keep_until = ceph_clock_now(g_ceph_context);
in->replica_caps_wanted_keep_until.sec_ref() += 2;
dout(7) << "request_inode_file_caps " << ccap_string(wanted)
m->h.seq = ++l->seq;
m->clear_payload();
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
now += mdcache->client_lease_durations[pool];
mdcache->touch_client_lease(l, pool, now);
<< " - already on list since " << lock->get_update_stamp() << dendl;
} else {
updated_scatterlocks.push_back(lock->get_updated_item());
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
lock->set_update_stamp(now);
dout(10) << "mark_updated_scatterlock " << *lock
<< " - added at " << now << dendl;
dout(10) << "scatter_tick" << dendl;
// updated
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
int n = updated_scatterlocks.size();
while (!updated_scatterlocks.empty()) {
ScatterLock *lock = updated_scatterlocks.front();
void MDBalancer::tick()
{
static int num_bal_times = g_conf->mds_bal_max;
- static utime_t first = ceph_clock_now(&g_ceph_context);
- utime_t now = ceph_clock_now(&g_ceph_context);
+ static utime_t first = ceph_clock_now(g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
utime_t elapsed = now;
elapsed -= first;
void MDBalancer::send_heartbeat()
{
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
if (mds->mdsmap->is_degraded()) {
dout(10) << "send_heartbeat degraded" << dendl;
} else {
int cluster_size = mds->get_mds_map()->get_num_mds();
int whoami = mds->get_nodeid();
- rebalance_time = ceph_clock_now(&g_ceph_context);
+ rebalance_time = ceph_clock_now(g_ceph_context);
dump_pop_map();
double total_load = 0;
multimap<double,int> load_map;
for (int i=0; i<cluster_size; i++) {
- map<int, mds_load_t>::value_type val(i, mds_load_t(ceph_clock_now(&g_ceph_context)));
+ map<int, mds_load_t>::value_type val(i, mds_load_t(ceph_clock_now(g_ceph_context)));
std::pair < map<int, mds_load_t>::iterator, bool > r(mds_load.insert(val));
mds_load_t &load(r.first->second);
if (mds->mdcache->root)
iq.push_back(mds->mdcache->root);
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
while (!iq.empty()) {
CInode *in = iq.front();
iq.pop_front();
in->inode.mode = 0500 | mode;
in->inode.size = 0;
in->inode.ctime =
- in->inode.mtime = ceph_clock_now(&g_ceph_context);
+ in->inode.mtime = ceph_clock_now(g_ceph_context);
in->inode.nlink = 1;
in->inode.truncate_size = -1ull;
// adjust recursive pop counters
if (dir->is_auth()) {
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
CDir *p = dir->get_parent_dir();
while (p) {
p->pop_auth_subtree.sub(now, decayrate, dir->pop_auth_subtree);
// adjust popularity?
if (dir->is_auth()) {
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
CDir *p = dir->get_parent_dir();
while (p) {
p->pop_auth_subtree.add(now, decayrate, dir->pop_auth_subtree);
// declare now?
if (mut->now == utime_t())
- mut->now = ceph_clock_now(&g_ceph_context);
+ mut->now = ceph_clock_now(g_ceph_context);
if (in->is_base())
return;
{
dout(10) << "parallel_fetch on " << pathmap.size() << " paths" << dendl;
- C_Gather *gather = new C_Gather(&g_ceph_context);
+ C_Gather *gather = new C_Gather(g_ceph_context);
// scan list
set<CDir*> fetch_queue;
dout(10) << "open_snap_parents" << dendl;
map<client_t,MClientSnap*> splits;
- C_Gather *gather = new C_Gather(&g_ceph_context);
+ C_Gather *gather = new C_Gather(g_ceph_context);
map<CInode*,map<client_t,set<inodeno_t> > >::iterator p = missing_snap_parents.begin();
while (p != missing_snap_parents.end()) {
p++) {
CDir *dir = *p;
if (!gather)
- gather = new C_Gather(&g_ceph_context, new C_MDC_OpenUndefDirfragsFinish(this));
+ gather = new C_Gather(g_ceph_context, new C_MDC_OpenUndefDirfragsFinish(this));
dir->fetch(gather->new_sub());
}
dout(10) << "purge_prealloc_ino " << ino << " oid " << oid << dendl;
SnapContext snapc;
- mds->objecter->remove(oid, oloc, snapc, ceph_clock_now(&g_ceph_context), 0, 0, fin);
+ mds->objecter->remove(oid, oloc, snapc, ceph_clock_now(g_ceph_context), 0, 0, fin);
}
mds->logger->inc("outt");
else {
mds->logger->inc("outut");
- mds->logger->favg("oututl", ceph_clock_now(&g_ceph_context) - in->hack_load_stamp);
+ mds->logger->favg("oututl", ceph_clock_now(g_ceph_context) - in->hack_load_stamp);
}
}
*/
void MDCache::trim_client_leases()
{
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
dout(10) << "trim_client_leases" << dendl;
void MDCache::check_memory_usage()
{
- static MemoryModel mm(&g_ceph_context);
+ static MemoryModel mm(g_ceph_context);
static MemoryModel::snap last;
mm.sample(&last);
static MemoryModel::snap baseline = last;
void MDCache::shutdown_check()
{
- dout(0) << "shutdown_check at " << ceph_clock_now(&g_ceph_context) << dendl;
+ dout(0) << "shutdown_check at " << ceph_clock_now(g_ceph_context) << dendl;
// cache
int o = g_conf->debug_mds;
uint64_t num = (to + period - 1) / period;
dout(10) << "purge_stray 0~" << to << " objects 0~" << num << " snapc " << snapc << " on " << *in << dendl;
mds->filer->purge_range(in->inode.ino, &in->inode.layout, *snapc,
- 0, num, ceph_clock_now(&g_ceph_context), 0,
+ 0, num, ceph_clock_now(g_ceph_context), 0,
new C_MDC_PurgeStrayPurged(this, dn));
} else {
dout(10) << "purge_stray 0 objects snapc " << snapc << " on " << *in << dendl;
}
// waiters
- finish_contexts(&g_ceph_context, error, -ENOENT); // finish errors directly
+ finish_contexts(g_ceph_context, error, -ENOENT); // finish errors directly
mds->queue_waiters(finished);
// done
return;
}
- C_Gather *gather = new C_Gather(&g_ceph_context, new C_MDC_FragmentFrozen(this, dirs, dir->get_frag(), bits));
+ C_Gather *gather = new C_Gather(g_ceph_context, new C_MDC_FragmentFrozen(this, dirs, dir->get_frag(), bits));
fragment_freeze_dirs(dirs, gather);
// initial mark+complete pass
int bits = first->get_frag().bits() - frag.bits();
dout(10) << " we are merginb by " << bits << " bits" << dendl;
- C_Gather *gather = new C_Gather(&g_ceph_context, new C_MDC_FragmentFrozen(this, dirs, frag, bits));
+ C_Gather *gather = new C_Gather(g_ceph_context, new C_MDC_FragmentFrozen(this, dirs, frag, bits));
fragment_freeze_dirs(dirs, gather);
// initial mark+complete pass
if (!dir->is_complete()) {
dout(15) << " fetching incomplete " << *dir << dendl;
if (!gather)
- gather = new C_Gather(&g_ceph_context,
+ gather = new C_Gather(g_ceph_context,
new C_MDC_FragmentMarking(this, dirs));
dir->fetch(gather->new_sub(),
true); // ignore authpinnability
*/
// freeze, journal, and store resulting frags
- C_Gather *gather = new C_Gather(&g_ceph_context,
+ C_Gather *gather = new C_Gather(g_ceph_context,
new C_MDC_FragmentLoggedAndStored(this, mut,
resultfrags, basefrag, bits));
{
if (journaler) { delete journaler; journaler = 0; }
if (logger) {
- g_ceph_context.GetProfLoggerCollection()->logger_remove(logger);
+ g_ceph_context->GetProfLoggerCollection()->logger_remove(logger);
delete logger;
logger = 0;
}
// logger
char name[80];
snprintf(name, sizeof(name), "mds.%s.log", g_conf->name.get_id().c_str());
- logger = new ProfLogger(&g_ceph_context, name, &mdlog_logtype);
- g_ceph_context.GetProfLoggerCollection()->logger_add(logger);
+ logger = new ProfLogger(g_ceph_context, name, &mdlog_logtype);
+ g_ceph_context->GetProfLoggerCollection()->logger_add(logger);
}
void MDLog::init_journaler()
le->_segment->num_events++;
le->update_segment();
- le->set_stamp(ceph_clock_now(&g_ceph_context));
+ le->set_stamp(ceph_clock_now(g_ceph_context));
num_events++;
assert(!capped);
if (segments.empty()) return;
// hack: only trim for a few seconds at a time
- utime_t stop = ceph_clock_now(&g_ceph_context);
+ utime_t stop = ceph_clock_now(g_ceph_context);
stop += 2.0;
map<uint64_t,LogSegment*>::iterator p = segments.begin();
((max_events >= 0 && left-expiring_events-expired_events > max_events) ||
(max_segments >= 0 && (int)(segments.size()-expiring_segments.size()-expired_segments.size()) > max_segments))) {
- if (stop < ceph_clock_now(&g_ceph_context))
+ if (stop < ceph_clock_now(g_ceph_context))
break;
if ((int)expiring_segments.size() >= g_conf->mds_log_max_expiring)
}
dout(10) << "_replay_thread kicking waiters" << dendl;
- finish_contexts(&g_ceph_context, waitfor_replay, 0);
+ finish_contexts(g_ceph_context, waitfor_replay, 0);
dout(10) << "_replay_thread finish" << dendl;
mds->mds_lock.Unlock();
monc->set_messenger(messenger);
- mdsmap = new MDSMap(&g_ceph_context);
+ mdsmap = new MDSMap(g_ceph_context);
osdmap = new OSDMap;
objecter = new Objecter(messenger, monc, osdmap, mds_lock, timer);
if (objecter) { delete objecter; objecter = 0; }
if (logger) {
- g_ceph_context.GetProfLoggerCollection()->logger_remove(logger);
+ g_ceph_context->GetProfLoggerCollection()->logger_remove(logger);
delete logger;
logger = 0;
}
if (mlogger) {
- g_ceph_context.GetProfLoggerCollection()->logger_remove(logger);
+ g_ceph_context->GetProfLoggerCollection()->logger_remove(logger);
delete mlogger;
mlogger = 0;
}
g_conf->name.get_id().c_str(),
(unsigned long long) monc->get_global_id());
logger = new ProfLogger(cct, name, (ProfLogType*)&mds_logtype);
- g_ceph_context.GetProfLoggerCollection()->logger_add(logger);
+ g_ceph_context->GetProfLoggerCollection()->logger_add(logger);
snprintf(name, sizeof(name), "mds.%s.%llu.mem.log",
g_conf->name.get_id().c_str(),
(unsigned long long) monc->get_global_id());
mlogger = new ProfLogger(cct, name, (ProfLogType*)&mdm_logtype);
- g_ceph_context.GetProfLoggerCollection()->logger_add(mlogger);
+ g_ceph_context->GetProfLoggerCollection()->logger_add(mlogger);
mdlog->open_logger();
server->open_logger();
{
- ProfLoggerCollection *coll = g_ceph_context.GetProfLoggerCollection();
+ ProfLoggerCollection *coll = g_ceph_context->GetProfLoggerCollection();
coll->logger_tare(mdsmap->get_created());
coll->logger_start();
}
}
// log
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
mds_load_t load = balancer->get_load(now);
if (logger) {
<< " (currently " << ceph_mds_state_name(state) << ")"
<< dendl;
- beacon_seq_stamp[beacon_last_seq] = ceph_clock_now(&g_ceph_context);
+ beacon_seq_stamp[beacon_last_seq] = ceph_clock_now(g_ceph_context);
MMDSBeacon *beacon = new MMDSBeacon(monc->get_fsid(), monc->get_global_id(), name, mdsmap->get_epoch(),
want_state, beacon_last_seq);
if (beacon_last_acked_stamp == utime_t())
return false;
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
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 (beacon_seq_stamp.count(seq)) {
assert(beacon_seq_stamp[seq] > beacon_last_acked_stamp);
beacon_last_acked_stamp = beacon_seq_stamp[seq];
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
utime_t rtt = now - beacon_last_acked_stamp;
dout(10) << "handle_mds_beacon " << ceph_mds_state_name(m->get_state())
entity_addr_t addr;
// decode and process
- mdsmap = new MDSMap(&g_ceph_context);
+ mdsmap = new MDSMap(g_ceph_context);
mdsmap->decode(m->get_encoded());
monc->sub_got("mdsmap", mdsmap->get_epoch());
{
dout(3) << "boot_create" << dendl;
- C_Gather *fin = new C_Gather(&g_ceph_context, new C_MDS_CreateFinish(this));
+ C_Gather *fin = new C_Gather(g_ceph_context, new C_MDS_CreateFinish(this));
mdcache->init_layouts();
case 1:
{
- C_Gather *gather = new C_Gather(&g_ceph_context, new C_MDS_BootStart(this, 2));
+ C_Gather *gather = new C_Gather(g_ceph_context, new C_MDS_BootStart(this, 2));
dout(2) << "boot_start " << step << ": opening inotable" << dendl;
inotable->load(gather->new_sub());
{
dout(2) << "boot_start " << step << ": loading/discovering base inodes" << dendl;
- C_Gather *gather = new C_Gather(&g_ceph_context, new C_MDS_BootStart(this, 3));
+ C_Gather *gather = new C_Gather(g_ceph_context, new C_MDS_BootStart(this, 3));
mdcache->open_mydir_inode(gather->new_sub());
reopen_log();
server->reconnect_clients();
- finish_contexts(&g_ceph_context, waiting_for_reconnect);
+ finish_contexts(g_ceph_context, waiting_for_reconnect);
}
void MDS::reconnect_done()
{
void MDS::clientreplay_start()
{
dout(1) << "clientreplay_start" << dendl;
- finish_contexts(&g_ceph_context, waiting_for_replay); // kick waiters
+ finish_contexts(g_ceph_context, waiting_for_replay); // kick waiters
queue_one_replay();
}
mdcache->clean_open_file_lists();
mdcache->scan_stray_dir();
- finish_contexts(&g_ceph_context, waiting_for_replay); // kick waiters
- finish_contexts(&g_ceph_context, waiting_for_active); // kick waiters
+ finish_contexts(g_ceph_context, waiting_for_replay); // kick waiters
+ finish_contexts(g_ceph_context, waiting_for_active); // kick waiters
}
// hack: thrash exports
static utime_t start;
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
if (start == utime_t())
start = now;
/*double el = now - start;
Mutex::Locker l(mds_lock);
AuthAuthorizeHandler *authorize_handler =
- get_authorize_handler(protocol, &g_ceph_context);
+ get_authorize_handler(protocol, g_ceph_context);
if (!authorize_handler) {
dout(0) << "No AuthAuthorizeHandler found for protocol " << protocol << dendl;
is_valid = false;
object_locator_t oloc(mds->mdsmap->get_metadata_pg_pool());
mds->objecter->write_full(oid, oloc,
snapc,
- bl, ceph_clock_now(&g_ceph_context), 0,
+ bl, ceph_clock_now(g_ceph_context), 0,
NULL, new C_MT_Save(this, version));
}
ls.splice(ls.end(), waitfor_save.begin()->second);
waitfor_save.erase(waitfor_save.begin());
}
- finish_contexts(&g_ceph_context, ls,0);
+ finish_contexts(g_ceph_context, ls,0);
}
cache->adjust_subtree_auth(dir, mds->get_nodeid(), dest);
// take away the popularity we're sending.
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
mds->balancer->subtract_export(dir, now);
// fill export message with cache data
assert(g_conf->mds_kill_export_at != 13);
// finish export (adjust local cache state)
- C_Contexts *fin = new C_Contexts(&g_ceph_context);
- finish_export_dir(dir, fin->contexts, ceph_clock_now(&g_ceph_context));
+ C_Contexts *fin = new C_Contexts(g_ceph_context);
+ finish_export_dir(dir, fin->contexts, ceph_clock_now(g_ceph_context));
dir->add_waiter(CDir::WAIT_UNFREEZE, fin);
// unfreeze
CDir *dir = cache->get_dirfrag(m->dirfrag);
assert(dir);
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
int oldauth = m->get_source().num();
dout(7) << "handle_export_dir importing " << *dir << " from " << oldauth << dendl;
assert(dir->is_auth() == false);
Dispatcher(messenger_->cct),
messenger(messenger_),
monc(monc_),
- lock("Resetter::lock"), timer(&g_ceph_context, lock)
+ lock("Resetter::lock"), timer(g_ceph_context, lock)
{}
virtual ~Resetter();
char name[80];
snprintf(name, sizeof(name), "mds.%s.server.log", g_conf->name.get_id().c_str());
- logger = new ProfLogger(&g_ceph_context, name, &mdserver_logtype);
- g_ceph_context.GetProfLoggerCollection()->logger_add(logger);
+ logger = new ProfLogger(g_ceph_context, name, &mdserver_logtype);
+ g_ceph_context->GetProfLoggerCollection()->logger_add(logger);
}
// timeout/stale
// (caps go stale, lease die)
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
utime_t cutoff = now;
cutoff -= g_conf->mds_session_timeout;
while (1) {
// clients will get the mdsmap and discover we're reconnecting via the monitor.
- reconnect_start = ceph_clock_now(&g_ceph_context);
+ reconnect_start = ceph_clock_now(g_ceph_context);
dout(1) << "reconnect_clients -- " << client_reconnect_gather.size() << " sessions" << dendl;
mds->sessionmap.dump();
}
return;
}
- utime_t delay = ceph_clock_now(&g_ceph_context);
+ utime_t delay = ceph_clock_now(g_ceph_context);
delay -= reconnect_start;
dout(10) << " reconnect_start " << reconnect_start << " delay " << delay << dendl;
{
utime_t reconnect_end = reconnect_start;
reconnect_end += g_conf->mds_reconnect_timeout;
- if (ceph_clock_now(&g_ceph_context) >= reconnect_end &&
+ if (ceph_clock_now(g_ceph_context) >= reconnect_end &&
!client_reconnect_gather.empty()) {
dout(10) << "reconnect timed out" << dendl;
for (set<client_t>::iterator p = client_reconnect_gather.begin();
mdr->did_early_reply = true;
mds->logger->inc(l_mds_reply);
- double lat = ceph_clock_now(&g_ceph_context) - mdr->client_request->get_recv_stamp();
+ double lat = ceph_clock_now(g_ceph_context) - mdr->client_request->get_recv_stamp();
mds->logger->favg(l_mds_replyl, lat);
dout(20) << "lat " << lat << dendl;
}
if (!did_early_reply && !is_replay) {
mds->logger->inc(l_mds_reply);
- double lat = ceph_clock_now(&g_ceph_context) - mdr->client_request->get_recv_stamp();
+ double lat = ceph_clock_now(g_ceph_context) - mdr->client_request->get_recv_stamp();
mds->logger->favg(l_mds_replyl, lat);
dout(20) << "lat " << lat << dendl;
bufferlist bl;
int whoami = mds->get_nodeid();
client_t client = session->get_client();
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
dout(20) << "set_trace_dist snapid " << snapid << dendl;
if (!mds->locker->acquire_locks(mdr, rdlocks, wrlocks, xlocks))
return;
- mds->balancer->hit_inode(ceph_clock_now(&g_ceph_context), ref, META_POP_IRD,
+ mds->balancer->hit_inode(ceph_clock_now(g_ceph_context), ref, META_POP_IRD,
mdr->client_request->get_source().num());
// reply
}
// hit pop
- mdr->now = ceph_clock_now(&g_ceph_context);
+ mdr->now = ceph_clock_now(g_ceph_context);
if (cmode == CEPH_FILE_MODE_RDWR ||
cmode == CEPH_FILE_MODE_WR)
mds->balancer->hit_inode(mdr->now, cur, META_POP_IWR);
// create inode.
- mdr->now = ceph_clock_now(&g_ceph_context);
+ mdr->now = ceph_clock_now(g_ceph_context);
SnapRealm *realm = diri->find_snaprealm(); // use directory's realm; inode isn't attached yet.
snapid_t follows = realm->get_newest_seq();
dir->verify_fragstat();
#endif
- mdr->now = ceph_clock_now(&g_ceph_context);
+ mdr->now = ceph_clock_now(g_ceph_context);
snapid_t snapid = mdr->snapid;
<< " complete=" << (int)complete << dendl;
// bump popularity. NOTE: this doesn't quite capture it.
- mds->balancer->hit_dir(ceph_clock_now(&g_ceph_context), dir, META_POP_IRD, -1, numfiles);
+ mds->balancer->hit_dir(ceph_clock_now(g_ceph_context), dir, META_POP_IRD, -1, numfiles);
// reply
reply_request(mdr, reply, diri);
pi = cur->project_inode();
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
if (mask & CEPH_SETATTR_MODE)
pi->mode = (pi->mode & ~07777) | (req->head.args.setattr.mode & 07777);
// prepare
inode_t *pi = in->project_inode();
- pi->mtime = pi->ctime = ceph_clock_now(&g_ceph_context);
+ pi->mtime = pi->ctime = ceph_clock_now(g_ceph_context);
pi->version = in->pre_dirty();
pi->truncate_from = pi->size;
inode_t *pi = cur->project_inode();
pi->layout = layout;
pi->version = cur->pre_dirty();
- pi->ctime = ceph_clock_now(&g_ceph_context);
+ pi->ctime = ceph_clock_now(g_ceph_context);
// log + wait
mdr->ls = mdlog->get_current_segment();
map<string,bufferptr> *px = new map<string,bufferptr>;
inode_t *pi = cur->project_inode(px);
pi->version = cur->pre_dirty();
- pi->ctime = ceph_clock_now(&g_ceph_context);
+ pi->ctime = ceph_clock_now(g_ceph_context);
pi->xattr_version++;
px->erase(name);
(*px)[name] = buffer::create(len);
map<string,bufferptr> *px = new map<string,bufferptr>;
inode_t *pi = cur->project_inode(px);
pi->version = cur->pre_dirty();
- pi->ctime = ceph_clock_now(&g_ceph_context);
+ pi->ctime = ceph_clock_now(g_ceph_context);
pi->xattr_version++;
px->erase(name);
SnapRealm *realm = dn->get_dir()->inode->find_snaprealm();
snapid_t follows = realm->get_newest_seq();
- mdr->now = ceph_clock_now(&g_ceph_context);
+ mdr->now = ceph_clock_now(g_ceph_context);
CInode *newi = prepare_new_inode(mdr, dn->get_dir(), inodeno_t(req->head.ino),
req->head.args.mknod.mode, &layout);
// new inode
SnapRealm *realm = dn->get_dir()->inode->find_snaprealm();
snapid_t follows = realm->get_newest_seq();
- mdr->now = ceph_clock_now(&g_ceph_context);
+ mdr->now = ceph_clock_now(g_ceph_context);
unsigned mode = req->head.args.mkdir.mode;
mode &= ~S_IFMT;
if (!mds->locker->acquire_locks(mdr, rdlocks, wrlocks, xlocks))
return;
- mdr->now = ceph_clock_now(&g_ceph_context);
+ mdr->now = ceph_clock_now(g_ceph_context);
snapid_t follows = dn->get_dir()->inode->find_snaprealm()->get_newest_seq();
unsigned mode = S_IFLNK | 0777;
// pick mtime
if (mdr->now == utime_t())
- mdr->now = ceph_clock_now(&g_ceph_context);
+ mdr->now = ceph_clock_now(g_ceph_context);
// does the target need an anchor?
if (targeti->is_auth()) {
// yay!
if (mdr->now == utime_t())
- mdr->now = ceph_clock_now(&g_ceph_context);
+ mdr->now = ceph_clock_now(g_ceph_context);
// NOTE: this is non-optimal. we create an anchor at the old
// location, and then change it. we can do better, but it's more
// -- declare now --
if (mdr->now == utime_t())
- mdr->now = ceph_clock_now(&g_ceph_context);
+ mdr->now = ceph_clock_now(g_ceph_context);
// -- prepare witnesses --
vector<Anchor> trace;
destdn->make_anchor_trace(trace, srcdnl->get_inode());
- anchorgather = new C_Gather(&g_ceph_context, new C_MDS_RetryRequest(mdcache, mdr));
+ anchorgather = new C_Gather(g_ceph_context, new C_MDS_RetryRequest(mdcache, mdr));
mds->anchorclient->prepare_update(srcdnl->get_inode()->ino(), trace, &mdr->more()->src_reanchor_atid,
anchorgather->new_sub());
}
straydn->make_anchor_trace(trace, destdnl->get_inode());
if (!anchorgather)
- anchorgather = new C_Gather(&g_ceph_context, new C_MDS_RetryRequest(mdcache, mdr));
+ anchorgather = new C_Gather(g_ceph_context, new C_MDS_RetryRequest(mdcache, mdr));
mds->anchorclient->prepare_update(destdnl->get_inode()->ino(), trace, &mdr->more()->dst_reanchor_atid,
anchorgather->new_sub());
}
map<snapid_t,SnapInfo*> infomap;
realm->get_snap_info(infomap, diri->get_oldest_snap());
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
__u32 num = 0;
bufferlist dnbl;
for (map<snapid_t,SnapInfo*>::iterator p = infomap.begin();
}
if (mdr->now == utime_t())
- mdr->now = ceph_clock_now(&g_ceph_context);
+ mdr->now = ceph_clock_now(g_ceph_context);
// anchor
if (!diri->is_anchored()) {
// journal
inode_t *pi = diri->project_inode();
- pi->ctime = ceph_clock_now(&g_ceph_context);
+ pi->ctime = ceph_clock_now(g_ceph_context);
pi->version = diri->pre_dirty();
mdr->ls = mdlog->get_current_segment();
terminating_sessions(false) {
}
~Server() {
- g_ceph_context.GetProfLoggerCollection()->logger_remove(logger);
+ g_ceph_context->GetProfLoggerCollection()->logger_remove(logger);
delete logger;
}
<< dendl;
projected = committing = committed = version;
dump();
- finish_contexts(&g_ceph_context, waiting_for_load);
+ finish_contexts(g_ceph_context, waiting_for_load);
}
mds->objecter->write_full(oid, oloc,
snapc,
- bl, ceph_clock_now(&g_ceph_context), 0,
+ bl, ceph_clock_now(g_ceph_context), 0,
NULL, new C_SM_Save(this, version));
}
dout(10) << "_save_finish v" << v << dendl;
committed = v;
- finish_contexts(&g_ceph_context, commit_waiters[v]);
+ finish_contexts(g_ceph_context, commit_waiters[v]);
commit_waiters.erase(v);
}
void SessionMap::decode(bufferlist::iterator& p)
{
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
uint64_t pre;
::decode(pre, p);
if (pre == (uint64_t)-1) {
else
s = session_map[i.name] = new Session;
s->inst = i;
- s->last_cap_renew = ceph_clock_now(&g_ceph_context);
+ s->last_cap_renew = ceph_clock_now(g_ceph_context);
return s;
}
void add_session(Session *s) {
void touch_session(Session *session) {
if (session->item_session_list.is_on_list()) {
by_state[session->state].push_back(&session->item_session_list);
- session->last_cap_renew = ceph_clock_now(&g_ceph_context);
+ session->last_cap_renew = ceph_clock_now(g_ceph_context);
} else {
assert(0); // hrm, should happen?
}
dout(20) << " dirty_inode " << **p << dendl;
assert((*p)->is_auth());
if ((*p)->is_base()) {
- if (!gather) gather = new C_Gather(&g_ceph_context);
+ if (!gather) gather = new C_Gather(g_ceph_context);
(*p)->store(gather->new_sub());
} else
commit.insert((*p)->get_parent_dn()->get_dir());
}
if (!commit.empty()) {
- if (!gather) gather = new C_Gather(&g_ceph_context);
+ if (!gather) gather = new C_Gather(g_ceph_context);
for (set<CDir*>::iterator p = commit.begin();
p != commit.end();
p != uncommitted_masters.end();
p++) {
dout(10) << "try_to_expire waiting for slaves to ack commit on " << *p << dendl;
- if (!gather) gather = new C_Gather(&g_ceph_context);
+ if (!gather) gather = new C_Gather(g_ceph_context);
mds->mdcache->wait_for_uncommitted_master(*p, gather->new_sub());
}
for (elist<CInode*>::iterator p = dirty_dirfrag_dir.begin(); !p.end(); ++p) {
CInode *in = *p;
dout(10) << "try_to_expire waiting for dirlock flush on " << *in << dendl;
- if (!gather) gather = new C_Gather(&g_ceph_context);
+ if (!gather) gather = new C_Gather(g_ceph_context);
mds->locker->scatter_nudge(&in->filelock, gather->new_sub());
}
for (elist<CInode*>::iterator p = dirty_dirfrag_dirfragtree.begin(); !p.end(); ++p) {
CInode *in = *p;
dout(10) << "try_to_expire waiting for dirfragtreelock flush on " << *in << dendl;
- if (!gather) gather = new C_Gather(&g_ceph_context);
+ if (!gather) gather = new C_Gather(g_ceph_context);
mds->locker->scatter_nudge(&in->dirfragtreelock, gather->new_sub());
}
for (elist<CInode*>::iterator p = dirty_dirfrag_nest.begin(); !p.end(); ++p) {
CInode *in = *p;
dout(10) << "try_to_expire waiting for nest flush on " << *in << dendl;
- if (!gather) gather = new C_Gather(&g_ceph_context);
+ if (!gather) gather = new C_Gather(g_ceph_context);
mds->locker->scatter_nudge(&in->nestlock, gather->new_sub());
}
}
}
if (le) {
- if (!gather) gather = new C_Gather(&g_ceph_context);
+ if (!gather) gather = new C_Gather(g_ceph_context);
mds->mdlog->submit_entry(le, gather->new_sub());
dout(10) << "try_to_expire waiting for open files to rejournal" << dendl;
}
CInode *in = *p;
dout(10) << "try_to_expire waiting for dir parent pointer update on " << *in << dendl;
assert(in->state_test(CInode::STATE_DIRTYPARENT));
- if (!gather) gather = new C_Gather(&g_ceph_context);
+ if (!gather) gather = new C_Gather(g_ceph_context);
in->store_parent(gather->new_sub());
}
MDSlaveUpdate *su = *p;
dout(10) << "try_to_expire waiting on slave update " << su << dendl;
assert(su->waiter == 0);
- if (!gather) gather = new C_Gather(&g_ceph_context);
+ if (!gather) gather = new C_Gather(g_ceph_context);
su->waiter = gather->new_sub();
}
<< ", committed is " << mds->inotable->get_committed_version()
<< " (" << mds->inotable->get_committing_version() << ")"
<< dendl;
- if (!gather) gather = new C_Gather(&g_ceph_context);
+ if (!gather) gather = new C_Gather(g_ceph_context);
mds->inotable->save(gather->new_sub(), inotablev);
}
<< ", committed is " << mds->sessionmap.committed
<< " (" << mds->sessionmap.committing << ")"
<< dendl;
- if (!gather) gather = new C_Gather(&g_ceph_context);
+ if (!gather) gather = new C_Gather(g_ceph_context);
mds->sessionmap.save(gather->new_sub(), sessionmapv);
}
for (hash_set<version_t>::iterator q = p->second.begin();
q != p->second.end();
++q) {
- if (!gather) gather = new C_Gather(&g_ceph_context);
+ if (!gather) gather = new C_Gather(g_ceph_context);
dout(10) << "try_to_expire " << get_mdstable_name(p->first) << " transaction " << *q
<< " pending commit (not yet acked), waiting" << dendl;
assert(!client->has_committed(*q));
if (p->second > server->get_committed_version()) {
dout(10) << "try_to_expire waiting for " << get_mdstable_name(p->first)
<< " to save, need " << p->second << dendl;
- if (!gather) gather = new C_Gather(&g_ceph_context);
+ if (!gather) gather = new C_Gather(g_ceph_context);
server->save(gather->new_sub());
}
}
p != truncating_inodes.end();
p++) {
dout(10) << "try_to_expire waiting for truncate of " << **p << dendl;
- if (!gather) gather = new C_Gather(&g_ceph_context);
+ if (!gather) gather = new C_Gather(g_ceph_context);
(*p)->add_waiter(CInode::WAIT_TRUNC, gather->new_sub());
}
inline ostream& operator<<(ostream& out, dirfrag_load_vec_t& dl)
{
// ugliness!
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
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)
DecayCounter count;
public:
- load_spread_t() : p(0), n(0), count(ceph_clock_now(&g_ceph_context))
+ load_spread_t() : p(0), n(0), count(ceph_clock_now(g_ceph_context))
{
for (int i=0; i<MAX; i++)
last[i] = -1;
void finish_waiting(uint64_t mask, int result = 0) {
list<Context*> finished;
take_waiting(mask, finished);
- finish_contexts(&g_ceph_context, finished, result);
+ finish_contexts(g_ceph_context, finished, result);
}
op(o), machine_id(mid),
first_committed(0), last_committed(0), pn_from(0), pn(0), uncommitted_pn(0),
latest_version(0) {
- sent_timestamp = ceph_clock_now(&g_ceph_context);
+ sent_timestamp = ceph_clock_now(g_ceph_context);
}
private:
dout(10) << "create_initial -- creating initial map" << dendl;
KeyRing keyring;
- if (keyring.load(&g_ceph_context, g_conf->keyring) == 0) {
+ if (keyring.load(g_ceph_context, g_conf->keyring) == 0) {
import_keyring(keyring);
}
goto reply;
}
- s->auth_handler = get_auth_service_handler(&g_ceph_context,
+ s->auth_handler = get_auth_service_handler(g_ceph_context,
&mon->key_server, supported);
if (!s->auth_handler) {
ret = -ENOTSUP;
// start by trying to elect me
if (epoch % 2 == 0)
bump_epoch(epoch+1); // odd == election cycle
- start_stamp = ceph_clock_now(&g_ceph_context);
+ start_stamp = ceph_clock_now(g_ceph_context);
electing_me = true;
acked_me.insert(mon->rank);
// ack them
leader_acked = who;
- ack_stamp = ceph_clock_now(&g_ceph_context);
+ ack_stamp = ceph_clock_now(g_ceph_context);
mon->messenger->send_message(new MMonElection(MMonElection::OP_ACK, epoch, mon->monmap),
mon->monmap->get_inst(who));
{
MMonElection *em = (MMonElection*)m;
- MonMap *peermap = new MonMap(ceph_clock_now(&g_ceph_context));
+ MonMap *peermap = new MonMap(ceph_clock_now(g_ceph_context));
peermap->decode(em->monmap_bl);
if (peermap->epoch > mon->monmap->epoch) {
dout(0) << m->get_source_inst() << " has newer monmap epoch " << peermap->epoch
dout(10) << "create_initial -- creating initial map" << dendl;
LogEntry e;
memset(&e.who, 0, sizeof(e.who));
- e.stamp = ceph_clock_now(&g_ceph_context);
+ e.stamp = ceph_clock_now(g_ceph_context);
e.type = CLOG_INFO;
std::stringstream ss;
ss << "mkfs " << mon->monmap->get_fsid();
void MDSMonitor::create_new_fs(MDSMap &m, int metadata_pool, int data_pool)
{
m.max_mds = g_conf->max_mds;
- m.created = ceph_clock_now(&g_ceph_context);
+ m.created = ceph_clock_now(g_ceph_context);
m.data_pg_pools.push_back(data_pool);
m.metadata_pg_pool = metadata_pool;
m.cas_pg_pool = -1;
{
dout(10) << "encode_pending e" << pending_mdsmap.epoch << dendl;
- pending_mdsmap.modified = ceph_clock_now(&g_ceph_context);
+ pending_mdsmap.modified = ceph_clock_now(g_ceph_context);
//print_map(pending_mdsmap);
version_t seq = m->get_seq();
dout(15) << "_note_beacon " << *m << " noting time" << dendl;
- last_beacon[gid].stamp = ceph_clock_now(&g_ceph_context);
+ last_beacon[gid].stamp = ceph_clock_now(g_ceph_context);
last_beacon[gid].seq = seq;
}
}
// initialize the beacon timer
- last_beacon[gid].stamp = ceph_clock_now(&g_ceph_context);
+ last_beacon[gid].stamp = ceph_clock_now(g_ceph_context);
last_beacon[gid].seq = seq;
// new incompat?
p = 0;
r = -ENOENT;
} else {
- p = new MDSMap(&g_ceph_context);
+ p = new MDSMap(g_ceph_context);
p->decode(b);
}
}
if (!b.length()) {
r = -ENOENT;
} else {
- MDSMap m(&g_ceph_context);
+ MDSMap m(g_ceph_context);
m.decode(b);
m.encode(rdata);
ss << "got mdsmap epoch " << m.get_epoch();
if (pending_mdsmap.up.count(w)) {
uint64_t gid = pending_mdsmap.up[w];
if (pending_mdsmap.mds_info.count(gid)) {
- utime_t until = ceph_clock_now(&g_ceph_context);
+ utime_t until = ceph_clock_now(g_ceph_context);
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);
// --- reset the cluster map ---
if (pending_mdsmap.mds_info.size()) {
// blacklist all old mds's
- utime_t until = ceph_clock_now(&g_ceph_context);
+ utime_t until = ceph_clock_now(g_ceph_context);
until += g_conf->mds_blacklist_interval;
for (map<int32_t,uint64_t>::iterator p = pending_mdsmap.up.begin();
p != pending_mdsmap.up.end();
ss << "max_mds = " << pending_mdsmap.max_mds;
}
else if (m->cmd[1] == "setmap" && m->cmd.size() == 3) {
- MDSMap map(&g_ceph_context);
+ MDSMap map(g_ceph_context);
map.decode(m->get_data());
epoch_t e = atoi(m->cmd[2].c_str());
//if (ceph_fsid_compare(&map.get_fsid(), &mon->monmap->fsid) == 0) {
}
}
} else if (m->cmd[1] == "newfs" && m->cmd.size() == 4) {
- MDSMap newmap(&g_ceph_context);
+ MDSMap newmap(g_ceph_context);
int metadata = atoi(m->cmd[2].c_str());
int data = atoi(m->cmd[3].c_str());
pending_mdsmap = newmap;
}
// check beacon timestamps
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
utime_t cutoff = now;
cutoff -= g_conf->mds_beacon_grace;
dout(10) << " adding " << p->second.addr << " mds" << info.rank << "." << info.inc
<< " " << ceph_mds_state_name(info.state)
<< " to last_beacon" << dendl;
- last_beacon[p->first].stamp = ceph_clock_now(&g_ceph_context);
+ last_beacon[p->first].stamp = ceph_clock_now(g_ceph_context);
last_beacon[p->first].seq = 0;
}
}
case MDSMap::STATE_CLIENTREPLAY:
// BUG: hrm, if this is the case, the STOPPING guys won't be able to stop, will they?
{
- utime_t until = ceph_clock_now(&g_ceph_context);
+ utime_t until = ceph_clock_now(g_ceph_context);
until += g_conf->mds_blacklist_interval;
pending_mdsmap.last_failure_osd_epoch = mon->osdmon()->blacklist(info.addr, until);
propose_osdmap = true;
public:
MDSMonitor(Monitor *mn, Paxos *p)
: PaxosService(mn, p),
- mdsmap(&g_ceph_context),
- pending_mdsmap(&g_ceph_context)
+ mdsmap(g_ceph_context),
+ pending_mdsmap(g_ceph_context)
{
}
void Monitor::win_election(epoch_t epoch, set<int>& active)
{
state = STATE_LEADER;
- leader_since = ceph_clock_now(&g_ceph_context);
+ leader_since = ceph_clock_now(g_ceph_context);
leader = rank;
quorum = active;
dout(10) << "win_election, epoch " << epoch << " quorum is " << quorum << dendl;
} else if (session && !session->closed) {
RoutedRequest *rr = new RoutedRequest;
rr->tid = ++routed_request_tid;
- encode_message(&g_ceph_context, req, rr->request_bl);
+ encode_message(g_ceph_context, req, rr->request_bl);
rr->session = (MonSession *)session->get();
routed_requests[rr->tid] = rr;
session->routed_request_tids.insert(rr->tid);
dout(10) << "try_send_message " << *m << " to " << to << dendl;
bufferlist bl;
- encode_message(&g_ceph_context, m, bl);
+ encode_message(g_ceph_context, m, bl);
messenger->send_message(m, to);
dout(10) << "setting timeout on session" << dendl;
// set an initial timeout here, so we will trim this session even if they don't
// do anything.
- s->until = ceph_clock_now(&g_ceph_context);
+ s->until = ceph_clock_now(g_ceph_context);
s->until += g_conf->mon_subscribe_interval;
} else {
//give it monitor caps; the peer type has been authenticated
return;
}
- s->until = ceph_clock_now(&g_ceph_context);
+ s->until = ceph_clock_now(g_ceph_context);
s->until += g_conf->mon_subscribe_interval;
for (map<string,ceph_mon_subscribe_item>::iterator p = m->what.begin();
p != m->what.end();
(*p)->tick();
// trim sessions
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
xlist<MonSession*>::iterator p = session_map.sessions.begin();
while (!p.end()) {
MonSession *s = *p;
if (service_id != CEPH_ENTITY_TYPE_MON)
return false;
- if (!is_supported_auth(CEPH_AUTH_CEPHX, &g_ceph_context))
+ if (!is_supported_auth(CEPH_AUTH_CEPHX, g_ceph_context))
return false;
CephXServiceTicketInfo auth_ticket_info;
::encode(blob, ticket_data);
bufferlist::iterator iter = ticket_data.begin();
- CephXTicketHandler handler(&g_ceph_context, service_id);
+ CephXTicketHandler handler(g_ceph_context, service_id);
::decode(handler.ticket, iter);
handler.session_key = info.session_key;
<< " protocol " << protocol << dendl;
if (peer_type == CEPH_ENTITY_TYPE_MON &&
- is_supported_auth(CEPH_AUTH_CEPHX, &g_ceph_context)) {
+ is_supported_auth(CEPH_AUTH_CEPHX, g_ceph_context)) {
// monitor, and cephx is enabled
isvalid = false;
if (protocol == CEPH_AUTH_CEPHX) {
CephXServiceTicketInfo auth_ticket_info;
if (authorizer_data.length()) {
- int ret = cephx_verify_authorizer(&g_ceph_context, &key_server, iter,
+ int ret = cephx_verify_authorizer(g_ceph_context, &key_server, iter,
auth_ticket_info, authorizer_reply);
if (ret >= 0)
isvalid = true;
{
pending_map = *mon->monmap;
pending_map.epoch++;
- pending_map.last_changed = ceph_clock_now(&g_ceph_context);
+ pending_map.last_changed = ceph_clock_now(g_ceph_context);
dout(10) << "create_pending monmap epoch " << pending_map.epoch << dendl;
}
}
pending_map.add(name, addr);
- pending_map.last_changed = ceph_clock_now(&g_ceph_context);
+ pending_map.last_changed = ceph_clock_now(g_ceph_context);
ss << "added mon." << name << " at " << addr;
getline(ss, rs);
paxos->wait_for_commit(new Monitor::C_Command(mon, m, 0, rs, paxos->get_version()));
entity_addr_t addr = pending_map.get_addr(name);
pending_map.remove(name);
- pending_map.last_changed = ceph_clock_now(&g_ceph_context);
+ pending_map.last_changed = ceph_clock_now(g_ceph_context);
ss << "removed mon." << name << " at " << addr << ", there are now " << pending_map.size() << " monitors" ;
getline(ss, rs);
// send reply immediately in case we get removed
class MonmapMonitor : public PaxosService {
public:
MonmapMonitor(Monitor *mn, Paxos *p)
- : PaxosService(mn, p), pending_map(ceph_clock_now(&g_ceph_context))
+ : PaxosService(mn, p), pending_map(ceph_clock_now(g_ceph_context))
{
}
MonMap pending_map; //the pending map awaiting passage
newmap.decode(bl);
newmap.set_epoch(1);
newmap.set_fsid(mon->monmap->fsid);
- newmap.created = newmap.modified = ceph_clock_now(&g_ceph_context);
+ newmap.created = newmap.modified = ceph_clock_now(g_ceph_context);
// encode into pending incremental
newmap.encode(pending_inc.fullmap);
if (osdmap.is_down(o) && osdmap.is_in(o) &&
down_pending_out.count(o) == 0) {
dout(10) << " adding osd" << o << " to down_pending_out map" << dendl;
- down_pending_out[o] = ceph_clock_now(&g_ceph_context);
+ down_pending_out[o] = ceph_clock_now(g_ceph_context);
}
if (mon->is_leader()) {
<< dendl;
// finalize up pending_inc
- pending_inc.modified = ceph_clock_now(&g_ceph_context);
+ pending_inc.modified = ceph_clock_now(g_ceph_context);
// tell me about it
for (map<int32_t,uint8_t>::iterator i = pending_inc.new_state.begin();
bool do_propose = false;
// mark down osds out?
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
map<int,utime_t>::iterator i = down_pending_out.begin();
while (i != down_pending_out.end()) {
int o = i->first;
ss << "unable to parse address " << m->cmd[3];
else if (m->cmd[2] == "add") {
- utime_t expires = ceph_clock_now(&g_ceph_context);
+ utime_t expires = ceph_clock_now(g_ceph_context);
double d = 60*60; // 1 hour default
if (m->cmd.size() > 4)
d = atof(m->cmd[4].c_str());
pp = &pending_inc.new_pools[pool];
*pp = *p;
}
- pp->add_snap(snapname.c_str(), ceph_clock_now(&g_ceph_context));
+ pp->add_snap(snapname.c_str(), ceph_clock_now(g_ceph_context));
pp->set_snap_epoch(pending_inc.epoch);
ss << "created pool " << m->cmd[3] << " snap " << snapname;
getline(ss, rs);
switch (m->op) {
case POOL_OP_CREATE_SNAP:
- pp->add_snap(m->name.c_str(), ceph_clock_now(&g_ceph_context));
+ pp->add_snap(m->name.c_str(), ceph_clock_now(g_ceph_context));
dout(10) << "create snap in pool " << m->pool << " " << m->name << " seq " << pp->get_snap_epoch() << dendl;
break;
}
// walk through incrementals
- utime_t now(ceph_clock_now(&g_ceph_context));
+ utime_t now(ceph_clock_now(g_ceph_context));
while (paxosv > pg_map.version) {
bufferlist bl;
bool success = paxos->read(pg_map.version+1, bl);
{
if (!mon->is_leader())
return;
- utime_t now(ceph_clock_now(&g_ceph_context));
+ utime_t now(ceph_clock_now(g_ceph_context));
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 false;
}
- last_osd_report[from] = ceph_clock_now(&g_ceph_context);
+ last_osd_report[from] = ceph_clock_now(g_ceph_context);
if (!stats->get_orig_source().is_osd() ||
!mon->osdmon()->osdmap.is_up(from) ||
dout(10) << "send_pg_creates to " << pg_map.creating_pgs.size() << " pgs" << dendl;
map<int, MOSDPGCreate*> msg;
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
OSDMap *osdmap = &mon->osdmon()->osdmap;
int max = MIN(osdmap->get_max_osd(), osdmap->crush.get_max_devices());
p++) {
dout(10) << "sending pg_create to osd" << p->first << dendl;
mon->messenger->send_message(p->second, mon->osdmon()->osdmap.get_inst(p->first));
- last_sent_pg_create[p->first] = ceph_clock_now(&g_ceph_context);
+ last_sent_pg_create[p->first] = ceph_clock_now(g_ceph_context);
}
}
extend_lease();
// wake people up
- finish_contexts(&g_ceph_context, waiting_for_active);
- finish_contexts(&g_ceph_context, waiting_for_readable);
- finish_contexts(&g_ceph_context, waiting_for_writeable);
+ finish_contexts(g_ceph_context, waiting_for_active);
+ finish_contexts(g_ceph_context, waiting_for_readable);
+ finish_contexts(g_ceph_context, waiting_for_writeable);
}
}
} else {
// we're alone, take it easy
commit();
state = STATE_ACTIVE;
- finish_contexts(&g_ceph_context, waiting_for_active);
- finish_contexts(&g_ceph_context, waiting_for_commit);
- finish_contexts(&g_ceph_context, waiting_for_readable);
- finish_contexts(&g_ceph_context, waiting_for_writeable);
+ finish_contexts(g_ceph_context, waiting_for_active);
+ finish_contexts(g_ceph_context, waiting_for_commit);
+ finish_contexts(g_ceph_context, waiting_for_readable);
+ finish_contexts(g_ceph_context, waiting_for_writeable);
update_observers();
return;
}
extend_lease();
// wake people up
- finish_contexts(&g_ceph_context, waiting_for_active);
- finish_contexts(&g_ceph_context, waiting_for_commit);
- finish_contexts(&g_ceph_context, waiting_for_readable);
- finish_contexts(&g_ceph_context, waiting_for_writeable);
+ finish_contexts(g_ceph_context, waiting_for_active);
+ finish_contexts(g_ceph_context, waiting_for_commit);
+ finish_contexts(g_ceph_context, waiting_for_readable);
+ finish_contexts(g_ceph_context, waiting_for_writeable);
}
accept->put();
}
// commit locally
last_committed++;
- last_commit_time = ceph_clock_now(&g_ceph_context);
+ last_commit_time = ceph_clock_now(g_ceph_context);
mon->store->put_int(last_committed, machine_name, "last_committed");
// tell everyone
commit->put();
- finish_contexts(&g_ceph_context, waiting_for_commit);
+ finish_contexts(g_ceph_context, waiting_for_commit);
}
void Paxos::extend_lease()
assert(mon->is_leader());
assert(is_active());
- lease_expire = ceph_clock_now(&g_ceph_context);
+ lease_expire = ceph_clock_now(g_ceph_context);
lease_expire += g_conf->mon_lease;
acked_lease.clear();
acked_lease.insert(mon->rank);
void Paxos::warn_on_future_time(utime_t t, entity_name_t from)
{
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
if (t > now) {
utime_t diff = t - now;
if (diff > g_conf->mon_clock_drift_allowed) {
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 = ceph_clock_now(&g_ceph_context);
+ last_clock_drift_warn = ceph_clock_now(g_ceph_context);
++clock_drift_warned;
}
}
MMonPaxos *ack = new MMonPaxos(mon->get_epoch(), MMonPaxos::OP_LEASE_ACK, machine_id);
ack->last_committed = last_committed;
ack->first_committed = first_committed;
- ack->lease_timestamp = ceph_clock_now(&g_ceph_context);
+ ack->lease_timestamp = ceph_clock_now(g_ceph_context);
mon->messenger->send_message(ack, lease->get_source_inst());
// (re)set timeout event.
trim_to(lease->first_committed);
// kick waiters
- finish_contexts(&g_ceph_context, waiting_for_active);
+ finish_contexts(g_ceph_context, waiting_for_active);
if (is_readable())
- finish_contexts(&g_ceph_context, waiting_for_readable);
+ finish_contexts(g_ceph_context, waiting_for_readable);
lease->put();
}
dout(10) << "peon_init -- i am a peon" << dendl;
// no chance to write now!
- finish_contexts(&g_ceph_context, waiting_for_writeable, -1);
- finish_contexts(&g_ceph_context, waiting_for_commit, -1);
+ finish_contexts(g_ceph_context, waiting_for_writeable, -1);
+ finish_contexts(g_ceph_context, waiting_for_commit, -1);
}
void Paxos::election_starting()
cancel_events();
new_value.clear();
- finish_contexts(&g_ceph_context, waiting_for_commit, -1);
+ finish_contexts(g_ceph_context, waiting_for_commit, -1);
}
observers[inst] = observer = new Observer(inst, v);
}
- utime_t timeout = ceph_clock_now(&g_ceph_context);
+ utime_t timeout = ceph_clock_now(g_ceph_context);
timeout += g_conf->paxos_observer_timeout;
observer->timeout = timeout;
Observer *observer = iter->second;
// timed out?
- if (ceph_clock_now(&g_ceph_context) > observer->timeout) {
+ if (ceph_clock_now(g_ceph_context) > observer->timeout) {
delete observer;
observers.erase(iter++);
continue;
bool Paxos::is_readable(version_t v)
{
- dout(1) << "is_readable now=" << ceph_clock_now(&g_ceph_context) << " lease_expire=" << lease_expire
+ dout(1) << "is_readable now=" << ceph_clock_now(g_ceph_context) << " lease_expire=" << lease_expire
<< " has v" << v << " lc " << last_committed << dendl;
if (v > last_committed)
return false;
(is_active() || is_updating()) &&
last_committed > 0 && // must have a value
(mon->get_quorum().size() == 1 || // alone, or
- ceph_clock_now(&g_ceph_context) < lease_expire); // have lease
+ ceph_clock_now(g_ceph_context) < lease_expire); // have lease
}
bool Paxos::read(version_t v, bufferlist &bl)
return
mon->is_leader() &&
is_active() &&
- ceph_clock_now(&g_ceph_context) < lease_expire;
+ ceph_clock_now(g_ceph_context) < lease_expire;
}
bool Paxos::propose_new_value(bufferlist& bl, Context *oncommit)
if (paxos->last_committed <= 1)
delay = 0.0;
else {
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
if ((now - paxos->last_commit_time) > g_conf->paxos_propose_interval)
delay = (double)g_conf->paxos_min_wait;
else
global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
FOR_EACH_ARG(args) {
if (CEPH_ARGPARSE_EQ("help", '\0')) {
usage();
if (!fn)
usage();
- MonMap monmap(ceph_clock_now(&g_ceph_context));
+ MonMap monmap(ceph_clock_now(g_ceph_context));
cout << me << ": monmap file " << fn << std::endl;
<< (hbp.length() ? " + header":"")
<< dendl;
- utime_t from = ceph_clock_now(&g_ceph_context);
+ utime_t from = ceph_clock_now(g_ceph_context);
// entry
off64_t pos = write_pos;
#endif
}
- utime_t lat = ceph_clock_now(&g_ceph_context) - from;
+ utime_t lat = ceph_clock_now(g_ceph_context) - from;
dout(20) << "do_write latency " << lat << dendl;
write_lock.Lock();
basedir_fd(-1), current_fd(-1),
attrs(this), fake_attrs(false),
collections(this), fake_collections(false),
- ondisk_finisher(&g_ceph_context),
+ ondisk_finisher(g_ceph_context),
lock("FileStore::lock"),
force_sync(false), sync_epoch(0),
sync_entry_timeo_lock("sync_entry_timeo_lock"),
- timer(&g_ceph_context, sync_entry_timeo_lock),
+ timer(g_ceph_context, sync_entry_timeo_lock),
stop(false), sync_thread(this),
- op_queue_len(0), op_queue_bytes(0), op_finisher(&g_ceph_context), next_finish(0),
- op_tp(&g_ceph_context, "FileStore::op_tp", g_conf->filestore_op_threads), op_wq(this, &op_tp),
+ op_queue_len(0), op_queue_bytes(0), op_finisher(g_ceph_context), next_finish(0),
+ op_tp(g_ceph_context, "FileStore::op_tp", g_conf->filestore_op_threads), op_wq(this, &op_tp),
flusher_queue_len(0), flusher_thread(this),
logger(NULL)
{
char name[80];
snprintf(name, sizeof(name), "osd.%d.fs.log", whoami);
- logger = new ProfLogger(&g_ceph_context, name, (ProfLogType*)&fs_logtype);
+ logger = new ProfLogger(g_ceph_context, name, (ProfLogType*)&fs_logtype);
if (journal)
journal->logger = logger;
{
- ProfLoggerCollection *coll = g_ceph_context.GetProfLoggerCollection();
+ ProfLoggerCollection *coll = g_ceph_context->GetProfLoggerCollection();
coll->logger_add(logger);
coll->logger_tare(tare);
coll->logger_start();
if (logger) {
if (journal)
journal->logger = NULL;
- g_ceph_context.GetProfLoggerCollection()->logger_remove(logger);
+ g_ceph_context->GetProfLoggerCollection()->logger_remove(logger);
delete logger;
logger = NULL;
}
utime_t min_interval;
min_interval.set_from_double(g_conf->filestore_min_sync_interval);
- utime_t startwait = ceph_clock_now(&g_ceph_context);
+ utime_t startwait = ceph_clock_now(g_ceph_context);
if (!force_sync) {
dout(20) << "sync_entry waiting for max_interval " << max_interval << dendl;
- sync_cond.WaitInterval(&g_ceph_context, lock, max_interval);
+ sync_cond.WaitInterval(g_ceph_context, lock, max_interval);
} else {
dout(20) << "sync_entry not waiting, force_sync set" << dendl;
}
force_sync = false;
} else {
// wait for at least the min interval
- utime_t woke = ceph_clock_now(&g_ceph_context);
+ utime_t woke = ceph_clock_now(g_ceph_context);
woke -= startwait;
dout(20) << "sync_entry woke after " << woke << dendl;
if (woke < min_interval) {
t -= woke;
dout(20) << "sync_entry waiting for another " << t
<< " to reach min interval " << min_interval << dendl;
- sync_cond.WaitInterval(&g_ceph_context, lock, t);
+ sync_cond.WaitInterval(g_ceph_context, lock, t);
}
}
lock.Unlock();
if (commit_start()) {
- utime_t start = ceph_clock_now(&g_ceph_context);
+ utime_t start = ceph_clock_now(g_ceph_context);
uint64_t cp = committing_seq;
SyncEntryTimeout *sync_entry_timeo = new SyncEntryTimeout();
}
}
- utime_t done = ceph_clock_now(&g_ceph_context);
+ utime_t done = ceph_clock_now(g_ceph_context);
done -= start;
dout(10) << "sync_entry commit took " << done << dendl;
commit_finish();
}
lock.Lock();
- finish_contexts(&g_ceph_context, fin, 0);
+ finish_contexts(g_ceph_context, fin, 0);
fin.clear();
if (!sync_waiters.empty()) {
dout(10) << "sync_entry more waiters, committing again" << dendl;
JournalingObjectStore() : op_seq(0),
applied_seq(0), committing_seq(0), committed_seq(0),
open_ops(0), blocked(false),
- journal(NULL), finisher(&g_ceph_context),
+ journal(NULL), finisher(g_ceph_context),
journal_lock("JournalingObjectStore::journal_lock"),
com_lock("JournalingObjectStore::com_lock") { }
bl.push_back(bp);
uint64_t wrote = 0;
while (1) {
- if (ceph_clock_now(&g_ceph_context) > until) break;
+ if (ceph_clock_now(g_ceph_context) > until) break;
struct statfs st;
store->statfs(&st);
store->_fake_writes(true);
srand(0);
- utime_t start = ceph_clock_now(&g_ceph_context);
+ utime_t start = ceph_clock_now(g_ceph_context);
utime_t until = start;
until.sec_ref() += time;
uint64_t wrote = 0;
for (int c=1; c<=count; c++) {
- if (ceph_clock_now(&g_ceph_context) > until) break;
+ if (ceph_clock_now(g_ceph_context) > until) break;
//if (c == 7) start_debug = true;
// dump freelist?
/*
- if (ceph_clock_now(&g_ceph_context) > nextfl) {
+ if (ceph_clock_now(g_ceph_context) > nextfl) {
elapsed += freelist_inc;
save_freelist(elapsed);
nextfl.sec_ref() += freelist_inc;
bp.zero();
bl.push_back(bp);
dout(0) << "testing disk bandwidth..." << dendl;
- utime_t start = ceph_clock_now(&g_ceph_context);
+ utime_t start = ceph_clock_now(g_ceph_context);
object_t oid("disk_bw_test");
for (int i=0; i<1000; i++) {
ObjectStore::Transaction *t = new ObjectStore::Transaction;
store->queue_transaction(NULL, t);
}
store->sync();
- utime_t end = ceph_clock_now(&g_ceph_context);
+ utime_t end = ceph_clock_now(g_ceph_context);
end -= start;
dout(0) << "measured " << (1000.0 / (double)end) << " mb/sec" << dendl;
ObjectStore::Transaction tr;
heartbeat_thread(this),
heartbeat_dispatcher(this),
decayrate(5.0),
- stat_oprate(ceph_clock_now(&g_ceph_context)),
+ stat_oprate(ceph_clock_now(g_ceph_context)),
peer_stat_lock("OSD::peer_stat_lock"),
read_latency_calc(g_conf->osd_max_opq<1 ? 1:g_conf->osd_max_opq),
qlen_calc(3),
{
delete map_in_progress_cond;
delete class_handler;
- g_ceph_context.GetProfLoggerCollection()->logger_remove(logger);
+ g_ceph_context->GetProfLoggerCollection()->logger_remove(logger);
delete logger;
delete store;
}
char name[80];
snprintf(name, sizeof(name), "osd.%d.log", whoami);
- logger = new ProfLogger(&g_ceph_context, name, (ProfLogType*)&osd_logtype);
- g_ceph_context.GetProfLoggerCollection()->logger_add(logger);
+ logger = new ProfLogger(g_ceph_context, name, (ProfLogType*)&osd_logtype);
+ g_ceph_context->GetProfLoggerCollection()->logger_add(logger);
if (osdmap->get_epoch() > 0)
start_logger();
void OSD::start_logger()
{
- ProfLoggerCollection *coll = g_ceph_context.GetProfLoggerCollection();
+ ProfLoggerCollection *coll = g_ceph_context->GetProfLoggerCollection();
coll->logger_tare(osdmap->get_created());
coll->logger_start();
logger_started = true;
// ok, create PG locally using provided Info and History
*pt = new ObjectStore::Transaction;
- *pfin = new C_Contexts(&g_ceph_context);
+ *pfin = new C_Contexts(g_ceph_context);
if (create) {
pg = _create_lock_new_pg(info.pgid, acting, **pt);
} else {
return NULL;
}
*pt = new ObjectStore::Transaction;
- *pfin = new C_Contexts(&g_ceph_context);
+ *pfin = new C_Contexts(g_ceph_context);
}
return pg;
}
old_from.swap(heartbeat_from);
old_con.swap(heartbeat_con);
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
heartbeat_epoch = osdmap->get_epoch();
if (locked && !is_booting())
_share_map_outgoing(osdmap->get_cluster_inst(from));
- heartbeat_from_stamp[from] = ceph_clock_now(&g_ceph_context); // don't let _my_ lag interfere.
+ heartbeat_from_stamp[from] = ceph_clock_now(g_ceph_context); // don't let _my_ lag interfere.
// remove from failure lists if needed
if (failure_pending.count(from)) {
utime_t w;
w.set_from_double(wait);
dout(30) << "heartbeat_entry sleeping for " << wait << dendl;
- heartbeat_cond.WaitInterval(&g_ceph_context, heartbeat_lock, w);
+ heartbeat_cond.WaitInterval(g_ceph_context, heartbeat_lock, w);
dout(30) << "heartbeat_entry woke up" << dendl;
}
heartbeat_lock.Unlock();
// we should also have map_lock rdlocked.
// check for incoming heartbeats (move me elsewhere?)
- utime_t grace = ceph_clock_now(&g_ceph_context);
+ utime_t grace = ceph_clock_now(g_ceph_context);
grace -= g_conf->osd_heartbeat_grace;
for (map<int, epoch_t>::iterator p = heartbeat_from.begin();
p != heartbeat_from.end();
void OSD::heartbeat()
{
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
dout(30) << "heartbeat" << dendl;
check_replay_queue();
// mon report?
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
if (now - last_pg_stats_sent > g_conf->osd_mon_report_interval_max) {
osd_stat_updated = true;
do_mon_report();
{
dout(7) << "do_mon_report" << dendl;
- utime_t now(ceph_clock_now(&g_ceph_context));
+ utime_t now(ceph_clock_now(g_ceph_context));
last_mon_report = now;
// do any pending reports
send_alive();
send_pg_temp();
send_failures();
- send_pg_stats(ceph_clock_now(&g_ceph_context));
+ send_pg_stats(ceph_clock_now(g_ceph_context));
}
}
<< " from " << obc->obs.oi << dendl;
entity_name_t entity = witer->first;
watch_info_t& w = obc->obs.oi.watchers[entity];
- utime_t expire = ceph_clock_now(&g_ceph_context);
+ utime_t expire = ceph_clock_now(g_ceph_context);
expire += w.timeout_seconds;
obc->unconnected_watchers[entity] = expire;
dout(10) << " disconnected watch " << w << " by " << entity << " session " << session
if (witer != obc->watchers.end()) {
watch_info_t& w = obc->obs.oi.watchers[notif_iter->first];
obc->watchers.erase(witer); // FIXME: hmm? notify timeout may be different than watch timeout?
- utime_t expire = ceph_clock_now(&g_ceph_context);
+ utime_t expire = ceph_clock_now(g_ceph_context);
expire += w.timeout_seconds;
obc->unconnected_watchers[notif_iter->first] = expire;
}
up_thru_wanted = want;
// expedite, a bit. WARNING this will somewhat delay other mon queries.
- last_mon_report = ceph_clock_now(&g_ceph_context);
+ last_mon_report = ceph_clock_now(g_ceph_context);
send_alive();
} else {
dout(10) << "queue_want_up_thru want " << want << " <= queued " << up_thru_wanted
ObjectStore::Transaction *cleanupt = new ObjectStore::Transaction;
store->sync_and_flush();
- utime_t start = ceph_clock_now(&g_ceph_context);
+ utime_t start = ceph_clock_now(g_ceph_context);
for (uint64_t pos = 0; pos < count; pos += bsize) {
char nm[30];
snprintf(nm, sizeof(nm), "disk_bw_test_%lld", (long long)pos);
cleanupt->remove(coll_t::META_COLL, soid);
}
store->sync_and_flush();
- utime_t end = ceph_clock_now(&g_ceph_context);
+ utime_t end = ceph_clock_now(g_ceph_context);
// clean up
store->queue_transaction(NULL, cleanupt);
}
} else if (m->cmd.size() == 2 && m->cmd[0] == "logger" && m->cmd[1] == "reset") {
- g_ceph_context.GetProfLoggerCollection()->logger_reset_all();
+ g_ceph_context->GetProfLoggerCollection()->logger_reset_all();
} else if (m->cmd.size() == 2 && m->cmd[0] == "logger" && m->cmd[1] == "reopen") {
- g_ceph_context.reopen_logs();
+ g_ceph_context->reopen_logs();
} else if (m->cmd[0] == "heap") {
if (ceph_using_tcmalloc())
ceph_heap_profiler_handle_command(m->cmd, clog);
clog.info() << "kicking recovery queue. set osd_recovery_delay_start "
<< "to " << g_conf->osd_recovery_delay_start << "\n";
- defer_recovery_until = ceph_clock_now(&g_ceph_context);
+ defer_recovery_until = ceph_clock_now(g_ceph_context);
defer_recovery_until += g_conf->osd_recovery_delay_start;
recovery_wq.kick();
}
bool& isvalid)
{
AuthAuthorizeHandler *authorize_handler =
- get_authorize_handler(protocol, &g_ceph_context);
+ get_authorize_handler(protocol, g_ceph_context);
if (!authorize_handler) {
dout(0) << "No AuthAuthorizeHandler found for protocol " << protocol << dendl;
isvalid = false;
uint64_t global_id;
uint64_t auid = CEPH_AUTH_UID_DEFAULT;
- isvalid = authorize_handler->verify_authorizer(&g_ceph_context, monc->rotating_secrets,
+ isvalid = authorize_handler->verify_authorizer(g_ceph_context, monc->rotating_secrets,
authorizer_data, authorizer_reply, name, global_id, caps_info, &auid);
dout(10) << "OSD::ms_verify_authorizer name=" << name << " auid=" << auid << dendl;
dout(20) << "sched_scrub" << dendl;
pair<utime_t,pg_t> pos;
- utime_t max = ceph_clock_now(&g_ceph_context);
+ utime_t max = ceph_clock_now(g_ceph_context);
max -= g_conf->osd_scrub_max_interval;
sched_scrub_lock.Lock();
note_down_osd(*p);
if (!logger_started)
- g_ceph_context.GetProfLoggerCollection()->logger_start();
+ g_ceph_context->GetProfLoggerCollection()->logger_start();
osdmap = newmap;
superblock.current_epoch = cur;
advance_map(t);
- had_map_since = ceph_clock_now(&g_ceph_context);
+ had_map_since = ceph_clock_now(g_ceph_context);
}
- C_Contexts *fin = new C_Contexts(&g_ceph_context);
+ C_Contexts *fin = new C_Contexts(g_ceph_context);
if (osdmap->is_up(whoami) &&
osdmap->get_addr(whoami) == client_messenger->get_myaddr()) {
// create and lock children
ObjectStore::Transaction *t = new ObjectStore::Transaction;
- C_Contexts *fin = new C_Contexts(&g_ceph_context);
+ C_Contexts *fin = new C_Contexts(g_ceph_context);
map<pg_t,PG*> children;
for (set<pg_t>::iterator q = p->second.begin();
q != p->second.end();
if (can_create_pg(pgid)) {
ObjectStore::Transaction *t = new ObjectStore::Transaction;
- C_Contexts *fin = new C_Contexts(&g_ceph_context);
+ C_Contexts *fin = new C_Contexts(g_ceph_context);
PG *pg = _create_lock_new_pg(pgid, creating_pgs[pgid].acting, *t);
creating_pgs.erase(pgid);
map< int, map<pg_t,PG::Query> > query_map;
map< int, MOSDPGInfo* > info_map;
ObjectStore::Transaction *t = new ObjectStore::Transaction;
- C_Contexts *fin = new C_Contexts(&g_ceph_context);
+ C_Contexts *fin = new C_Contexts(g_ceph_context);
PG::RecoveryCtx rctx(&query_map, &info_map, 0, &fin->contexts, t);
if (!pg->generate_backlog_epoch) {
void OSD::check_replay_queue()
{
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
list< pair<pg_t,utime_t> > pgids;
replay_queue_lock.Lock();
while (!replay_queue.empty() &&
<< " >= max " << g_conf->osd_recovery_max_active << dendl;
return false;
}
- if (ceph_clock_now(&g_ceph_context) < defer_recovery_until) {
+ if (ceph_clock_now(g_ceph_context) < defer_recovery_until) {
dout(15) << "_recover_now defer until " << defer_recovery_until << dendl;
return false;
}
// ...
throttle_op_queue();
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
int r = init_op_flags(op);
if (r) {
public:
OSD *osd;
HeartbeatDispatcher(OSD *o)
- : Dispatcher(&g_ceph_context), osd(o)
+ : Dispatcher(g_ceph_context), osd(o)
{
}
} heartbeat_dispatcher;
osd->recovery_queue.push_back(&pg->recovery_item);
if (g_conf->osd_recovery_delay_start > 0) {
- osd->defer_recovery_until = ceph_clock_now(&g_ceph_context);
+ osd->defer_recovery_until = ceph_clock_now(g_ceph_context);
osd->defer_recovery_until += g_conf->osd_recovery_delay_start;
}
return true;
log.print(*_dout);
*_dout << dendl;
- utime_t mtime = ceph_clock_now(&g_ceph_context);
+ utime_t mtime = ceph_clock_now(g_ceph_context);
eversion_t old_last_update = info.last_update;
info.last_update.epoch = osd->osdmap->get_epoch();
map<sobject_t, Missing::item>::iterator m = missing.missing.begin();
assert(!is_active());
// -- crash recovery?
if (is_crashed()) {
- replay_until = ceph_clock_now(&g_ceph_context);
+ replay_until = ceph_clock_now(g_ceph_context);
replay_until += g_conf->osd_replay_window;
dout(10) << "crashed, allowing op replay for " << g_conf->osd_replay_window
<< " until " << replay_until << dendl;
}
// just scrubbed?
- if (info.history.last_scrub_stamp + g_conf->osd_scrub_min_interval > ceph_clock_now(&g_ceph_context)) {
+ if (info.history.last_scrub_stamp + g_conf->osd_scrub_min_interval > ceph_clock_now(g_ceph_context)) {
dout(20) << "sched_scrub: just scrubbed, skipping" << dendl;
return true;
}
// finish up
osd->unreg_last_pg_scrub(info.pgid, info.history.last_scrub_stamp);
info.history.last_scrub = info.last_update;
- info.history.last_scrub_stamp = ceph_clock_now(&g_ceph_context);
+ info.history.last_scrub_stamp = ceph_clock_now(g_ceph_context);
osd->reg_last_pg_scrub(info.pgid, info.history.last_scrub_stamp);
{
void PG::RecoveryState::RecoveryMachine::log_exit(const char *state_name, utime_t enter_time)
{
- utime_t dur = ceph_clock_now(&g_ceph_context) - enter_time;
+ utime_t dur = ceph_clock_now(g_ceph_context) - enter_time;
dout(20) << "exit " << state_name << " " << dur << " " << event_count << " " << event_time << dendl;
- pg->osd->pg_recovery_stats.log_exit(state_name, ceph_clock_now(&g_ceph_context) - enter_time,
+ pg->osd->pg_recovery_stats.log_exit(state_name, ceph_clock_now(g_ceph_context) - enter_time,
event_count, event_time);
event_count = 0;
event_time = utime_t();
assert(!rctx);
rctx = new_ctx;
if (rctx)
- rctx->start_time = ceph_clock_now(&g_ceph_context);
+ rctx->start_time = ceph_clock_now(g_ceph_context);
}
void end_handle() {
if (rctx) {
- utime_t dur = ceph_clock_now(&g_ceph_context) - rctx->start_time;
+ utime_t dur = ceph_clock_now(g_ceph_context) - rctx->start_time;
machine.event_time += dur;
}
machine.event_count++;
const char *state_name;
utime_t enter_time;
const char *get_state_name() { return state_name; }
- NamedState() : enter_time(ceph_clock_now(&g_ceph_context)) {}
+ NamedState() : enter_time(ceph_clock_now(g_ceph_context)) {}
virtual ~NamedState() {}
};
}
// note my stats
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
// note some basic context for op replication that prepare_transaction may clobber
eversion_t old_last_update = log.head;
osd->logger->inc(l_osd_c_rd);
osd->logger->inc(l_osd_c_rdb, ctx->outdata.length());
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
utime_t diff = now;
diff -= ctx->op->get_recv_stamp();
//dout(20) << "do_op " << ctx->reqid << " total op latency " << diff << dendl;
tid_t rep_tid = osd->get_tid();
osd_reqid_t reqid(osd->cluster_messenger->get_myname(), 0, rep_tid);
OpContext *ctx = new OpContext(NULL, reqid, ops, &obc->obs, this);
- ctx->mtime = ceph_clock_now(&g_ceph_context);
+ ctx->mtime = ceph_clock_now(g_ceph_context);
ctx->at_version.epoch = osd->osdmap->get_epoch();
ctx->at_version.version = log.head.version + 1;
}
// unconnected
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
for (map<entity_name_t, utime_t>::iterator q = obc->unconnected_watchers.begin();
q != obc->unconnected_watchers.end();
q++) {
repop->sent_ack = true;
}
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
now -= repop->start;
osd->logger->finc(l_osd_rlsum, now);
osd->logger->inc(l_osd_rlnum, 1);
repop->waitfor_disk.insert(osd);
}
- repop->start = ceph_clock_now(&g_ceph_context);
+ repop->start = ceph_clock_now(g_ceph_context);
repop_queue.push_back(&repop->queue_item);
repop_map[repop->rep_tid] = repop;
if (!obc->obs.oi.watchers.empty()) {
// populate unconnected_watchers
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
for (map<entity_name_t, watch_info_t>::iterator p = obc->obs.oi.watchers.begin();
p != obc->obs.oi.watchers.end();
p++) {
if (!rm->committed) {
// send ack to acker only if we haven't sent a commit already
MOSDSubOpReply *ack = new MOSDSubOpReply(rm->op, 0, osd->osdmap->get_epoch(), CEPH_OSD_FLAG_ACK);
- ack->set_peer_stat(osd->get_my_stat_for(ceph_clock_now(&g_ceph_context), rm->ackerosd));
+ ack->set_peer_stat(osd->get_my_stat_for(ceph_clock_now(g_ceph_context), rm->ackerosd));
ack->set_priority(CEPH_MSG_PRIO_HIGH); // this better match commit priority!
osd->cluster_messenger->
send_message(ack, osd->osdmap->get_cluster_inst(rm->ackerosd));
MOSDSubOpReply *commit = new MOSDSubOpReply(rm->op, 0, osd->osdmap->get_epoch(), CEPH_OSD_FLAG_ONDISK);
commit->set_last_complete_ondisk(rm->last_complete);
commit->set_priority(CEPH_MSG_PRIO_HIGH); // this better match ack priority!
- commit->set_peer_stat(osd->get_my_stat_for(ceph_clock_now(&g_ceph_context), rm->ackerosd));
+ commit->set_peer_stat(osd->get_my_stat_for(ceph_clock_now(g_ceph_context), rm->ackerosd));
osd->cluster_messenger->
send_message(commit, osd->osdmap->get_cluster_inst(rm->ackerosd));
}
dout(10) << __func__ << ": all OSDs in the PG are up-to-date!" << dendl;
log.reset_recovery_pointers();
ObjectStore::Transaction *t = new ObjectStore::Transaction;
- C_Contexts *fin = new C_Contexts(&g_ceph_context);
+ C_Contexts *fin = new C_Contexts(g_ceph_context);
finish_recovery(*t, fin->contexts);
int tr = osd->store->queue_transaction(&osr, t, new ObjectStore::C_DeleteTransaction(t), fin);
assert(tr == 0);
} else {
C_Gather *gack = 0, *gcom = 0;
if (onack)
- gack = new C_Gather(&g_ceph_context, onack);
+ gack = new C_Gather(g_ceph_context, onack);
if (oncommit)
- gcom = new C_Gather(&g_ceph_context, oncommit);
+ gcom = new C_Gather(g_ceph_context, oncommit);
for (vector<ObjectExtent>::iterator p = extents.begin(); p != extents.end(); p++) {
vector<OSDOp> ops(1);
ops[0].op.op = CEPH_OSD_OP_TRIMTRUNC;
} else {
C_Gather *gack = 0, *gcom = 0;
if (onack)
- gack = new C_Gather(&g_ceph_context, onack);
+ gack = new C_Gather(g_ceph_context, onack);
if (oncommit)
- gcom = new C_Gather(&g_ceph_context, oncommit);
+ gcom = new C_Gather(g_ceph_context, oncommit);
for (vector<ObjectExtent>::iterator p = extents.begin(); p != extents.end(); p++) {
if (p->offset == 0 && p->length == layout->fl_object_size)
objecter->remove(p->oid, p->oloc,
state = STATE_ACTIVE;
list<Context*> ls;
ls.swap(waitfor_recover);
- finish_contexts(&g_ceph_context, ls, 0);
+ finish_contexts(g_ceph_context, ls, 0);
return;
}
<< magic << "'" << dendl;
list<Context*> ls;
ls.swap(waitfor_recover);
- finish_contexts(&g_ceph_context, ls, -EINVAL);
+ finish_contexts(g_ceph_context, ls, -EINVAL);
return;
}
// done.
list<Context*> ls;
ls.swap(waitfor_recover);
- finish_contexts(&g_ceph_context, ls, 0);
+ finish_contexts(g_ceph_context, ls, 0);
}
class Journaler::C_RereadHeadProbe : public Context
last_written.write_pos = safe_pos;
dout(10) << "write_head " << last_written << dendl;
- last_wrote_head = ceph_clock_now(&g_ceph_context);
+ last_wrote_head = ceph_clock_now(g_ceph_context);
bufferlist bl;
::encode(last_written, bl);
object_t oid = file_object_t(ino, 0);
object_locator_t oloc(pg_pool);
- objecter->write_full(oid, oloc, snapc, bl, ceph_clock_now(&g_ceph_context), 0,
+ objecter->write_full(oid, oloc, snapc, bl, ceph_clock_now(g_ceph_context), 0,
NULL,
new C_WriteHead(this, last_written, oncommit));
}
// calc latency?
if (logger) {
- utime_t lat = ceph_clock_now(&g_ceph_context);
+ utime_t lat = ceph_clock_now(g_ceph_context);
lat -= stamp;
logger->favg(logger_key_lat, lat);
}
while (!waitfor_safe.empty()) {
if (waitfor_safe.begin()->first > safe_pos)
break;
- finish_contexts(&g_ceph_context, waitfor_safe.begin()->second);
+ finish_contexts(g_ceph_context, waitfor_safe.begin()->second);
waitfor_safe.erase(waitfor_safe.begin());
}
}
// submit write for anything pending
// flush _start_ pos to _finish_flush
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
SnapContext snapc;
Context *onsafe = new C_Flush(this, flush_pos, now); // on COMMIT
}
filer.write(ino, &layout, snapc,
- flush_pos, len, write_bl, ceph_clock_now(&g_ceph_context),
+ flush_pos, len, write_bl, ceph_clock_now(g_ceph_context),
0,
NULL, onsafe);
}
// write head?
- if (last_wrote_head.sec() + g_conf->journaler_write_head_interval < ceph_clock_now(&g_ceph_context).sec()) {
+ if (last_wrote_head.sec() + g_conf->journaler_write_head_interval < ceph_clock_now(g_ceph_context).sec()) {
write_head();
}
}
}
SnapContext snapc;
Context *c = new C_Journaler_Prezero(this, prezeroing_pos, len);
- filer.zero(ino, &layout, snapc, prezeroing_pos, len, ceph_clock_now(&g_ceph_context), 0, NULL, c);
+ filer.zero(ino, &layout, snapc, prezeroing_pos, len, ceph_clock_now(g_ceph_context), 0, NULL, c);
prezeroing_pos += len;
}
}
uint64_t first = trimming_pos / period;
uint64_t num = (trim_to - trimming_pos) / period;
SnapContext snapc;
- filer.purge_range(ino, &layout, snapc, first, num, ceph_clock_now(&g_ceph_context), 0,
+ filer.purge_range(ino, &layout, snapc, first, num, ceph_clock_now(g_ceph_context), 0,
new C_Trim(this, trim_to));
trimming_pos = trim_to;
}
// finishers?
while (!waitfor_trim.empty() &&
waitfor_trim.begin()->first <= trimmed_pos) {
- finish_contexts(&g_ceph_context, waitfor_trim.begin()->second, 0);
+ finish_contexts(g_ceph_context, waitfor_trim.begin()->second, 0);
waitfor_trim.erase(waitfor_trim.begin());
}
}
p++)
ls.splice(ls.end(), p->second);
bh->waitfor_read.clear();
- finish_contexts(&g_ceph_context, ls);
+ finish_contexts(g_ceph_context, ls);
// clean up?
ob->try_merge_bh(bh);
<< " tid " << tid << " obsolete" << dendl;
}
- finish_contexts(&g_ceph_context, ls);
+ finish_contexts(g_ceph_context, ls);
}
}
list<Context*> ls;
ls.splice(ls.begin(), ob->waitfor_ack[tid]);
ob->waitfor_ack.erase(tid);
- finish_contexts(&g_ceph_context, ls);
+ finish_contexts(g_ceph_context, ls);
}
// is the entire object set now clean?
list<Context*> ls;
ls.splice(ls.begin(), ob->waitfor_commit[tid]);
ob->waitfor_commit.erase(tid);
- finish_contexts(&g_ceph_context, ls);
+ finish_contexts(g_ceph_context, ls);
}
// is the entire object set now clean and fully committed?
void ObjectCacher::flush(loff_t amount)
{
- utime_t cutoff = ceph_clock_now(&g_ceph_context);
+ utime_t cutoff = ceph_clock_now(g_ceph_context);
//cutoff.sec_ref() -= g_conf->client_oc_max_dirty_age;
dout(10) << "flush " << amount << dendl;
int ObjectCacher::writex(OSDWrite *wr, ObjectSet *oset)
{
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
for (vector<ObjectExtent>::iterator ex_it = wr->extents.begin();
ex_it != wr->extents.end();
}
else {
// check tail of lru for old dirty items
- utime_t cutoff = ceph_clock_now(&g_ceph_context);
+ utime_t cutoff = ceph_clock_now(g_ceph_context);
cutoff.sec_ref()--;
BufferHead *bh = 0;
while ((bh = (BufferHead*)lru_dirty.lru_get_next_expire()) != 0 &&
}
}
if (flusher_stop) break;
- flusher_cond.WaitInterval(&g_ceph_context, lock, utime_t(1,0));
+ flusher_cond.WaitInterval(g_ceph_context, lock, utime_t(1,0));
}
lock.Unlock();
dout(10) << "flusher finish" << dendl;
if (!flush(ob)) {
// we'll need to gather...
if (!gather && onfinish)
- gather = new C_Gather(&g_ceph_context, onfinish);
+ gather = new C_Gather(g_ceph_context, onfinish);
safe = false;
dout(10) << "flush_set " << oset << " will wait for ack tid "
dout(10) << "commit_set " << oset << " " << *ob
<< " will finish on commit tid " << ob->last_write_tid
<< dendl;
- if (!gather && onfinish) gather = new C_Gather(&g_ceph_context, onfinish);
+ if (!gather && onfinish) gather = new C_Gather(g_ceph_context, onfinish);
safe = false;
if (gather)
ob->waitfor_commit[ob->last_write_tid].push_back( gather->new_sub() );
ls.splice(ls.begin(), ob->waitfor_wr);
}
- finish_contexts(&g_ceph_context, ls);
+ finish_contexts(g_ceph_context, ls);
}
void ObjectCacher::kick_sync_readers(ObjectSet *oset)
ls.splice(ls.begin(), ob->waitfor_rd);
}
- finish_contexts(&g_ceph_context, ls);
+ finish_contexts(g_ceph_context, ls);
}
void mark_dirty(BufferHead *bh) {
bh_set_state(bh, BufferHead::STATE_DIRTY);
lru_dirty.lru_touch(bh);
- //bh->set_dirty_stamp(ceph_clock_now(&g_ceph_context));
+ //bh->set_dirty_stamp(ceph_clock_now(g_ceph_context));
};
void bh_add(Object *ob, BufferHead *bh) {
set<OSDSession*> toping;
// look for laggy requests
- utime_t cutoff = ceph_clock_now(&g_ceph_context);
+ utime_t cutoff = ceph_clock_now(g_ceph_context);
cutoff -= g_conf->objecter_timeout; // timeout
for (hash_map<tid_t,Op*>::iterator p = ops.begin();
void Objecter::resend_mon_ops()
{
- utime_t cutoff = ceph_clock_now(&g_ceph_context);
+ utime_t cutoff = ceph_clock_now(g_ceph_context);
cutoff -= g_conf->objecter_mon_retry_interval;
op->paused = false;
op->incarnation = op->session->incarnation;
- op->stamp = ceph_clock_now(&g_ceph_context);
+ op->stamp = ceph_clock_now(g_ceph_context);
MOSDOp *m = new MOSDOp(client_inc, op->tid,
op->oid, op->oloc, op->pgid, osdmap->get_epoch(),
if (op->snapid) m->snapid = op->snapid;
if (op->crush_rule) m->crush_rule = op->crush_rule;
monc->send_mon_message(m);
- op->last_submit = ceph_clock_now(&g_ceph_context);
+ op->last_submit = ceph_clock_now(g_ceph_context);
}
/**
{
dout(10) << "poolstat_submit " << op->tid << dendl;
monc->send_mon_message(new MGetPoolStats(monc->get_fsid(), op->tid, op->pools, last_seen_pgmap_version));
- op->last_submit = ceph_clock_now(&g_ceph_context);
+ op->last_submit = ceph_clock_now(g_ceph_context);
}
void Objecter::handle_get_pool_stats_reply(MGetPoolStatsReply *m)
{
dout(10) << "fs_stats_submit" << op->tid << dendl;
monc->send_mon_message(new MStatfs(monc->get_fsid(), op->tid, last_seen_pgmap_version));
- op->last_submit = ceph_clock_now(&g_ceph_context);
+ op->last_submit = ceph_clock_now(g_ceph_context);
}
void Objecter::handle_fs_stats_reply(MStatfsReply *m) {
read_trunc(extents[0].oid, extents[0].oloc, extents[0].offset, extents[0].length,
snap, bl, flags, trunc_size, trunc_seq, onfinish);
} else {
- C_Gather *g = new C_Gather(&g_ceph_context);
+ C_Gather *g = new C_Gather(g_ceph_context);
vector<bufferlist> resultbl(extents.size());
int i=0;
for (vector<ObjectExtent>::iterator p = extents.begin(); p != extents.end(); p++) {
} else {
C_Gather *gack = 0, *gcom = 0;
if (onack)
- gack = new C_Gather(&g_ceph_context, onack);
+ gack = new C_Gather(g_ceph_context, onack);
if (oncommit)
- gcom = new C_Gather(&g_ceph_context, oncommit);
+ gcom = new C_Gather(g_ceph_context, oncommit);
for (vector<ObjectExtent>::iterator p = extents.begin(); p != extents.end(); p++) {
bufferlist cur;
for (map<__u32,__u32>::iterator bit = p->buffer_extents.begin();
pthread_create(&print_thread, NULL, status_printer, (void *)data);
dataLock.Lock();
- data->start_time = ceph_clock_now(&g_ceph_context);
+ data->start_time = ceph_clock_now(g_ceph_context);
dataLock.Unlock();
for (int i = 0; i<concurrentios; ++i) {
- start_times[i] = ceph_clock_now(&g_ceph_context);
+ start_times[i] = ceph_clock_now(g_ceph_context);
completions[i] = rados.aio_create_completion((void *) &cond, 0,
&_aio_cb);
r = io_ctx.aio_write(name[i], completions[i], *contents[i], data->object_size, 0);
runtime.set_from_double(secondsToRun);
stopTime = data->start_time + runtime;
- while( ceph_clock_now(&g_ceph_context) < stopTime ) {
+ while( ceph_clock_now(g_ceph_context) < stopTime ) {
dataLock.Lock();
while (1) {
for (slot = 0; slot < concurrentios; ++slot) {
dataLock.Unlock();
goto ERR;
}
- data->cur_latency = ceph_clock_now(&g_ceph_context) - start_times[slot];
+ data->cur_latency = ceph_clock_now(g_ceph_context) - start_times[slot];
total_latency += data->cur_latency;
if( data->cur_latency > data->max_latency) data->max_latency = data->cur_latency;
if (data->cur_latency < data->min_latency) data->min_latency = data->cur_latency;
dataLock.Unlock();
completions[slot]->release();
completions[slot] = 0;
- timePassed = ceph_clock_now(&g_ceph_context) - data->start_time;
+ timePassed = ceph_clock_now(g_ceph_context) - data->start_time;
//write new stuff to rados, then delete old stuff
//and save locations of new stuff for later deletion
- start_times[slot] = ceph_clock_now(&g_ceph_context);
+ start_times[slot] = ceph_clock_now(g_ceph_context);
completions[slot] = rados.aio_create_completion((void *) &cond, 0, &_aio_cb);
r = io_ctx.aio_write(newName, completions[slot], *newContents, data->object_size, 0);
if (r < 0) {//naughty; doesn't clean up heap space.
dataLock.Unlock();
goto ERR;
}
- data->cur_latency = ceph_clock_now(&g_ceph_context) - start_times[slot];
+ data->cur_latency = ceph_clock_now(g_ceph_context) - start_times[slot];
total_latency += data->cur_latency;
if (data->cur_latency > data->max_latency) data->max_latency = data->cur_latency;
if (data->cur_latency < data->min_latency) data->min_latency = data->cur_latency;
delete contents[slot];
}
- timePassed = ceph_clock_now(&g_ceph_context) - data->start_time;
+ timePassed = ceph_clock_now(g_ceph_context) - data->start_time;
dataLock.Lock();
data->done = true;
dataLock.Unlock();
pthread_create(&print_thread, NULL, status_printer, (void *)data);
dataLock.Lock();
- data->start_time = ceph_clock_now(&g_ceph_context);
+ data->start_time = ceph_clock_now(g_ceph_context);
dataLock.Unlock();
utime_t finish_time = data->start_time + time_to_run;
//start initial reads
for (int i = 0; i < concurrentios; ++i) {
index[i] = i;
- start_times[i] = ceph_clock_now(&g_ceph_context);
+ start_times[i] = ceph_clock_now(g_ceph_context);
completions[i] = rados.aio_create_completion((void *) &cond, &_aio_cb, 0);
r = io_ctx.aio_read(name[i], completions[i], contents[i], data->object_size, 0);
if (r < 0) { //naughty, doesn't clean up heap -- oh, or handle the print thread!
char* newName;
bufferlist *cur_contents;
- while (seconds_to_run && (ceph_clock_now(&g_ceph_context) < finish_time) &&
+ while (seconds_to_run && (ceph_clock_now(g_ceph_context) < finish_time) &&
write_data->finished > data->started) {
dataLock.Lock();
while (1) {
dataLock.Unlock();
goto ERR;
}
- data->cur_latency = ceph_clock_now(&g_ceph_context) - start_times[slot];
+ data->cur_latency = ceph_clock_now(g_ceph_context) - start_times[slot];
total_latency += data->cur_latency;
if( data->cur_latency > data->max_latency) data->max_latency = data->cur_latency;
if (data->cur_latency < data->min_latency) data->min_latency = data->cur_latency;
cur_contents = contents[slot];
//start new read and check data if requested
- start_times[slot] = ceph_clock_now(&g_ceph_context);
+ start_times[slot] = ceph_clock_now(g_ceph_context);
contents[slot] = new bufferlist();
completions[slot] = rados.aio_create_completion((void *) &cond, &_aio_cb, 0);
r = io_ctx.aio_read(newName, completions[slot], contents[slot], data->object_size, 0);
dataLock.Unlock();
goto ERR;
}
- data->cur_latency = ceph_clock_now(&g_ceph_context) - start_times[slot];
+ data->cur_latency = ceph_clock_now(g_ceph_context) - start_times[slot];
total_latency += data->cur_latency;
if (data->cur_latency > data->max_latency) data->max_latency = data->cur_latency;
if (data->cur_latency < data->min_latency) data->min_latency = data->cur_latency;
delete contents[slot];
}
- runtime = ceph_clock_now(&g_ceph_context) - data->start_time;
+ runtime = ceph_clock_now(g_ceph_context) - data->start_time;
dataLock.Lock();
data->done = true;
dataLock.Unlock();
/ (1024*1024)
/ cycleSinceChange;
avg_bandwidth = (double) (data->trans_size) * (data->finished)
- / (double)(ceph_clock_now(&g_ceph_context) - data->start_time) / (1024*1024);
+ / (double)(ceph_clock_now(g_ceph_context) - data->start_time) / (1024*1024);
if (previous_writes != data->finished) {
previous_writes = data->finished;
cycleSinceChange = 0;
}
++i;
++cycleSinceChange;
- cond.WaitInterval(&g_ceph_context, dataLock, ONE_SECOND);
+ cond.WaitInterval(g_ceph_context, dataLock, ONE_SECOND);
}
dataLock.Unlock();
return NULL;
global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY,
CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
const char *me = argv[0];
}
ceph_fsid_t fsid;
memset(&fsid, 0, sizeof(ceph_fsid_t));
- osdmap.build_simple(&g_ceph_context, 0, fsid, num_osd, num_dom, pg_bits, pgp_bits, lpg_bits);
+ osdmap.build_simple(g_ceph_context, 0, fsid, num_osd, num_dom, pg_bits, pgp_bits, lpg_bits);
modified = true;
}
// open rados
Rados rados;
- ret = rados.init_with_context(&g_ceph_context);
+ ret = rados.init_with_context(g_ceph_context);
if (ret) {
cerr << "couldn't initialize rados! error " << ret << std::endl;
return ret;
env_to_vec(args);
global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
std::map < std::string, std::string > opts;
std::vector<const char*>::iterator i;
// open rados
Rados rados;
- if (rados.init_with_context(&g_ceph_context) < 0) {
+ if (rados.init_with_context(g_ceph_context) < 0) {
cerr << "rados" << ": failed to initialize Rados!" << std::endl;
exit(1);
}
static int do_kernel_add(const char *poolname, const char *imgname, const char *secretfile, const char *user)
{
- MonMap monmap(ceph_clock_now(&g_ceph_context));
- int r = MonClient::build_initial_monmap(&g_ceph_context, monmap);
+ MonMap monmap(ceph_clock_now(g_ceph_context));
+ int r = MonClient::build_initial_monmap(g_ceph_context, monmap);
if (r < 0)
return r;
int opt_cmd = OPT_NO_CMD;
global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
const char *poolname = NULL;
uint64_t size = 0;
}
bool talk_to_cluster = (opt_cmd != OPT_MAP && opt_cmd != OPT_UNMAP);
- if (talk_to_cluster && rados.init_with_context(&g_ceph_context) < 0) {
+ if (talk_to_cluster && rados.init_with_context(g_ceph_context) < 0) {
cerr << "error: couldn't initialize rados!" << std::endl;
exit(1);
}
common_init_finish(cct);
}
else {
- cct = &g_ceph_context;
+ cct = g_ceph_context;
}
librgw_init_mutex.Unlock();
- *rgw = &g_ceph_context;
+ *rgw = g_ceph_context;
return 0;
}
env_to_vec(args);
global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
const char *user_id = 0;
const char *access_key = 0;
opt_cmd == OPT_SUBUSER_CREATE || opt_cmd == OPT_SUBUSER_RM ||
opt_cmd == OPT_KEY_CREATE || opt_cmd == OPT_KEY_RM);
- store = RGWAccess::init_storage_provider("rados", &g_ceph_context);
+ store = RGWAccess::init_storage_provider("rados", g_ceph_context);
if (!store) {
cerr << "couldn't init storage provider" << std::endl;
return 5; //EIO
entry.owner = s->acl->get_owner().get_id();
entry.time = s->time;
- entry.total_time = ceph_clock_now(&g_ceph_context) - s->time;
+ entry.total_time = ceph_clock_now(g_ceph_context) - s->time;
entry.bytes_sent = s->bytes_sent;
entry.bytes_received = s->bytes_received;
if (s->err.http_ret) {
argv_to_vec(argc, argv, args);
env_to_vec(args);
global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
- if (!RGWAccess::init_storage_provider("rados", &g_ceph_context)) {
+ if (!RGWAccess::init_storage_provider("rados", g_ceph_context)) {
derr << "Couldn't init storage provider (RADOS)" << dendl;
return EIO;
}
info.num = atoi(part_num.c_str());
info.etag = etag;
info.size = s->obj_size;
- info.modified = ceph_clock_now(&g_ceph_context);
+ info.modified = ceph_clock_now(g_ceph_context);
::encode(info, bl);
RGW_LOG(0) << "JJJ name=" << p << "bl.length()=" << bl.length() << dendl;
meta_attrs[p] = bl;
s->os_auth_token = NULL;
s->os_user = NULL;
s->os_groups = NULL;
- s->time = ceph_clock_now(&g_ceph_context);
+ s->time = ceph_clock_now(g_ceph_context);
s->user.clear();
s->perm_mask = 0;
}
if (ret < 0)
return ret;
- utime_t expiration = ceph_clock_now(&g_ceph_context);
+ utime_t expiration = ceph_clock_now(g_ceph_context);
expiration += RGW_OS_TOKEN_EXPIRATION; // 15 minutes
ret = build_token(os_user, key, nonce, expiration, bl);
RGW_LOG(0) << "failed to decode token" << dendl;
return -EINVAL;
}
- if (expiration < ceph_clock_now(&g_ceph_context)) {
- RGW_LOG(0) << "old timed out token was used now=" << ceph_clock_now(&g_ceph_context) << " token.expiration=" << expiration << dendl;
+ if (expiration < ceph_clock_now(g_ceph_context)) {
+ RGW_LOG(0) << "old timed out token was used now=" << ceph_clock_now(g_ceph_context) << " token.expiration=" << expiration << dendl;
return -EPERM;
}
off_t off;
C_Ack(off_t o) : off(o) {}
void finish(int r) {
- set_ack(off, ceph_clock_now(&g_ceph_context));
+ set_ack(off, ceph_clock_now(g_ceph_context));
}
};
struct C_Commit : public Context {
off_t off;
C_Commit(off_t o) : off(o) {}
void finish(int r) {
- set_commit(off, ceph_clock_now(&g_ceph_context));
+ set_commit(off, ceph_clock_now(g_ceph_context));
}
};
env_to_vec(args);
global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
// args
if (args.size() < 3) return -1;
ft.create_collection(coll_t());
fs->apply_transaction(ft);
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
utime_t end = now;
end += seconds;
off_t pos = 0;
while (now < end) {
sobject_t poid(object_t("streamtest"), 0);
- set_start(pos, ceph_clock_now(&g_ceph_context));
+ set_start(pos, ceph_clock_now(g_ceph_context));
ObjectStore::Transaction *t = new ObjectStore::Transaction;
t->write(coll_t(), poid, pos, bytes, bl);
fs->queue_transaction(NULL, t, new C_Ack(pos), new C_Commit(pos));
env_to_vec(args);
global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
DoutStreambuf<char> *dos = new DoutStreambuf<char>();
env_to_vec(args);
global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
DEFINE_CONF_VARS(usage);
FOR_EACH_ARG(args) {
if (lock)
lock->Lock();
utime_t inc(2 * i, 0);
- utime_t t = ceph_clock_now(&g_ceph_context) + inc;
+ utime_t t = ceph_clock_now(g_ceph_context) + inc;
timer.add_event_at(t, test_contexts[i]);
if (lock)
lock->Unlock();
{
utime_t inc(100, 0);
- utime_t t = ceph_clock_now(&g_ceph_context) + inc;
+ utime_t t = ceph_clock_now(g_ceph_context) + inc;
lock->Lock();
timer.add_event_at(t, test_contexts[0]);
lock->Unlock();
{
utime_t inc(2, 0);
- utime_t t = ceph_clock_now(&g_ceph_context) + inc;
+ utime_t t = ceph_clock_now(g_ceph_context) + inc;
lock->Lock();
timer.add_event_at(t, test_contexts[1]);
lock->Unlock();
safe_timer_lock.Lock();
for (int i = 0; i < MAX_TEST_CONTEXTS; ++i) {
utime_t inc(4 * i, 0);
- utime_t t = ceph_clock_now(&g_ceph_context) + inc;
+ utime_t t = ceph_clock_now(g_ceph_context) + inc;
safe_timer.add_event_at(t, test_contexts[i]);
}
safe_timer_lock.Unlock();
safe_timer_lock.Lock();
for (int i = 0; i < MAX_TEST_CONTEXTS; ++i) {
utime_t inc(4 * i, 0);
- utime_t t = ceph_clock_now(&g_ceph_context) + inc;
+ utime_t t = ceph_clock_now(g_ceph_context) + inc;
safe_timer.add_event_at(t, test_contexts[i]);
}
safe_timer_lock.Unlock();
env_to_vec(args);
global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
int ret;
Mutex safe_timer_lock("safe_timer_lock");
- SafeTimer safe_timer(&g_ceph_context, safe_timer_lock);
+ SafeTimer safe_timer(g_ceph_context, safe_timer_lock);
ret = basic_timer_test <SafeTimer>(safe_timer, &safe_timer_lock);
if (ret)
};
TEST(ContextGather, Constructor) {
- C_Gather *gather = new C_Gather(&g_ceph_context );
+ C_Gather *gather = new C_Gather(g_ceph_context );
EXPECT_TRUE(gather->empty());
EXPECT_EQ(0, gather->get_num());
EXPECT_EQ(0, gather->get_num_remaining());
}
TEST(ContextGather, OneSub) {
- C_Gather *gather = new C_Gather(&g_ceph_context);
+ C_Gather *gather = new C_Gather(g_ceph_context);
Context *sub = gather->new_sub();
EXPECT_EQ(1, gather->get_num());
EXPECT_EQ(1, gather->get_num_remaining());
}
TEST(ContextGather, ManySubs) {
- C_Gather *gather = new C_Gather(&g_ceph_context);
+ C_Gather *gather = new C_Gather(g_ceph_context);
int sub_count = 8;
bool finish_called = false;
int result = 0;
}
TEST(ContextGather, AlternatingSubCreateFinish) {
- C_Gather *gather = new C_Gather(&g_ceph_context);
+ C_Gather *gather = new C_Gather(g_ceph_context);
int sub_count = 8;
bool finish_called = false;
int result = 0;
}
- utime_t start = ceph_clock_now(&g_ceph_context);
+ utime_t start = ceph_clock_now(g_ceph_context);
while (loop++ < count) {
ret = safe_write(fd, buf, bsize);
if (ret)
}
::fsync(fd);
::close(fd);
- utime_t end = ceph_clock_now(&g_ceph_context);
+ utime_t end = ceph_clock_now(g_ceph_context);
end -= start;
int s = blocks*4096;
- utime_t start = ceph_clock_now(&g_ceph_context);
+ utime_t start = ceph_clock_now(g_ceph_context);
for (int i=0; i<count; i++) {
off64_t so, o = (lrand48() % numblocks) * 4096;
//cout << "s = " << s << " o = " << o << endl;
//int r = ::read(fd, buf, s);
if (r < 0) cout << "r = " << r << " " << strerror(errno) << endl;
}
- utime_t end = ceph_clock_now(&g_ceph_context);
+ utime_t end = ceph_clock_now(g_ceph_context);
double timeper = end - start;
timeper /= count;
so = o + 4096*((rand() % range) );//- range/2);
//cout << o << " " << so << " " << (so-o) << endl;
- utime_t start = ceph_clock_now(&g_ceph_context);
+ utime_t start = ceph_clock_now(g_ceph_context);
lseek64(fd, so, SEEK_SET);
r = ::read(fd, buf, blocks*4096);
- utime_t end = ceph_clock_now(&g_ceph_context);
+ utime_t end = ceph_clock_now(g_ceph_context);
timeper += (end-start);
}
DecayCounter dc(hl);
RealCounter rc;
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
for (int ms=0; ms < 300*1000; ms++) {
if (ms % 30000 == 0) {
}
/* This program exists to test that we can build libcommon without
- * referencing g_ceph_context.
+ * referencing g_ceph_context->
*
* This program will go away as soon as we actually don't use g_ceph_context in
* more programs. Obviously, at that point, those programs will provide an
argv_to_vec(argc, argv, args);
env_to_vec(args);
global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
string val;
string oid("test_object");
}
Rados rados;
- if (rados.init_with_context(&g_ceph_context) < 0) {
+ if (rados.init_with_context(g_ceph_context) < 0) {
cerr << "couldn't initialize rados!" << std::endl;
return 1;
}
env_to_vec(args);
global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
// args
if (args.size() < 2) return -1;
char aes_key[AES_KEY_LEN];
memset(aes_key, 0x77, sizeof(aes_key));
bufferptr keybuf(aes_key, sizeof(aes_key));
- CryptoKey key(CEPH_CRYPTO_AES, ceph_clock_now(&g_ceph_context), keybuf);
+ CryptoKey key(CEPH_CRYPTO_AES, ceph_clock_now(g_ceph_context), keybuf);
const char *msg="hello! this is a message\n";
char pad[16];
env_to_vec(args);
global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
- KeyServer server(&g_ceph_context);
+ KeyServer server(g_ceph_context);
dout(0) << "server created" << dendl;
char aes_key[AES_KEY_LEN];
memset(aes_key, 0x77, sizeof(aes_key));
bufferptr keybuf(aes_key, sizeof(aes_key));
- CryptoKey key(CEPH_CRYPTO_AES, ceph_clock_now(&g_ceph_context), keybuf);
+ CryptoKey key(CEPH_CRYPTO_AES, ceph_clock_now(g_ceph_context), keybuf);
const char *msg="hello! this is a message\n";
char pad[16];
class Admin : public Dispatcher {
public:
Admin()
- : Dispatcher(&g_ceph_context)
+ : Dispatcher(g_ceph_context)
{
}
private:
env_to_vec(args);
global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
vec_to_argv(args, argc, argv);
dout(0) << "i am mon " << args[0] << dendl;
// get monmap
- MonClient mc(&g_ceph_context);
+ MonClient mc(g_ceph_context);
if (mc.build_initial_monmap() < 0)
return -1;
int whoami = mc.monmap.get_rank(args[0]);
assert(whoami >= 0);
g_conf->public_addr = mc.monmap.get_addr(whoami);
- SimpleMessenger *rank = new SimpleMessenger(&g_ceph_context);
+ SimpleMessenger *rank = new SimpleMessenger(g_ceph_context);
int err = rank->bind(getpid());
if (err < 0)
return 1;
env_to_vec(args);
global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
vec_to_argv(args, argc, argv);
static void handle_notify(CephToolCtx *ctx, MMonObserveNotify *notify)
{
- utime_t now = ceph_clock_now(&g_ceph_context);
+ utime_t now = ceph_clock_now(g_ceph_context);
dout(1) << notify->get_source() << " -> " << get_paxos_name(notify->machine_id)
<< " v" << notify->ver
m->set_data(pending_bl);
if (!ctx->concise)
- *ctx->log << ceph_clock_now(&g_ceph_context) << " mon" << " <- " << pending_cmd << std::endl;
+ *ctx->log << ceph_clock_now(g_ceph_context) << " mon" << " <- " << pending_cmd << std::endl;
ctx->mc.send_mon_message(m);
}
class Admin : public Dispatcher {
public:
Admin(CephToolCtx *ctx_)
- : Dispatcher(&g_ceph_context),
+ : Dispatcher(g_ceph_context),
ctx(ctx_)
{
}
rs = rs;
rbl = reply_bl;
if (!ctx->concise)
- *ctx->log << ceph_clock_now(&g_ceph_context) << " "
+ *ctx->log << ceph_clock_now(g_ceph_context) << " "
<< reply_from.name << " -> '"
<< reply_rs << "' (" << reply_rc << ")"
<< std::endl;
ceph_tool_mode = mode;
std::auto_ptr <CephToolCtx> ctx;
- ctx.reset(new CephToolCtx(&g_ceph_context, concise));
+ ctx.reset(new CephToolCtx(g_ceph_context, concise));
// get monmap
if (ctx->mc.build_initial_monmap() < 0)
tok = tok_init(NULL);
// start up network
- messenger = new SimpleMessenger(&g_ceph_context);
+ messenger = new SimpleMessenger(g_ceph_context);
messenger->register_entity(entity_name_t::CLIENT());
messenger->start_with_nonce(getpid());
ctx->dispatcher = new Admin(ctx.get());
CephToolCtx(CephContext *cct_, bool concise_) :
cct(cct_),
mdsmap(cct_),
- mc(&g_ceph_context),
+ mc(g_ceph_context),
updates(EVERYTHING_UPDATE),
log(&std::cout),
slog(NULL),
env_to_vec(args);
global_init(args, CEPH_ENTITY_TYPE_CLIENT, CODE_ENVIRONMENT_UTILITY, 0);
- common_init_finish(&g_ceph_context);
+ common_init_finish(g_ceph_context);
vec_to_argv(args, argc, argv);
CephToolCtx *ctx = gui->ctx;
ctx->lock.Lock();
while (true) {
- utime_t t(ceph_clock_now(&g_ceph_context));
+ utime_t t(ceph_clock_now(g_ceph_context));
t += 3.0;
ctx->gui_cond.WaitUntil(ctx->lock, t);
if (shutting_down) {
projects / ceph.git / commitdiff