RepoMirrors/ceph
1
0
Fork 0
mirror of https://github.com/ceph/ceph synced 2025-04-07 18:17:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

rgw: high resolution time

Browse Source 
replace time_t, and some utime_t with ceph::real_clock. Use new
librados interfaces to stat() and set mtime.

Signed-off-by: Yehuda Sadeh <yehuda@redhat.com>
Signed-off-by: Matt Benjamin <mbenjamin@redhat.com>
This commit is contained in:
Yehuda Sadeh 2016-03-02 22:23:41 -08:00
parent 0695698d34
commit 416234b38b
53 changed files with 797 additions and 676 deletions

39
src/cls/rgw/cls_rgw.cc
View File

@ -9,7 +9,7 @@
#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"
@ -114,10 +114,11 @@ static bool bi_entry_gt(const string& first, const string& second)
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;
}
@ -140,7 +141,7 @@ static void bi_log_index_key(cls_method_context_t hctx, string& key, string& id,
}
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)
{
@ -678,7 +679,7 @@ int rgw_bucket_prepare_op(cls_method_context_t hctx, bufferlist *in, bufferlist
// 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));
@ -1183,7 +1184,7 @@ public:
return 0;
}
time_t mtime() {
real_time mtime() {
return instance_entry.meta.mtime;
}
};
@ -1389,7 +1390,7 @@ static int rgw_bucket_link_olh(cls_method_context_t hctx, bufferlist *in, buffer
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 */
}
@ -1654,7 +1655,7 @@ static int rgw_bucket_unlink_instance(cls_method_context_t hctx, bufferlist *in,
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,
@ -1842,7 +1843,6 @@ int rgw_dir_suggest_changes(cls_method_context_t hctx, bufferlist *in, bufferlis
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) {
@ -1850,7 +1850,7 @@ int rgw_dir_suggest_changes(cls_method_context_t hctx, bufferlist *in, bufferlis
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();
@ -1882,7 +1882,7 @@ int rgw_dir_suggest_changes(cls_method_context_t hctx, bufferlist *in, bufferlis
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()) {
@ -2091,8 +2091,8 @@ static int rgw_obj_check_mtime(cls_method_context_t hctx, bufferlist *in, buffer
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;
@ -2101,11 +2101,12 @@ static int rgw_obj_check_mtime(cls_method_context_t hctx, bufferlist *in, buffer
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;
@ -2931,8 +2932,8 @@ static int gc_update_entry(cls_method_context_t hctx, uint32_t expiration_secs,
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;
@ -3027,7 +3028,7 @@ static int gc_iterate_entries(cls_method_context_t hctx, const string& marker, b
}
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);

4
src/cls/rgw/cls_rgw_client.cc
View File

@ -227,7 +227,7 @@ void cls_rgw_obj_check_attrs_prefix(librados::ObjectOperation& o, const string&
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;
@ -306,7 +306,7 @@ int cls_rgw_bi_list(librados::IoCtx& io_ctx, const string oid,
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;

5
src/cls/rgw/cls_rgw_client.h
View File

@ -8,6 +8,7 @@
#include "cls_rgw_ops.h"
#include "common/RefCountedObj.h"
#include "include/compat.h"
#include "common/ceph_time.h"
// Forward declaration
class BucketIndexAioManager;
@ -317,7 +318,7 @@ void cls_rgw_bucket_complete_op(librados::ObjectWriteOperation& o, RGWModifyOp o
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,
@ -330,7 +331,7 @@ int cls_rgw_bi_list(librados::IoCtx& io_ctx, const string oid,
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,

4
src/cls/rgw/cls_rgw_ops.cc
View File

@ -3,6 +3,7 @@
#include "common/Formatter.h"
#include "common/ceph_json.h"
#include "include/utime.h"
void rgw_cls_tag_timeout_op::dump(Formatter *f) const
{
@ -175,7 +176,8 @@ void rgw_cls_link_olh_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)

18
src/cls/rgw/cls_rgw_ops.h
View File

@ -4,6 +4,7 @@
#include <map>
#include "include/types.h"
#include "common/ceph_time.h"
#include "cls/rgw/cls_rgw_types.h"
struct rgw_cls_tag_timeout_op
@ -164,12 +165,12 @@ struct rgw_cls_link_olh_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);
@ -178,12 +179,14 @@ struct rgw_cls_link_olh_op {
::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);
@ -192,7 +195,12 @@ struct rgw_cls_link_olh_op {
::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);
@ -482,7 +490,7 @@ struct rgw_cls_obj_check_attrs_prefix {
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) {}

22
src/cls/rgw/cls_rgw_types.cc
View File

@ -2,6 +2,7 @@
#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)
@ -16,7 +17,8 @@ void rgw_bucket_pending_info::generate_test_instances(list<rgw_bucket_pending_in
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);
}
@ -24,7 +26,8 @@ void rgw_bucket_pending_info::decode_json(JSONObj *obj) {
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;
}
@ -51,7 +54,8 @@ void rgw_bucket_dir_entry_meta::dump(Formatter *f) const
{
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);
@ -64,7 +68,8 @@ void rgw_bucket_dir_entry_meta::decode_json(JSONObj *obj) {
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);
@ -343,7 +348,9 @@ void rgw_bi_log_entry::decode_json(JSONObj *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);
@ -399,7 +406,8 @@ void rgw_bi_log_entry::dump(Formatter *f) const
}
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();
@ -415,7 +423,7 @@ void rgw_bi_log_entry::generate_test_instances(list<rgw_bi_log_entry*>& ls)
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;

15
src/cls/rgw/cls_rgw_types.h
View File

@ -4,7 +4,7 @@
#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"
@ -49,7 +49,7 @@ enum RGWCheckMTimeType {
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) {}
@ -80,7 +80,7 @@ WRITE_CLASS_ENCODER(rgw_bucket_pending_info)
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;
@ -88,7 +88,7 @@ struct rgw_bucket_dir_entry_meta {
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);
@ -474,7 +474,7 @@ struct rgw_bi_log_entry {
string id;
string object;
string instance;
utime_t timestamp;
ceph::real_time timestamp;
rgw_bucket_entry_ver ver;
RGWModifyOp op;
RGWPendingState state;
@ -891,7 +891,7 @@ struct cls_rgw_gc_obj_info
{
string tag;
cls_rgw_obj_chain chain;
utime_t time;
ceph::real_time time;
cls_rgw_gc_obj_info() {}
@ -922,7 +922,8 @@ struct 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)

4
src/cls/user/cls_user_client.cc
View File

@ -18,7 +18,7 @@ void cls_user_set_buckets(librados::ObjectWriteOperation& op, list<cls_user_buck
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);
}
@ -27,7 +27,7 @@ void cls_user_complete_stats_sync(librados::ObjectWriteOperation& op)
{
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);
}

8
src/cls/user/cls_user_ops.cc
View File

@ -10,7 +10,7 @@ void cls_user_set_buckets_op::dump(Formatter *f) const
{
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)
@ -23,7 +23,7 @@ void cls_user_set_buckets_op::generate_test_instances(list<cls_user_set_buckets_
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);
}
@ -101,14 +101,14 @@ void cls_user_get_header_ret::generate_test_instances(list<cls_user_get_header_r
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);
}

5
src/cls/user/cls_user_ops.h
View File

@ -6,11 +6,12 @@
#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) {}
@ -159,7 +160,7 @@ struct cls_user_get_header_ret {
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() {}

12
src/cls/user/cls_user_types.cc
View File

@ -40,7 +40,7 @@ void cls_user_bucket_entry::dump(Formatter *f) const
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);
}
@ -50,7 +50,7 @@ void cls_user_gen_test_bucket_entry(cls_user_bucket_entry *entry, int i)
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;
}
@ -88,15 +88,15 @@ void cls_user_stats::generate_test_instances(list<cls_user_stats*>& ls)
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)

20
src/cls/user/cls_user_types.h
View File

@ -7,6 +7,7 @@
#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
@ -72,16 +73,16 @@ struct cls_user_bucket_entry {
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);
@ -91,6 +92,7 @@ struct cls_user_bucket_entry {
s = size_rounded;
::encode(s, bl);
::encode(user_stats_sync, bl);
::encode(creation_time, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
@ -102,7 +104,9 @@ struct cls_user_bucket_entry {
::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)
@ -112,6 +116,8 @@ struct cls_user_bucket_entry {
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;
@ -154,8 +160,8 @@ WRITE_CLASS_ENCODER(cls_user_stats)
*/
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);

37
src/rgw/rgw_admin.cc
View File

@ -807,7 +807,7 @@ static void dump_bucket_usage(map<RGWObjCategory, RGWStorageStats>& stats, Forma
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)
@ -829,7 +829,7 @@ int bucket_stats(rgw_bucket& bucket, int shard_id, Formatter *formatter)
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);
@ -1043,7 +1043,7 @@ int set_bucket_quota(RGWRados *store, int opt_cmd,
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;
@ -1704,21 +1704,21 @@ static void get_md_sync_status(list<string>& status)
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;
}
}
@ -1838,21 +1838,21 @@ static void get_data_sync_status(const string& source_zone, list<string>& status
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;
}
}
@ -4399,7 +4399,7 @@ next:
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) ||
@ -4753,8 +4753,7 @@ next:
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);
@ -4833,7 +4832,7 @@ next:
}
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;
@ -5162,8 +5161,8 @@ next:
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;
}
@ -5247,7 +5246,7 @@ next:
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;
@ -5303,7 +5302,7 @@ next:
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;

87
src/rgw/rgw_bucket.cc
View File

@ -178,7 +178,7 @@ int rgw_bucket_sync_user_stats(RGWRados *store, const string& tenant_name, const
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;
@ -191,8 +191,8 @@ int rgw_link_bucket(RGWRados *store, const rgw_user& user_id, rgw_bucket& bucket
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;
@ -222,7 +222,7 @@ int rgw_link_bucket(RGWRados *store, const rgw_user& user_id, rgw_bucket& bucket
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;
@ -275,7 +275,7 @@ int rgw_unlink_bucket(RGWRados *store, const rgw_user& user_id, const string& te
}
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;
@ -284,13 +284,13 @@ int rgw_unlink_bucket(RGWRados *store, const rgw_user& user_id, const string& te
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);
}
@ -350,7 +350,7 @@ int rgw_bucket_set_attrs(RGWRados *store, RGWBucketInfo& bucket_info,
::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,
@ -400,7 +400,7 @@ void check_bad_user_bucket_mapping(RGWRados *store, const rgw_user& user_id,
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) {
@ -658,13 +658,13 @@ int RGWBucket::link(RGWBucketAdminOpState& op_state, std::string *err_msg)
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;
}
@ -1129,7 +1129,7 @@ static int bucket_stats(RGWRados *store, const std::string& tenant_name, std::st
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)
@ -1145,7 +1145,7 @@ static int bucket_stats(RGWRados *store, const std::string& tenant_name, std::st
return ret;
}
utime_t ut(mtime, 0);
utime_t ut(mtime);
formatter->open_object_section("stats");
formatter->dump_string("bucket", bucket.name);
@ -1259,7 +1259,8 @@ void rgw_data_change::dump(Formatter *f) const
}
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) {
@ -1271,19 +1272,24 @@ 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);
}
@ -1311,7 +1317,7 @@ int RGWDataChangesLog::renew_entries()
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;
@ -1343,7 +1349,7 @@ int RGWDataChangesLog::renew_entries()
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) {
@ -1353,8 +1359,8 @@ int RGWDataChangesLog::renew_entries()
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;
@ -1381,7 +1387,7 @@ void RGWDataChangesLog::register_renew(rgw_bucket_shard& bs)
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;
@ -1413,7 +1419,7 @@ int RGWDataChangesLog::add_entry(rgw_bucket& bucket, int shard_id) {
lock.Unlock();
utime_t now = ceph_clock_now(cct);
real_time now = real_clock::now();
status->lock->Lock();
@ -1449,7 +1455,7 @@ int RGWDataChangesLog::add_entry(rgw_bucket& bucket, int shard_id) {
status->pending = true;
string& oid = oids[index];
utime_t expiration;
real_time expiration;
int ret;
@ -1457,7 +1463,7 @@ int RGWDataChangesLog::add_entry(rgw_bucket& bucket, int shard_id) {
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();
@ -1478,17 +1484,17 @@ int RGWDataChangesLog::add_entry(rgw_bucket& bucket, int shard_id) {
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();
@ -1498,7 +1504,7 @@ int RGWDataChangesLog::add_entry(rgw_bucket& bucket, int shard_id) {
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,
@ -1516,7 +1522,8 @@ int RGWDataChangesLog::list_entries(int shard, utime_t& start_time, utime_t& end
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);
@ -1530,7 +1537,7 @@ int RGWDataChangesLog::list_entries(int shard, utime_t& start_time, utime_t& end
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();
@ -1570,12 +1577,12 @@ int RGWDataChangesLog::get_info(int shard_id, RGWDataChangesLogInfo *info)
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;
@ -1591,7 +1598,7 @@ int RGWDataChangesLog::trim_entries(int shard_id, const utime_t& start_time, con
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++) {
@ -1692,7 +1699,7 @@ public:
RGWObjVersionTracker ot;
RGWBucketEntryPoint be;
time_t mtime;
real_time mtime;
map<string, bufferlist> attrs;
RGWObjectCtx obj_ctx(store);
@ -1710,7 +1717,7 @@ public:
}
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);
@ -1718,7 +1725,7 @@ public:
return -EINVAL;
}
time_t orig_mtime;
real_time orig_mtime;
map<string, bufferlist> attrs;
RGWObjVersionTracker old_ot;
@ -1850,7 +1857,7 @@ public:
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);
@ -1865,7 +1872,7 @@ public:
}
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);
@ -1873,7 +1880,7 @@ public:
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,

33
src/rgw/rgw_bucket.h
View File

@ -17,6 +17,7 @@
#include "common/Formatter.h"
#include "common/lru_map.h"
#include "common/ceph_time.h"
#include "rgw_formats.h"
@ -27,10 +28,10 @@ extern void rgw_get_buckets_obj(const rgw_user& user_id, string& buckets_obj_id)
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);
@ -64,7 +65,7 @@ struct RGWBucketCompleteInfo {
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;
}
@ -78,7 +79,7 @@ class RGWBucketInstanceMetadataObject : public RGWMetadataObject {
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;
}
@ -167,7 +168,7 @@ extern int rgw_read_user_buckets(RGWRados *store,
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);
@ -315,7 +316,7 @@ enum DataLogEntityType {
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);
@ -343,7 +344,7 @@ WRITE_CLASS_ENCODER(rgw_data_change)
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 {
@ -369,7 +370,7 @@ WRITE_CLASS_ENCODER(rgw_data_change_log_entry)
struct RGWDataChangesLogInfo {
string marker;
utime_t last_update;
real_time last_update;
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
@ -389,8 +390,8 @@ class RGWDataChangesLog {
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;
@ -412,7 +413,7 @@ class RGWDataChangesLog {
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;
@ -459,17 +460,17 @@ public:
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) {
@ -481,7 +482,7 @@ public:
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);

29
src/rgw/rgw_cache.h
View File

@ -27,23 +27,20 @@ enum {
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;
@ -231,11 +228,11 @@ public:
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,
@ -244,7 +241,7 @@ public:
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);
@ -387,11 +384,11 @@ int RGWCache<T>::system_obj_set_attrs(void *ctx, rgw_obj& obj,
}
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;
@ -406,9 +403,9 @@ int RGWCache<T>::put_system_obj_impl(rgw_obj& obj, uint64_t size, time_t *mtime,
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;
}
@ -459,7 +456,7 @@ int RGWCache<T>::put_system_obj_data(void *ctx, rgw_obj& obj, bufferlist& data,
}
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)
{
@ -470,7 +467,7 @@ int RGWCache<T>::raw_obj_stat(rgw_obj& obj, uint64_t *psize, time_t *pmtime,
string name = normal_name(bucket, oid);
uint64_t size;
time_t mtime;
real_time mtime;
uint64_t epoch;
ObjectCacheInfo info;

32
src/rgw/rgw_common.cc
View File

@ -388,7 +388,7 @@ bool parse_rfc2616(const char *s, struct tm *t)
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;
@ -416,10 +416,33 @@ bool parse_iso8601(const char *s, struct tm *t, bool extended_format)
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;
}
@ -445,14 +468,15 @@ int parse_key_value(string& in_str, string& key, string& val)
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;
}

63
src/rgw/rgw_common.h
View File

@ -866,7 +866,7 @@ struct RGWBucketInfo
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 */
@ -897,12 +897,12 @@ struct RGWBucketInfo
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);
@ -920,10 +920,11 @@ struct RGWBucketInfo
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;
@ -934,10 +935,10 @@ struct RGWBucketInfo
::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);
@ -976,6 +977,9 @@ struct RGWBucketInfo
::decode(swift_ver_location, bl);
}
}
if (struct_v >= 17) {
::decode(creation_time, bl);
}
DECODE_FINISH(bl);
}
void dump(Formatter *f) const;
@ -989,7 +993,7 @@ struct RGWBucketInfo
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)
@ -998,27 +1002,28 @@ struct RGWBucketEntryPoint
{
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);
@ -1031,10 +1036,15 @@ struct RGWBucketEntryPoint
::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);
}
@ -1284,7 +1294,7 @@ struct RGWObjEnt {
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;
@ -1311,10 +1321,10 @@ struct RGWBucketEnt {
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),
@ -1331,9 +1341,9 @@ struct RGWBucketEnt {
}
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);
@ -1342,10 +1352,11 @@ struct RGWBucketEnt {
::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
@ -1353,7 +1364,9 @@ struct RGWBucketEnt {
::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)
@ -1361,6 +1374,8 @@ struct RGWBucketEnt {
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;
@ -1816,9 +1831,9 @@ extern void parse_csv_string(const string& ival, vector<string>& ovals);
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);

4
src/rgw/rgw_cr_rados.cc
View File

@ -477,7 +477,7 @@ int RGWAsyncFetchRemoteObj::_send_request()
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, */
@ -624,7 +624,7 @@ int RGWAsyncStatObj::_send_request()
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),

16
src/rgw/rgw_cr_rados.h
View File

@ -718,7 +718,7 @@ class RGWAsyncRemoveObj : public RGWAsyncRadosRequest {
string marker_version_id;
bool del_if_older;
utime_t timestamp;
ceph::real_time timestamp;
protected:
int _send_request();
@ -733,7 +733,7 @@ public:
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),
@ -765,7 +765,7 @@ class RGWRemoveObjCR : public RGWSimpleCoroutine {
string owner_display_name;
bool del_if_older;
utime_t timestamp;
real_time timestamp;
RGWAsyncRemoveObj *req;
@ -779,7 +779,7 @@ public:
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),
@ -896,7 +896,7 @@ class RGWAsyncStatObj : public RGWAsyncRadosRequest {
RGWRados *store;
rgw_obj obj;
uint64_t *psize;
time_t *pmtime;
ceph::real_time *pmtime;
uint64_t *pepoch;
RGWObjVersionTracker *objv_tracker;
protected:
@ -904,7 +904,7 @@ 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) {}
@ -915,14 +915,14 @@ class RGWStatObjCR : public RGWSimpleCoroutine {
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();

33
src/rgw/rgw_data_sync.cc
View File

@ -30,10 +30,11 @@ void rgw_datalog_info::decode_json(JSONObj *obj) {
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) {
@ -705,7 +706,7 @@ public:
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;
@ -984,7 +985,7 @@ public:
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
@ -1656,7 +1657,7 @@ struct bucket_list_entry {
bool delete_marker;
rgw_obj_key key;
bool is_latest;
utime_t mtime;
real_time mtime;
string etag;
uint64_t size;
string storage_class;
@ -1675,11 +1676,12 @@ struct bucket_list_entry {
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);
@ -1827,7 +1829,7 @@ public:
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;
@ -1869,7 +1871,7 @@ public:
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;
@ -1922,7 +1924,7 @@ class RGWBucketSyncSingleEntryCR : public RGWCoroutine {
bool versioned;
uint64_t versioned_epoch;
bucket_entry_owner owner;
utime_t timestamp;
real_time timestamp;
RGWModifyOp op;
RGWPendingState op_state;
@ -1938,7 +1940,7 @@ public:
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),
@ -2115,7 +2117,7 @@ int RGWBucketShardFullSyncCR::operate()
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);
@ -2309,6 +2311,7 @@ int RGWBucketShardIncrementalSyncCR::operate()
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);

6
src/rgw/rgw_data_sync.h
View File

@ -74,7 +74,7 @@ struct rgw_data_sync_marker {
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) {}
@ -106,7 +106,7 @@ struct rgw_data_sync_marker {
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)
@ -140,7 +140,7 @@ WRITE_CLASS_ENCODER(rgw_data_sync_status)
struct rgw_datalog_entry {
string key;
utime_t timestamp;
ceph::real_time timestamp;
void decode_json(JSONObj *obj);
};

12
src/rgw/rgw_file.cc
View File

@ -105,7 +105,7 @@ namespace rgw {
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;
}
@ -614,11 +614,11 @@ namespace rgw {
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);
}
@ -758,8 +758,7 @@ int rgw_create(struct rgw_fs *rgw_fs,
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);
@ -832,8 +831,7 @@ int rgw_mkdir(struct rgw_fs *rgw_fs,
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;

18
src/rgw/rgw_file.h
View File

@ -461,10 +461,10 @@ namespace rgw {
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) {
@ -679,7 +679,7 @@ namespace rgw {
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)
@ -1503,14 +1503,14 @@ public:
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; }
@ -1612,7 +1612,7 @@ public:
return 0;
}
time_t get_ctime() const {
real_time get_ctime() const {
return bucket.creation_time;
}

44
src/rgw/rgw_json_enc.cc
View File

@ -45,7 +45,8 @@ void RGWOLHInfo::dump(Formatter *f) const
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
@ -188,7 +189,7 @@ void RGWAccessControlPolicy::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
@ -520,7 +521,8 @@ void RGWBucketEntryPoint::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) {
@ -531,7 +533,8 @@ void RGWBucketEntryPoint::dump(Formatter *f) const
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) {
@ -623,7 +626,8 @@ void RGWBucketWebsiteConf::decode_json(JSONObj *obj) {
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);
@ -643,7 +647,8 @@ void RGWBucketInfo::dump(Formatter *f) const
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);
@ -681,7 +686,8 @@ void RGWObjEnt::dump(Formatter *f) const
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);
@ -693,7 +699,8 @@ void RGWBucketEnt::dump(Formatter *f) const
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);
}
@ -702,7 +709,8 @@ void RGWUploadPartInfo::dump(Formatter *f) const
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
@ -1019,25 +1027,29 @@ void RGWZoneGroupMap::decode_json(JSONObj *obj)
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);
}
@ -1208,7 +1220,9 @@ void rgw_meta_sync_marker::decode_json(JSONObj *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
@ -1218,7 +1232,7 @@ 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)

3
src/rgw/rgw_log.cc
View File

@ -135,7 +135,8 @@ public:
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);

4
src/rgw/rgw_meta_sync_status.h
View File

@ -3,6 +3,8 @@
#include <string>
#include "common/ceph_time.h"
struct rgw_meta_sync_info {
enum SyncState {
StateInit = 0,
@ -52,7 +54,7 @@ struct rgw_meta_sync_marker {
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) {}

31
src/rgw/rgw_metadata.cc
View File

@ -102,7 +102,7 @@ int RGWMetadataLog::add_entry(RGWMetadataHandler *handler, const string& section
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);
}
@ -115,7 +115,7 @@ int RGWMetadataLog::store_entries_in_shard(list<cls_log_entry>& entries, int sha
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();
@ -171,7 +171,7 @@ int RGWMetadataLog::get_info(int shard_id, RGWMetadataLogInfo *info)
return ret;
info->marker = header.max_marker;
info->last_update = header.max_time;
info->last_update = header.max_time.to_real_time();
return 0;
}
@ -201,7 +201,7 @@ public:
*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();
@ -243,7 +243,7 @@ int RGWMetadataLog::get_info_async(int shard_id, RGWMetadataLogInfo *info, RGWCo
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;
@ -259,7 +259,7 @@ int RGWMetadataLog::trim(int shard_id, const utime_t& from_time, const utime_t&
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);
@ -311,7 +311,7 @@ public:
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) {}
@ -567,9 +567,10 @@ int RGWMetadataManager::get(string& metadata_key, Formatter *f)
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();
@ -599,7 +600,7 @@ int RGWMetadataManager::put(string& metadata_key, bufferlist& bl,
obj_version *objv = &objv_tracker.write_version;
time_t mtime = 0;
utime_t mtime;
try {
JSONDecoder::decode_json("key", metadata_key, &parser);
@ -614,7 +615,7 @@ int RGWMetadataManager::put(string& metadata_key, bufferlist& bl,
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;
}
@ -646,7 +647,7 @@ int RGWMetadataManager::remove(string& metadata_key)
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;
@ -820,7 +821,7 @@ string RGWMetadataManager::heap_oid(RGWMetadataHandler *handler, const string& k
}
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) {
@ -863,7 +864,7 @@ int RGWMetadataManager::remove_from_heap(RGWMetadataHandler *handler, const stri
}
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;

31
src/rgw/rgw_metadata.h
View File

@ -12,6 +12,7 @@
#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;
@ -33,13 +34,13 @@ enum RGWMDLogStatus {
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;
};
@ -72,7 +73,7 @@ public:
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;
@ -92,8 +93,8 @@ protected:
*
* @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:
@ -131,7 +132,7 @@ protected:
struct RGWMetadataLogInfo {
string marker;
utime_t last_update;
real_time last_update;
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
@ -172,8 +173,8 @@ public:
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;
@ -182,7 +183,7 @@ public:
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,
@ -190,10 +191,10 @@ public:
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);
@ -245,7 +246,7 @@ class RGWMetadataManager {
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:
@ -266,7 +267,7 @@ 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,
@ -281,7 +282,7 @@ public:
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);

10
src/rgw/rgw_object_expirer_core.cc
View File

@ -129,7 +129,10 @@ void RGWObjectExpirer::trim_chunk(const string& shard,
{
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;
}
@ -163,8 +166,11 @@ void RGWObjectExpirer::process_single_shard(const string& shard,
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) {

27
src/rgw/rgw_op.cc
View File

@ -1546,7 +1546,7 @@ void RGWSetBucketVersioning::execute()
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
@ -1598,7 +1598,7 @@ void RGWSetBucketWebsite::execute()
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;
@ -1623,7 +1623,7 @@ void RGWDeleteBucketWebsite::execute()
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;
@ -1866,7 +1866,7 @@ void RGWCreateBucket::execute()
RGWBucketInfo master_info;
rgw_bucket *pmaster_bucket;
time_t creation_time;
real_time creation_time;
if (!store->is_meta_master()) {
JSONParser jp;
@ -1884,7 +1884,6 @@ void RGWCreateBucket::execute()
pobjv = &objv;
} else {
pmaster_bucket = NULL;
creation_time = 0;
}
string zonegroup_id;
@ -2060,8 +2059,8 @@ class RGWPutObjProcessor_Multipart : public RGWPutObjProcessor_Atomic
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:
@ -2134,8 +2133,8 @@ static bool is_v2_upload_id(const string& upload_id)
(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();
@ -2173,7 +2172,7 @@ int RGWPutObjProcessor_Multipart::do_complete(string& etag, time_t *mtime, time_
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);
@ -2467,7 +2466,7 @@ void RGWPutObj::execute()
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:
@ -2589,7 +2588,7 @@ void RGWPostObj::execute()
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);
@ -2750,7 +2749,7 @@ void RGWPutMetadataAccount::execute()
/* 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;
}
@ -3592,7 +3591,7 @@ void RGWSetRequestPayment::execute()
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

59
src/rgw/rgw_op.h
View File

@ -23,6 +23,7 @@
#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"
@ -111,11 +112,11 @@ protected:
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;
@ -140,9 +141,6 @@ public:
ofs = 0;
total_len = 0;
end = -1;
mod_time = 0;
lastmod = 0;
unmod_time = 0;
mod_ptr = NULL;
unmod_ptr = NULL;
get_data = false;
@ -647,11 +645,11 @@ protected:
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),
@ -662,9 +660,7 @@ public:
chunked_upload(0),
dlo_manifest(NULL),
slo_info(NULL),
mtime(0),
olh_epoch(0),
delete_at(0) {}
olh_epoch(0) {}
~RGWPutObj() {
delete slo_info;
@ -707,12 +703,12 @@ protected:
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);
@ -794,13 +790,12 @@ class RGWPutMetadataObject : public RGWOp {
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) {
@ -824,7 +819,7 @@ protected:
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;
@ -832,7 +827,6 @@ public:
RGWDeleteObj()
: delete_marker(false),
multipart_delete(false),
unmod_since(0),
no_precondition_error(false),
deleter(nullptr) {
}
@ -860,10 +854,10 @@ protected:
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;
@ -871,8 +865,8 @@ protected:
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;
@ -886,7 +880,7 @@ protected:
string version_id;
uint64_t olh_epoch;
time_t delete_at;
ceph::real_time delete_at;
bool copy_if_newer;
int init_common();
@ -900,16 +894,11 @@ public:
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;
}
@ -1451,15 +1440,15 @@ static inline void rgw_get_request_metadata(CephContext *cct,
}
} /* 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 */

5
src/rgw/rgw_quota.cc
View File

@ -590,10 +590,11 @@ int RGWUserStatsCache::sync_user(const rgw_user& user)
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) {

276
src/rgw/rgw_rados.cc
View File

@ -108,7 +108,7 @@ static string RGW_DEFAULT_PERIOD_ROOT_POOL = "rgw.root";
struct bucket_info_entry {
RGWBucketInfo info;
time_t mtime;
real_time mtime;
map<string, bufferlist> attrs;
};
@ -454,7 +454,7 @@ int RGWSystemMetaObj::set_as_default()
::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;
@ -544,7 +544,7 @@ int RGWSystemMetaObj::store_name(bool exclusive)
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)
@ -663,7 +663,7 @@ int RGWSystemMetaObj::store_info(bool exclusive)
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)
@ -759,7 +759,7 @@ int RGWRealm::create_control()
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()
@ -1021,7 +1021,7 @@ int RGWPeriod::set_latest_epoch(epoch_t epoch, bool exclusive)
::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()
@ -1106,7 +1106,7 @@ int RGWPeriod::store_info(bool exclusive)
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;
@ -2123,8 +2123,8 @@ void RGWObjVersionTracker::generate_new_write_ver(CephContext *cct)
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);
@ -2446,8 +2446,8 @@ int RGWPutObjProcessor_Atomic::complete_writing_data()
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();
@ -4257,8 +4257,7 @@ int RGWRados::log_usage(map<rgw_user_bucket, RGWUsageBatch>& usage_info)
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);
}
}
@ -4376,9 +4375,9 @@ void RGWRados::shard_name(const string& prefix, unsigned shard_id, string& name)
}
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)
@ -4402,7 +4401,7 @@ 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;
@ -4412,7 +4411,8 @@ int RGWRados::time_log_add(const string& oid, const utime_t& ut, const string& s
}
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;
@ -4439,7 +4439,7 @@ int RGWRados::time_log_add(const string& oid, list<cls_log_entry>& entries,
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,
@ -4454,7 +4454,10 @@ int RGWRados::time_log_list(const string& oid, utime_t& start_time, utime_t& end
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;
@ -4507,7 +4510,7 @@ int RGWRados::time_log_info_async(librados::IoCtx& io_ctx, const string& oid, cl
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;
@ -4518,7 +4521,10 @@ int RGWRados::time_log_trim(const string& oid, const utime_t& start_time, const
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)
@ -4551,7 +4557,7 @@ static string objexp_hint_get_keyext(const string& tenant_name,
":" + 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,
@ -4568,7 +4574,7 @@ int RGWRados::objexp_hint_add(const utime_t& delete_at,
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);
@ -4581,8 +4587,8 @@ void RGWRados::objexp_get_shard(int shard_num,
}
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 */
@ -4590,7 +4596,7 @@ int RGWRados::objexp_hint_list(const string& oid,
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;
@ -4621,12 +4627,12 @@ int RGWRados::objexp_hint_parse(cls_timeindex_entry &ti_entry, /* in */
}
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;
@ -4635,7 +4641,7 @@ int RGWRados::objexp_hint_trim(const string& oid,
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;
@ -4645,9 +4651,11 @@ int RGWRados::lock_exclusive(rgw_bucket& pool, const string& oid, utime_t& durat
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);
@ -4949,7 +4957,7 @@ int RGWRados::create_bucket(RGWUserInfo& owner, rgw_bucket& bucket,
RGWBucketInfo& info,
obj_version *pobjv,
obj_version *pep_objv,
time_t creation_time,
real_time creation_time,
rgw_bucket *pmaster_bucket,
bool exclusive)
{
@ -5010,11 +5018,11 @@ int RGWRados::create_bucket(RGWUserInfo& owner, rgw_bucket& bucket,
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;
@ -5440,13 +5448,13 @@ int RGWRados::fix_head_obj_locator(rgw_bucket& bucket, bool copy_obj, bool remov
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);
@ -5469,7 +5477,7 @@ int RGWRados::fix_head_obj_locator(rgw_bucket& bucket, bool copy_obj, bool remov
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) {
@ -5506,7 +5514,7 @@ int RGWRados::move_rados_obj(librados::IoCtx& src_ioctx,
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) {
@ -5522,7 +5530,7 @@ int RGWRados::move_rados_obj(librados::IoCtx& src_ioctx,
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);
@ -5536,7 +5544,7 @@ int RGWRados::move_rados_obj(librados::IoCtx& src_ioctx,
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);
@ -5668,8 +5676,9 @@ int RGWRados::swift_versioning_copy(RGWBucketInfo& bucket_info, RGWRados::Object
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;
@ -5708,7 +5717,7 @@ int RGWRados::swift_versioning_copy(RGWBucketInfo& bucket_info, RGWRados::Object
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 */
@ -5765,18 +5774,15 @@ int RGWRados::Object::Write::write_meta(uint64_t size,
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
@ -5884,7 +5890,7 @@ int RGWRados::Object::Write::write_meta(uint64_t size,
}
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;
@ -5898,17 +5904,17 @@ int RGWRados::Object::Write::write_meta(uint64_t size,
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;
@ -5968,11 +5974,11 @@ done_cancel:
}
/** 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;
@ -5996,15 +6002,13 @@ int RGWRados::put_system_obj_impl(rgw_obj& obj, uint64_t size, time_t *mtime,
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;
@ -6189,7 +6193,7 @@ public:
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);
}
@ -6230,7 +6234,7 @@ int RGWRados::rewrite_obj(RGWBucketInfo& dest_bucket_info, rgw_obj& obj)
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);
@ -6257,15 +6261,16 @@ int RGWRados::rewrite_obj(RGWBucketInfo& dest_bucket_info, rgw_obj& obj)
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) {
@ -6280,7 +6285,7 @@ struct obj_time_weight {
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;
@ -6313,10 +6318,10 @@ int RGWRados::fetch_remote_obj(RGWObjectCtx& obj_ctx,
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,
@ -6324,7 +6329,7 @@ int RGWRados::fetch_remote_obj(RGWObjectCtx& obj_ctx,
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,
@ -6388,11 +6393,11 @@ int RGWRados::fetch_remote_obj(RGWObjectCtx& obj_ctx,
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;
@ -6439,9 +6444,7 @@ int RGWRados::fetch_remote_obj(RGWObjectCtx& obj_ctx,
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;
}
@ -6540,7 +6543,7 @@ int RGWRados::copy_obj_to_remote_dest(RGWObjState *astate,
RGWRados::Object::Read& read_op,
const rgw_user& user_id,
rgw_obj& dest_obj,
time_t *mtime)
real_time *mtime)
{
string etag;
@ -6588,10 +6591,10 @@ int RGWRados::copy_obj(RGWObjectCtx& obj_ctx,
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,
@ -6599,7 +6602,7 @@ int RGWRados::copy_obj(RGWObjectCtx& obj_ctx,
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,
@ -6713,7 +6716,7 @@ int RGWRados::copy_obj(RGWObjectCtx& obj_ctx,
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);
}
@ -6844,12 +6847,12 @@ int RGWRados::copy_obj_data(RGWObjectCtx& obj_ctx,
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,
@ -7013,7 +7016,7 @@ int RGWRados::set_bucket_owner(rgw_bucket& bucket, ACLOwner& owner)
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;
@ -7051,7 +7054,7 @@ int RGWRados::set_buckets_enabled(vector<rgw_bucket>& buckets, bool enabled)
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;
@ -7302,7 +7305,7 @@ void RGWRados::cls_obj_check_prefix_exist(ObjectOperation& op, const string& pre
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);
}
@ -7347,10 +7350,10 @@ int RGWRados::Object::Delete::delete_obj()
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);
@ -7402,8 +7405,8 @@ int RGWRados::Object::Delete::delete_obj()
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) {
@ -7411,13 +7414,13 @@ int RGWRados::Object::Delete::delete_obj()
}
/* 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 {
@ -7504,7 +7507,7 @@ int RGWRados::delete_obj(RGWObjectCtx& obj_ctx,
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);
@ -7640,7 +7643,7 @@ int RGWRados::get_system_obj_state_impl(RGWObjectCtx *rctx, rgw_obj& obj, RGWObj
if (r == -ENOENT) {
s->exists = false;
s->has_attrs = true;
s->mtime = 0;
s->mtime = real_time();
return 0;
}
if (r < 0)
@ -7690,7 +7693,7 @@ int RGWRados::get_obj_state_impl(RGWObjectCtx *rctx, rgw_obj& obj, RGWObjState *
if (r == -ENOENT) {
s->exists = false;
s->has_attrs = true;
s->mtime = 0;
s->mtime = real_time();
return 0;
}
if (r < 0)
@ -7823,7 +7826,7 @@ int RGWRados::Object::Stat::stat_async()
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;
@ -7841,7 +7844,7 @@ int RGWRados::Object::Stat::stat_async()
}
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);
@ -8151,7 +8154,7 @@ int RGWRados::set_attrs(void *ctx, rgw_obj& obj,
op.setxattr(name.c_str(), bl);
if (name.compare(RGW_ATTR_DELETE_AT) == 0) {
utime_t ts;
real_time ts;
try {
::decode(ts, bl);
@ -8205,7 +8208,7 @@ int RGWRados::set_attrs(void *ctx, rgw_obj& obj,
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);
@ -8386,7 +8389,7 @@ int RGWRados::stat_system_obj(RGWObjectCtx& obj_ctx,
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)
{
@ -8459,7 +8462,7 @@ int RGWRados::Bucket::UpdateIndex::prepare(RGWModifyOp op)
}
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) {
@ -9269,13 +9272,14 @@ int RGWRados::olh_init_modification_impl(RGWObjState& state, rgw_obj& olh_obj, s
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;
@ -9318,7 +9322,7 @@ int RGWRados::bucket_index_link_olh(RGWObjState& olh_state, rgw_obj& obj_instanc
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;
@ -9618,7 +9622,7 @@ int RGWRados::update_olh(RGWObjectCtx& obj_ctx, RGWObjState *state, RGWBucketInf
}
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;
@ -9798,7 +9802,7 @@ void RGWRados::check_pending_olh_entries(map<string, bufferlist>& pending_entrie
{
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();
@ -9814,7 +9818,7 @@ void RGWRados::check_pending_olh_entries(map<string, bufferlist>& pending_entrie
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 {
@ -9908,7 +9912,7 @@ int RGWRados::follow_olh(RGWObjectCtx& obj_ctx, RGWObjState *state, rgw_obj& olh
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)
{
@ -9921,7 +9925,7 @@ int RGWRados::raw_obj_stat(rgw_obj& obj, uint64_t *psize, time_t *pmtime, uint64
map<string, bufferlist> unfiltered_attrset;
uint64_t size = 0;
time_t mtime = 0;
struct timespec mtime_ts;
ObjectReadOperation op;
if (objv_tracker) {
@ -9931,7 +9935,7 @@ int RGWRados::raw_obj_stat(rgw_obj& obj, uint64_t *psize, time_t *pmtime, uint64
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);
@ -9949,7 +9953,7 @@ int RGWRados::raw_obj_stat(rgw_obj& obj, uint64_t *psize, time_t *pmtime, uint64
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);
}
@ -10141,7 +10145,7 @@ void RGWRados::get_bucket_instance_obj(rgw_bucket& bucket, rgw_obj& obj)
}
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) {
@ -10153,7 +10157,7 @@ int RGWRados::get_bucket_instance_info(RGWObjectCtx& obj_ctx, const string& meta
}
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()) {
@ -10166,7 +10170,7 @@ int RGWRados::get_bucket_instance_info(RGWObjectCtx& obj_ctx, rgw_bucket& bucket
}
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;
@ -10194,7 +10198,7 @@ int RGWRados::get_bucket_entrypoint_info(RGWObjectCtx& obj_ctx,
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)
{
@ -10222,7 +10226,7 @@ int RGWRados::convert_old_bucket_info(RGWObjectCtx& obj_ctx,
const string& bucket_name)
{
RGWBucketEntryPoint entry_point;
time_t ep_mtime;
real_time ep_mtime;
RGWObjVersionTracker ot;
map<string, bufferlist> attrs;
RGWBucketInfo info;
@ -10256,7 +10260,7 @@ int RGWRados::convert_old_bucket_info(RGWObjectCtx& obj_ctx,
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;
@ -10274,7 +10278,7 @@ int RGWRados::get_bucket_info(RGWObjectCtx& obj_ctx,
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);
@ -10340,7 +10344,7 @@ int RGWRados::get_bucket_info(RGWObjectCtx& obj_ctx,
}
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;
@ -10351,7 +10355,7 @@ int RGWRados::put_bucket_entrypoint_info(const string& tenant_name, const string
}
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;
@ -10363,7 +10367,7 @@ int RGWRados::put_bucket_instance_info(RGWBucketInfo& info, bool exclusive,
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;
@ -10888,7 +10892,7 @@ int RGWRados::cls_obj_complete_op(BucketShard& bs, RGWModifyOp op, string& tag,
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;
@ -11202,7 +11206,7 @@ int RGWRados::check_disk_state(librados::IoCtx io_ctx,
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()) {
@ -11245,7 +11249,7 @@ int RGWRados::check_disk_state(librados::IoCtx io_ctx,
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;
@ -11831,17 +11835,17 @@ RGWOpStateSingleOp::RGWOpStateSingleOp(RGWRados *store, const string& cid, const
}
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;
}

147
src/rgw/rgw_rados.h
View File

@ -8,6 +8,7 @@
#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"
@ -92,7 +93,7 @@ struct RGWOLHInfo {
WRITE_CLASS_ENCODER(RGWOLHInfo)
struct RGWOLHPendingInfo {
utime_t time;
ceph::real_time time;
RGWOLHPendingInfo() {}
@ -113,9 +114,9 @@ struct 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);
@ -579,7 +580,7 @@ struct RGWUploadPartInfo {
uint32_t num;
uint64_t size;
string etag;
utime_t modified;
ceph::real_time modified;
RGWObjManifest manifest;
RGWUploadPartInfo() : num(0), size(0) {}
@ -614,7 +615,7 @@ struct RGWObjState {
bool has_attrs;
bool exists;
uint64_t size;
time_t mtime;
ceph::real_time mtime;
uint64_t epoch;
bufferlist obj_tag;
string write_tag;
@ -637,7 +638,7 @@ struct RGWObjState {
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) {
@ -1264,7 +1265,7 @@ struct objexp_hint_entry {
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);
@ -1609,7 +1610,7 @@ class RGWOpStateSingleOp
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);
@ -1785,7 +1786,7 @@ class RGWRados
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;
@ -2037,7 +2038,7 @@ public:
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);
@ -2078,7 +2079,7 @@ public:
} state;
struct StatParams {
time_t *lastmod;
ceph::real_time *lastmod;
uint64_t *obj_size;
map<string, bufferlist> *attrs;
struct rgw_err *perr;
@ -2174,8 +2175,8 @@ public:
} 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;
@ -2187,7 +2188,7 @@ public:
} conds;
struct Params {
time_t *lastmod;
ceph::real_time *lastmod;
uint64_t *read_size;
uint64_t *obj_size;
map<string, bufferlist> *attrs;
@ -2208,25 +2209,25 @@ public:
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) {}
@ -2246,11 +2247,11 @@ public:
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 {
@ -2273,10 +2274,10 @@ public:
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 {
@ -2350,7 +2351,7 @@ public:
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,
@ -2386,11 +2387,11 @@ public:
};
/** 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);
@ -2400,8 +2401,8 @@ public:
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;
@ -2430,10 +2431,10 @@ public:
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,
@ -2441,7 +2442,7 @@ public:
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,
@ -2455,7 +2456,7 @@ public:
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
@ -2481,10 +2482,10 @@ public:
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,
@ -2492,7 +2493,7 @@ public:
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,
@ -2506,12 +2507,12 @@ public:
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,
@ -2543,7 +2544,7 @@ public:
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);
@ -2592,7 +2593,7 @@ public:
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);
@ -2624,7 +2625,7 @@ public:
* 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);
@ -2637,7 +2638,7 @@ public:
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);
@ -2648,7 +2649,7 @@ public:
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);
@ -2703,15 +2704,15 @@ public:
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);
@ -2719,8 +2720,8 @@ public:
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);
@ -2757,31 +2758,31 @@ public:
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 */
@ -2790,12 +2791,12 @@ public:
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);
@ -3039,8 +3040,8 @@ protected:
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:
@ -3055,8 +3056,8 @@ 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();
@ -3128,8 +3129,8 @@ protected:
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);

32
src/rgw/rgw_rest.cc
View File

@ -468,12 +468,14 @@ void dump_redirect(struct req_state *s, const string& redirect)
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;
@ -486,34 +488,42 @@ void dump_time_header(struct req_state *s, const char *name, time_t t)
}
}
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,

8
src/rgw/rgw_rest.h
View File

@ -484,16 +484,16 @@ extern void dump_string_header(struct req_state *s, const char *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);

61
src/rgw/rgw_rest_client.cc
View File

@ -10,6 +10,7 @@
#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
@ -532,25 +533,54 @@ void set_str_from_headers(map<string, string>& out_headers, const string& header
}
}
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;
}
*mtime = (time_t)t;
}
ret = parse_rgwx_mtime(cct, mtime_str, mtime);
if (ret < 0) {
return ret;
}
}
return status;
}
@ -639,20 +669,15 @@ int RGWRESTStreamRWRequest::get_resource(RGWAccessKey& key, map<string, string>&
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;
}
}

4
src/rgw/rgw_rest_client.h
View File

@ -79,7 +79,7 @@ public:
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; }
};
@ -109,7 +109,7 @@ public:
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);

10
src/rgw/rgw_rest_conn.cc
View File

@ -87,7 +87,7 @@ int RGWRESTConn::put_obj_init(const rgw_user& uid, rgw_obj& obj, uint64_t obj_si
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;
@ -95,13 +95,13 @@ int RGWRESTConn::complete_request(RGWRESTStreamWriteRequest *req, string& etag,
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();
}
@ -116,7 +116,7 @@ static void set_header(T val, map<string, string>& headers, const string& header
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)
{
@ -166,7 +166,7 @@ int RGWRESTConn::get_obj(const rgw_user& uid, req_info *info /* optional */, rgw
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;

6
src/rgw/rgw_rest_conn.h
View File

@ -88,13 +88,13 @@ public:
/* 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,

27
src/rgw/rgw_rest_log.cc
View File

@ -24,7 +24,7 @@
#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;
@ -34,7 +34,7 @@ static int parse_date_str(string& in, utime_t& out) {
return -EINVAL;
}
}
out = utime_t(epoch, nsec);
out = utime_t(epoch, nsec).to_real_time();
return 0;
}
@ -46,8 +46,8 @@ void RGWOp_MDLog_List::execute() {
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;
@ -184,8 +184,8 @@ void RGWOp_MDLog_Delete::execute() {
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;
@ -259,8 +259,8 @@ void RGWOp_MDLog_Lock::execute() {
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;
}
@ -545,8 +545,8 @@ void RGWOp_DATALog_List::execute() {
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);
@ -695,8 +695,7 @@ void RGWOp_DATALog_Lock::execute() {
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;
}
@ -783,8 +782,8 @@ void RGWOp_DATALog_Delete::execute() {
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;

3
src/rgw/rgw_rest_metadata.cc
View File

@ -250,8 +250,7 @@ void RGWOp_Metadata_Lock::execute() {
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;
}

2
src/rgw/rgw_rest_replica_log.cc
View File

@ -148,7 +148,7 @@ void RGWOp_OBJLog_DeleteBounds::execute() {
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);

42
src/rgw/rgw_rest_s3.cc
View File

@ -159,7 +159,8 @@ int RGWGetObj_ObjStore_S3::send_response_data(bufferlist& bl, off_t bl_ofs,
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);
@ -169,7 +170,7 @@ int RGWGetObj_ObjStore_S3::send_response_data(bufferlist& bl, off_t bl_ofs,
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;
@ -488,7 +489,6 @@ void RGWListBucket_ObjStore_S3::send_versioned_response()
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);
@ -514,7 +514,7 @@ void RGWListBucket_ObjStore_S3::send_versioned_response()
}
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);
@ -588,8 +588,7 @@ void RGWListBucket_ObjStore_S3::send_response()
} 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");
@ -1068,7 +1067,7 @@ void RGWPutObj_ObjStore_S3::send_response()
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);
@ -1571,7 +1570,7 @@ int RGWPostObj_ObjStore_S3::get_policy()
/* 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="
@ -1593,7 +1592,7 @@ int RGWPostObj_ObjStore_S3::get_policy()
/* 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
@ -1864,11 +1863,12 @@ int RGWDeleteObj_ObjStore_S3::get_params()
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;
@ -2410,16 +2410,9 @@ void RGWListMultipart_ObjStore_S3::send_response()
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);
@ -2475,8 +2468,7 @@ void RGWListBucketMultiparts_ObjStore_S3::send_response()
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()) {
@ -3231,7 +3223,7 @@ int RGW_Auth_S3::authorize_v4(RGWRados *store, struct req_state *s)
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");
@ -3352,7 +3344,7 @@ int RGW_Auth_S3::authorize_v4(RGWRados *store, struct req_state *s)
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;
}
@ -3688,7 +3680,7 @@ int RGW_Auth_S3::authorize_v2(RGWRados *store, struct req_state *s)
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;
@ -3716,7 +3708,7 @@ int RGW_Auth_S3::authorize_v2(RGWRados *store, struct req_state *s)
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;

25
src/rgw/rgw_rest_swift.cc
View File

@ -272,8 +272,7 @@ void RGWListBucket_ObjStore_SWIFT::send_response()
}
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();
}
@ -327,8 +326,9 @@ static void dump_container_metadata(struct req_state *s, RGWBucketEnt& bucket)
{
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);
@ -515,10 +515,10 @@ void RGWDeleteBucket_ObjStore_SWIFT::send_response()
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()) {
@ -526,7 +526,7 @@ static int get_delete_at_param(req_state *s, time_t *delete_at)
} 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()) {
@ -539,12 +539,12 @@ static int get_delete_at_param(req_state *s, time_t *delete_at)
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;
}
@ -1090,7 +1090,10 @@ int RGWGetObj_ObjStore_SWIFT::send_response_data(bufferlist& bl,
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");
}

2
src/rgw/rgw_swift.cc
View File

@ -418,7 +418,7 @@ int RGWSwift::update_user_info(RGWRados *store, struct rgw_swift_auth_info *info
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;

21
src/rgw/rgw_sync.cc
View File

@ -48,7 +48,7 @@ RGWCoroutine *RGWSyncErrorLogger::log_error_cr(const string& source_zone, const
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;
@ -122,12 +122,13 @@ void rgw_mdlog_info::decode_json(JSONObj *obj) {
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);
}
@ -375,8 +376,8 @@ class RGWAsyncReadMDLogEntries : public RGWAsyncRadosRequest {
protected:
int _send_request() {
utime_t from_time;
utime_t end_time;
real_time from_time;
real_time end_time;
void *handle;
@ -1081,13 +1082,13 @@ public:
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;
}
@ -1422,7 +1423,7 @@ public:
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
@ -1570,7 +1571,7 @@ public:
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;
@ -2124,7 +2125,7 @@ int RGWCloneMetaLogCoroutine::state_store_mdlog_entries()
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);

16
src/rgw/rgw_sync.h
View File

@ -25,7 +25,7 @@ struct rgw_mdlog_entry {
string id;
string section;
string name;
utime_t timestamp;
ceph::real_time timestamp;
RGWMetadataLogData log_data;
void decode_json(JSONObj *obj);
@ -34,7 +34,7 @@ struct rgw_mdlog_entry {
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);
@ -231,7 +231,7 @@ class RGWMetaSyncStatusManager {
map<int, rgw_obj> shard_objs;
struct utime_shard {
utime_t ts;
real_time ts;
int shard_id;
utime_shard() : shard_id(-1) {}
@ -283,10 +283,10 @@ template <class T, class K>
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;
@ -300,14 +300,14 @@ class RGWSyncShardMarkerTrack {
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;
}
@ -315,7 +315,7 @@ public:
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);

4
src/rgw/rgw_tools.cc
View File

@ -19,7 +19,7 @@
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)
@ -39,7 +39,7 @@ int rgw_put_system_obj(RGWRados *rgwstore, rgw_bucket& bucket, string& oid, cons
}
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;

5
src/rgw/rgw_tools.h
View File

@ -7,6 +7,7 @@
#include <string>
#include "include/types.h"
#include "common/ceph_time.h"
#include "rgw_common.h"
class RGWRados;
@ -16,9 +17,9 @@ struct RGWObjVersionTracker;
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);

32
src/rgw/rgw_user.cc
View File

@ -95,7 +95,7 @@ int rgw_store_user_info(RGWRados *store,
RGWUserInfo& info,
RGWUserInfo *old_info,
RGWObjVersionTracker *objv_tracker,
time_t mtime,
real_time mtime,
bool exclusive,
map<string, bufferlist> *pattrs)
{
@ -169,7 +169,7 @@ int rgw_store_user_info(RGWRados *store,
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;
}
@ -184,7 +184,7 @@ int rgw_store_user_info(RGWRados *store,
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;
}
@ -198,7 +198,7 @@ int rgw_store_user_info(RGWRados *store,
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;
}
@ -209,13 +209,13 @@ int rgw_store_user_info(RGWRados *store,
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)) {
@ -271,7 +271,7 @@ int rgw_get_user_info_by_uid(RGWRados *store,
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)
{
@ -308,7 +308,7 @@ int rgw_get_user_info_by_uid(RGWRados *store,
* 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);
}
@ -318,7 +318,7 @@ int rgw_get_user_info_by_email(RGWRados *store, string& email, RGWUserInfo& info
* 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);
}
@ -328,7 +328,7 @@ extern int rgw_get_user_info_by_swift(RGWRados *store, string& swift_name, RGWUs
* 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);
}
@ -1803,7 +1803,7 @@ int RGWUser::update(RGWUserAdminOpState& op_state, std::string *err_msg)
}
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;
@ -1815,7 +1815,7 @@ int RGWUser::update(RGWUserAdminOpState& op_state, std::string *err_msg)
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;
@ -2569,7 +2569,7 @@ struct RGWUserCompleteInfo {
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;
@ -2587,7 +2587,7 @@ public:
int get(RGWRados *store, string& entry, RGWMetadataObject **obj) {
RGWUserCompleteInfo uci;
RGWObjVersionTracker objv_tracker;
time_t mtime;
real_time mtime;
rgw_user uid(entry);
@ -2604,7 +2604,7 @@ public:
}
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 {
@ -2621,7 +2621,7 @@ public:
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;

10
src/rgw/rgw_user.h
View File

@ -63,7 +63,7 @@ extern int rgw_store_user_info(RGWRados *store,
RGWUserInfo& info,
RGWUserInfo *old_info,
RGWObjVersionTracker *objv_tracker,
time_t mtime,
real_time mtime,
bool exclusive,
map<string, bufferlist> *pattrs = NULL);
@ -75,7 +75,7 @@ extern int rgw_get_user_info_by_uid(RGWRados *store,
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);
/**
@ -83,19 +83,19 @@ extern int rgw_get_user_info_by_uid(RGWRados *store,
* 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.