1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2004-2006 Sage Weil <sage@newdream.net>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#ifndef CEPH_LOGEVENT_H
#define CEPH_LOGEVENT_H
#define EVENT_NEW_ENCODING 0 // indicates that the encoding is versioned
#define EVENT_UNUSED 1 // was previously EVENT_STRING
#define EVENT_SUBTREEMAP 2
#define EVENT_EXPORT 3
#define EVENT_IMPORTSTART 4
#define EVENT_IMPORTFINISH 5
#define EVENT_FRAGMENT 6
#define EVENT_RESETJOURNAL 9
#define EVENT_SESSION 10
#define EVENT_SESSIONS_OLD 11
#define EVENT_SESSIONS 12
#define EVENT_UPDATE 20
#define EVENT_SLAVEUPDATE 21
#define EVENT_OPEN 22
#define EVENT_COMMITTED 23
#define EVENT_TABLECLIENT 42
#define EVENT_TABLESERVER 43
#define EVENT_SUBTREEMAP_TEST 50
#define EVENT_NOOP 51
#include "include/buffer_fwd.h"
#include "include/Context.h"
#include "include/utime.h"
class MDSRank;
class LogSegment;
class EMetaBlob;
// generic log event
class LogEvent {
public:
friend class MDLog;
typedef __u32 EventType;
LogEvent() = delete;
explicit LogEvent(int t) : _type(t) {}
LogEvent(const LogEvent&) = delete;
LogEvent& operator=(const LogEvent&) = delete;
virtual ~LogEvent() {}
std::string_view get_type_str() const;
static EventType str_to_type(std::string_view str);
EventType get_type() const { return _type; }
void set_type(EventType t) { _type = t; }
uint64_t get_start_off() const { return _start_off; }
void set_start_off(uint64_t o) { _start_off = o; }
utime_t get_stamp() const { return stamp; }
void set_stamp(utime_t t) { stamp = t; }
// encoding
virtual void encode(bufferlist& bl, uint64_t features) const = 0;
virtual void decode(bufferlist::const_iterator &) = 0;
static std::unique_ptr<LogEvent> decode_event(bufferlist::const_iterator);
virtual void dump(Formatter *f) const = 0;
void encode_with_header(bufferlist& bl, uint64_t features) {
using ceph::encode;
encode(EVENT_NEW_ENCODING, bl);
ENCODE_START(1, 1, bl)
encode(_type, bl);
this->encode(bl, features);
ENCODE_FINISH(bl);
}
virtual void print(ostream& out) const {
out << "event(" << _type << ")";
}
/*** live journal ***/
/* update_segment() - adjust any state we need to in the LogSegment
*/
virtual void update_segment() { }
/*** recovery ***/
/* replay() - replay given event. this is idempotent.
*/
virtual void replay(MDSRank *m) { ceph_abort(); }
/**
* If the subclass embeds a MetaBlob, return it here so that
* tools can examine metablobs while traversing lists of LogEvent.
*/
virtual EMetaBlob *get_metablob() { return NULL; }
protected:
utime_t stamp;
LogSegment* get_segment() { return _segment; }
LogSegment const* get_segment() const { return _segment; }
private:
static const std::map<std::string, LogEvent::EventType> types;
static std::unique_ptr<LogEvent> decode_event(bufferlist::const_iterator&, EventType);
EventType _type = 0;
uint64_t _start_off = 0;
LogSegment *_segment = nullptr;
};
inline ostream& operator<<(ostream& out, const LogEvent &le) {
le.print(out);
return out;
}
#endif
|
