#include <stdlib.h>
#include <errno.h>
-#include "include/utime.h"
+#include "common/ceph_time.h"
#include "objclass/objclass.h"
#include "cls/rgw/cls_rgw_ops.h"
#include "common/Clock.h"
return first > second;
}
-static void get_time_key(utime_t& ut, string *key)
+static void get_time_key(real_time& ut, string *key)
{
char buf[32];
- snprintf(buf, 32, "%011llu.%09u", (unsigned long long)ut.sec(), ut.nsec());
+ ceph_timespec ts = ceph::real_clock::to_ceph_timespec(ut);
+ snprintf(buf, 32, "%011llu.%09u", (unsigned long long)ts.tv_sec, (unsigned int)ts.tv_nsec);
*key = buf;
}
}
static int log_index_operation(cls_method_context_t hctx, cls_rgw_obj_key& obj_key, RGWModifyOp op,
- string& tag, utime_t& timestamp,
+ string& tag, real_time& timestamp,
rgw_bucket_entry_ver& ver, RGWPendingState state, uint64_t index_ver,
string& max_marker, uint16_t bilog_flags, string *owner, string *owner_display_name)
{
// fill in proper state
struct rgw_bucket_pending_info info;
- info.timestamp = ceph_clock_now(g_ceph_context);
+ info.timestamp = real_clock::now();
info.state = CLS_RGW_STATE_PENDING_MODIFY;
info.op = op.op;
entry.pending_map.insert(pair<string, rgw_bucket_pending_info>(op.tag, info));
return 0;
}
- time_t mtime() {
+ real_time mtime() {
return instance_entry.meta.mtime;
}
};
return ret;
}
- if (existed && op.unmod_since > 0) {
+ if (existed && !real_clock::is_zero(op.unmod_since)) {
if (obj.mtime() >= op.unmod_since) {
return 0; /* no need to set error, we just return 0 and avoid writing to the bi log */
}
rgw_bucket_entry_ver ver;
ver.epoch = (op.olh_epoch ? op.olh_epoch : olh.get_epoch());
- utime_t mtime = ceph_clock_now(g_ceph_context); /* mtime has no real meaning in instance removal context */
+ real_time mtime = real_clock::now(); /* mtime has no real meaning in instance removal context */
ret = log_index_operation(hctx, op.key, CLS_RGW_OP_UNLINK_INSTANCE, op.op_tag,
mtime, ver,
CLS_RGW_STATE_COMPLETE, header.ver, header.max_marker,
bufferlist header_bl;
struct rgw_bucket_dir_header header;
bool header_changed = false;
- uint64_t tag_timeout;
int rc = read_bucket_header(hctx, &header);
if (rc < 0) {
return rc;
}
- tag_timeout = (header.tag_timeout ? header.tag_timeout : CEPH_RGW_TAG_TIMEOUT);
+ timespan tag_timeout(header.tag_timeout ? header.tag_timeout : CEPH_RGW_TAG_TIMEOUT);
bufferlist::iterator in_iter = in->begin();
return -EINVAL;
}
- utime_t cur_time = ceph_clock_now(g_ceph_context);
+ real_time cur_time = real_clock::now();
map<string, struct rgw_bucket_pending_info>::iterator iter =
cur_disk.pending_map.begin();
while(iter != cur_disk.pending_map.end()) {
return -EINVAL;
}
- time_t mtime;
- int ret = cls_cxx_stat(hctx, NULL, &mtime);
+ real_time obj_ut;
+ int ret = cls_cxx_stat2(hctx, NULL, &obj_ut);
if (ret < 0 && ret != -ENOENT) {
CLS_LOG(0, "ERROR: %s(): cls_cxx_stat() returned %d", __func__, ret);
return ret;
CLS_LOG(10, "object does not exist, skipping check");
}
- utime_t obj_ut(mtime, 0);
+ ceph_timespec obj_ts = ceph::real_clock::to_ceph_timespec(obj_ut);
+ ceph_timespec op_ts = ceph::real_clock::to_ceph_timespec(op.mtime);
CLS_LOG(10, "%s: obj_ut=%lld.%06lld op.mtime=%lld.%06lld", __func__,
- (long long)obj_ut.sec(), (long long)obj_ut.nsec(),
- (long long)op.mtime.sec(), (long long)op.mtime.nsec());
+ (long long)obj_ts.tv_sec, (long long)obj_ts.tv_nsec,
+ (long long)op_ts.tv_sec, (long long)op_ts.tv_nsec);
bool check;
return ret;
}
}
- info.time = ceph_clock_now(g_ceph_context);
- info.time += expiration_secs;
+ info.time = ceph::real_clock::now();
+ info.time += timespan(expiration_secs);
ret = gc_omap_set(hctx, GC_OBJ_NAME_INDEX, info.tag, &info);
if (ret < 0)
return ret;
}
if (expired_only) {
- utime_t now = ceph_clock_now(g_ceph_context);
+ real_time now = ceph::real_clock::now();
string now_str;
get_time_key(now, &now_str);
prepend_index_prefix(now_str, GC_OBJ_TIME_INDEX, &end_key);
o.exec("rgw", "obj_check_attrs_prefix", in);
}
-void cls_rgw_obj_check_mtime(librados::ObjectOperation& o, const utime_t& mtime, RGWCheckMTimeType type)
+void cls_rgw_obj_check_mtime(librados::ObjectOperation& o, const real_time& mtime, RGWCheckMTimeType type)
{
bufferlist in;
struct rgw_cls_obj_check_mtime call;
int cls_rgw_bucket_link_olh(librados::IoCtx& io_ctx, const string& oid, const cls_rgw_obj_key& key, bufferlist& olh_tag,
bool delete_marker, const string& op_tag, struct rgw_bucket_dir_entry_meta *meta,
- uint64_t olh_epoch, time_t unmod_since, bool log_op)
+ uint64_t olh_epoch, ceph::real_time unmod_since, bool log_op)
{
bufferlist in, out;
struct rgw_cls_link_olh_op call;
#include "cls_rgw_ops.h"
#include "common/RefCountedObj.h"
#include "include/compat.h"
+#include "common/ceph_time.h"
// Forward declaration
class BucketIndexAioManager;
void cls_rgw_remove_obj(librados::ObjectWriteOperation& o, list<string>& keep_attr_prefixes);
void cls_rgw_obj_store_pg_ver(librados::ObjectWriteOperation& o, const string& attr);
void cls_rgw_obj_check_attrs_prefix(librados::ObjectOperation& o, const string& prefix, bool fail_if_exist);
-void cls_rgw_obj_check_mtime(librados::ObjectOperation& o, const utime_t& mtime, RGWCheckMTimeType type);
+void cls_rgw_obj_check_mtime(librados::ObjectOperation& o, const ceph::real_time& mtime, RGWCheckMTimeType type);
int cls_rgw_bi_get(librados::IoCtx& io_ctx, const string oid,
BIIndexType index_type, cls_rgw_obj_key& key,
int cls_rgw_bucket_link_olh(librados::IoCtx& io_ctx, const string& oid, const cls_rgw_obj_key& key, bufferlist& olh_tag,
bool delete_marker, const string& op_tag, struct rgw_bucket_dir_entry_meta *meta,
- uint64_t olh_epoch, time_t unmod_since, bool log_op);
+ uint64_t olh_epoch, ceph::real_time unmod_since, bool log_op);
int cls_rgw_bucket_unlink_instance(librados::IoCtx& io_ctx, const string& oid, const cls_rgw_obj_key& key, const string& op_tag,
uint64_t olh_epoch, bool log_op);
int cls_rgw_get_olh_log(librados::IoCtx& io_ctx, string& oid, librados::ObjectReadOperation& op, const cls_rgw_obj_key& olh, uint64_t ver_marker,
#include "common/Formatter.h"
#include "common/ceph_json.h"
+#include "include/utime.h"
void rgw_cls_tag_timeout_op::dump(Formatter *f) const
{
::encode_json("olh_epoch", olh_epoch, f);
::encode_json("log_op", log_op, f);
::encode_json("bilog_flags", (uint32_t)bilog_flags, f);
- ::encode_json("unmod_since", unmod_since, f);
+ utime_t ut(unmod_since);
+ ::encode_json("unmod_since", ut, f);
}
void rgw_cls_unlink_instance_op::generate_test_instances(list<rgw_cls_unlink_instance_op*>& o)
#include <map>
#include "include/types.h"
+#include "common/ceph_time.h"
#include "cls/rgw/cls_rgw_types.h"
struct rgw_cls_tag_timeout_op
uint64_t olh_epoch;
bool log_op;
uint16_t bilog_flags;
- uint64_t unmod_since; /* only create delete marker if newer then this */
+ real_time unmod_since; /* only create delete marker if newer then this */
rgw_cls_link_olh_op() : delete_marker(false), olh_epoch(0), log_op(false), bilog_flags(0) {}
void encode(bufferlist& bl) const {
- ENCODE_START(2, 1, bl);
+ ENCODE_START(3, 1, bl);
::encode(key, bl);
::encode(olh_tag, bl);
::encode(delete_marker, bl);
::encode(olh_epoch, bl);
::encode(log_op, bl);
::encode(bilog_flags, bl);
+ time_t t = ceph::real_clock::to_time_t(unmod_since);
+ ::encode(t, bl);
::encode(unmod_since, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
- DECODE_START(2, bl);
+ DECODE_START(3, bl);
::decode(key, bl);
::decode(olh_tag, bl);
::decode(delete_marker, bl);
::decode(olh_epoch, bl);
::decode(log_op, bl);
::decode(bilog_flags, bl);
- if (struct_v >= 2) {
+ if (struct_v == 2) {
+ time_t t;
+ ::decode(t, bl);
+ unmod_since = ceph::real_clock::from_time_t(t);
+ }
+ if (struct_v >= 3) {
::decode(unmod_since, bl);
}
DECODE_FINISH(bl);
WRITE_CLASS_ENCODER(rgw_cls_obj_check_attrs_prefix)
struct rgw_cls_obj_check_mtime {
- utime_t mtime;
+ ceph::real_time mtime;
RGWCheckMTimeType type;
rgw_cls_obj_check_mtime() : type(CLS_RGW_CHECK_TIME_MTIME_EQ) {}
#include "cls/rgw/cls_rgw_types.h"
#include "common/Formatter.h"
#include "common/ceph_json.h"
+#include "include/utime.h"
void rgw_bucket_pending_info::generate_test_instances(list<rgw_bucket_pending_info*>& o)
void rgw_bucket_pending_info::dump(Formatter *f) const
{
encode_json("state", (int)state, f);
- encode_json("timestamp", timestamp, f);
+ utime_t ut(timestamp);
+ encode_json("timestamp", ut, f);
encode_json("op", (int)op, f);
}
int val;
JSONDecoder::decode_json("state", val, obj);
state = (RGWPendingState)val;
- JSONDecoder::decode_json("timestamp", timestamp, obj);
+ utime_t ut(timestamp);
+ JSONDecoder::decode_json("timestamp", ut, obj);
JSONDecoder::decode_json("op", val, obj);
op = (uint8_t)val;
}
{
encode_json("category", (int)category, f);
encode_json("size", size, f);
- encode_json("mtime", mtime, f);
+ utime_t ut(mtime);
+ encode_json("mtime", ut, f);
encode_json("etag", etag, f);
encode_json("owner", owner, f);
encode_json("owner_display_name", owner_display_name, f);
JSONDecoder::decode_json("category", val, obj);
category = (uint8_t)val;
JSONDecoder::decode_json("size", size, obj);
- JSONDecoder::decode_json("mtime", mtime, obj);
+ utime_t ut(mtime);
+ JSONDecoder::decode_json("mtime", ut, obj);
JSONDecoder::decode_json("etag", etag, obj);
JSONDecoder::decode_json("owner", owner, obj);
JSONDecoder::decode_json("owner_display_name", owner_display_name, obj);
state = CLS_RGW_STATE_UNKNOWN;
}
JSONDecoder::decode_json("index_ver", index_ver, obj);
- JSONDecoder::decode_json("timestamp", timestamp, obj);
+ utime_t ut;
+ JSONDecoder::decode_json("timestamp", ut, obj);
+ timestamp = ut.to_real_time();
uint32_t f;
JSONDecoder::decode_json("bilog_flags", f, obj);
JSONDecoder::decode_json("ver", ver, obj);
}
f->dump_int("index_ver", index_ver);
- timestamp.gmtime(f->dump_stream("timestamp"));
+ utime_t ut(timestamp);
+ ut.gmtime(f->dump_stream("timestamp"));
f->open_object_section("ver");
ver.dump(f);
f->close_section();
ls.push_back(new rgw_bi_log_entry);
ls.back()->id = "midf";
ls.back()->object = "obj";
- ls.back()->timestamp = utime_t(2, 3);
+ ls.back()->timestamp = ceph::real_clock::from_ceph_timespec({2, 3});
ls.back()->index_ver = 4323;
ls.back()->tag = "tagasdfds";
ls.back()->op = CLS_RGW_OP_DEL;
#include <map>
#include "include/types.h"
-#include "include/utime.h"
+#include "common/ceph_time.h"
#include "common/Formatter.h"
#include "rgw/rgw_basic_types.h"
struct rgw_bucket_pending_info {
RGWPendingState state;
- utime_t timestamp;
+ ceph::real_time timestamp;
uint8_t op;
rgw_bucket_pending_info() : state(CLS_RGW_STATE_PENDING_MODIFY), op(0) {}
struct rgw_bucket_dir_entry_meta {
uint8_t category;
uint64_t size;
- utime_t mtime;
+ ceph::real_time mtime;
string etag;
string owner;
string owner_display_name;
uint64_t accounted_size;
rgw_bucket_dir_entry_meta() :
- category(0), size(0), accounted_size(0) { mtime.set_from_double(0); }
+ category(0), size(0), accounted_size(0) { }
void encode(bufferlist &bl) const {
ENCODE_START(4, 3, bl);
string id;
string object;
string instance;
- utime_t timestamp;
+ ceph::real_time timestamp;
rgw_bucket_entry_ver ver;
RGWModifyOp op;
RGWPendingState state;
{
string tag;
cls_rgw_obj_chain chain;
- utime_t time;
+ ceph::real_time time;
cls_rgw_gc_obj_info() {}
ls.push_back(new cls_rgw_gc_obj_info);
ls.push_back(new cls_rgw_gc_obj_info);
ls.back()->tag = "footag";
- ls.back()->time = utime_t(21, 32);
+ ceph_timespec ts{21, 32};
+ ls.back()->time = ceph::real_clock::from_ceph_timespec(ts);
}
};
WRITE_CLASS_ENCODER(cls_rgw_gc_obj_info)
cls_user_set_buckets_op call;
call.entries = entries;
call.add = add;
- call.time = ceph_clock_now(NULL);
+ call.time = real_clock::now();
::encode(call, in);
op.exec("user", "set_buckets_info", in);
}
{
bufferlist in;
cls_user_complete_stats_sync_op call;
- call.time = ceph_clock_now(NULL);
+ call.time = real_clock::now();
::encode(call, in);
op.exec("user", "complete_stats_sync", in);
}
{
encode_json("entries", entries, f);
encode_json("add", add, f);
- encode_json("time", time, f);
+ encode_json("time", utime_t(time), f);
}
void cls_user_set_buckets_op::generate_test_instances(list<cls_user_set_buckets_op*>& ls)
op->entries.push_back(e);
}
op->add = true;
- op->time = utime_t(1, 0);
+ op->time = utime_t(1, 0).to_real_time();
ls.push_back(op);
}
void cls_user_complete_stats_sync_op::dump(Formatter *f) const
{
- encode_json("time", time, f);
+ encode_json("time", utime_t(time), f);
}
void cls_user_complete_stats_sync_op::generate_test_instances(list<cls_user_complete_stats_sync_op*>& ls)
{
ls.push_back(new cls_user_complete_stats_sync_op);
cls_user_complete_stats_sync_op *op = new cls_user_complete_stats_sync_op;
- op->time = utime_t(12345, 0);
+ op->time = utime_t(12345, 0).to_real_time();
ls.push_back(op);
}
#include "include/types.h"
#include "cls_user_types.h"
+#include "common/ceph_time.h"
struct cls_user_set_buckets_op {
list<cls_user_bucket_entry> entries;
bool add;
- utime_t time; /* op time */
+ real_time time; /* op time */
cls_user_set_buckets_op() : add(false) {}
WRITE_CLASS_ENCODER(cls_user_get_header_ret)
struct cls_user_complete_stats_sync_op {
- utime_t time;
+ real_time time;
cls_user_complete_stats_sync_op() {}
encode_json("bucket", bucket, f);
encode_json("size", size, f);
encode_json("size_rounded", size_rounded, f);
- encode_json("creation_time", creation_time, f);
+ encode_json("creation_time", utime_t(creation_time), f);
encode_json("count", count, f);
encode_json("user_stats_sync", user_stats_sync, f);
}
cls_user_gen_test_bucket(&entry->bucket, i);
entry->size = i + 1;
entry->size_rounded = i + 2;
- entry->creation_time = i + 3;
+ entry->creation_time = real_clock::from_time_t(i + 3);
entry->count = i + 4;
entry->user_stats_sync = true;
}
void cls_user_gen_test_header(cls_user_header *h)
{
cls_user_gen_test_stats(&h->stats);
- h->last_stats_sync = utime_t(1, 0);
- h->last_stats_update = utime_t(2, 0);
+ h->last_stats_sync = utime_t(1, 0).to_real_time();
+ h->last_stats_update = utime_t(2, 0).to_real_time();
}
void cls_user_header::dump(Formatter *f) const
{
encode_json("stats", stats, f);
- encode_json("last_stats_sync", last_stats_sync, f);
- encode_json("last_stats_update", last_stats_update, f);
+ encode_json("last_stats_sync", utime_t(last_stats_sync), f);
+ encode_json("last_stats_update", utime_t(last_stats_update), f);
}
void cls_user_header::generate_test_instances(list<cls_user_header*>& ls)
#include "include/encoding.h"
#include "include/types.h"
#include "include/utime.h"
+#include "common/ceph_time.h"
/*
* this needs to be compatible with with rgw_bucket, as it replaces it
cls_user_bucket bucket;
size_t size;
size_t size_rounded;
- time_t creation_time;
+ real_time creation_time;
uint64_t count;
bool user_stats_sync;
- cls_user_bucket_entry() : size(0), size_rounded(0), creation_time(0), count(0), user_stats_sync(false) {}
+ cls_user_bucket_entry() : size(0), size_rounded(0), count(0), user_stats_sync(false) {}
void encode(bufferlist& bl) const {
- ENCODE_START(6, 5, bl);
+ ENCODE_START(7, 5, bl);
uint64_t s = size;
- __u32 mt = creation_time;
+ __u32 mt = ceph::real_clock::to_time_t(creation_time);
string empty_str; // originally had the bucket name here, but we encode bucket later
::encode(empty_str, bl);
::encode(s, bl);
s = size_rounded;
::encode(s, bl);
::encode(user_stats_sync, bl);
+ ::encode(creation_time, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
::decode(s, bl);
::decode(mt, bl);
size = s;
- creation_time = mt;
+ if (struct_v < 7) {
+ creation_time = ceph::real_clock::from_time_t(mt);
+ }
if (struct_v >= 2)
::decode(count, bl);
if (struct_v >= 3)
size_rounded = s;
if (struct_v >= 6)
::decode(user_stats_sync, bl);
+ if (struct_v >= 7)
+ ::decode(creation_time, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
*/
struct cls_user_header {
cls_user_stats stats;
- utime_t last_stats_sync; /* last time a full stats sync completed */
- utime_t last_stats_update; /* last time a stats update was done */
+ ceph::real_time last_stats_sync; /* last time a full stats sync completed */
+ ceph::real_time last_stats_update; /* last time a stats update was done */
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
int bucket_stats(rgw_bucket& bucket, int shard_id, Formatter *formatter)
{
RGWBucketInfo bucket_info;
- time_t mtime;
+ real_time mtime;
RGWObjectCtx obj_ctx(store);
int r = store->get_bucket_info(obj_ctx, bucket.tenant, bucket.name, bucket_info, &mtime);
if (r < 0)
formatter->dump_string("id", bucket.bucket_id);
formatter->dump_string("marker", bucket.marker);
::encode_json("owner", bucket_info.owner, formatter);
- formatter->dump_int("mtime", mtime);
+ formatter->dump_int("mtime", utime_t(mtime));
formatter->dump_string("ver", bucket_ver);
formatter->dump_string("master_ver", master_ver);
formatter->dump_string("max_marker", max_marker);
set_quota_info(bucket_info.quota, opt_cmd, max_size, max_objects, have_max_size, have_max_objects);
- r = store->put_bucket_instance_info(bucket_info, false, 0, &attrs);
+ r = store->put_bucket_instance_info(bucket_info, false, real_time(), &attrs);
if (r < 0) {
cerr << "ERROR: failed writing bucket instance info: " << cpp_strerror(-r) << std::endl;
return -r;
if (ret < 0) {
derr << "ERROR: failed to fetch master next positions (" << cpp_strerror(-ret) << ")" << dendl;
} else {
- utime_t oldest;
+ ceph::real_time oldest;
for (auto iter : master_pos) {
rgw_mdlog_shard_data& shard_data = iter.second;
if (!shard_data.entries.empty()) {
rgw_mdlog_entry& entry = shard_data.entries.front();
- if (oldest.is_zero()) {
+ if (ceph::real_clock::is_zero(oldest)) {
oldest = entry.timestamp;
- } else if (!entry.timestamp.is_zero() && entry.timestamp < oldest) {
+ } else if (!ceph::real_clock::is_zero(entry.timestamp) && entry.timestamp < oldest) {
oldest = entry.timestamp;
}
}
}
- if (!oldest.is_zero()) {
+ if (!ceph::real_clock::is_zero(oldest)) {
push_ss(ss, status) << "oldest incremental change not applied: " << oldest;
}
}
if (ret < 0) {
derr << "ERROR: failed to fetch next positions (" << cpp_strerror(-ret) << ")" << dendl;
} else {
- utime_t oldest;
+ ceph::real_time oldest;
for (auto iter : master_pos) {
rgw_datalog_shard_data& shard_data = iter.second;
if (!shard_data.entries.empty()) {
rgw_datalog_entry& entry = shard_data.entries.front();
- if (oldest.is_zero()) {
+ if (ceph::real_clock::is_zero(oldest)) {
oldest = entry.timestamp;
- } else if (!entry.timestamp.is_zero() && entry.timestamp < oldest) {
+ } else if (!ceph::real_clock::is_zero(entry.timestamp) && entry.timestamp < oldest) {
oldest = entry.timestamp;
}
}
}
- if (!oldest.is_zero()) {
+ if (!ceph::real_clock::is_zero(oldest)) {
push_ss(ss, status, tab) << "oldest incremental change not applied: " << oldest;
}
}
formatter->dump_string("name", key.name);
formatter->dump_string("instance", key.instance);
formatter->dump_int("size", entry.size);
- utime_t ut(entry.mtime, 0);
+ utime_t ut(entry.mtime);
ut.gmtime(formatter->dump_stream("mtime"));
if ((entry.size < min_rewrite_size) ||
list<cls_log_entry> entries;
- meta_log->init_list_entries(i, start_time, end_time, marker, &handle);
-
+ meta_log->init_list_entries(i, start_time.to_real_time(), end_time.to_real_time(), marker, &handle);
bool truncated;
do {
int ret = meta_log->list_entries(handle, 1000, entries, NULL, &truncated);
}
RGWMetadataLog *meta_log = store->meta_mgr->get_log(period_id);
- ret = meta_log->trim(shard_id, start_time, end_time, start_marker, end_marker);
+ ret = meta_log->trim(shard_id, start_time.to_real_time(), end_time.to_real_time(), start_marker, end_marker);
if (ret < 0) {
cerr << "ERROR: meta_log->trim(): " << cpp_strerror(-ret) << std::endl;
return -ret;
do {
list<cls_log_entry> entries;
- ret = store->time_log_list(oid, start_time, end_time, max_entries - count, entries,
- marker, &marker, &truncated);
+ ret = store->time_log_list(oid, start_time.to_real_time(), end_time.to_real_time(),
+ max_entries - count, entries, marker, &marker, &truncated);
if (ret == -ENOENT) {
break;
}
do {
list<rgw_data_change_log_entry> entries;
- ret = log->list_entries(start_time, end_time, max_entries - count, entries, marker, &truncated);
+ ret = log->list_entries(start_time.to_real_time(), end_time.to_real_time(), max_entries - count, entries, marker, &truncated);
if (ret < 0) {
cerr << "ERROR: list_bi_log_entries(): " << cpp_strerror(-ret) << std::endl;
return -ret;
return -ret;
RGWDataChangesLog *log = store->data_log;
- ret = log->trim_entries(start_time, end_time, start_marker, end_marker);
+ ret = log->trim_entries(start_time.to_real_time(), end_time.to_real_time(), start_marker, end_marker);
if (ret < 0) {
cerr << "ERROR: trim_entries(): " << cpp_strerror(-ret) << std::endl;
return -ret;
return 0;
}
-int rgw_link_bucket(RGWRados *store, const rgw_user& user_id, rgw_bucket& bucket, time_t creation_time, bool update_entrypoint)
+int rgw_link_bucket(RGWRados *store, const rgw_user& user_id, rgw_bucket& bucket, real_time creation_time, bool update_entrypoint)
{
int ret;
string& tenant_name = bucket.tenant;
bucket.convert(&new_bucket.bucket);
new_bucket.size = 0;
- if (!creation_time)
- time(&new_bucket.creation_time);
+ if (real_clock::is_zero(creation_time))
+ new_bucket.creation_time = real_clock::now();
else
new_bucket.creation_time = creation_time;
ep.linked = true;
ep.owner = user_id;
- ret = store->put_bucket_entrypoint_info(tenant_name, bucket_name, ep, false, ot, 0, &attrs);
+ ret = store->put_bucket_entrypoint_info(tenant_name, bucket_name, ep, false, ot, real_time(), &attrs);
if (ret < 0)
goto done_err;
}
ep.linked = false;
- ret = store->put_bucket_entrypoint_info(tenant_name, bucket_name, ep, false, ot, 0, &attrs);
+ ret = store->put_bucket_entrypoint_info(tenant_name, bucket_name, ep, false, ot, real_time(), &attrs);
if (ret < 0)
return ret;
int rgw_bucket_store_info(RGWRados *store, const string& bucket_name, bufferlist& bl, bool exclusive,
map<string, bufferlist> *pattrs, RGWObjVersionTracker *objv_tracker,
- time_t mtime) {
+ real_time mtime) {
return store->meta_mgr->put_entry(bucket_meta_handler, bucket_name, bl, exclusive, objv_tracker, mtime, pattrs);
}
int rgw_bucket_instance_store_info(RGWRados *store, string& entry, bufferlist& bl, bool exclusive,
map<string, bufferlist> *pattrs, RGWObjVersionTracker *objv_tracker,
- time_t mtime) {
+ real_time mtime) {
return store->meta_mgr->put_entry(bucket_instance_meta_handler, entry, bl, exclusive, objv_tracker, mtime, pattrs);
}
::encode(bucket_info, bl);
- return rgw_bucket_instance_store_info(store, key, bl, false, &attrs, objv_tracker, 0);
+ return rgw_bucket_instance_store_info(store, key, bl, false, &attrs, objv_tracker, real_time());
}
static void dump_mulipart_index_results(list<rgw_obj_key>& objs_to_unlink,
rgw_bucket& bucket = bucket_ent.bucket;
RGWBucketInfo bucket_info;
- time_t mtime;
+ real_time mtime;
RGWObjectCtx obj_ctx(store);
int r = store->get_bucket_info(obj_ctx, user_id.tenant, bucket.name, bucket_info, &mtime);
if (r < 0) {
aclbl.clear();
policy_instance.encode(aclbl);
- string oid_bucket_instance = RGW_BUCKET_INSTANCE_MD_PREFIX + key;
+ string oid_bucket_instance = RGW_BUCKET_INSTANCE_MD_PREFIX + key;
rgw_bucket bucket_instance;
bucket_instance.name = oid_bucket_instance;
rgw_obj obj_bucket_instance(bucket_instance, no_oid);
r = store->system_obj_set_attr(NULL, obj_bucket_instance, RGW_ATTR_ACL, aclbl, &objv_tracker);
- r = rgw_link_bucket(store, user_info.user_id, bucket, 0);
+ r = rgw_link_bucket(store, user_info.user_id, bucket, real_time());
if (r < 0)
return r;
}
rgw_bucket bucket;
map<RGWObjCategory, RGWStorageStats> stats;
- time_t mtime;
+ real_time mtime;
RGWObjectCtx obj_ctx(store);
int r = store->get_bucket_info(obj_ctx, tenant_name, bucket_name, bucket_info, &mtime);
if (r < 0)
return ret;
}
- utime_t ut(mtime, 0);
+ utime_t ut(mtime);
formatter->open_object_section("stats");
formatter->dump_string("bucket", bucket.name);
}
encode_json("entity_type", type, f);
encode_json("key", key, f);
- encode_json("timestamp", timestamp, f);
+ utime_t ut(timestamp);
+ encode_json("timestamp", ut, f);
}
void rgw_data_change::decode_json(JSONObj *obj) {
entity_type = ENTITY_TYPE_UNKNOWN;
}
JSONDecoder::decode_json("key", key, obj);
- JSONDecoder::decode_json("timestamp", timestamp, obj);
+ utime_t ut;
+ JSONDecoder::decode_json("timestamp", ut, obj);
+ timestamp = ut.to_real_time();
}
void rgw_data_change_log_entry::dump(Formatter *f) const
{
encode_json("log_id", log_id, f);
- encode_json("log_timestamp", log_timestamp, f);
+ utime_t ut(log_timestamp);
+ encode_json("log_timestamp", ut, f);
encode_json("entry", entry, f);
}
void rgw_data_change_log_entry::decode_json(JSONObj *obj) {
JSONDecoder::decode_json("log_id", log_id, obj);
- JSONDecoder::decode_json("log_timestamp", log_timestamp, obj);
+ utime_t ut;
+ JSONDecoder::decode_json("log_timestamp", ut, obj);
+ log_timestamp = ut.to_real_time();
JSONDecoder::decode_json("entry", entry, obj);
}
map<rgw_bucket_shard, bool>::iterator iter;
string section;
- utime_t ut = ceph_clock_now(cct);
+ real_time ut = real_clock::now();
for (iter = entries.begin(); iter != entries.end(); ++iter) {
const rgw_bucket_shard& bs = iter->first;
const rgw_bucket& bucket = bs.bucket;
for (miter = m.begin(); miter != m.end(); ++miter) {
list<cls_log_entry>& entries = miter->second.second;
- utime_t now = ceph_clock_now(cct);
+ real_time now = real_clock::now();
int ret = store->time_log_add(oids[miter->first], entries, NULL);
if (ret < 0) {
return ret;
}
- utime_t expiration = now;
- expiration += utime_t(cct->_conf->rgw_data_log_window, 0);
+ real_time expiration = now;
+ expiration += timespan(cct->_conf->rgw_data_log_window);
list<rgw_bucket_shard>& buckets = miter->second.first;
list<rgw_bucket_shard>::iterator liter;
cur_cycle[bs] = true;
}
-void RGWDataChangesLog::update_renewed(rgw_bucket_shard& bs, utime_t& expiration)
+void RGWDataChangesLog::update_renewed(rgw_bucket_shard& bs, real_time& expiration)
{
Mutex::Locker l(lock);
ChangeStatusPtr status;
lock.Unlock();
- utime_t now = ceph_clock_now(cct);
+ real_time now = real_clock::now();
status->lock->Lock();
status->pending = true;
string& oid = oids[index];
- utime_t expiration;
+ real_time expiration;
int ret;
status->cur_sent = now;
expiration = now;
- expiration += utime_t(cct->_conf->rgw_data_log_window, 0);
+ expiration += timespan(cct->_conf->rgw_data_log_window);
status->lock->Unlock();
ret = store->time_log_add(oid, now, section, change.key, bl);
- now = ceph_clock_now(cct);
+ now = real_clock::now();
status->lock->Lock();
- } while (!ret && ceph_clock_now(cct) > expiration);
+ } while (!ret && real_clock::now() > expiration);
cond = status->cond;
status->pending = false;
status->cur_expiration = status->cur_sent; /* time of when operation started, not completed */
- status->cur_expiration += utime_t(cct->_conf->rgw_data_log_window, 0);
+ status->cur_expiration += timespan(cct->_conf->rgw_data_log_window);
status->cond = NULL;
status->lock->Unlock();
return ret;
}
-int RGWDataChangesLog::list_entries(int shard, utime_t& start_time, utime_t& end_time, int max_entries,
+int RGWDataChangesLog::list_entries(int shard, const real_time& start_time, const real_time& end_time, int max_entries,
list<rgw_data_change_log_entry>& entries,
const string& marker,
string *out_marker,
for (iter = log_entries.begin(); iter != log_entries.end(); ++iter) {
rgw_data_change_log_entry log_entry;
log_entry.log_id = iter->id;
- log_entry.log_timestamp = iter->timestamp;
+ real_time rt = iter->timestamp.to_real_time();
+ log_entry.log_timestamp = rt;
bufferlist::iterator liter = iter->data.begin();
try {
::decode(log_entry.entry, liter);
return 0;
}
-int RGWDataChangesLog::list_entries(utime_t& start_time, utime_t& end_time, int max_entries,
+int RGWDataChangesLog::list_entries(const real_time& start_time, const real_time& end_time, int max_entries,
list<rgw_data_change_log_entry>& entries, LogMarker& marker, bool *ptruncated) {
bool truncated;
entries.clear();
return ret;
info->marker = header.max_marker;
- info->last_update = header.max_time;
+ info->last_update = header.max_time.to_real_time();
return 0;
}
-int RGWDataChangesLog::trim_entries(int shard_id, const utime_t& start_time, const utime_t& end_time,
+int RGWDataChangesLog::trim_entries(int shard_id, const real_time& start_time, const real_time& end_time,
const string& start_marker, const string& end_marker)
{
int ret;
return ret;
}
-int RGWDataChangesLog::trim_entries(const utime_t& start_time, const utime_t& end_time,
+int RGWDataChangesLog::trim_entries(const real_time& start_time, const real_time& end_time,
const string& start_marker, const string& end_marker)
{
for (int shard = 0; shard < num_shards; shard++) {
RGWObjVersionTracker ot;
RGWBucketEntryPoint be;
- time_t mtime;
+ real_time mtime;
map<string, bufferlist> attrs;
RGWObjectCtx obj_ctx(store);
}
int put(RGWRados *store, string& entry, RGWObjVersionTracker& objv_tracker,
- time_t mtime, JSONObj *obj, sync_type_t sync_type) {
+ real_time mtime, JSONObj *obj, sync_type_t sync_type) {
RGWBucketEntryPoint be, old_be;
try {
decode_json_obj(be, obj);
return -EINVAL;
}
- time_t orig_mtime;
+ real_time orig_mtime;
map<string, bufferlist> attrs;
RGWObjVersionTracker old_ot;
int get(RGWRados *store, string& oid, RGWMetadataObject **obj) {
RGWBucketCompleteInfo bci;
- time_t mtime;
+ real_time mtime;
RGWObjectCtx obj_ctx(store);
int ret = store->get_bucket_instance_info(obj_ctx, oid, bci.info, &mtime, &bci.attrs);
}
int put(RGWRados *store, string& entry, RGWObjVersionTracker& objv_tracker,
- time_t mtime, JSONObj *obj, sync_type_t sync_type) {
+ real_time mtime, JSONObj *obj, sync_type_t sync_type) {
RGWBucketCompleteInfo bci, old_bci;
try {
decode_json_obj(bci, obj);
return -EINVAL;
}
- time_t orig_mtime;
+ real_time orig_mtime;
RGWObjectCtx obj_ctx(store);
int ret = store->get_bucket_instance_info(obj_ctx, entry, old_bci.info,
#include "common/Formatter.h"
#include "common/lru_map.h"
+#include "common/ceph_time.h"
#include "rgw_formats.h"
extern int rgw_bucket_store_info(RGWRados *store, const string& bucket_name, bufferlist& bl, bool exclusive,
map<string, bufferlist> *pattrs, RGWObjVersionTracker *objv_tracker,
- time_t mtime);
+ real_time mtime);
extern int rgw_bucket_instance_store_info(RGWRados *store, string& oid, bufferlist& bl, bool exclusive,
map<string, bufferlist> *pattrs, RGWObjVersionTracker *objv_tracker,
- time_t mtime);
+ real_time mtime);
extern int rgw_bucket_parse_bucket_instance(const string& bucket_instance, string *target_bucket_instance, int *shard_id);
class RGWBucketEntryMetadataObject : public RGWMetadataObject {
RGWBucketEntryPoint ep;
public:
- RGWBucketEntryMetadataObject(RGWBucketEntryPoint& _ep, obj_version& v, time_t m) : ep(_ep) {
+ RGWBucketEntryMetadataObject(RGWBucketEntryPoint& _ep, obj_version& v, real_time m) : ep(_ep) {
objv = v;
mtime = m;
}
RGWBucketCompleteInfo info;
public:
RGWBucketInstanceMetadataObject() {}
- RGWBucketInstanceMetadataObject(RGWBucketCompleteInfo& i, obj_version& v, time_t m) : info(i) {
+ RGWBucketInstanceMetadataObject(RGWBucketCompleteInfo& i, obj_version& v, real_time m) : info(i) {
objv = v;
mtime = m;
}
bool* is_truncated,
uint64_t default_amount = 1000);
-extern int rgw_link_bucket(RGWRados *store, const rgw_user& user_id, rgw_bucket& bucket, time_t creation_time, bool update_entrypoint = true);
+extern int rgw_link_bucket(RGWRados *store, const rgw_user& user_id, rgw_bucket& bucket, real_time creation_time, bool update_entrypoint = true);
extern int rgw_unlink_bucket(RGWRados *store, const rgw_user& user_id,
const string& tenant_name, const string& bucket_name, bool update_entrypoint = true);
struct rgw_data_change {
DataLogEntityType entity_type;
string key;
- utime_t timestamp;
+ real_time timestamp;
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
struct rgw_data_change_log_entry {
string log_id;
- utime_t log_timestamp;
+ real_time log_timestamp;
rgw_data_change entry;
void encode(bufferlist& bl) const {
struct RGWDataChangesLogInfo {
string marker;
- utime_t last_update;
+ real_time last_update;
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
atomic_t down_flag;
struct ChangeStatus {
- utime_t cur_expiration;
- utime_t cur_sent;
+ real_time cur_expiration;
+ real_time cur_sent;
bool pending;
RefCountedCond *cond;
Mutex *lock;
void _get_change(const rgw_bucket_shard& bs, ChangeStatusPtr& status);
void register_renew(rgw_bucket_shard& bs);
- void update_renewed(rgw_bucket_shard& bs, utime_t& expiration);
+ void update_renewed(rgw_bucket_shard& bs, real_time& expiration);
class ChangesRenewThread : public Thread {
CephContext *cct;
int add_entry(rgw_bucket& bucket, int shard_id);
int get_log_shard_id(rgw_bucket& bucket, int shard_id);
int renew_entries();
- int list_entries(int shard, utime_t& start_time, utime_t& end_time, int max_entries,
+ int list_entries(int shard, const real_time& start_time, const real_time& end_time, int max_entries,
list<rgw_data_change_log_entry>& entries,
const string& marker,
string *out_marker,
bool *truncated);
- int trim_entries(int shard_id, const utime_t& start_time, const utime_t& end_time,
+ int trim_entries(int shard_id, const real_time& start_time, const real_time& end_time,
const string& start_marker, const string& end_marker);
- int trim_entries(const utime_t& start_time, const utime_t& end_time,
+ int trim_entries(const real_time& start_time, const real_time& end_time,
const string& start_marker, const string& end_marker);
int get_info(int shard_id, RGWDataChangesLogInfo *info);
- int lock_exclusive(int shard_id, utime_t& duration, string& zone_id, string& owner_id) {
+ int lock_exclusive(int shard_id, timespan duration, string& zone_id, string& owner_id) {
return store->lock_exclusive(store->get_zone_params().log_pool, oids[shard_id], duration, zone_id, owner_id);
}
int unlock(int shard_id, string& zone_id, string& owner_id) {
LogMarker() : shard(0) {}
};
- int list_entries(utime_t& start_time, utime_t& end_time, int max_entries,
+ int list_entries(const real_time& start_time, const real_time& end_time, int max_entries,
list<rgw_data_change_log_entry>& entries, LogMarker& marker, bool *ptruncated);
void mark_modified(int shard_id, rgw_bucket_shard& bs);
struct ObjectMetaInfo {
uint64_t size;
- time_t mtime;
+ real_time mtime;
- ObjectMetaInfo() : size(0), mtime(0) {}
+ ObjectMetaInfo() : size(0) {}
void encode(bufferlist& bl) const {
ENCODE_START(2, 2, bl);
::encode(size, bl);
- utime_t t(mtime, 0);
- ::encode(t, bl);
+ ::encode(mtime, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
::decode(size, bl);
- utime_t t;
- ::decode(t, bl);
- mtime = t.sec();
+ ::decode(mtime, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
map<string, bufferlist>& attrs,
map<string, bufferlist>* rmattrs,
RGWObjVersionTracker *objv_tracker);
- int put_system_obj_impl(rgw_obj& obj, uint64_t size, time_t *mtime,
+ int put_system_obj_impl(rgw_obj& obj, uint64_t size, real_time *mtime,
map<std::string, bufferlist>& attrs, int flags,
bufferlist& data,
RGWObjVersionTracker *objv_tracker,
- time_t set_mtime);
+ real_time set_mtime);
int put_system_obj_data(void *ctx, rgw_obj& obj, bufferlist& bl, off_t ofs, bool exclusive);
int get_system_obj(RGWObjectCtx& obj_ctx, RGWRados::SystemObject::Read::GetObjState& read_state,
map<string, bufferlist> *attrs,
rgw_cache_entry_info *cache_info);
- int raw_obj_stat(rgw_obj& obj, uint64_t *psize, time_t *pmtime, uint64_t *epoch, map<string, bufferlist> *attrs,
+ int raw_obj_stat(rgw_obj& obj, uint64_t *psize, real_time *pmtime, uint64_t *epoch, map<string, bufferlist> *attrs,
bufferlist *first_chunk, RGWObjVersionTracker *objv_tracker);
int delete_system_obj(rgw_obj& obj, RGWObjVersionTracker *objv_tracker);
}
template <class T>
-int RGWCache<T>::put_system_obj_impl(rgw_obj& obj, uint64_t size, time_t *mtime,
+int RGWCache<T>::put_system_obj_impl(rgw_obj& obj, uint64_t size, real_time *mtime,
map<std::string, bufferlist>& attrs, int flags,
bufferlist& data,
RGWObjVersionTracker *objv_tracker,
- time_t set_mtime)
+ real_time set_mtime)
{
rgw_bucket bucket;
string oid;
info.version = objv_tracker->write_version;
info.flags |= CACHE_FLAG_OBJV;
}
- time_t result_mtime;
+ ceph::real_time result_mtime;
int ret = T::put_system_obj_impl(obj, size, &result_mtime, attrs, flags, data,
- objv_tracker, set_mtime);
+ objv_tracker, set_mtime);
if (mtime) {
*mtime = result_mtime;
}
}
template <class T>
-int RGWCache<T>::raw_obj_stat(rgw_obj& obj, uint64_t *psize, time_t *pmtime,
+int RGWCache<T>::raw_obj_stat(rgw_obj& obj, uint64_t *psize, real_time *pmtime,
uint64_t *pepoch, map<string, bufferlist> *attrs,
bufferlist *first_chunk, RGWObjVersionTracker *objv_tracker)
{
string name = normal_name(bucket, oid);
uint64_t size;
- time_t mtime;
+ real_time mtime;
uint64_t epoch;
ObjectCacheInfo info;
return parse_rfc850(s, t) || parse_asctime(s, t) || parse_rfc1123(s, t) || parse_rfc1123_alt(s,t);
}
-bool parse_iso8601(const char *s, struct tm *t, bool extended_format)
+bool parse_iso8601(const char *s, struct tm *t, uint32_t *pns, bool extended_format)
{
memset(t, 0, sizeof(*t));
const char *p;
return false;
uint32_t ms;
- int r = stringtoul(str.substr(1, len - 2), &ms);
+ string nsstr = str.substr(1, len - 2);
+ int r = stringtoul(nsstr, &ms);
if (r < 0)
return false;
+ if (!pns) {
+ return true;
+ }
+
+ if (nsstr.size() > 9) {
+ nsstr = nsstr.substr(0, 9);
+ }
+
+ uint64_t mul_table[] = { 0,
+ 100000000LL,
+ 10000000LL,
+ 1000000LL,
+ 100000LL,
+ 10000LL,
+ 1000LL,
+ 100LL,
+ 10LL,
+ 1 };
+
+
+ *pns = ms * mul_table[nsstr.size()];
+
return true;
}
return parse_key_value(in_str, "=", key,val);
}
-int parse_time(const char *time_str, time_t *time)
+int parse_time(const char *time_str, real_time *time)
{
struct tm tm;
if (!parse_rfc2616(time_str, &tm))
return -EINVAL;
- *time = timegm(&tm);
+ time_t sec = timegm(&tm);
+ *time = utime_t(sec, 0).to_real_time();
return 0;
}
rgw_user owner;
uint32_t flags;
string zonegroup;
- time_t creation_time;
+ ceph::real_time creation_time;
string placement_rule;
bool has_instance_obj;
RGWObjVersionTracker objv_tracker; /* we don't need to serialize this, for runtime tracking */
void encode(bufferlist& bl) const {
- ENCODE_START(16, 4, bl);
+ ENCODE_START(17, 4, bl);
::encode(bucket, bl);
::encode(owner.id, bl);
::encode(flags, bl);
::encode(zonegroup, bl);
- uint64_t ct = (uint64_t)creation_time;
+ uint64_t ct = real_clock::to_time_t(creation_time);
::encode(ct, bl);
::encode(placement_rule, bl);
::encode(has_instance_obj, bl);
if (swift_versioning) {
::encode(swift_ver_location, bl);
}
+ ::encode(creation_time, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
- DECODE_START_LEGACY_COMPAT_LEN_32(16, 4, 4, bl);
+ DECODE_START_LEGACY_COMPAT_LEN_32(17, 4, 4, bl);
::decode(bucket, bl);
if (struct_v >= 2) {
string s;
::decode(flags, bl);
if (struct_v >= 5)
::decode(zonegroup, bl);
- if (struct_v >= 6) {
- uint64_t ct;
- ::decode(ct, bl);
- creation_time = (time_t)ct;
+ uint64_t ct;
+ ::decode(ct, bl);
+ if (struct_v >= 6 && struct_v < 17) {
+ creation_time = ceph::real_clock::from_time_t((time_t)ct);
}
if (struct_v >= 7)
::decode(placement_rule, bl);
::decode(swift_ver_location, bl);
}
}
+ if (struct_v >= 17) {
+ ::decode(creation_time, bl);
+ }
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
bool has_swift_versioning() { return swift_versioning; }
- RGWBucketInfo() : flags(0), creation_time(0), has_instance_obj(false), num_shards(0), bucket_index_shard_hash_type(MOD), requester_pays(false),
+ RGWBucketInfo() : flags(0), has_instance_obj(false), num_shards(0), bucket_index_shard_hash_type(MOD), requester_pays(false),
has_website(false), swift_versioning(false) {}
};
WRITE_CLASS_ENCODER(RGWBucketInfo)
{
rgw_bucket bucket;
rgw_user owner;
- time_t creation_time;
+ ceph::real_time creation_time;
bool linked;
bool has_bucket_info;
RGWBucketInfo old_bucket_info;
- RGWBucketEntryPoint() : creation_time(0), linked(false), has_bucket_info(false) {}
+ RGWBucketEntryPoint() : linked(false), has_bucket_info(false) {}
void encode(bufferlist& bl) const {
- ENCODE_START(9, 8, bl);
+ ENCODE_START(10, 8, bl);
::encode(bucket, bl);
::encode(owner.id, bl);
::encode(linked, bl);
- uint64_t ctime = (uint64_t)creation_time;
+ uint64_t ctime = (uint64_t)real_clock::to_time_t(creation_time);
::encode(ctime, bl);
::encode(owner, bl);
+ ::encode(creation_time, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
bufferlist::iterator orig_iter = bl;
- DECODE_START_LEGACY_COMPAT_LEN_32(9, 4, 4, bl);
+ DECODE_START_LEGACY_COMPAT_LEN_32(10, 4, 4, bl);
if (struct_v < 8) {
/* ouch, old entry, contains the bucket info itself */
old_bucket_info.decode(orig_iter);
::decode(linked, bl);
uint64_t ctime;
::decode(ctime, bl);
- creation_time = (uint64_t)ctime;
+ if (struct_v < 10) {
+ creation_time = real_clock::from_time_t((time_t)ctime);
+ }
if (struct_v >= 9) {
::decode(owner, bl);
}
+ if (struct_v >= 10) {
+ ::decode(creation_time, bl);
+ }
DECODE_FINISH(bl);
}
rgw_user owner;
std::string owner_display_name;
uint64_t size;
- utime_t mtime;
+ ceph::real_time mtime;
string etag;
string content_type;
string tag;
rgw_bucket bucket;
size_t size;
size_t size_rounded;
- time_t creation_time;
+ real_time creation_time;
uint64_t count;
- RGWBucketEnt() : size(0), size_rounded(0), creation_time(0), count(0) {}
+ RGWBucketEnt() : size(0), size_rounded(0), count(0) {}
explicit RGWBucketEnt(const cls_user_bucket_entry& e) : bucket(e.bucket),
size(e.size),
}
void encode(bufferlist& bl) const {
- ENCODE_START(5, 5, bl);
+ ENCODE_START(6, 5, bl);
uint64_t s = size;
- __u32 mt = creation_time;
+ __u32 mt = ceph::real_clock::to_time_t(creation_time);
string empty_str; // originally had the bucket name here, but we encode bucket later
::encode(empty_str, bl);
::encode(s, bl);
::encode(bucket, bl);
s = size_rounded;
::encode(s, bl);
+ ::encode(creation_time, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
- DECODE_START_LEGACY_COMPAT_LEN(5, 5, 5, bl);
+ DECODE_START_LEGACY_COMPAT_LEN(6, 5, 5, bl);
__u32 mt;
uint64_t s;
string empty_str; // backward compatibility
::decode(s, bl);
::decode(mt, bl);
size = s;
- creation_time = mt;
+ if (struct_v < 6) {
+ creation_time = ceph::real_clock::from_time_t(mt);
+ }
if (struct_v >= 2)
::decode(count, bl);
if (struct_v >= 3)
if (struct_v >= 4)
::decode(s, bl);
size_rounded = s;
+ if (struct_v >= 6)
+ ::decode(creation_time, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
extern int parse_key_value(string& in_str, string& key, string& val);
extern int parse_key_value(string& in_str, const char *delim, string& key, string& val);
/** time parsing */
-extern int parse_time(const char *time_str, time_t *time);
+extern int parse_time(const char *time_str, real_time *time);
extern bool parse_rfc2616(const char *s, struct tm *t);
-extern bool parse_iso8601(const char *s, struct tm *t, bool extended_format = true);
+extern bool parse_iso8601(const char *s, struct tm *t, uint32_t *pns = NULL, bool extended_format = true);
extern string rgw_trim_whitespace(const string& src);
extern string rgw_trim_quotes(const string& val);
attrs,
RGW_OBJ_CATEGORY_MAIN,
versioned_epoch,
- 0, /* delete_at */
+ real_time(), /* delete_at */
&key.instance, /* string *version_id, */
NULL, /* string *ptag, */
NULL, /* string *petag, */
RGWStatObjCR::RGWStatObjCR(RGWAsyncRadosProcessor *async_rados, RGWRados *store,
const rgw_obj& obj, uint64_t *psize,
- time_t *pmtime, uint64_t *pepoch,
+ ceph::real_time *pmtime, uint64_t *pepoch,
RGWObjVersionTracker *objv_tracker)
: RGWSimpleCoroutine(store->ctx()), store(store), async_rados(async_rados),
obj(obj), psize(psize), pmtime(pmtime), pepoch(pepoch),
string marker_version_id;
bool del_if_older;
- utime_t timestamp;
+ ceph::real_time timestamp;
protected:
int _send_request();
uint64_t _versioned_epoch,
bool _delete_marker,
bool _if_older,
- utime_t& _timestamp) : RGWAsyncRadosRequest(cn), store(_store),
+ real_time& _timestamp) : RGWAsyncRadosRequest(cn), store(_store),
source_zone(_source_zone),
bucket_info(_bucket_info),
key(_key),
string owner_display_name;
bool del_if_older;
- utime_t timestamp;
+ real_time timestamp;
RGWAsyncRemoveObj *req;
string *_owner,
string *_owner_display_name,
bool _delete_marker,
- utime_t *_timestamp) : RGWSimpleCoroutine(_store->ctx()), cct(_store->ctx()),
+ real_time *_timestamp) : RGWSimpleCoroutine(_store->ctx()), cct(_store->ctx()),
async_rados(_async_rados), store(_store),
source_zone(_source_zone),
bucket_info(_bucket_info),
RGWRados *store;
rgw_obj obj;
uint64_t *psize;
- time_t *pmtime;
+ ceph::real_time *pmtime;
uint64_t *pepoch;
RGWObjVersionTracker *objv_tracker;
protected:
public:
RGWAsyncStatObj(RGWAioCompletionNotifier *cn, RGWRados *store,
const rgw_obj& obj, uint64_t *psize = nullptr,
- time_t *pmtime = nullptr, uint64_t *pepoch = nullptr,
+ ceph::real_time *pmtime = nullptr, uint64_t *pepoch = nullptr,
RGWObjVersionTracker *objv_tracker = nullptr)
: RGWAsyncRadosRequest(cn), store(store), obj(obj), psize(psize),
pmtime(pmtime), pepoch(pepoch), objv_tracker(objv_tracker) {}
RGWAsyncRadosProcessor *async_rados;
rgw_obj obj;
uint64_t *psize;
- time_t *pmtime;
+ ceph::real_time *pmtime;
uint64_t *pepoch;
RGWObjVersionTracker *objv_tracker;
RGWAsyncStatObj *req = nullptr;
public:
RGWStatObjCR(RGWAsyncRadosProcessor *async_rados, RGWRados *store,
const rgw_obj& obj, uint64_t *psize = nullptr,
- time_t *pmtime = nullptr, uint64_t *pepoch = nullptr,
+ ceph::real_time *pmtime = nullptr, uint64_t *pepoch = nullptr,
RGWObjVersionTracker *objv_tracker = nullptr);
~RGWStatObjCR();
JSONDecoder::decode_json("num_objects", num_shards, obj);
}
-
void rgw_datalog_entry::decode_json(JSONObj *obj) {
JSONDecoder::decode_json("key", key, obj);
- JSONDecoder::decode_json("timestamp", timestamp, obj);
+ utime_t ut;
+ JSONDecoder::decode_json("timestamp", ut, obj);
+ timestamp = ut.to_real_time();
}
void rgw_datalog_shard_data::decode_json(JSONObj *obj) {
marker_oid(_marker_oid),
sync_marker(_marker) {}
- RGWCoroutine *store_marker(const string& new_marker, uint64_t index_pos, const utime_t& timestamp) {
+ RGWCoroutine *store_marker(const string& new_marker, uint64_t index_pos, const real_time& timestamp) {
sync_marker.marker = new_marker;
sync_marker.pos = index_pos;
for (; iter != entries.end(); ++iter) {
ldout(sync_env->cct, 20) << __func__ << ": full sync: " << iter->first << dendl;
total_entries++;
- if (!marker_tracker->start(iter->first, total_entries, utime_t())) {
+ if (!marker_tracker->start(iter->first, total_entries, real_time())) {
ldout(sync_env->cct, 0) << "ERROR: cannot start syncing " << iter->first << ". Duplicate entry?" << dendl;
} else {
// fetch remote and write locally
bool delete_marker;
rgw_obj_key key;
bool is_latest;
- utime_t mtime;
+ real_time mtime;
string etag;
uint64_t size;
string storage_class;
JSONDecoder::decode_json("LastModified", mtime_str, obj);
struct tm t;
- if (parse_iso8601(mtime_str.c_str(), &t)) {
- time_t sec = timegm(&t);
-
- /* FIXME: eventually we'll want to have a high def clock for rgw objects */
- mtime = utime_t(sec, 0);
+ uint32_t nsec;
+ if (parse_iso8601(mtime_str.c_str(), &t, &nsec)) {
+ ceph_timespec ts;
+ ts.tv_sec = (uint64_t)timegm(&t);
+ ts.tv_nsec = nsec;
+ mtime = real_clock::from_ceph_timespec(ts);
}
JSONDecoder::decode_json("ETag", etag, obj);
JSONDecoder::decode_json("Size", size, obj);
marker_oid(_marker_oid),
sync_marker(_marker) {}
- RGWCoroutine *store_marker(const rgw_obj_key& new_marker, uint64_t index_pos, const utime_t& timestamp) {
+ RGWCoroutine *store_marker(const rgw_obj_key& new_marker, uint64_t index_pos, const real_time& timestamp) {
sync_marker.position = new_marker;
sync_marker.count = index_pos;
marker_oid(_marker_oid),
sync_marker(_marker) {}
- RGWCoroutine *store_marker(const string& new_marker, uint64_t index_pos, const utime_t& timestamp) {
+ RGWCoroutine *store_marker(const string& new_marker, uint64_t index_pos, const real_time& timestamp) {
sync_marker.position = new_marker;
map<string, bufferlist> attrs;
bool versioned;
uint64_t versioned_epoch;
bucket_entry_owner owner;
- utime_t timestamp;
+ real_time timestamp;
RGWModifyOp op;
RGWPendingState op_state;
RGWBucketSyncSingleEntryCR(RGWDataSyncEnv *_sync_env,
RGWBucketInfo *_bucket_info, int _shard_id,
const rgw_obj_key& _key, bool _versioned, uint64_t _versioned_epoch,
- utime_t& _timestamp,
+ real_time& _timestamp,
const bucket_entry_owner& _owner,
RGWModifyOp _op, RGWPendingState _op_state,
const T& _entry_marker, RGWSyncShardMarkerTrack<T, K> *_marker_tracker) : RGWCoroutine(_sync_env->cct),
entry = &(*entries_iter);
total_entries++;
list_marker = entries_iter->key;
- if (!marker_tracker->start(entry->key, total_entries, utime_t())) {
+ if (!marker_tracker->start(entry->key, total_entries, real_time())) {
ldout(sync_env->cct, 0) << "ERROR: cannot start syncing " << entry->key << ". Duplicate entry?" << dendl;
} else {
op = (entry->key.instance.empty() || entry->key.instance == "null" ? CLS_RGW_OP_ADD : CLS_RGW_OP_LINK_OLH);
if (entry->ver.pool < 0) {
versioned_epoch = entry->ver.epoch;
}
+ldout(sync_env->cct, 0) << __FILE__ << ":" << __LINE__ << " entry->timestamp=" << entry->timestamp << dendl;
spawn(new RGWBucketSyncSingleEntryCR<string, rgw_obj_key>(sync_env, bucket_info, shard_id,
key, entry->is_versioned(), versioned_epoch, entry->timestamp, owner, entry->op,
entry->state, entry->id, marker_tracker), false);
string next_step_marker;
uint64_t total_entries;
uint64_t pos;
- utime_t timestamp;
+ real_time timestamp;
rgw_data_sync_marker() : state(FullSync), total_entries(0), pos(0) {}
encode_json("next_step_marker", next_step_marker, f);
encode_json("total_entries", total_entries, f);
encode_json("pos", pos, f);
- encode_json("timestamp", timestamp, f);
+ encode_json("timestamp", utime_t(timestamp), f);
}
};
WRITE_CLASS_ENCODER(rgw_data_sync_marker)
struct rgw_datalog_entry {
string key;
- utime_t timestamp;
+ ceph::real_time timestamp;
void decode_json(JSONObj *obj);
};
if (get<0>(fhr)) {
RGWFileHandle* rgw_fh = get<0>(fhr);
rgw_fh->set_size(req.get_size());
- rgw_fh->set_mtime({req.get_mtime(), 0});
+ rgw_fh->set_mtime(real_clock::to_timespec(req.get_mtime()));
}
goto done;
}
attrs[RGW_ATTR_SLO_UINDICATOR] = slo_userindicator_bl;
}
- op_ret = processor->complete(etag, &mtime, 0, attrs, delete_at, if_match,
+ op_ret = processor->complete(etag, &mtime, real_time(), attrs, delete_at, if_match,
if_nomatch);
if (! op_ret) {
/* update stats */
- rgw_fh->set_mtime({mtime, 0});
+ rgw_fh->set_mtime(real_clock::to_timespec(mtime));
rgw_fh->set_size(bytes_written);
}
if (rgw_fh) {
if (get<1>(fhr) & RGWFileHandle::FLAG_CREATE) {
/* fill in stat data */
- time_t now = time(0);
- rgw_fh->set_times(now);
+ rgw_fh->set_times(real_clock::now());
rgw_fh->open_for_create(); // XXX needed?
}
(void) rgw_fh->stat(st);
rgw_fh = get<0>(fhr);
if (rgw_fh) {
/* XXX unify timestamps */
- time_t now = time(0);
- rgw_fh->set_times(now);
+ rgw_fh->set_times(real_clock::now());
rgw_fh->stat(st);
struct rgw_file_handle *rfh = rgw_fh->get_fh();
*fh = rfh;
state.size = size;
}
- void set_times(time_t t) {
- state.ctime = {t, 0};
- state.mtime = {t, 0};
- state.atime = {t, 0};
+ void set_times(real_time t) {
+ state.ctime = real_clock::to_timespec(t);
+ state.mtime = state.ctime;
+ state.atime = state.ctime;
}
void set_ctime(const struct timespec &ts) {
if (ldh->auth(token.id, token.key) == 0) {
/* try to store user if it doesn't already exist */
if (rgw_get_user_info_by_uid(store, token.id, user) < 0) {
- int ret = rgw_store_user_info(store, user, NULL, NULL, 0,
+ int ret = rgw_store_user_info(store, user, NULL, NULL, real_time(),
true);
if (ret < 0) {
lsubdout(get_context(), rgw, 10)
virtual const string name() { return "stat_obj"; }
virtual RGWOpType get_type() { return RGW_OP_STAT_OBJ; }
- time_t get_mtime() const {
+ real_time get_mtime() const {
return lastmod;
}
/* attributes */
uint64_t get_size() { return _size; }
- time_t ctime() { return mod_time; } // XXX
- time_t mtime() { return mod_time; }
+ real_time ctime() { return mod_time; } // XXX
+ real_time mtime() { return mod_time; }
map<string, bufferlist>& get_attrs() { return attrs; }
virtual bool only_bucket() { return false; }
return 0;
}
- time_t get_ctime() const {
+ real_time get_ctime() const {
return bucket.creation_time;
}
void RGWOLHPendingInfo::dump(Formatter *f) const
{
- encode_json("time", time, f);
+ utime_t ut(time);
+ encode_json("time", ut, f);
}
void RGWObjManifestPart::dump(Formatter *f) const
void ObjectMetaInfo::dump(Formatter *f) const
{
encode_json("size", size, f);
- encode_json("mtime", mtime, f);
+ encode_json("mtime", utime_t(mtime), f);
}
void ObjectCacheInfo::dump(Formatter *f) const
{
encode_json("bucket", bucket, f);
encode_json("owner", owner, f);
- encode_json("creation_time", creation_time, f);
+ utime_t ut(creation_time);
+ encode_json("creation_time", ut, f);
encode_json("linked", linked, f);
encode_json("has_bucket_info", has_bucket_info, f);
if (has_bucket_info) {
void RGWBucketEntryPoint::decode_json(JSONObj *obj) {
JSONDecoder::decode_json("bucket", bucket, obj);
JSONDecoder::decode_json("owner", owner, obj);
- JSONDecoder::decode_json("creation_time", creation_time, obj);
+ utime_t ut(creation_time);
+ JSONDecoder::decode_json("creation_time", ut, obj);
JSONDecoder::decode_json("linked", linked, obj);
JSONDecoder::decode_json("has_bucket_info", has_bucket_info, obj);
if (has_bucket_info) {
void RGWBucketInfo::dump(Formatter *f) const
{
encode_json("bucket", bucket, f);
- encode_json("creation_time", creation_time, f);
+ utime_t ut(creation_time);
+ encode_json("creation_time", ut, f);
encode_json("owner", owner.to_str(), f);
encode_json("flags", flags, f);
encode_json("zonegroup", zonegroup, f);
void RGWBucketInfo::decode_json(JSONObj *obj) {
JSONDecoder::decode_json("bucket", bucket, obj);
- JSONDecoder::decode_json("creation_time", creation_time, obj);
+ utime_t ut(creation_time);
+ JSONDecoder::decode_json("creation_time", ut, obj);
JSONDecoder::decode_json("owner", owner, obj);
JSONDecoder::decode_json("flags", flags, obj);
JSONDecoder::decode_json("zonegroup", zonegroup, obj);
encode_json("owner", owner.to_str(), f);
encode_json("owner_display_name", owner_display_name, f);
encode_json("size", size, f);
- encode_json("mtime", mtime, f);
+ utime_t ut(mtime);
+ encode_json("mtime", ut, f);
encode_json("etag", etag, f);
encode_json("content_type", content_type, f);
encode_json("tag", tag, f);
encode_json("bucket", bucket, f);
encode_json("size", size, f);
encode_json("size_rounded", size_rounded, f);
- encode_json("mtime", creation_time, f); /* mtime / creation time discrepency needed for backward compatibility */
+ utime_t ut(creation_time);
+ encode_json("mtime", ut, f); /* mtime / creation time discrepency needed for backward compatibility */
encode_json("count", count, f);
}
encode_json("num", num, f);
encode_json("size", size, f);
encode_json("etag", etag, f);
- encode_json("modified", modified, f);
+ utime_t ut(modified);
+ encode_json("modified", ut, f);
}
void rgw_obj::dump(Formatter *f) const
void RGWMetadataLogInfo::dump(Formatter *f) const
{
encode_json("marker", marker, f);
- encode_json("last_update", last_update, f);
+ utime_t ut(last_update);
+ encode_json("last_update", ut, f);
}
void RGWMetadataLogInfo::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("marker", marker, obj);
- JSONDecoder::decode_json("last_update", last_update, obj);
+ utime_t ut(last_update);
+ JSONDecoder::decode_json("last_update", ut, obj);
}
void RGWDataChangesLogInfo::dump(Formatter *f) const
{
encode_json("marker", marker, f);
- encode_json("last_update", last_update, f);
+ utime_t ut(last_update);
+ encode_json("last_update", ut, f);
}
void RGWDataChangesLogInfo::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("marker", marker, obj);
- JSONDecoder::decode_json("last_update", last_update, obj);
+ utime_t ut(last_update);
+ JSONDecoder::decode_json("last_update", ut, obj);
}
JSONDecoder::decode_json("next_step_marker", next_step_marker, obj);
JSONDecoder::decode_json("total_entries", total_entries, obj);
JSONDecoder::decode_json("pos", pos, obj);
- JSONDecoder::decode_json("timestamp", timestamp, obj);
+ utime_t ut;
+ JSONDecoder::decode_json("timestamp", ut, obj);
+ timestamp = ut.to_real_time();
}
void rgw_meta_sync_marker::dump(Formatter *f) const
encode_json("next_step_marker", next_step_marker, f);
encode_json("total_entries", total_entries, f);
encode_json("pos", pos, f);
- encode_json("timestamp", timestamp, f);
+ encode_json("timestamp", utime_t(timestamp), f);
}
void rgw_meta_sync_status::decode_json(JSONObj *obj)
bool account;
string u = user.to_str();
rgw_user_bucket ub(u, entry.bucket);
- usage_map[ub].insert(round_timestamp, entry, &account);
+ real_time rt = round_timestamp.to_real_time();
+ usage_map[ub].insert(rt, entry, &account);
if (account)
num_entries++;
bool need_flush = (num_entries > cct->_conf->rgw_usage_log_flush_threshold);
#include <string>
+#include "common/ceph_time.h"
+
struct rgw_meta_sync_info {
enum SyncState {
StateInit = 0,
string next_step_marker;
uint64_t total_entries;
uint64_t pos;
- utime_t timestamp;
+ real_time timestamp;
rgw_meta_sync_marker() : state(FullSync), total_entries(0), pos(0) {}
int shard_id;
store->shard_name(prefix, cct->_conf->rgw_md_log_max_shards, hash_key, oid, &shard_id);
mark_modified(shard_id);
- utime_t now = ceph_clock_now(cct);
+ real_time now = real_clock::now();
return store->time_log_add(oid, now, section, key, bl);
}
return store->time_log_add(oid, entries, completion, false);
}
-void RGWMetadataLog::init_list_entries(int shard_id, utime_t& from_time, utime_t& end_time,
+void RGWMetadataLog::init_list_entries(int shard_id, const real_time& from_time, const real_time& end_time,
string& marker, void **handle)
{
LogListCtx *ctx = new LogListCtx();
return ret;
info->marker = header.max_marker;
- info->last_update = header.max_time;
+ info->last_update = header.max_time.to_real_time();
return 0;
}
*pret = completion->get_return_value();
if (*pret >= 0) {
pinfo->marker = header.max_marker;
- pinfo->last_update = header.max_time;
+ pinfo->last_update = header.max_time.to_real_time();
}
completion_manager->complete(NULL, user_info);
put();
return 0;
}
-int RGWMetadataLog::trim(int shard_id, const utime_t& from_time, const utime_t& end_time,
+int RGWMetadataLog::trim(int shard_id, const real_time& from_time, const real_time& end_time,
const string& start_marker, const string& end_marker)
{
string oid;
return ret;
}
-int RGWMetadataLog::lock_exclusive(int shard_id, utime_t& duration, string& zone_id, string& owner_id) {
+int RGWMetadataLog::lock_exclusive(int shard_id, timespan duration, string& zone_id, string& owner_id) {
string oid;
get_shard_oid(shard_id, oid);
virtual int get(RGWRados *store, string& entry, RGWMetadataObject **obj) { return -ENOTSUP; }
virtual int put(RGWRados *store, string& entry, RGWObjVersionTracker& objv_tracker,
- time_t mtime, JSONObj *obj, sync_type_t sync_type) { return -ENOTSUP; }
+ real_time mtime, JSONObj *obj, sync_type_t sync_type) { return -ENOTSUP; }
virtual void get_pool_and_oid(RGWRados *store, const string& key, rgw_bucket& bucket, string& oid) {}
f->open_object_section("metadata_info");
encode_json("key", metadata_key, f);
encode_json("ver", obj->get_version(), f);
- time_t mtime = obj->get_mtime();
- if (mtime > 0) {
- encode_json("mtime", mtime, f);
+ real_time mtime = obj->get_mtime();
+ if (!real_clock::is_zero(mtime)) {
+ utime_t ut(mtime);
+ encode_json("mtime", ut, f);
}
encode_json("data", *obj, f);
f->close_section();
obj_version *objv = &objv_tracker.write_version;
- time_t mtime = 0;
+ utime_t mtime;
try {
JSONDecoder::decode_json("key", metadata_key, &parser);
return -EINVAL;
}
- ret = handler->put(store, entry, objv_tracker, mtime, jo, sync_type);
+ ret = handler->put(store, entry, objv_tracker, mtime.to_real_time(), jo, sync_type);
if (existing_version) {
*existing_version = objv_tracker.read_version;
}
return handler->remove(store, entry, objv_tracker);
}
-int RGWMetadataManager::lock_exclusive(string& metadata_key, utime_t duration, string& owner_id) {
+int RGWMetadataManager::lock_exclusive(string& metadata_key, timespan duration, string& owner_id) {
RGWMetadataHandler *handler;
string entry;
string zone_id;
}
int RGWMetadataManager::store_in_heap(RGWMetadataHandler *handler, const string& key, bufferlist& bl,
- RGWObjVersionTracker *objv_tracker, time_t mtime,
+ RGWObjVersionTracker *objv_tracker, real_time mtime,
map<string, bufferlist> *pattrs)
{
if (!objv_tracker) {
}
int RGWMetadataManager::put_entry(RGWMetadataHandler *handler, const string& key, bufferlist& bl, bool exclusive,
- RGWObjVersionTracker *objv_tracker, time_t mtime, map<string, bufferlist> *pattrs)
+ RGWObjVersionTracker *objv_tracker, real_time mtime, map<string, bufferlist> *pattrs)
{
string section;
RGWMetadataLogData log_data;
#include "cls/version/cls_version_types.h"
#include "cls/log/cls_log_types.h"
#include "common/RWLock.h"
+#include "common/ceph_time.h"
class RGWRados;
class RGWMetadataObject {
protected:
obj_version objv;
- time_t mtime;
+ ceph::real_time mtime;
public:
- RGWMetadataObject() : mtime(0) {}
+ RGWMetadataObject() {}
virtual ~RGWMetadataObject() {}
obj_version& get_version();
- time_t get_mtime() { return mtime; }
+ real_time get_mtime() { return mtime; }
virtual void dump(Formatter *f) const = 0;
};
virtual int get(RGWRados *store, string& entry, RGWMetadataObject **obj) = 0;
virtual int put(RGWRados *store, string& entry, RGWObjVersionTracker& objv_tracker,
- time_t mtime, JSONObj *obj, sync_type_t type) = 0;
+ real_time mtime, JSONObj *obj, sync_type_t type) = 0;
virtual int remove(RGWRados *store, string& entry, RGWObjVersionTracker& objv_tracker) = 0;
virtual int list_keys_init(RGWRados *store, void **phandle) = 0;
*
* @return true if the update should proceed, false otherwise.
*/
- bool check_versions(const obj_version& ondisk, const time_t& ondisk_time,
- const obj_version& incoming, const time_t& incoming_time,
+ bool check_versions(const obj_version& ondisk, const real_time& ondisk_time,
+ const obj_version& incoming, const real_time& incoming_time,
sync_type_t sync_mode) {
switch (sync_mode) {
case APPLY_UPDATES:
struct RGWMetadataLogInfo {
string marker;
- utime_t last_update;
+ real_time last_update;
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
struct LogListCtx {
int cur_shard;
string marker;
- utime_t from_time;
- utime_t end_time;
+ real_time from_time;
+ real_time end_time;
string cur_oid;
LogListCtx() : cur_shard(0), done(false) {}
};
- void init_list_entries(int shard_id, utime_t& from_time, utime_t& end_time, string& marker, void **handle);
+ void init_list_entries(int shard_id, const real_time& from_time, const real_time& end_time, string& marker, void **handle);
void complete_list_entries(void *handle);
int list_entries(void *handle,
int max_entries,
string *out_marker,
bool *truncated);
- int trim(int shard_id, const utime_t& from_time, const utime_t& end_time, const string& start_marker, const string& end_marker);
+ int trim(int shard_id, const real_time& from_time, const real_time& end_time, const string& start_marker, const string& end_marker);
int get_info(int shard_id, RGWMetadataLogInfo *info);
int get_info_async(int shard_id, RGWMetadataLogInfo *info, RGWCompletionManager *completion_manager, void *user_info, int *pret);
- int lock_exclusive(int shard_id, utime_t& duration, string&zone_id, string& owner_id);
+ int lock_exclusive(int shard_id, timespan duration, string&zone_id, string& owner_id);
int unlock(int shard_id, string& zone_id, string& owner_id);
int update_shards(list<int>& shards);
string heap_oid(RGWMetadataHandler *handler, const string& key, const obj_version& objv);
int store_in_heap(RGWMetadataHandler *handler, const string& key, bufferlist& bl,
- RGWObjVersionTracker *objv_tracker, time_t mtime,
+ RGWObjVersionTracker *objv_tracker, real_time mtime,
map<string, bufferlist> *pattrs);
int remove_from_heap(RGWMetadataHandler *handler, const string& key, RGWObjVersionTracker *objv_tracker);
public:
RGWMetadataHandler *get_handler(const string& type);
int put_entry(RGWMetadataHandler *handler, const string& key, bufferlist& bl, bool exclusive,
- RGWObjVersionTracker *objv_tracker, time_t mtime, map<string, bufferlist> *pattrs = NULL);
+ RGWObjVersionTracker *objv_tracker, real_time mtime, map<string, bufferlist> *pattrs = NULL);
int remove_entry(RGWMetadataHandler *handler, string& key, RGWObjVersionTracker *objv_tracker);
int get(string& metadata_key, Formatter *f);
int put(string& metadata_key, bufferlist& bl,
void dump_log_entry(cls_log_entry& entry, Formatter *f);
void get_sections(list<string>& sections);
- int lock_exclusive(string& metadata_key, utime_t duration, string& owner_id);
+ int lock_exclusive(string& metadata_key, timespan duration, string& owner_id);
int unlock(string& metadata_key, string& owner_id);
int get_log_shard_id(const string& section, const string& key, int *shard_id);
{
ldout(store->ctx(), 20) << "trying to trim removal hints to " << to << dendl;
- int ret = store->objexp_hint_trim(shard, from, to);
+ real_time rt_from = from.to_real_time();
+ real_time rt_to = to.to_real_time();
+
+ int ret = store->objexp_hint_trim(shard, rt_from, rt_to);
if (ret < 0) {
ldout(store->ctx(), 0) << "ERROR during trim: " << ret << dendl;
}
return;
}
do {
+ real_time rt_last = last_run.to_real_time();
+ real_time rt_start = round_start.to_real_time();
+
list<cls_timeindex_entry> entries;
- ret = store->objexp_hint_list(shard, last_run, round_start,
+ ret = store->objexp_hint_list(shard, rt_last, rt_start,
num_entries, marker, entries,
&out_marker, &truncated);
if (ret < 0) {
s->bucket_info.flags |= (BUCKET_VERSIONED | BUCKET_VERSIONS_SUSPENDED);
}
- op_ret = store->put_bucket_instance_info(s->bucket_info, false, 0,
+ op_ret = store->put_bucket_instance_info(s->bucket_info, false, real_time(),
&s->bucket_attrs);
if (op_ret < 0) {
ldout(s->cct, 0) << "NOTICE: put_bucket_info on bucket=" << s->bucket.name
s->bucket_info.has_website = true;
s->bucket_info.website_conf = website_conf;
- op_ret = store->put_bucket_instance_info(s->bucket_info, false, 0, &s->bucket_attrs);
+ op_ret = store->put_bucket_instance_info(s->bucket_info, false, real_time(), &s->bucket_attrs);
if (op_ret < 0) {
ldout(s->cct, 0) << "NOTICE: put_bucket_info on bucket=" << s->bucket.name << " returned err=" << op_ret << dendl;
return;
s->bucket_info.has_website = false;
s->bucket_info.website_conf = RGWBucketWebsiteConf();
- op_ret = store->put_bucket_instance_info(s->bucket_info, false, 0, &s->bucket_attrs);
+ op_ret = store->put_bucket_instance_info(s->bucket_info, false, real_time(), &s->bucket_attrs);
if (op_ret < 0) {
ldout(s->cct, 0) << "NOTICE: put_bucket_info on bucket=" << s->bucket.name << " returned err=" << op_ret << dendl;
return;
RGWBucketInfo master_info;
rgw_bucket *pmaster_bucket;
- time_t creation_time;
+ real_time creation_time;
if (!store->is_meta_master()) {
JSONParser jp;
pobjv = &objv;
} else {
pmaster_bucket = NULL;
- creation_time = 0;
}
string zonegroup_id;
protected:
int prepare(RGWRados *store, string *oid_rand);
- int do_complete(string& etag, time_t *mtime, time_t set_mtime,
- map<string, bufferlist>& attrs, time_t delete_at,
+ int do_complete(string& etag, real_time *mtime, real_time set_mtime,
+ map<string, bufferlist>& attrs, real_time delete_at,
const char *if_match = NULL, const char *if_nomatch = NULL);
public:
(strncmp(uid, MULTIPART_UPLOAD_ID_PREFIX_LEGACY, sizeof(MULTIPART_UPLOAD_ID_PREFIX_LEGACY) - 1) == 0);
}
-int RGWPutObjProcessor_Multipart::do_complete(string& etag, time_t *mtime, time_t set_mtime,
- map<string, bufferlist>& attrs, time_t delete_at,
+int RGWPutObjProcessor_Multipart::do_complete(string& etag, real_time *mtime, real_time set_mtime,
+ map<string, bufferlist>& attrs, real_time delete_at,
const char *if_match, const char *if_nomatch)
{
complete_writing_data();
info.num = atoi(part_num.c_str());
info.etag = etag;
info.size = s->obj_size;
- info.modified = ceph_clock_now(store->ctx());
+ info.modified = real_clock::now();
info.manifest = manifest;
::encode(info, bl);
attrs[RGW_ATTR_SLO_UINDICATOR] = slo_userindicator_bl;
}
- op_ret = processor->complete(etag, &mtime, 0, attrs, delete_at, if_match,
+ op_ret = processor->complete(etag, &mtime, real_time(), attrs, delete_at, if_match,
if_nomatch);
done:
attrs[RGW_ATTR_CONTENT_TYPE] = ct_bl;
}
- op_ret = processor->complete(etag, NULL, 0, attrs, delete_at);
+ op_ret = processor->complete(etag, NULL, real_time(), attrs, delete_at);
done:
dispose_processor(processor);
/* XXX tenant needed? */
op_ret = rgw_store_user_info(store, *(s->user), &orig_uinfo,
- &acct_op_tracker, 0, false, &attrs);
+ &acct_op_tracker, real_time(), false, &attrs);
if (op_ret < 0) {
return;
}
return;
s->bucket_info.requester_pays = requester_pays;
- op_ret = store->put_bucket_instance_info(s->bucket_info, false, 0,
+ op_ret = store->put_bucket_instance_info(s->bucket_info, false, real_time(),
&s->bucket_attrs);
if (op_ret < 0) {
ldout(s->cct, 0) << "NOTICE: put_bucket_info on bucket=" << s->bucket.name
#include "common/utf8.h"
#include "common/ceph_json.h"
#include "common/utf8.h"
+#include "common/ceph_time.h"
#include "rgw_common.h"
#include "rgw_rados.h"
uint64_t total_len;
off_t start;
off_t end;
- time_t mod_time;
- time_t lastmod;
- time_t unmod_time;
- time_t *mod_ptr;
- time_t *unmod_ptr;
+ ceph::real_time mod_time;
+ ceph::real_time lastmod;
+ ceph::real_time unmod_time;
+ ceph::real_time *mod_ptr;
+ ceph::real_time *unmod_ptr;
map<string, bufferlist> attrs;
bool get_data;
bool partial_content;
ofs = 0;
total_len = 0;
end = -1;
- mod_time = 0;
- lastmod = 0;
- unmod_time = 0;
mod_ptr = NULL;
unmod_ptr = NULL;
get_data = false;
const char *dlo_manifest;
RGWSLOInfo *slo_info;
- time_t mtime;
+ ceph::real_time mtime;
uint64_t olh_epoch;
string version_id;
- time_t delete_at;
+ ceph::real_time delete_at;
public:
RGWPutObj() : ofs(0),
chunked_upload(0),
dlo_manifest(NULL),
slo_info(NULL),
- mtime(0),
- olh_epoch(0),
- delete_at(0) {}
+ olh_epoch(0) {}
~RGWPutObj() {
delete slo_info;
string content_type;
RGWAccessControlPolicy policy;
map<string, bufferlist> attrs;
- time_t delete_at;
+ ceph::real_time delete_at;
public:
RGWPostObj() : min_len(0), max_len(LLONG_MAX), len(0), ofs(0),
supplied_md5_b64(NULL), supplied_etag(NULL),
- data_pending(false), delete_at(0) {}
+ data_pending(false) {}
virtual void init(RGWRados *store, struct req_state *s, RGWHandler *h) {
RGWOp::init(store, s, h);
protected:
RGWAccessControlPolicy policy;
string placement_rule;
- time_t delete_at;
+ ceph::real_time delete_at;
const char *dlo_manifest;
public:
RGWPutMetadataObject()
- : delete_at(0),
- dlo_manifest(NULL)
+ : dlo_manifest(NULL)
{}
virtual void init(RGWRados *store, struct req_state *s, RGWHandler *h) {
bool delete_marker;
bool multipart_delete;
string version_id;
- time_t unmod_since; /* if unmodified since */
+ ceph::real_time unmod_since; /* if unmodified since */
bool no_precondition_error;
std::unique_ptr<RGWBulkDelete::Deleter> deleter;
RGWDeleteObj()
: delete_marker(false),
multipart_delete(false),
- unmod_since(0),
no_precondition_error(false),
deleter(nullptr) {
}
off_t ofs;
off_t len;
off_t end;
- time_t mod_time;
- time_t unmod_time;
- time_t *mod_ptr;
- time_t *unmod_ptr;
+ ceph::real_time mod_time;
+ ceph::real_time unmod_time;
+ ceph::real_time *mod_ptr;
+ ceph::real_time *unmod_ptr;
map<string, bufferlist> attrs;
string src_tenant_name, src_bucket_name;
rgw_bucket src_bucket;
string dest_tenant_name, dest_bucket_name;
rgw_bucket dest_bucket;
string dest_object;
- time_t src_mtime;
- time_t mtime;
+ ceph::real_time src_mtime;
+ ceph::real_time mtime;
RGWRados::AttrsMod attrs_mod;
RGWBucketInfo src_bucket_info;
RGWBucketInfo dest_bucket_info;
string version_id;
uint64_t olh_epoch;
- time_t delete_at;
+ ceph::real_time delete_at;
bool copy_if_newer;
int init_common();
ofs = 0;
len = 0;
end = -1;
- mod_time = 0;
- unmod_time = 0;
mod_ptr = NULL;
unmod_ptr = NULL;
- src_mtime = 0;
- mtime = 0;
attrs_mod = RGWRados::ATTRSMOD_NONE;
last_ofs = 0;
olh_epoch = 0;
- delete_at = 0;
copy_if_newer = false;
}
}
} /* rgw_get_request_metadata */
-static inline void encode_delete_at_attr(time_t delete_at,
+static inline void encode_delete_at_attr(ceph::real_time delete_at,
map<string, bufferlist>& attrs)
{
- if (delete_at == 0) {
+ if (real_clock::is_zero(delete_at)) {
return;
}
bufferlist delatbl;
- ::encode(utime_t(delete_at, 0), delatbl);
+ ::encode(delete_at, delatbl);
attrs[RGW_ATTR_DELETE_AT] = delatbl;
} /* encode_delete_at_attr */
return 0;
}
- utime_t when_need_full_sync = header.last_stats_sync;
- when_need_full_sync += store->ctx()->_conf->rgw_user_quota_sync_wait_time;
+ real_time when_need_full_sync = header.last_stats_sync;
+ when_need_full_sync += timespan(store->ctx()->_conf->rgw_user_quota_sync_wait_time);
// check if enough time passed since last full sync
+ /* FIXME: missing check? */
ret = rgw_user_sync_all_stats(store, user);
if (ret < 0) {
struct bucket_info_entry {
RGWBucketInfo info;
- time_t mtime;
+ real_time mtime;
map<string, bufferlist> attrs;
};
::encode(default_info, bl);
- int ret = rgw_put_system_obj(store, pool, oid, bl.c_str(), bl.length(), false, NULL, 0, NULL);
+ int ret = rgw_put_system_obj(store, pool, oid, bl.c_str(), bl.length(), false, NULL, real_time(), NULL);
if (ret < 0)
return ret;
bufferlist bl;
::encode(nameToId, bl);
- return rgw_put_system_obj(store, pool, oid, bl.c_str(), bl.length(), exclusive, NULL, 0, NULL);
+ return rgw_put_system_obj(store, pool, oid, bl.c_str(), bl.length(), exclusive, NULL, real_time(), NULL);
}
int RGWSystemMetaObj::rename(const string& new_name)
bufferlist bl;
::encode(*this, bl);
- return rgw_put_system_obj(store, pool, oid, bl.c_str(), bl.length(), exclusive, NULL, 0, NULL);
+ return rgw_put_system_obj(store, pool, oid, bl.c_str(), bl.length(), exclusive, NULL, real_time(), NULL);
}
int RGWSystemMetaObj::write(bool exclusive)
auto pool = rgw_bucket{pool_name.c_str()};
auto oid = get_control_oid();
return rgw_put_system_obj(store, pool, oid, nullptr, 0, true,
- nullptr, 0, nullptr);
+ nullptr, real_time(), nullptr);
}
int RGWRealm::delete_control()
::encode(info, bl);
return rgw_put_system_obj(store, pool, oid, bl.c_str(), bl.length(),
- exclusive, NULL, 0, NULL);
+ exclusive, NULL, real_time(), NULL);
}
int RGWPeriod::delete_obj()
string oid = get_period_oid();
bufferlist bl;
::encode(*this, bl);
- ret = rgw_put_system_obj(store, pool, oid, bl.c_str(), bl.length(), exclusive, NULL, 0, NULL);
+ ret = rgw_put_system_obj(store, pool, oid, bl.c_str(), bl.length(), exclusive, NULL, real_time(), NULL);
if (ret < 0) {
ldout(cct, 0) << "ERROR: rgw_put_system_obj(" << pool << ":" << oid << "): " << cpp_strerror(-ret) << dendl;
return ret;
append_rand_alpha(cct, write_version.tag, write_version.tag, TAG_LEN);
}
-int RGWPutObjProcessor::complete(string& etag, time_t *mtime, time_t set_mtime,
- map<string, bufferlist>& attrs, time_t delete_at,
+int RGWPutObjProcessor::complete(string& etag, real_time *mtime, real_time set_mtime,
+ map<string, bufferlist>& attrs, real_time delete_at,
const char *if_match, const char * if_nomatch)
{
int r = do_complete(etag, mtime, set_mtime, attrs, delete_at, if_match, if_nomatch);
return 0;
}
-int RGWPutObjProcessor_Atomic::do_complete(string& etag, time_t *mtime, time_t set_mtime,
- map<string, bufferlist>& attrs, time_t delete_at,
+int RGWPutObjProcessor_Atomic::do_complete(string& etag, real_time *mtime, real_time set_mtime,
+ map<string, bufferlist>& attrs, real_time delete_at,
const char *if_match,
const char *if_nomatch) {
int r = complete_writing_data();
last_user = ub.user;
vector<rgw_usage_log_entry>& v = log_objs[hash].entries;
- map<utime_t, rgw_usage_log_entry>::iterator miter;
- for (miter = info.m.begin(); miter != info.m.end(); ++miter) {
+ for (auto miter = info.m.begin(); miter != info.m.end(); ++miter) {
v.push_back(miter->second);
}
}
}
-void RGWRados::time_log_prepare_entry(cls_log_entry& entry, const utime_t& ut, const string& section, const string& key, bufferlist& bl)
+void RGWRados::time_log_prepare_entry(cls_log_entry& entry, const real_time& ut, const string& section, const string& key, bufferlist& bl)
{
- cls_log_add_prepare_entry(entry, ut, section, key, bl);
+ cls_log_add_prepare_entry(entry, utime_t(ut), section, key, bl);
}
int RGWRados::time_log_add_init(librados::IoCtx& io_ctx)
}
-int RGWRados::time_log_add(const string& oid, const utime_t& ut, const string& section, const string& key, bufferlist& bl)
+int RGWRados::time_log_add(const string& oid, const real_time& ut, const string& section, const string& key, bufferlist& bl)
{
librados::IoCtx io_ctx;
}
ObjectWriteOperation op;
- cls_log_add(op, ut, section, key, bl);
+ utime_t t(ut);
+ cls_log_add(op, t, section, key, bl);
r = io_ctx.operate(oid, &op);
return r;
return r;
}
-int RGWRados::time_log_list(const string& oid, utime_t& start_time, utime_t& end_time,
+int RGWRados::time_log_list(const string& oid, const real_time& start_time, const real_time& end_time,
int max_entries, list<cls_log_entry>& entries,
const string& marker,
string *out_marker,
return r;
librados::ObjectReadOperation op;
- cls_log_list(op, start_time, end_time, marker, max_entries, entries,
+ utime_t st(start_time);
+ utime_t et(end_time);
+
+ cls_log_list(op, st, et, marker, max_entries, entries,
out_marker, truncated);
bufferlist obl;
return 0;
}
-int RGWRados::time_log_trim(const string& oid, const utime_t& start_time, const utime_t& end_time,
+int RGWRados::time_log_trim(const string& oid, const real_time& start_time, const real_time& end_time,
const string& from_marker, const string& to_marker)
{
librados::IoCtx io_ctx;
if (r < 0)
return r;
- return cls_log_trim(io_ctx, oid, start_time, end_time, from_marker, to_marker);
+ utime_t st(start_time);
+ utime_t et(end_time);
+
+ return cls_log_trim(io_ctx, oid, st, et, from_marker, to_marker);
}
string RGWRados::objexp_hint_get_shardname(int shard_num)
":" + obj_key.name + ":" + obj_key.instance;
}
-int RGWRados::objexp_hint_add(const utime_t& delete_at,
+int RGWRados::objexp_hint_add(const ceph::real_time& delete_at,
const string& tenant_name,
const string& bucket_name,
const string& bucket_id,
bufferlist hebl;
::encode(he, hebl);
ObjectWriteOperation op;
- cls_timeindex_add(op, delete_at, keyext, hebl);
+ cls_timeindex_add(op, utime_t(delete_at), keyext, hebl);
string shard_name = objexp_hint_get_shardname(objexp_key_shard(obj_key));
return objexp_pool_ctx.operate(shard_name, &op);
}
int RGWRados::objexp_hint_list(const string& oid,
- const utime_t& start_time,
- const utime_t& end_time,
+ const ceph::real_time& start_time,
+ const ceph::real_time& end_time,
const int max_entries,
const string& marker,
list<cls_timeindex_entry>& entries, /* out */
bool *truncated) /* out */
{
librados::ObjectReadOperation op;
- cls_timeindex_list(op, start_time, end_time, marker, max_entries, entries,
+ cls_timeindex_list(op, utime_t(start_time), utime_t(end_time), marker, max_entries, entries,
out_marker, truncated);
bufferlist obl;
}
int RGWRados::objexp_hint_trim(const string& oid,
- const utime_t& start_time,
- const utime_t& end_time,
+ const ceph::real_time& start_time,
+ const ceph::real_time& end_time,
const string& from_marker,
const string& to_marker)
{
- int ret = cls_timeindex_trim(objexp_pool_ctx, oid, start_time, end_time,
+ int ret = cls_timeindex_trim(objexp_pool_ctx, oid, utime_t(start_time), utime_t(end_time),
from_marker, to_marker);
if ((ret < 0 ) && (ret != -ENOENT)) {
return ret;
return 0;
}
-int RGWRados::lock_exclusive(rgw_bucket& pool, const string& oid, utime_t& duration,
+int RGWRados::lock_exclusive(rgw_bucket& pool, const string& oid, timespan& duration,
string& zone_id, string& owner_id) {
librados::IoCtx io_ctx;
int r = rad->ioctx_create(pool_name, io_ctx);
if (r < 0)
return r;
+ uint64_t msec = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
+ utime_t ut(msec / 1000, msec % 1000);
rados::cls::lock::Lock l(log_lock_name);
- l.set_duration(duration);
+ l.set_duration(ut);
l.set_cookie(owner_id);
l.set_tag(zone_id);
l.set_renew(true);
RGWBucketInfo& info,
obj_version *pobjv,
obj_version *pep_objv,
- time_t creation_time,
+ real_time creation_time,
rgw_bucket *pmaster_bucket,
bool exclusive)
{
info.num_shards = bucket_index_max_shards;
info.bucket_index_shard_hash_type = RGWBucketInfo::MOD;
info.requester_pays = false;
- if (!creation_time)
- time(&info.creation_time);
+ if (real_clock::is_zero(creation_time))
+ creation_time = ceph::real_clock::now(cct);
else
info.creation_time = creation_time;
- ret = put_linked_bucket_info(info, exclusive, 0, pep_objv, &attrs, true);
+ ret = put_linked_bucket_info(info, exclusive, ceph::real_time(), pep_objv, &attrs, true);
if (ret == -EEXIST) {
/* we need to reread the info and return it, caller will have a use for it */
RGWObjVersionTracker instance_ver = info.objv_tracker;
ioctx.locator_set_key(string()); /* override locator for this object, use empty locator */
uint64_t size;
- time_t mtime;
bufferlist data;
+ struct timespec mtime_ts;
map<string, bufferlist> attrs;
librados::ObjectReadOperation op;
op.getxattrs(&attrs, NULL);
- op.stat(&size, &mtime, NULL);
+ op.stat2(&size, &mtime_ts, NULL);
#define HEAD_SIZE 512 * 1024
op.read(0, HEAD_SIZE, &data, NULL);
if (copy_obj) {
librados::ObjectWriteOperation wop;
- wop.mtime(&mtime);
+ wop.mtime2(&mtime_ts);
map<string, bufferlist>::iterator iter;
for (iter = attrs.begin(); iter != attrs.end(); ++iter) {
uint64_t chunk_size = COPY_BUF_SIZE;
uint64_t ofs = 0;
int ret = 0;
- time_t mtime = 0;
+ struct timespec mtime_ts;
uint64_t size;
if (src_oid == dst_oid && src_locator == dst_locator) {
ObjectWriteOperation wop;
if (ofs == 0) {
- rop.stat(&size, &mtime, NULL);
+ rop.stat2(&size, &mtime_ts, NULL);
}
rop.read(ofs, chunk_size, &data, NULL);
ret = src_ioctx.operate(src_oid, &rop, NULL);
if (ofs == 0) {
wop.create(true); /* make it exclusive */
- wop.mtime(&mtime);
+ wop.mtime2(&mtime_ts);
}
wop.write(ofs, data);
ret = dst_ioctx.operate(dst_oid, &wop);
rgw_obj& obj = source->get_obj();
const string& src_name = obj.get_object();
char buf[src_name.size() + 32];
- snprintf(buf, sizeof(buf), "%03d%s/%lld.%06d", (int)src_name.size(),
- src_name.c_str(), (long long)state->mtime, 0);
+ struct timespec ts = ceph::real_clock::to_timespec(state->mtime);
+ snprintf(buf, sizeof(buf), "%03d%s/%lld.%06ld", (int)src_name.size(),
+ src_name.c_str(), (long long)ts.tv_sec, ts.tv_nsec / 1000);
RGWBucketInfo dest_bucket_info;
state->attrset,
RGW_OBJ_CATEGORY_MAIN,
0, /* uint64_t olh_epoch */
- 0, /* time_t delete_at */
+ real_time(), /* time_t delete_at */
NULL, /* string *version_id */
NULL, /* string *ptag */
NULL, /* string *petag */
if (r < 0)
return r;
- utime_t ut;
- if (meta.set_mtime) {
- ut = utime_t(meta.set_mtime, 0);
- } else {
- ut = ceph_clock_now(0);
- meta.set_mtime = ut.sec();
+ if (real_clock::is_zero(meta.set_mtime)) {
+ meta.set_mtime = real_clock::now();
}
if (state->is_olh) {
op.setxattr(RGW_ATTR_OLH_ID_TAG, state->olh_tag);
}
- op.mtime(&meta.set_mtime);
+ struct timespec mtime_ts = ceph::real_clock::to_timespec(meta.set_mtime);
+ op.mtime2(&mtime_ts);
if (meta.data) {
/* if we want to overwrite the data, we also want to overwrite the
}
r = index_op.complete(poolid, epoch, size,
- ut, etag, content_type, &acl_bl,
+ meta.set_mtime, etag, content_type, &acl_bl,
meta.category, meta.remove_objs);
if (r < 0)
goto done_cancel;
state = NULL;
if (versioned_op) {
- r = store->set_olh(target->get_ctx(), target->get_bucket_info(), obj, false, NULL, meta.olh_epoch, 0);
+ r = store->set_olh(target->get_ctx(), target->get_bucket_info(), obj, false, NULL, meta.olh_epoch, real_time());
if (r < 0) {
return r;
}
}
- if (meta.delete_at > 0) {
+ if (!real_clock::is_zero(meta.delete_at)) {
rgw_obj_key obj_key;
obj.get_index_key(&obj_key);
- r = store->objexp_hint_add(utime_t(meta.delete_at, 0),
+ r = store->objexp_hint_add(meta.delete_at,
bucket.tenant, bucket.name, bucket.bucket_id, obj_key);
if (r < 0) {
ldout(store->ctx(), 0) << "ERROR: objexp_hint_add() returned r=" << r << ", object will not get removed" << dendl;
}
/** Write/overwrite a system object. */
-int RGWRados::put_system_obj_impl(rgw_obj& obj, uint64_t size, time_t *mtime,
+int RGWRados::put_system_obj_impl(rgw_obj& obj, uint64_t size, real_time *mtime,
map<std::string, bufferlist>& attrs, int flags,
bufferlist& data,
RGWObjVersionTracker *objv_tracker,
- time_t set_mtime /* 0 for don't set */)
+ real_time set_mtime /* 0 for don't set */)
{
rgw_bucket bucket;
rgw_rados_ref ref;
objv_tracker->prepare_op_for_write(&op);
}
- utime_t ut;
- if (set_mtime) {
- ut = utime_t(set_mtime, 0);
- } else {
- ut = ceph_clock_now(0);
- set_mtime = ut.sec();
+ if (real_clock::is_zero(set_mtime)) {
+ set_mtime = real_clock::now();
}
- op.mtime(&set_mtime);
+ struct timespec mtime_ts = ceph::real_clock::to_timespec(set_mtime);
+
+ op.mtime2(&mtime_ts);
op.write_full(data);
bufferlist acl_bl;
processor->set_extra_data_len(len);
}
- int complete(string& etag, time_t *mtime, time_t set_mtime, map<string, bufferlist>& attrs, time_t delete_at) {
+ int complete(string& etag, real_time *mtime, real_time set_mtime, map<string, bufferlist>& attrs, real_time delete_at) {
return processor->complete(etag, mtime, set_mtime, attrs, delete_at);
}
int64_t ofs = 0;
int64_t end = -1;
- time_t mtime;
+ real_time mtime;
uint64_t total_len;
uint64_t obj_size;
RGWObjectCtx rctx(this);
return ret;
}
- return copy_obj_data(rctx, dest_bucket_info, read_op, end, obj, obj, max_chunk_size, NULL, mtime, attrset, RGW_OBJ_CATEGORY_MAIN, 0, 0, NULL, NULL, NULL, NULL);
+ return copy_obj_data(rctx, dest_bucket_info, read_op, end, obj, obj, max_chunk_size, NULL, mtime, attrset,
+ RGW_OBJ_CATEGORY_MAIN, 0, real_time(), NULL, NULL, NULL, NULL);
}
struct obj_time_weight {
- time_t mtime;
+ real_time mtime;
uint32_t zone_short_id;
uint64_t pg_ver;
- obj_time_weight() : mtime(0), zone_short_id(0), pg_ver(0) {}
+ obj_time_weight() : zone_short_id(0), pg_ver(0) {}
bool operator<(const obj_time_weight& rhs) {
if (mtime > rhs.mtime) {
return (pg_ver < rhs.pg_ver);
}
- void init(const time_t& _mtime, uint32_t _short_id, uint64_t _pg_ver) {
+ void init(const real_time& _mtime, uint32_t _short_id, uint64_t _pg_ver) {
mtime = _mtime;
zone_short_id = _short_id;
pg_ver = _pg_ver;
rgw_obj& src_obj,
RGWBucketInfo& dest_bucket_info,
RGWBucketInfo& src_bucket_info,
- time_t *src_mtime,
- time_t *mtime,
- const time_t *mod_ptr,
- const time_t *unmod_ptr,
+ real_time *src_mtime,
+ real_time *mtime,
+ const real_time *mod_ptr,
+ const real_time *unmod_ptr,
const char *if_match,
const char *if_nomatch,
AttrsMod attrs_mod,
map<string, bufferlist>& attrs,
RGWObjCategory category,
uint64_t olh_epoch,
- time_t delete_at,
+ real_time delete_at,
string *version_id,
string *ptag,
string *petag,
RGWRadosPutObj cb(&processor, &opstate, progress_cb, progress_data);
string etag;
map<string, string> req_headers;
- time_t set_mtime;
+ real_time set_mtime;
RGWObjState *dest_state = NULL;
- const time_t *pmod = mod_ptr;
+ const real_time *pmod = mod_ptr;
obj_time_weight dest_mtime_weight;
map<string, bufferlist>::iterator iter = src_attrs.find(RGW_ATTR_DELETE_AT);
if (iter != src_attrs.end()) {
try {
- utime_t da;
- ::decode(da, iter->second);
- delete_at = (time_t)da.sec();
+ ::decode(delete_at, iter->second);
} catch (buffer::error& err) {
ldout(cct, 0) << "ERROR: failed to decode delete_at field in intra zone copy" << dendl;
}
RGWRados::Object::Read& read_op,
const rgw_user& user_id,
rgw_obj& dest_obj,
- time_t *mtime)
+ real_time *mtime)
{
string etag;
rgw_obj& src_obj,
RGWBucketInfo& dest_bucket_info,
RGWBucketInfo& src_bucket_info,
- time_t *src_mtime,
- time_t *mtime,
- const time_t *mod_ptr,
- const time_t *unmod_ptr,
+ real_time *src_mtime,
+ real_time *mtime,
+ const real_time *mod_ptr,
+ const real_time *unmod_ptr,
const char *if_match,
const char *if_nomatch,
AttrsMod attrs_mod,
map<string, bufferlist>& attrs,
RGWObjCategory category,
uint64_t olh_epoch,
- time_t delete_at,
+ real_time delete_at,
string *version_id,
string *ptag,
string *petag,
if (copy_data) { /* refcounting tail wouldn't work here, just copy the data */
return copy_obj_data(obj_ctx, dest_bucket_info, read_op, end, dest_obj, src_obj,
- max_chunk_size, mtime, 0, attrs, category, olh_epoch, delete_at,
+ max_chunk_size, mtime, real_time(), attrs, category, olh_epoch, delete_at,
version_id, ptag, petag, err);
}
rgw_obj& dest_obj,
rgw_obj& src_obj,
uint64_t max_chunk_size,
- time_t *mtime,
- time_t set_mtime,
+ real_time *mtime,
+ real_time set_mtime,
map<string, bufferlist>& attrs,
RGWObjCategory category,
uint64_t olh_epoch,
- time_t delete_at,
+ real_time delete_at,
string *version_id,
string *ptag,
string *petag,
info.owner = owner.get_id();
- r = put_bucket_instance_info(info, false, 0, &attrs);
+ r = put_bucket_instance_info(info, false, real_time(), &attrs);
if (r < 0) {
ldout(cct, 0) << "NOTICE: put_bucket_info on bucket=" << bucket.name << " returned err=" << r << dendl;
return r;
info.flags |= BUCKET_SUSPENDED;
}
- r = put_bucket_instance_info(info, false, 0, &attrs);
+ r = put_bucket_instance_info(info, false, real_time(), &attrs);
if (r < 0) {
ldout(cct, 0) << "NOTICE: put_bucket_info on bucket=" << bucket.name << " returned err=" << r << ", skipping bucket" << dendl;
ret = r;
cls_rgw_obj_check_attrs_prefix(op, prefix, fail_if_exist);
}
-void RGWRados::cls_obj_check_mtime(ObjectOperation& op, const utime_t& mtime, RGWCheckMTimeType type)
+void RGWRados::cls_obj_check_mtime(ObjectOperation& op, const real_time& mtime, RGWCheckMTimeType type)
{
cls_rgw_obj_check_mtime(op, mtime, type);
}
meta.owner = params.obj_owner.get_id().to_str();
meta.owner_display_name = params.obj_owner.get_display_name();
- if (params.mtime == 0) {
- meta.mtime = ceph_clock_now(store->ctx());
+ if (real_clock::is_zero(params.mtime)) {
+ meta.mtime = real_clock::now();
} else {
- meta.mtime = utime_t(params.mtime, 0);
+ meta.mtime = params.mtime;
}
int r = store->set_olh(target->get_ctx(), target->get_bucket_info(), marker, true, &meta, params.olh_epoch, params.unmod_since);
ObjectWriteOperation op;
- if (params.unmod_since > 0) {
- time_t ctime = state->mtime;
+ if (!real_clock::is_zero(params.unmod_since)) {
+ real_time ctime = state->mtime;
ldout(store->ctx(), 10) << "If-UnModified-Since: " << params.unmod_since << " Last-Modified: " << ctime << dendl;
if (ctime > params.unmod_since) {
}
/* only delete object if mtime is less than or equal to params.unmod_since */
- store->cls_obj_check_mtime(op, utime_t(params.unmod_since, 0), CLS_RGW_CHECK_TIME_MTIME_LE);
+ store->cls_obj_check_mtime(op, params.unmod_since, CLS_RGW_CHECK_TIME_MTIME_LE);
}
uint64_t obj_size = state->size;
- if (!params.expiration_time.is_zero()) {
+ if (!real_clock::is_zero(params.expiration_time)) {
bufferlist bl;
- utime_t delete_at;
+ real_time delete_at;
if (state->get_attr(RGW_ATTR_DELETE_AT, bl)) {
try {
rgw_obj& obj,
int versioning_status,
uint16_t bilog_flags,
- const utime_t& expiration_time)
+ const real_time& expiration_time)
{
RGWRados::Object del_target(this, bucket_info, obj_ctx, obj);
RGWRados::Object::Delete del_op(&del_target);
if (r == -ENOENT) {
s->exists = false;
s->has_attrs = true;
- s->mtime = 0;
+ s->mtime = real_time();
return 0;
}
if (r < 0)
if (r == -ENOENT) {
s->exists = false;
s->has_attrs = true;
- s->mtime = 0;
+ s->mtime = real_time();
return 0;
}
if (r < 0)
if (s->has_attrs) {
state.ret = 0;
result.size = s->size;
- result.mtime = s->mtime;
+ result.mtime = ceph::real_clock::to_timespec(s->mtime);
result.attrs = s->attrset;
result.has_manifest = s->has_manifest;
result.manifest = s->manifest;
}
librados::ObjectReadOperation op;
- op.stat(&result.size, &result.mtime, NULL);
+ op.stat2(&result.size, &result.mtime, NULL);
op.getxattrs(&result.attrs, NULL);
state.completion = librados::Rados::aio_create_completion(NULL, NULL, NULL);
state.io_ctx.locator_set_key(loc);
op.setxattr(name.c_str(), bl);
if (name.compare(RGW_ATTR_DELETE_AT) == 0) {
- utime_t ts;
+ real_time ts;
try {
::decode(ts, bl);
string content_type(content_type_bl.c_str(), content_type_bl.length());
uint64_t epoch = ref.ioctx.get_last_version();
int64_t poolid = ref.ioctx.get_id();
- utime_t mtime = ceph_clock_now(cct);
+ real_time mtime = real_clock::now();
r = index_op.complete(poolid, epoch, state->size,
mtime, etag, content_type, &acl_bl,
RGW_OBJ_CATEGORY_MAIN, NULL);
RGWRados::SystemObject::Read::GetObjState& state,
rgw_obj& obj,
map<string, bufferlist> *attrs,
- time_t *lastmod,
+ real_time *lastmod,
uint64_t *obj_size,
RGWObjVersionTracker *objv_tracker)
{
}
int RGWRados::Bucket::UpdateIndex::complete(int64_t poolid, uint64_t epoch, uint64_t size,
- utime_t& ut, string& etag, string& content_type, bufferlist *acl_bl, RGWObjCategory category,
+ ceph::real_time& ut, string& etag, string& content_type, bufferlist *acl_bl, RGWObjCategory category,
list<rgw_obj_key> *remove_objs)
{
if (blind) {
bufferlist bl;
RGWOLHPendingInfo pending_info;
- pending_info.time = ceph_clock_now(cct);
+ pending_info.time = real_clock::now();
::encode(pending_info, bl);
#define OLH_PENDING_TAG_LEN 32
/* tag will start with current time epoch, this so that entries are sorted by time */
char buf[32];
- snprintf(buf, sizeof(buf), "%016llx", (unsigned long long)pending_info.time.sec());
+ utime_t ut(pending_info.time);
+ snprintf(buf, sizeof(buf), "%016llx", (unsigned long long)ut.sec());
*op_tag = buf;
string s;
const string& op_tag,
struct rgw_bucket_dir_entry_meta *meta,
uint64_t olh_epoch,
- time_t unmod_since)
+ real_time unmod_since)
{
rgw_rados_ref ref;
rgw_bucket bucket;
}
int RGWRados::set_olh(RGWObjectCtx& obj_ctx, RGWBucketInfo& bucket_info, rgw_obj& target_obj, bool delete_marker, rgw_bucket_dir_entry_meta *meta,
- uint64_t olh_epoch, time_t unmod_since)
+ uint64_t olh_epoch, real_time unmod_since)
{
string op_tag;
{
map<string, bufferlist>::iterator iter = pending_entries.begin();
- utime_t now = ceph_clock_now(cct);
+ real_time now = real_clock::now();
while (iter != pending_entries.end()) {
bufferlist::iterator biter = iter->second.begin();
map<string, bufferlist>::iterator cur_iter = iter;
++iter;
- if (now - pending_info.time >= cct->_conf->rgw_olh_pending_timeout_sec) {
+ if (now - pending_info.time >= timespan(cct->_conf->rgw_olh_pending_timeout_sec)) {
(*rm_pending_entries)[cur_iter->first] = cur_iter->second;
pending_entries.erase(cur_iter);
} else {
return 0;
}
-int RGWRados::raw_obj_stat(rgw_obj& obj, uint64_t *psize, time_t *pmtime, uint64_t *epoch,
+int RGWRados::raw_obj_stat(rgw_obj& obj, uint64_t *psize, real_time *pmtime, uint64_t *epoch,
map<string, bufferlist> *attrs, bufferlist *first_chunk,
RGWObjVersionTracker *objv_tracker)
{
map<string, bufferlist> unfiltered_attrset;
uint64_t size = 0;
- time_t mtime = 0;
+ struct timespec mtime_ts;
ObjectReadOperation op;
if (objv_tracker) {
op.getxattrs(&unfiltered_attrset, NULL);
}
if (psize || pmtime) {
- op.stat(&size, &mtime, NULL);
+ op.stat2(&size, &mtime_ts, NULL);
}
if (first_chunk) {
op.read(0, cct->_conf->rgw_max_chunk_size, first_chunk, NULL);
if (psize)
*psize = size;
if (pmtime)
- *pmtime = mtime;
+ *pmtime = ceph::real_clock::from_timespec(mtime_ts);
if (attrs) {
filter_attrset(unfiltered_attrset, RGW_ATTR_PREFIX, attrs);
}
}
int RGWRados::get_bucket_instance_info(RGWObjectCtx& obj_ctx, const string& meta_key, RGWBucketInfo& info,
- time_t *pmtime, map<string, bufferlist> *pattrs)
+ real_time *pmtime, map<string, bufferlist> *pattrs)
{
int pos = meta_key.find(':');
if (pos < 0) {
}
int RGWRados::get_bucket_instance_info(RGWObjectCtx& obj_ctx, rgw_bucket& bucket, RGWBucketInfo& info,
- time_t *pmtime, map<string, bufferlist> *pattrs)
+ real_time *pmtime, map<string, bufferlist> *pattrs)
{
string oid;
if (bucket.oid.empty()) {
}
int RGWRados::get_bucket_instance_from_oid(RGWObjectCtx& obj_ctx, string& oid, RGWBucketInfo& info,
- time_t *pmtime, map<string, bufferlist> *pattrs,
+ real_time *pmtime, map<string, bufferlist> *pattrs,
rgw_cache_entry_info *cache_info)
{
ldout(cct, 20) << "reading from " << get_zone_params().domain_root << ":" << oid << dendl;
const string& bucket_name,
RGWBucketEntryPoint& entry_point,
RGWObjVersionTracker *objv_tracker,
- time_t *pmtime,
+ real_time *pmtime,
map<string, bufferlist> *pattrs,
rgw_cache_entry_info *cache_info)
{
const string& bucket_name)
{
RGWBucketEntryPoint entry_point;
- time_t ep_mtime;
+ real_time ep_mtime;
RGWObjVersionTracker ot;
map<string, bufferlist> attrs;
RGWBucketInfo info;
int RGWRados::get_bucket_info(RGWObjectCtx& obj_ctx,
const string& tenant, const string& bucket_name, RGWBucketInfo& info,
- time_t *pmtime, map<string, bufferlist> *pattrs)
+ real_time *pmtime, map<string, bufferlist> *pattrs)
{
bucket_info_entry e;
string bucket_entry;
bufferlist bl;
RGWBucketEntryPoint entry_point;
- time_t ep_mtime;
+ real_time ep_mtime;
RGWObjVersionTracker ot;
rgw_cache_entry_info entry_cache_info;
int ret = get_bucket_entrypoint_info(obj_ctx, tenant, bucket_name, entry_point, &ot, &ep_mtime, pattrs, &entry_cache_info);
}
int RGWRados::put_bucket_entrypoint_info(const string& tenant_name, const string& bucket_name, RGWBucketEntryPoint& entry_point,
- bool exclusive, RGWObjVersionTracker& objv_tracker, time_t mtime,
+ bool exclusive, RGWObjVersionTracker& objv_tracker, real_time mtime,
map<string, bufferlist> *pattrs)
{
bufferlist epbl;
}
int RGWRados::put_bucket_instance_info(RGWBucketInfo& info, bool exclusive,
- time_t mtime, map<string, bufferlist> *pattrs)
+ real_time mtime, map<string, bufferlist> *pattrs)
{
info.has_instance_obj = true;
bufferlist bl;
return rgw_bucket_instance_store_info(this, key, bl, exclusive, pattrs, &info.objv_tracker, mtime);
}
-int RGWRados::put_linked_bucket_info(RGWBucketInfo& info, bool exclusive, time_t mtime, obj_version *pep_objv,
+int RGWRados::put_linked_bucket_info(RGWBucketInfo& info, bool exclusive, real_time mtime, obj_version *pep_objv,
map<string, bufferlist> *pattrs, bool create_entry_point)
{
bufferlist bl;
rgw_bucket_dir_entry_meta dir_meta;
dir_meta.size = ent.size;
dir_meta.accounted_size = ent.size;
- dir_meta.mtime = utime_t(ent.mtime, 0);
+ dir_meta.mtime = ent.mtime;
dir_meta.etag = ent.etag;
dir_meta.owner = ent.owner.to_str();
dir_meta.owner_display_name = ent.owner_display_name;
ACLOwner owner;
object.size = astate->size;
- object.mtime = utime_t(astate->mtime, 0);
+ object.mtime = astate->mtime;
map<string, bufferlist>::iterator iter = astate->attrset.find(RGW_ATTR_ETAG);
if (iter != astate->attrset.end()) {
list_state.ver.pool = io_ctx.get_id();
list_state.ver.epoch = astate->epoch;
list_state.meta.size = object.size;
- list_state.meta.mtime.set_from_double(double(object.mtime));
+ list_state.meta.mtime = object.mtime;
list_state.meta.category = main_category;
list_state.meta.etag = etag;
list_state.meta.content_type = content_type;
}
int RGWOpStateSingleOp::set_state(RGWOpState::OpState state) {
- last_update = ceph_clock_now(cct);
+ last_update = real_clock::now();
cur_state = state;
return os.set_state(client_id, op_id, object, state);
}
int RGWOpStateSingleOp::renew_state() {
- utime_t now = ceph_clock_now(cct);
+ real_time now = real_clock::now();
int rate_limit_sec = cct->_conf->rgw_opstate_ratelimit_sec;
- if (rate_limit_sec && now - last_update < rate_limit_sec) {
+ if (rate_limit_sec && now - last_update < timespan(rate_limit_sec)) {
return 0;
}
#include "include/Context.h"
#include "common/RefCountedObj.h"
#include "common/RWLock.h"
+#include "common/ceph_time.h"
#include "rgw_common.h"
#include "cls/rgw/cls_rgw_types.h"
#include "cls/version/cls_version_types.h"
WRITE_CLASS_ENCODER(RGWOLHInfo)
struct RGWOLHPendingInfo {
- utime_t time;
+ ceph::real_time time;
RGWOLHPendingInfo() {}
WRITE_CLASS_ENCODER(RGWOLHPendingInfo)
struct RGWUsageBatch {
- map<utime_t, rgw_usage_log_entry> m;
+ map<ceph::real_time, rgw_usage_log_entry> m;
- void insert(utime_t& t, rgw_usage_log_entry& entry, bool *account) {
+ void insert(ceph::real_time& t, rgw_usage_log_entry& entry, bool *account) {
bool exists = m.find(t) != m.end();
*account = !exists;
m[t].aggregate(entry);
uint32_t num;
uint64_t size;
string etag;
- utime_t modified;
+ ceph::real_time modified;
RGWObjManifest manifest;
RGWUploadPartInfo() : num(0), size(0) {}
bool has_attrs;
bool exists;
uint64_t size;
- time_t mtime;
+ ceph::real_time mtime;
uint64_t epoch;
bufferlist obj_tag;
string write_tag;
map<string, bufferlist> attrset;
RGWObjState() : is_atomic(false), has_attrs(0), exists(false),
- size(0), mtime(0), epoch(0), fake_tag(false), has_manifest(false),
+ size(0), epoch(0), fake_tag(false), has_manifest(false),
has_data(false), prefetch_data(false), keep_tail(false), is_olh(false),
pg_ver(0), zone_short_id(0) {}
RGWObjState(const RGWObjState& rhs) : obj (rhs.obj) {
string bucket_name;
string bucket_id;
rgw_obj_key obj_key;
- utime_t exp_time;
+ ceph::real_time exp_time;
void encode(bufferlist& bl) const {
ENCODE_START(2, 1, bl);
CephContext *cct;
RGWOpState::OpState cur_state;
- utime_t last_update;
+ ceph::real_time last_update;
public:
RGWOpStateSingleOp(RGWRados *store, const string& cid, const string& oid, const string& obj);
void remove_rgw_head_obj(librados::ObjectWriteOperation& op);
void cls_obj_check_prefix_exist(librados::ObjectOperation& op, const string& prefix, bool fail_if_exist);
- void cls_obj_check_mtime(librados::ObjectOperation& op, const utime_t& mtime, RGWCheckMTimeType type);
+ void cls_obj_check_mtime(librados::ObjectOperation& op, const real_time& mtime, RGWCheckMTimeType type);
protected:
CephContext *cct;
RGWBucketInfo& bucket_info,
obj_version *pobjv,
obj_version *pep_objv,
- time_t creation_time,
+ ceph::real_time creation_time,
rgw_bucket *master_bucket,
bool exclusive = true);
virtual int add_bucket_placement(std::string& new_pool);
} state;
struct StatParams {
- time_t *lastmod;
+ ceph::real_time *lastmod;
uint64_t *obj_size;
map<string, bufferlist> *attrs;
struct rgw_err *perr;
} state;
struct ConditionParams {
- const time_t *mod_ptr;
- const time_t *unmod_ptr;
+ const ceph::real_time *mod_ptr;
+ const ceph::real_time *unmod_ptr;
uint32_t mod_zone_id;
uint64_t mod_pg_ver;
const char *if_match;
} conds;
struct Params {
- time_t *lastmod;
+ ceph::real_time *lastmod;
uint64_t *read_size;
uint64_t *obj_size;
map<string, bufferlist> *attrs;
RGWRados::Object *target;
struct MetaParams {
- time_t *mtime;
+ ceph::real_time *mtime;
map<std::string, bufferlist>* rmattrs;
const bufferlist *data;
RGWObjManifest *manifest;
const string *ptag;
list<rgw_obj_key> *remove_objs;
- time_t set_mtime;
+ ceph::real_time set_mtime;
rgw_user owner;
RGWObjCategory category;
int flags;
const char *if_match;
const char *if_nomatch;
uint64_t olh_epoch;
- time_t delete_at;
+ ceph::real_time delete_at;
bool canceled;
MetaParams() : mtime(NULL), rmattrs(NULL), data(NULL), manifest(NULL), ptag(NULL),
- remove_objs(NULL), set_mtime(0), category(RGW_OBJ_CATEGORY_MAIN), flags(0),
- if_match(NULL), if_nomatch(NULL), olh_epoch(0), delete_at(0), canceled(false) {}
+ remove_objs(NULL), category(RGW_OBJ_CATEGORY_MAIN), flags(0),
+ if_match(NULL), if_nomatch(NULL), olh_epoch(0), canceled(false) {}
} meta;
explicit Write(RGWRados::Object *_target) : target(_target) {}
string marker_version_id;
uint32_t bilog_flags;
list<rgw_obj_key> *remove_objs;
- utime_t expiration_time;
- time_t unmod_since;
- time_t mtime; /* for setting delete marker mtime */
+ ceph::real_time expiration_time;
+ ceph::real_time unmod_since;
+ ceph::real_time mtime; /* for setting delete marker mtime */
- DeleteParams() : versioning_status(0), olh_epoch(0), bilog_flags(0), remove_objs(NULL), unmod_since(0), mtime(0) {}
+ DeleteParams() : versioning_status(0), olh_epoch(0), bilog_flags(0), remove_objs(NULL) {}
} params;
struct DeleteResult {
RGWObjManifest manifest;
bool has_manifest;
uint64_t size;
- time_t mtime;
+ struct timespec mtime;
map<string, bufferlist> attrs;
- Result() : has_manifest(false), size(0), mtime(0) {}
+ Result() : has_manifest(false), size(0) {}
} result;
struct State {
int prepare(RGWModifyOp);
int complete(int64_t poolid, uint64_t epoch, uint64_t size,
- utime_t& ut, string& etag, string& content_type,
+ ceph::real_time& ut, string& etag, string& content_type,
bufferlist *acl_bl, RGWObjCategory category,
list<rgw_obj_key> *remove_objs);
int complete_del(int64_t poolid, uint64_t epoch,
};
/** Write/overwrite an object to the bucket storage. */
- virtual int put_system_obj_impl(rgw_obj& obj, uint64_t size, time_t *mtime,
+ virtual int put_system_obj_impl(rgw_obj& obj, uint64_t size, ceph::real_time *mtime,
map<std::string, bufferlist>& attrs, int flags,
bufferlist& data,
RGWObjVersionTracker *objv_tracker,
- time_t set_mtime /* 0 for don't set */);
+ ceph::real_time set_mtime /* 0 for don't set */);
virtual int put_system_obj_data(void *ctx, rgw_obj& obj, bufferlist& bl,
off_t ofs, bool exclusive);
off_t ofs, bool exclusive, void **handle);
int put_system_obj(void *ctx, rgw_obj& obj, const char *data, size_t len, bool exclusive,
- time_t *mtime, map<std::string, bufferlist>& attrs, RGWObjVersionTracker *objv_tracker,
- time_t set_mtime) {
+ ceph::real_time *mtime, map<std::string, bufferlist>& attrs, RGWObjVersionTracker *objv_tracker,
+ ceph::real_time set_mtime) {
bufferlist bl;
bl.append(data, len);
int flags = PUT_OBJ_CREATE;
rgw_obj& src_obj,
RGWBucketInfo& dest_bucket_info,
RGWBucketInfo& src_bucket_info,
- time_t *src_mtime,
- time_t *mtime,
- const time_t *mod_ptr,
- const time_t *unmod_ptr,
+ ceph::real_time *src_mtime,
+ ceph::real_time *mtime,
+ const ceph::real_time *mod_ptr,
+ const ceph::real_time *unmod_ptr,
const char *if_match,
const char *if_nomatch,
AttrsMod attrs_mod,
map<string, bufferlist>& attrs,
RGWObjCategory category,
uint64_t olh_epoch,
- time_t delete_at,
+ ceph::real_time delete_at,
string *version_id,
string *ptag,
string *petag,
RGWRados::Object::Read& read_op,
const rgw_user& user_id,
rgw_obj& dest_obj,
- time_t *mtime);
+ ceph::real_time *mtime);
/**
* Copy an object.
* dest_obj: the object to copy into
rgw_obj& src_obj,
RGWBucketInfo& dest_bucket_info,
RGWBucketInfo& src_bucket_info,
- time_t *src_mtime,
- time_t *mtime,
- const time_t *mod_ptr,
- const time_t *unmod_ptr,
+ ceph::real_time *src_mtime,
+ ceph::real_time *mtime,
+ const ceph::real_time *mod_ptr,
+ const ceph::real_time *unmod_ptr,
const char *if_match,
const char *if_nomatch,
AttrsMod attrs_mod,
map<std::string, bufferlist>& attrs,
RGWObjCategory category,
uint64_t olh_epoch,
- time_t delete_at,
+ ceph::real_time delete_at,
string *version_id,
string *ptag,
string *petag,
rgw_obj& dest_obj,
rgw_obj& src_obj,
uint64_t max_chunk_size,
- time_t *mtime,
- time_t set_mtime,
+ ceph::real_time *mtime,
+ ceph::real_time set_mtime,
map<string, bufferlist>& attrs,
RGWObjCategory category,
uint64_t olh_epoch,
- time_t delete_at,
+ ceph::real_time delete_at,
string *version_id,
string *ptag,
string *petag,
rgw_obj& src_obj,
int versioning_status,
uint16_t bilog_flags = 0,
- const utime_t& expiration_time = utime_t());
+ const ceph::real_time& expiration_time = ceph::real_time());
/* Delete a system object */
virtual int delete_system_obj(rgw_obj& src_obj, RGWObjVersionTracker *objv_tracker = NULL);
RGWRados::SystemObject::Read::GetObjState& state,
rgw_obj& obj,
map<string, bufferlist> *attrs,
- time_t *lastmod,
+ ceph::real_time *lastmod,
uint64_t *obj_size,
RGWObjVersionTracker *objv_tracker);
* a simple object read without keeping state
*/
- virtual int raw_obj_stat(rgw_obj& obj, uint64_t *psize, time_t *pmtime, uint64_t *epoch,
+ virtual int raw_obj_stat(rgw_obj& obj, uint64_t *psize, ceph::real_time *pmtime, uint64_t *epoch,
map<string, bufferlist> *attrs, bufferlist *first_chunk,
RGWObjVersionTracker *objv_tracker);
int bucket_index_link_olh(RGWObjState& olh_state, rgw_obj& obj_instance, bool delete_marker,
const string& op_tag, struct rgw_bucket_dir_entry_meta *meta,
uint64_t olh_epoch,
- time_t unmod_since);
+ ceph::real_time unmod_since);
int bucket_index_unlink_instance(rgw_obj& obj_instance, const string& op_tag, uint64_t olh_epoch);
int bucket_index_read_olh_log(RGWObjState& state, rgw_obj& obj_instance, uint64_t ver_marker,
map<uint64_t, vector<rgw_bucket_olh_log_entry> > *log, bool *is_truncated);
uint64_t *plast_ver);
int update_olh(RGWObjectCtx& obj_ctx, RGWObjState *state, RGWBucketInfo& bucket_info, rgw_obj& obj);
int set_olh(RGWObjectCtx& obj_ctx, RGWBucketInfo& bucket_info, rgw_obj& target_obj, bool delete_marker, rgw_bucket_dir_entry_meta *meta,
- uint64_t olh_epoch, time_t unmod_since);
+ uint64_t olh_epoch, ceph::real_time unmod_since);
int unlink_obj_instance(RGWObjectCtx& obj_ctx, RGWBucketInfo& bucket_info, rgw_obj& target_obj,
uint64_t olh_epoch);
void get_bucket_meta_oid(rgw_bucket& bucket, string& oid);
int put_bucket_entrypoint_info(const string& tenant_name, const string& bucket_name, RGWBucketEntryPoint& entry_point,
- bool exclusive, RGWObjVersionTracker& objv_tracker, time_t mtime,
+ bool exclusive, RGWObjVersionTracker& objv_tracker, ceph::real_time mtime,
map<string, bufferlist> *pattrs);
- int put_bucket_instance_info(RGWBucketInfo& info, bool exclusive, time_t mtime, map<string, bufferlist> *pattrs);
+ int put_bucket_instance_info(RGWBucketInfo& info, bool exclusive, ceph::real_time mtime, map<string, bufferlist> *pattrs);
int get_bucket_entrypoint_info(RGWObjectCtx& obj_ctx, const string& tenant_name, const string& bucket_name,
RGWBucketEntryPoint& entry_point, RGWObjVersionTracker *objv_tracker,
- time_t *pmtime, map<string, bufferlist> *pattrs, rgw_cache_entry_info *cache_info = NULL);
- int get_bucket_instance_info(RGWObjectCtx& obj_ctx, const string& meta_key, RGWBucketInfo& info, time_t *pmtime, map<string, bufferlist> *pattrs);
- int get_bucket_instance_info(RGWObjectCtx& obj_ctx, rgw_bucket& bucket, RGWBucketInfo& info, time_t *pmtime, map<string, bufferlist> *pattrs);
- int get_bucket_instance_from_oid(RGWObjectCtx& obj_ctx, string& oid, RGWBucketInfo& info, time_t *pmtime, map<string, bufferlist> *pattrs,
+ ceph::real_time *pmtime, map<string, bufferlist> *pattrs, rgw_cache_entry_info *cache_info = NULL);
+ int get_bucket_instance_info(RGWObjectCtx& obj_ctx, const string& meta_key, RGWBucketInfo& info, ceph::real_time *pmtime, map<string, bufferlist> *pattrs);
+ int get_bucket_instance_info(RGWObjectCtx& obj_ctx, rgw_bucket& bucket, RGWBucketInfo& info, ceph::real_time *pmtime, map<string, bufferlist> *pattrs);
+ int get_bucket_instance_from_oid(RGWObjectCtx& obj_ctx, string& oid, RGWBucketInfo& info, ceph::real_time *pmtime, map<string, bufferlist> *pattrs,
rgw_cache_entry_info *cache_info = NULL);
int convert_old_bucket_info(RGWObjectCtx& obj_ctx, const string& tenant_name, const string& bucket_name);
virtual int get_bucket_info(RGWObjectCtx& obj_ctx,
const string& tenant_name, const string& bucket_name,
RGWBucketInfo& info,
- time_t *pmtime, map<string, bufferlist> *pattrs = NULL);
- virtual int put_linked_bucket_info(RGWBucketInfo& info, bool exclusive, time_t mtime, obj_version *pep_objv,
+ ceph::real_time *pmtime, map<string, bufferlist> *pattrs = NULL);
+ virtual int put_linked_bucket_info(RGWBucketInfo& info, bool exclusive, ceph::real_time mtime, obj_version *pep_objv,
map<string, bufferlist> *pattrs, bool create_entry_point);
int cls_rgw_init_index(librados::IoCtx& io_ctx, librados::ObjectWriteOperation& op, string& oid);
void shard_name(const string& prefix, unsigned max_shards, const string& key, string& name, int *shard_id);
void shard_name(const string& prefix, unsigned max_shards, const string& section, const string& key, string& name);
void shard_name(const string& prefix, unsigned shard_id, string& name);
- void time_log_prepare_entry(cls_log_entry& entry, const utime_t& ut, const string& section, const string& key, bufferlist& bl);
+ void time_log_prepare_entry(cls_log_entry& entry, const ceph::real_time& ut, const string& section, const string& key, bufferlist& bl);
int time_log_add_init(librados::IoCtx& io_ctx);
int time_log_add(const string& oid, list<cls_log_entry>& entries,
librados::AioCompletion *completion, bool monotonic_inc = true);
- int time_log_add(const string& oid, const utime_t& ut, const string& section, const string& key, bufferlist& bl);
- int time_log_list(const string& oid, utime_t& start_time, utime_t& end_time,
+ int time_log_add(const string& oid, const ceph::real_time& ut, const string& section, const string& key, bufferlist& bl);
+ int time_log_list(const string& oid, const ceph::real_time& start_time, const ceph::real_time& end_time,
int max_entries, list<cls_log_entry>& entries,
const string& marker, string *out_marker, bool *truncated);
int time_log_info(const string& oid, cls_log_header *header);
int time_log_info_async(librados::IoCtx& io_ctx, const string& oid, cls_log_header *header, librados::AioCompletion *completion);
- int time_log_trim(const string& oid, const utime_t& start_time, const utime_t& end_time,
+ int time_log_trim(const string& oid, const ceph::real_time& start_time, const ceph::real_time& end_time,
const string& from_marker, const string& to_marker);
string objexp_hint_get_shardname(int shard_num);
int objexp_key_shard(const rgw_obj_key& key);
void objexp_get_shard(int shard_num,
string& shard); /* out */
- int objexp_hint_add(const utime_t& delete_at,
+ int objexp_hint_add(const ceph::real_time& delete_at,
const string& tenant_name,
const string& bucket_name,
const string& bucket_id,
const rgw_obj_key& obj_key);
int objexp_hint_list(const string& oid,
- const utime_t& start_time,
- const utime_t& end_time,
+ const ceph::real_time& start_time,
+ const ceph::real_time& end_time,
const int max_entries,
const string& marker,
list<cls_timeindex_entry>& entries, /* out */
int objexp_hint_parse(cls_timeindex_entry &ti_entry,
objexp_hint_entry& hint_entry); /* out */
int objexp_hint_trim(const string& oid,
- const utime_t& start_time,
- const utime_t& end_time,
+ const ceph::real_time& start_time,
+ const ceph::real_time& end_time,
const string& from_marker = std::string(),
const string& to_marker = std::string());
- int lock_exclusive(rgw_bucket& pool, const string& oid, utime_t& duration, string& zone_id, string& owner_id);
+ int lock_exclusive(rgw_bucket& pool, const string& oid, ceph::timespan& duration, string& zone_id, string& owner_id);
int unlock(rgw_bucket& pool, const string& oid, string& zone_id, string& owner_id);
void update_gc_chain(rgw_obj& head_obj, RGWObjManifest& manifest, cls_rgw_obj_chain *chain);
RGWBucketInfo bucket_info;
bool canceled;
- virtual int do_complete(string& etag, time_t *mtime, time_t set_mtime,
- map<string, bufferlist>& attrs, time_t delete_at,
+ virtual int do_complete(string& etag, ceph::real_time *mtime, ceph::real_time set_mtime,
+ map<string, bufferlist>& attrs, ceph::real_time delete_at,
const char *if_match = NULL, const char *if_nomatch = NULL) = 0;
public:
virtual void complete_hash(MD5 *hash) {
assert(0);
}
- virtual int complete(string& etag, time_t *mtime, time_t set_mtime,
- map<string, bufferlist>& attrs, time_t delete_at,
+ virtual int complete(string& etag, ceph::real_time *mtime, ceph::real_time set_mtime,
+ map<string, bufferlist>& attrs, ceph::real_time delete_at,
const char *if_match = NULL, const char *if_nomatch = NULL);
CephContext *ctx();
RGWObjManifest::generator manifest_gen;
int write_data(bufferlist& bl, off_t ofs, void **phandle, bool exclusive);
- virtual int do_complete(string& etag, time_t *mtime, time_t set_mtime,
- map<string, bufferlist>& attrs, time_t delete_at,
+ virtual int do_complete(string& etag, ceph::real_time *mtime, ceph::real_time set_mtime,
+ map<string, bufferlist>& attrs, ceph::real_time delete_at,
const char *if_match = NULL, const char *if_nomatch = NULL);
int prepare_next_part(off_t ofs);
STREAM_IO(s)->print("Location: %s\r\n", redirect.c_str());
}
-void dump_time_header(struct req_state *s, const char *name, time_t t)
+void dump_time_header(struct req_state *s, const char *name, real_time t)
{
+ utime_t ut(t);
+ time_t secs = (time_t)ut.sec();
char timestr[TIME_BUF_SIZE];
struct tm result;
- struct tm *tmp = gmtime_r(&t, &result);
+ struct tm *tmp = gmtime_r(&secs, &result);
if (tmp == NULL)
return;
}
}
-void dump_last_modified(struct req_state *s, time_t t)
+void dump_last_modified(struct req_state *s, real_time t)
{
dump_time_header(s, "Last-Modified", t);
}
-void dump_epoch_header(struct req_state *s, const char *name, time_t t)
+void dump_epoch_header(struct req_state *s, const char *name, real_time t)
{
- char buf[32];
- snprintf(buf, sizeof(buf), "%lld", (long long)t);
+ utime_t ut(t);
+ char sec_buf[32], nsec_buf[32];
+ snprintf(sec_buf, sizeof(sec_buf), "%lld", (long long)ut.sec());
+ snprintf(nsec_buf, sizeof(nsec_buf), "%09lld", (long long)ut.nsec());
- int r = STREAM_IO(s)->print("%s: %s\r\n", name, buf);
+ int r = STREAM_IO(s)->print("%s: %s.%s\r\n", name, sec_buf, nsec_buf);
if (r < 0) {
ldout(s->cct, 0) << "ERROR: s->cio->print() returned err=" << r << dendl;
}
}
-void dump_time(struct req_state *s, const char *name, time_t *t)
+void dump_time(struct req_state *s, const char *name, real_time *t)
{
+ utime_t ut(*t);
+
char buf[TIME_BUF_SIZE];
struct tm result;
- struct tm *tmp = gmtime_r(t, &result);
+ time_t epoch = ut.sec();
+ struct tm *tmp = gmtime_r(&epoch, &result);
if (tmp == NULL)
return;
- if (strftime(buf, sizeof(buf), "%Y-%m-%dT%T.000Z", tmp) == 0)
+ if (strftime(buf, sizeof(buf), "%Y-%m-%dT%T", tmp) == 0)
return;
- s->formatter->dump_string(name, buf);
+ char buf2[TIME_BUF_SIZE];
+ snprintf(buf2, sizeof(buf2), "%s.%03dZ", buf, (int)(ut.usec() / 1000));
+
+ s->formatter->dump_string(name, buf2);
}
void dump_owner(struct req_state *s, rgw_user& id, string& name,
const char *val);
extern void dump_content_length(struct req_state *s, uint64_t len);
extern void dump_etag(struct req_state *s, const char *etag);
-extern void dump_epoch_header(struct req_state *s, const char *name, time_t t);
-extern void dump_time_header(struct req_state *s, const char *name, time_t t);
-extern void dump_last_modified(struct req_state *s, time_t t);
+extern void dump_epoch_header(struct req_state *s, const char *name, real_time t);
+extern void dump_time_header(struct req_state *s, const char *name, real_time t);
+extern void dump_last_modified(struct req_state *s, real_time t);
extern void abort_early(struct req_state* s, RGWOp* op, int err,
RGWHandler* handler);
extern void dump_range(struct req_state* s, uint64_t ofs, uint64_t end,
uint64_t total_size);
extern void dump_continue(struct req_state *s);
extern void list_all_buckets_end(struct req_state *s);
-extern void dump_time(struct req_state *s, const char *name, time_t *t);
+extern void dump_time(struct req_state *s, const char *name, real_time *t);
extern void dump_bucket_from_state(struct req_state *s);
extern void dump_uri_from_state(struct req_state *s);
extern void dump_redirect(struct req_state *s, const string& redirect);
#include "common/ceph_crypto_cms.h"
#include "common/armor.h"
#include "common/strtol.h"
+#include "include/str_list.h"
#define dout_subsys ceph_subsys_rgw
}
}
-int RGWRESTStreamWriteRequest::complete(string& etag, time_t *mtime)
+static int parse_rgwx_mtime(CephContext *cct, const string& s, ceph::real_time *rt)
+{
+ string err;
+ vector<string> vec;
+
+ get_str_vec(s, ".", vec);
+
+ if (vec.empty()) {
+ return -EINVAL;
+ }
+
+ long secs = strict_strtol(vec[0].c_str(), 10, &err);
+ long nsecs = 0;
+ if (!err.empty()) {
+ ldout(cct, 0) << "ERROR: failed converting mtime (" << s << ") to real_time " << dendl;
+ return -EINVAL;
+ }
+
+ if (vec.size() > 1) {
+ nsecs = strict_strtol(vec[1].c_str(), 10, &err);
+ if (!err.empty()) {
+ ldout(cct, 0) << "ERROR: failed converting mtime (" << s << ") to real_time " << dendl;
+ return -EINVAL;
+ }
+ }
+
+ *rt = utime_t(secs, nsecs).to_real_time();
+
+ return 0;
+}
+
+int RGWRESTStreamWriteRequest::complete(string& etag, real_time *mtime)
{
int ret = http_manager.complete_requests();
if (ret < 0)
return ret;
set_str_from_headers(out_headers, "ETAG", etag);
+
if (mtime) {
string mtime_str;
set_str_from_headers(out_headers, "RGWX_MTIME", mtime_str);
- string err;
- long t = strict_strtol(mtime_str.c_str(), 10, &err);
- if (!err.empty()) {
- ldout(cct, 0) << "ERROR: failed converting mtime (" << mtime_str << ") to int " << dendl;
- return -EINVAL;
+
+ ret = parse_rgwx_mtime(cct, mtime_str, mtime);
+ if (ret < 0) {
+ return ret;
}
- *mtime = (time_t)t;
}
-
return status;
}
return 0;
}
-int RGWRESTStreamRWRequest::complete(string& etag, time_t *mtime, map<string, string>& attrs)
+int RGWRESTStreamRWRequest::complete(string& etag, real_time *mtime, map<string, string>& attrs)
{
set_str_from_headers(out_headers, "ETAG", etag);
if (mtime) {
string mtime_str;
set_str_from_headers(out_headers, "RGWX_MTIME", mtime_str);
- if (!mtime_str.empty()) {
- string err;
- long t = strict_strtol(mtime_str.c_str(), 10, &err);
- if (!err.empty()) {
- ldout(cct, 0) << "ERROR: failed converting mtime (" << mtime_str << ") to int " << dendl;
- return -EINVAL;
- }
- *mtime = (time_t)t;
+ int ret = parse_rgwx_mtime(cct, mtime_str, mtime);
+ if (ret < 0) {
+ return ret;
}
}
lock("RGWRESTStreamWriteRequest"), cb(NULL), http_manager(_cct) {}
~RGWRESTStreamWriteRequest();
int put_obj_init(RGWAccessKey& key, rgw_obj& obj, uint64_t obj_size, map<string, bufferlist>& attrs);
- int complete(string& etag, time_t *mtime);
+ int complete(string& etag, real_time *mtime);
RGWGetDataCB *get_out_cb() { return cb; }
};
virtual ~RGWRESTStreamRWRequest() {}
int get_obj(RGWAccessKey& key, map<string, string>& extra_headers, rgw_obj& obj);
int get_resource(RGWAccessKey& key, map<string, string>& extra_headers, const string& resource, RGWHTTPManager *mgr = NULL);
- int complete(string& etag, time_t *mtime, map<string, string>& attrs);
+ int complete(string& etag, real_time *mtime, map<string, string>& attrs);
void set_outbl(bufferlist& _outbl) {
outbl.swap(_outbl);
return (*req)->put_obj_init(key, obj, obj_size, attrs);
}
-int RGWRESTConn::complete_request(RGWRESTStreamWriteRequest *req, string& etag, time_t *mtime)
+int RGWRESTConn::complete_request(RGWRESTStreamWriteRequest *req, string& etag, real_time *mtime)
{
int ret = req->complete(etag, mtime);
delete req;
return ret;
}
-static void set_date_header(const time_t *t, map<string, string>& headers, const string& header_name)
+static void set_date_header(const real_time *t, map<string, string>& headers, const string& header_name)
{
if (!t) {
return;
}
stringstream s;
- utime_t tm = utime_t(*t, 0);
+ utime_t tm = utime_t(*t);
tm.asctime(s);
headers[header_name] = s.str();
}
int RGWRESTConn::get_obj(const rgw_user& uid, req_info *info /* optional */, rgw_obj& obj,
- const time_t *mod_ptr, const time_t *unmod_ptr,
+ const real_time *mod_ptr, const real_time *unmod_ptr,
uint32_t mod_zone_id, uint64_t mod_pg_ver,
bool prepend_metadata, RGWGetDataCB *cb, RGWRESTStreamReadRequest **req)
{
return (*req)->get_obj(key, extra_headers, obj);
}
-int RGWRESTConn::complete_request(RGWRESTStreamReadRequest *req, string& etag, time_t *mtime, map<string, string>& attrs)
+int RGWRESTConn::complete_request(RGWRESTStreamReadRequest *req, string& etag, real_time *mtime, map<string, string>& attrs)
{
int ret = req->complete(etag, mtime, attrs);
delete req;
/* async request */
int put_obj_init(const rgw_user& uid, rgw_obj& obj, uint64_t obj_size,
map<string, bufferlist>& attrs, RGWRESTStreamWriteRequest **req);
- int complete_request(RGWRESTStreamWriteRequest *req, string& etag, time_t *mtime);
+ int complete_request(RGWRESTStreamWriteRequest *req, string& etag, ceph::real_time *mtime);
int get_obj(const rgw_user& uid, req_info *info /* optional */, rgw_obj& obj,
- const time_t *mod_ptr, const time_t *unmod_ptr,
+ const ceph::real_time *mod_ptr, const ceph::real_time *unmod_ptr,
uint32_t mod_zone_id, uint64_t mod_pg_ver,
bool prepend_metadata, RGWGetDataCB *cb, RGWRESTStreamReadRequest **req);
- int complete_request(RGWRESTStreamReadRequest *req, string& etag, time_t *mtime, map<string, string>& attrs);
+ int complete_request(RGWRESTStreamReadRequest *req, string& etag, ceph::real_time *mtime, map<string, string>& attrs);
int get_resource(const string& resource,
param_list_t *extra_params,
#define LOG_CLASS_LIST_MAX_ENTRIES (1000)
#define dout_subsys ceph_subsys_rgw
-static int parse_date_str(string& in, utime_t& out) {
+static int parse_date_str(string& in, real_time& out) {
uint64_t epoch = 0;
uint64_t nsec = 0;
return -EINVAL;
}
}
- out = utime_t(epoch, nsec);
+ out = utime_t(epoch, nsec).to_real_time();
return 0;
}
et = s->info.args.get("end-time"),
marker = s->info.args.get("marker"),
err;
- utime_t ut_st,
- ut_et;
+ real_time ut_st,
+ ut_et;
void *handle;
unsigned shard_id, max_entries = LOG_CLASS_LIST_MAX_ENTRIES;
period = s->info.args.get("period"),
shard = s->info.args.get("id"),
err;
- utime_t ut_st,
- ut_et;
+ real_time ut_st,
+ ut_et;
unsigned shard_id;
http_ret = 0;
http_ret = -EINVAL;
return;
}
- utime_t time(dur, 0);
- http_ret = meta_log.lock_exclusive(shard_id, time, zone_id, locker_id);
+ http_ret = meta_log.lock_exclusive(shard_id, timespan(dur), zone_id,
+ locker_id);
if (http_ret == -EBUSY)
http_ret = -ERR_LOCKED;
}
max_entries_str = s->info.args.get("max-entries"),
marker = s->info.args.get("marker"),
err;
- utime_t ut_st,
- ut_et;
+ real_time ut_st,
+ ut_et;
unsigned shard_id, max_entries = LOG_CLASS_LIST_MAX_ENTRIES;
s->info.args.get_bool("extra-info", &extra_info, false);
http_ret = -EINVAL;
return;
}
- utime_t time(dur, 0);
- http_ret = store->data_log->lock_exclusive(shard_id, time, zone_id, locker_id);
+ http_ret = store->data_log->lock_exclusive(shard_id, timespan(dur), zone_id, locker_id);
if (http_ret == -EBUSY)
http_ret = -ERR_LOCKED;
}
end_marker = s->info.args.get("end-marker"),
shard = s->info.args.get("id"),
err;
- utime_t ut_st,
- ut_et;
+ real_time ut_st,
+ ut_et;
unsigned shard_id;
http_ret = 0;
http_ret = -EINVAL;
return;
}
- utime_t time(dur, 0);
- http_ret = store->meta_mgr->lock_exclusive(metadata_key, time, lock_id);
+ http_ret = store->meta_mgr->lock_exclusive(metadata_key, timespan(dur), lock_id);
if (http_ret == -EBUSY)
http_ret = -ERR_LOCKED;
}
static int bucket_instance_to_bucket(RGWRados *store, const string& bucket_instance, rgw_bucket& bucket) {
RGWBucketInfo bucket_info;
- time_t mtime;
+ real_time mtime;
RGWObjectCtx obj_ctx(store);
int r = store->get_bucket_instance_info(obj_ctx, bucket_instance, bucket_info, &mtime, NULL);
JSONFormatter jf;
jf.open_object_section("obj_metadata");
encode_json("attrs", attrs, &jf);
- encode_json("mtime", lastmod, &jf);
+ utime_t ut(lastmod);
+ encode_json("mtime", ut, &jf);
jf.close_section();
stringstream ss;
jf.flush(ss);
total_len += metadata_bl.length();
}
- if (s->system_request && lastmod) {
+ if (s->system_request && !real_clock::is_zero(lastmod)) {
/* we end up dumping mtime in two different methods, a bit redundant */
dump_epoch_header(s, "Rgwx-Mtime", lastmod);
uint64_t pg_ver = 0;
vector<RGWObjEnt>::iterator iter;
for (iter = objs.begin(); iter != objs.end(); ++iter) {
- time_t mtime = iter->mtime.sec();
const char *section_name = (iter->is_delete_marker() ? "DeleteMarker"
: "Version");
s->formatter->open_object_section(section_name);
}
s->formatter->dump_string("VersionId", version_id);
s->formatter->dump_bool("IsLatest", iter->is_current());
- dump_time(s, "LastModified", &mtime);
+ dump_time(s, "LastModified", &iter->mtime);
if (!iter->is_delete_marker()) {
s->formatter->dump_format("ETag", "\"%s\"", iter->etag.c_str());
s->formatter->dump_int("Size", iter->size);
} else {
s->formatter->dump_string("Key", iter->key.name);
}
- time_t mtime = iter->mtime.sec();
- dump_time(s, "LastModified", &mtime);
+ dump_time(s, "LastModified", &iter->mtime);
s->formatter->dump_format("ETag", "\"%s\"", iter->etag.c_str());
s->formatter->dump_int("Size", iter->size);
s->formatter->dump_string("StorageClass", "STANDARD");
dump_etag(s, etag.c_str());
dump_content_length(s, 0);
}
- if (s->system_request && mtime) {
+ if (s->system_request && !real_clock::is_zero(mtime)) {
dump_epoch_header(s, "Rgwx-Mtime", mtime);
}
dump_errno(s);
/* try to store user if it not already exists */
if (rgw_get_user_info_by_uid(store, uid, user_info) < 0) {
- int ret = rgw_store_user_info(store, user_info, NULL, NULL, 0, true);
+ int ret = rgw_store_user_info(store, user_info, NULL, NULL, real_time(), true);
if (ret < 0) {
ldout(store->ctx(), 10)
<< "NOTICE: failed to store new user's info: ret="
/* try to store user if it not already exists */
if (rgw_get_user_info_by_uid(store, user_info.user_id,
user_info) < 0) {
- int ret = rgw_store_user_info(store, user_info, NULL, NULL, 0, true);
+ int ret = rgw_store_user_info(store, user_info, NULL, NULL, real_time(), true);
if (ret < 0) {
ldout(store->ctx(), 10)
<< "NOTICE: failed to store new user's info: ret=" << ret
string if_unmod_decoded;
url_decode(if_unmod_str, if_unmod_decoded);
uint64_t epoch;
- if (utime_t::parse_date(if_unmod_decoded, &epoch, NULL) < 0) {
+ uint64_t nsec;
+ if (utime_t::parse_date(if_unmod_decoded, &epoch, &nsec) < 0) {
ldout(s->cct, 10) << "failed to parse time: " << if_unmod_decoded << dendl;
return -EINVAL;
}
- unmod_since = epoch;
+ unmod_since = utime_t(epoch, nsec).to_real_time();
}
return 0;
for (; iter != parts.end(); ++iter) {
RGWUploadPartInfo& info = iter->second;
- time_t sec = info.modified.sec();
- struct tm tmp;
- gmtime_r(&sec, &tmp);
- char buf[TIME_BUF_SIZE];
-
s->formatter->open_object_section("Part");
- if (strftime(buf, sizeof(buf), "%Y-%m-%dT%T.000Z", &tmp) > 0) {
- s->formatter->dump_string("LastModified", buf);
- }
+ dump_time(s, "LastModified", &info.modified);
s->formatter->dump_unsigned("PartNumber", info.num);
s->formatter->dump_string("ETag", info.etag);
dump_owner(s, s->user->user_id, s->user->display_name, "Initiator");
dump_owner(s, s->user->user_id, s->user->display_name);
s->formatter->dump_string("StorageClass", "STANDARD");
- time_t mtime = iter->obj.mtime.sec();
- dump_time(s, "Initiated", &mtime);
+ dump_time(s, "Initiated", &iter->obj.mtime);
s->formatter->close_section();
}
if (!common_prefixes.empty()) {
s->aws4_auth->date = s->info.args.get("X-Amz-Date");
struct tm date_t;
- if (!parse_iso8601(s->aws4_auth->date.c_str(), &date_t, false))
+ if (!parse_iso8601(s->aws4_auth->date.c_str(), &date_t, NULL, false))
return -EPERM;
s->aws4_auth->expires = s->info.args.get("X-Amz-Expires");
const char *d = s->info.env->get("HTTP_X_AMZ_DATE");
struct tm t;
- if (!parse_iso8601(d, &t, false)) {
+ if (!parse_iso8601(d, &t, NULL, false)) {
dout(10) << "error reading date via http_x_amz_date" << dendl;
return -EACCES;
}
rgw_user uid(project_id);
/* try to store user if it not already exists */
if (rgw_get_user_info_by_uid(store, uid, *(s->user)) < 0) {
- int ret = rgw_store_user_info(store, *(s->user), NULL, NULL, 0, true);
+ int ret = rgw_store_user_info(store, *(s->user), NULL, NULL, real_time(), true);
if (ret < 0)
dout(10) << "NOTICE: failed to store new user's info: ret="
<< ret << dendl;
s->user->display_name = token.id; // cn?
if (rgw_get_user_info_by_uid(store, s->user->user_id,
*(s->user)) < 0) {
- int ret = rgw_store_user_info(store, *(s->user), NULL, NULL, 0, true);
+ int ret = rgw_store_user_info(store, *(s->user), NULL, NULL, real_time(), true);
if (ret < 0) {
dout(10) << "NOTICE: failed to store new user's info: ret=" << ret
<< dendl;
}
s->formatter->dump_string("content_type", single_content_type);
}
- time_t mtime = iter->mtime.sec();
- dump_time(s, "last_modified", &mtime);
+ dump_time(s, "last_modified", &iter->mtime);
s->formatter->close_section();
}
{
char buf[32];
/* Adding X-Timestamp to keep align with Swift API */
- snprintf(buf, sizeof(buf), "%lld.00000",
- (long long)s->bucket_info.creation_time);
+ utime_t ut(s->bucket_info.creation_time);
+ snprintf(buf, sizeof(buf), "%lld.%05d",
+ (long long)ut.sec(), (int)(ut.usec() / 10));
STREAM_IO(s)->print("X-Timestamp: %s\r\n", buf);
snprintf(buf, sizeof(buf), "%lld", (long long)bucket.count);
STREAM_IO(s)->print("X-Container-Object-Count: %s\r\n", buf);
rgw_flush_formatter_and_reset(s, s->formatter);
}
-static int get_delete_at_param(req_state *s, time_t *delete_at)
+static int get_delete_at_param(req_state *s, real_time *delete_at)
{
/* Handle Swift object expiration. */
- utime_t delat_proposal;
+ real_time delat_proposal;
string x_delete = s->info.env->get("HTTP_X_DELETE_AFTER", "");
if (x_delete.empty()) {
} else {
/* X-Delete-After HTTP is present. It means we need add its value
* to the current time. */
- delat_proposal = ceph_clock_now(g_ceph_context);
+ delat_proposal = real_clock::now();
}
if (x_delete.empty()) {
return -EINVAL;
}
- delat_proposal += utime_t(ts, 0);
- if (delat_proposal < ceph_clock_now(g_ceph_context)) {
+ delat_proposal += timespan(ts);
+ if (delat_proposal < real_clock::now()) {
return -EINVAL;
}
- *delete_at = delat_proposal.sec();
+ *delete_at = delat_proposal;
return 0;
}
dump_content_length(s, total_len);
dump_last_modified(s, lastmod);
- STREAM_IO(s)->print("X-Timestamp: %lld.00000\r\n", (long long)lastmod);
+ {
+ utime_t ut(lastmod);
+ STREAM_IO(s)->print("X-Timestamp: %lld.%05d\r\n", (long long)ut.sec(), (int)(ut.usec() / 10));
+ }
if (is_slo) {
STREAM_IO(s)->print("X-Static-Large-Object: True\r\n");
}
user_info.user_id = info->user;
user_info.display_name = info->display_name;
- int ret = rgw_store_user_info(store, user_info, NULL, NULL, 0, true);
+ int ret = rgw_store_user_info(store, user_info, NULL, NULL, real_time(), true);
if (ret < 0) {
ldout(cct, 0) << "ERROR: failed to store new user's info: ret=" << ret << dendl;
return ret;
rgw_sync_error_info info(source_zone, error_code, message);
bufferlist bl;
::encode(info, bl);
- store->time_log_prepare_entry(entry, ceph_clock_now(store->ctx()), section, name, bl);
+ store->time_log_prepare_entry(entry, real_clock::now(), section, name, bl);
uint32_t shard_id = counter.inc() % num_shards;
JSONDecoder::decode_json("realm_epoch", realm_epoch, obj);
}
-
void rgw_mdlog_entry::decode_json(JSONObj *obj) {
JSONDecoder::decode_json("id", id, obj);
JSONDecoder::decode_json("section", section, obj);
JSONDecoder::decode_json("name", name, obj);
- JSONDecoder::decode_json("timestamp", timestamp, obj);
+ utime_t ut;
+ JSONDecoder::decode_json("timestamp", ut, obj);
+ timestamp = ut.to_real_time();
JSONDecoder::decode_json("data", log_data, obj);
}
protected:
int _send_request() {
- utime_t from_time;
- utime_t end_time;
+ real_time from_time;
+ real_time end_time;
void *handle;
marker_oid(_marker_oid),
sync_marker(_marker) {}
- RGWCoroutine *store_marker(const string& new_marker, uint64_t index_pos, const utime_t& timestamp) {
+ RGWCoroutine *store_marker(const string& new_marker, uint64_t index_pos, const real_time& timestamp) {
sync_marker.marker = new_marker;
if (index_pos > 0) {
sync_marker.pos = index_pos;
}
- if (timestamp.sec() > 0) {
+ if (!real_clock::is_zero(timestamp)) {
sync_marker.timestamp = timestamp;
}
for (; iter != entries.end(); ++iter) {
ldout(sync_env->cct, 20) << __func__ << ": full sync: " << iter->first << dendl;
total_entries++;
- if (!marker_tracker->start(iter->first, total_entries, utime_t())) {
+ if (!marker_tracker->start(iter->first, total_entries, real_time())) {
ldout(sync_env->cct, 0) << "ERROR: cannot start syncing " << iter->first << ". Duplicate entry?" << dendl;
} else {
// fetch remote and write locally
continue;
}
ldout(sync_env->cct, 20) << __func__ << ":" << __LINE__ << ": shard_id=" << shard_id << " log_entry: " << log_iter->id << ":" << log_iter->section << ":" << log_iter->name << ":" << log_iter->timestamp << dendl;
- if (!marker_tracker->start(log_iter->id, 0, log_iter->timestamp)) {
+ if (!marker_tracker->start(log_iter->id, 0, log_iter->timestamp.to_real_time())) {
ldout(sync_env->cct, 0) << "ERROR: cannot start syncing " << log_iter->id << ". Duplicate entry?" << dendl;
} else {
raw_key = log_iter->section + ":" + log_iter->name;
dest_entry.id = entry.id;
dest_entry.section = entry.section;
dest_entry.name = entry.name;
- dest_entry.timestamp = entry.timestamp;
+ dest_entry.timestamp = utime_t(entry.timestamp);
::encode(entry.log_data, dest_entry.data);
string id;
string section;
string name;
- utime_t timestamp;
+ ceph::real_time timestamp;
RGWMetadataLogData log_data;
void decode_json(JSONObj *obj);
id = le.id;
section = le.section;
name = le.name;
- timestamp = le.timestamp;
+ timestamp = le.timestamp.to_real_time();
try {
bufferlist::iterator iter = le.data.begin();
::decode(log_data, iter);
map<int, rgw_obj> shard_objs;
struct utime_shard {
- utime_t ts;
+ real_time ts;
int shard_id;
utime_shard() : shard_id(-1) {}
class RGWSyncShardMarkerTrack {
struct marker_entry {
uint64_t pos;
- utime_t timestamp;
+ real_time timestamp;
marker_entry() : pos(0) {}
- marker_entry(uint64_t _p, const utime_t& _ts) : pos(_p), timestamp(_ts) {}
+ marker_entry(uint64_t _p, const real_time& _ts) : pos(_p), timestamp(_ts) {}
};
typename std::map<T, marker_entry> pending;
protected:
typename std::set<K> need_retry_set;
- virtual RGWCoroutine *store_marker(const T& new_marker, uint64_t index_pos, const utime_t& timestamp) = 0;
+ virtual RGWCoroutine *store_marker(const T& new_marker, uint64_t index_pos, const real_time& timestamp) = 0;
virtual void handle_finish(const T& marker) { }
public:
RGWSyncShardMarkerTrack(int _window_size) : window_size(_window_size), updates_since_flush(0) {}
virtual ~RGWSyncShardMarkerTrack() {}
- bool start(const T& pos, int index_pos, const utime_t& timestamp) {
+ bool start(const T& pos, int index_pos, const real_time& timestamp) {
if (pending.find(pos) != pending.end()) {
return false;
}
return true;
}
- void try_update_high_marker(const T& pos, int index_pos, const utime_t& timestamp) {
+ void try_update_high_marker(const T& pos, int index_pos, const real_time& timestamp) {
if (!(pos <= high_marker)) {
high_marker = pos;
high_entry = marker_entry(index_pos, timestamp);
static map<string, string> ext_mime_map;
int rgw_put_system_obj(RGWRados *rgwstore, rgw_bucket& bucket, string& oid, const char *data, size_t size, bool exclusive,
- RGWObjVersionTracker *objv_tracker, time_t set_mtime, map<string, bufferlist> *pattrs)
+ RGWObjVersionTracker *objv_tracker, real_time set_mtime, map<string, bufferlist> *pattrs)
{
map<string,bufferlist> no_attrs;
if (!pattrs)
}
int rgw_get_system_obj(RGWRados *rgwstore, RGWObjectCtx& obj_ctx, rgw_bucket& bucket, const string& key, bufferlist& bl,
- RGWObjVersionTracker *objv_tracker, time_t *pmtime, map<string, bufferlist> *pattrs,
+ RGWObjVersionTracker *objv_tracker, real_time *pmtime, map<string, bufferlist> *pattrs,
rgw_cache_entry_info *cache_info)
{
struct rgw_err err;
#include <string>
#include "include/types.h"
+#include "common/ceph_time.h"
#include "rgw_common.h"
class RGWRados;
struct obj_version;
int rgw_put_system_obj(RGWRados *rgwstore, rgw_bucket& bucket, string& oid, const char *data, size_t size, bool exclusive,
- RGWObjVersionTracker *objv_tracker, time_t set_mtime, map<string, bufferlist> *pattrs = NULL);
+ RGWObjVersionTracker *objv_tracker, real_time set_mtime, map<string, bufferlist> *pattrs = NULL);
int rgw_get_system_obj(RGWRados *rgwstore, RGWObjectCtx& obj_ctx, rgw_bucket& bucket, const string& key, bufferlist& bl,
- RGWObjVersionTracker *objv_tracker, time_t *pmtime, map<string, bufferlist> *pattrs = NULL,
+ RGWObjVersionTracker *objv_tracker, real_time *pmtime, map<string, bufferlist> *pattrs = NULL,
rgw_cache_entry_info *cache_info = NULL);
int rgw_tools_init(CephContext *cct);
RGWUserInfo& info,
RGWUserInfo *old_info,
RGWObjVersionTracker *objv_tracker,
- time_t mtime,
+ real_time mtime,
bool exclusive,
map<string, bufferlist> *pattrs)
{
if (!old_info ||
old_info->user_email.compare(info.user_email) != 0) { /* only if new index changed */
ret = rgw_put_system_obj(store, store->get_zone_params().user_email_pool, info.user_email,
- link_bl.c_str(), link_bl.length(), exclusive, NULL, 0);
+ link_bl.c_str(), link_bl.length(), exclusive, NULL, real_time());
if (ret < 0)
return ret;
}
ret = rgw_put_system_obj(store, store->get_zone_params().user_keys_pool, k.id,
link_bl.c_str(), link_bl.length(), exclusive,
- NULL, 0);
+ NULL, real_time());
if (ret < 0)
return ret;
}
ret = rgw_put_system_obj(store, store->get_zone_params().user_swift_pool, k.id,
link_bl.c_str(), link_bl.length(), exclusive,
- NULL, 0);
+ NULL, real_time());
if (ret < 0)
return ret;
}
struct user_info_entry {
RGWUserInfo info;
RGWObjVersionTracker objv_tracker;
- time_t mtime;
+ real_time mtime;
};
static RGWChainedCacheImpl<user_info_entry> uinfo_cache;
int rgw_get_user_info_from_index(RGWRados *store, string& key, rgw_bucket& bucket, RGWUserInfo& info,
- RGWObjVersionTracker *objv_tracker, time_t *pmtime)
+ RGWObjVersionTracker *objv_tracker, real_time *pmtime)
{
user_info_entry e;
if (uinfo_cache.find(key, &e)) {
const rgw_user& uid,
RGWUserInfo& info,
RGWObjVersionTracker *objv_tracker,
- time_t *pmtime,
+ real_time *pmtime,
rgw_cache_entry_info *cache_info,
map<string, bufferlist> *pattrs)
{
* returns: 0 on success, -ERR# on failure (including nonexistence)
*/
int rgw_get_user_info_by_email(RGWRados *store, string& email, RGWUserInfo& info,
- RGWObjVersionTracker *objv_tracker, time_t *pmtime)
+ RGWObjVersionTracker *objv_tracker, real_time *pmtime)
{
return rgw_get_user_info_from_index(store, email, store->get_zone_params().user_email_pool, info, objv_tracker, pmtime);
}
* returns: 0 on success, -ERR# on failure (including nonexistence)
*/
extern int rgw_get_user_info_by_swift(RGWRados *store, string& swift_name, RGWUserInfo& info,
- RGWObjVersionTracker *objv_tracker, time_t *pmtime)
+ RGWObjVersionTracker *objv_tracker, real_time *pmtime)
{
return rgw_get_user_info_from_index(store, swift_name, store->get_zone_params().user_swift_pool, info, objv_tracker, pmtime);
}
* returns: 0 on success, -ERR# on failure (including nonexistence)
*/
extern int rgw_get_user_info_by_access_key(RGWRados *store, string& access_key, RGWUserInfo& info,
- RGWObjVersionTracker *objv_tracker, time_t *pmtime)
+ RGWObjVersionTracker *objv_tracker, real_time *pmtime)
{
return rgw_get_user_info_from_index(store, access_key, store->get_zone_params().user_keys_pool, info, objv_tracker, pmtime);
}
}
if (is_populated()) {
- ret = rgw_store_user_info(store, user_info, &old_info, &op_state.objv, 0, false);
+ ret = rgw_store_user_info(store, user_info, &old_info, &op_state.objv, real_time(), false);
if (ret < 0) {
set_err_msg(err_msg, "unable to store user info");
return ret;
return ret;
}
} else {
- ret = rgw_store_user_info(store, user_info, NULL, &op_state.objv, 0, false);
+ ret = rgw_store_user_info(store, user_info, NULL, &op_state.objv, real_time(), false);
if (ret < 0) {
set_err_msg(err_msg, "unable to store user info");
return ret;
class RGWUserMetadataObject : public RGWMetadataObject {
RGWUserCompleteInfo uci;
public:
- RGWUserMetadataObject(const RGWUserCompleteInfo& _uci, obj_version& v, time_t m)
+ RGWUserMetadataObject(const RGWUserCompleteInfo& _uci, obj_version& v, real_time m)
: uci(_uci) {
objv = v;
mtime = m;
int get(RGWRados *store, string& entry, RGWMetadataObject **obj) {
RGWUserCompleteInfo uci;
RGWObjVersionTracker objv_tracker;
- time_t mtime;
+ real_time mtime;
rgw_user uid(entry);
}
int put(RGWRados *store, string& entry, RGWObjVersionTracker& objv_tracker,
- time_t mtime, JSONObj *obj, sync_type_t sync_mode) {
+ real_time mtime, JSONObj *obj, sync_type_t sync_mode) {
RGWUserCompleteInfo uci;
try {
rgw_user uid(entry);
RGWUserInfo old_info;
- time_t orig_mtime;
+ real_time orig_mtime;
int ret = rgw_get_user_info_by_uid(store, uid, old_info, &objv_tracker, &orig_mtime);
if (ret < 0 && ret != -ENOENT)
return ret;
RGWUserInfo& info,
RGWUserInfo *old_info,
RGWObjVersionTracker *objv_tracker,
- time_t mtime,
+ real_time mtime,
bool exclusive,
map<string, bufferlist> *pattrs = NULL);
const rgw_user& user_id,
RGWUserInfo& info,
RGWObjVersionTracker *objv_tracker = NULL,
- time_t *pmtime = NULL,
+ real_time *pmtime = NULL,
rgw_cache_entry_info *cache_info = NULL,
map<string, bufferlist> *pattrs = NULL);
/**
* returns: 0 on success, -ERR# on failure (including nonexistence)
*/
extern int rgw_get_user_info_by_email(RGWRados *store, string& email, RGWUserInfo& info,
- RGWObjVersionTracker *objv_tracker = NULL, time_t *pmtime = NULL);
+ RGWObjVersionTracker *objv_tracker = NULL, real_time *pmtime = NULL);
/**
* Given an swift username, finds the user info associated with it.
* returns: 0 on success, -ERR# on failure (including nonexistence)
*/
extern int rgw_get_user_info_by_swift(RGWRados *store, string& swift_name, RGWUserInfo& info,
- RGWObjVersionTracker *objv_tracker = NULL, time_t *pmtime = NULL);
+ RGWObjVersionTracker *objv_tracker = NULL, real_time *pmtime = NULL);
/**
* Given an access key, finds the user info associated with it.
* returns: 0 on success, -ERR# on failure (including nonexistence)
*/
extern int rgw_get_user_info_by_access_key(RGWRados *store, string& access_key, RGWUserInfo& info,
- RGWObjVersionTracker *objv_tracker = NULL, time_t *pmtime = NULL);
+ RGWObjVersionTracker *objv_tracker = NULL, real_time *pmtime = NULL);
/**
* Get all the custom metadata stored for user specified in @user_id
* and put it into @attrs.
projects / ceph.git / commitdiff