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
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef CEPH_CLASSHANDLER_H
#define CEPH_CLASSHANDLER_H
#include "include/types.h"
#include "objclass/objclass.h"
#include "common/Mutex.h"
//forward declaration
class CephContext;
class ClassHandler
{
public:
CephContext *cct;
struct ClassData;
struct ClassMethod {
struct ClassHandler::ClassData *cls;
string name;
int flags;
cls_method_call_t func;
cls_method_cxx_call_t cxx_func;
int exec(cls_method_context_t ctx, bufferlist& indata, bufferlist& outdata);
void unregister();
int get_flags() {
std::lock_guard l(cls->handler->mutex);
return flags;
}
ClassMethod() : cls(0), flags(0), func(0), cxx_func(0) {}
};
struct ClassFilter {
struct ClassHandler::ClassData *cls = nullptr;
std::string name;
cls_cxx_filter_factory_t fn;
void unregister();
ClassFilter() : fn(0)
{}
};
struct ClassData {
enum Status {
CLASS_UNKNOWN,
CLASS_MISSING, // missing
CLASS_MISSING_DEPS, // missing dependencies
CLASS_INITIALIZING, // calling init() right now
CLASS_OPEN, // initialized, usable
} status;
string name;
ClassHandler *handler;
void *handle;
bool whitelisted = false;
map<string, ClassMethod> methods_map;
map<string, ClassFilter> filters_map;
set<ClassData *> dependencies; /* our dependencies */
set<ClassData *> missing_dependencies; /* only missing dependencies */
ClassMethod *_get_method(const char *mname);
ClassData() : status(CLASS_UNKNOWN),
handler(NULL),
handle(NULL) {}
~ClassData() { }
ClassMethod *register_method(const char *mname, int flags, cls_method_call_t func);
ClassMethod *register_cxx_method(const char *mname, int flags, cls_method_cxx_call_t func);
void unregister_method(ClassMethod *method);
ClassFilter *register_cxx_filter(
const std::string &filter_name,
cls_cxx_filter_factory_t fn);
void unregister_filter(ClassFilter *method);
ClassMethod *get_method(const char *mname) {
std::lock_guard l(handler->mutex);
return _get_method(mname);
}
int get_method_flags(const char *mname);
ClassFilter *get_filter(const std::string &filter_name)
{
std::lock_guard l(handler->mutex);
std::map<std::string, ClassFilter>::iterator i = filters_map.find(filter_name);
if (i == filters_map.end()) {
return NULL;
} else {
return &(i->second);
}
}
};
private:
map<string, ClassData> classes;
ClassData *_get_class(const string& cname, bool check_allowed);
int _load_class(ClassData *cls);
static bool in_class_list(const std::string& cname,
const std::string& list);
public:
Mutex mutex;
explicit ClassHandler(CephContext *cct_) : cct(cct_), mutex("ClassHandler") {}
int open_all_classes();
void add_embedded_class(const string& cname);
int open_class(const string& cname, ClassData **pcls);
ClassData *register_class(const char *cname);
void unregister_class(ClassData *cls);
void shutdown();
};
#endif
|
