Commit | Line | Data |
---|---|---|
ebdb334b JR |
1 | /* |
2 | * Copyright (C) 2020 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com> | |
3 | * | |
4 | * SPDX-License-Identifier: LGPL-2.1-only | |
5 | * | |
6 | */ | |
7 | ||
8 | #include <assert.h> | |
9 | #include <common/dynamic-buffer.h> | |
10 | #include <common/error.h> | |
11 | #include <common/macros.h> | |
12 | #include <common/hashtable/hashtable.h> | |
13 | #include <common/hashtable/utils.h> | |
14 | #include <lttng/log-level-rule-internal.h> | |
15 | #include <lttng/log-level-rule.h> | |
16 | #include <stdbool.h> | |
17 | #include <stdlib.h> | |
18 | ||
19 | static bool is_log_level_rule_exactly_type(const struct lttng_log_level_rule *rule) | |
20 | { | |
21 | enum lttng_log_level_rule_type type = | |
22 | lttng_log_level_rule_get_type(rule); | |
23 | ||
24 | return type == LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY; | |
25 | } | |
26 | ||
27 | static bool is_log_level_rule_at_least_as_severe_type(const struct lttng_log_level_rule *rule) | |
28 | { | |
29 | ||
30 | enum lttng_log_level_rule_type type = | |
31 | lttng_log_level_rule_get_type(rule); | |
32 | ||
33 | return type == LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS; | |
34 | } | |
35 | ||
36 | enum lttng_log_level_rule_type lttng_log_level_rule_get_type( | |
37 | const struct lttng_log_level_rule *rule) | |
38 | { | |
39 | return rule ? rule->type : LTTNG_LOG_LEVEL_RULE_TYPE_UNKNOWN; | |
40 | } | |
41 | ||
42 | struct lttng_log_level_rule *lttng_log_level_rule_exactly_create( | |
43 | int level) | |
44 | { | |
45 | struct lttng_log_level_rule *rule = NULL; | |
46 | ||
47 | rule = zmalloc(sizeof(struct lttng_log_level_rule)); | |
48 | if (!rule) { | |
49 | goto end; | |
50 | } | |
51 | ||
52 | rule->type = LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY; | |
53 | rule->level = level; | |
54 | ||
55 | end: | |
56 | return rule; | |
57 | } | |
58 | ||
59 | enum lttng_log_level_rule_status lttng_log_level_rule_exactly_get_level( | |
60 | const struct lttng_log_level_rule *rule, int *level) | |
61 | { | |
62 | enum lttng_log_level_rule_status status = LTTNG_LOG_LEVEL_RULE_STATUS_OK; | |
63 | if (!rule || !level || !is_log_level_rule_exactly_type(rule)) { | |
64 | status = LTTNG_LOG_LEVEL_RULE_STATUS_INVALID; | |
65 | goto end; | |
66 | } | |
67 | ||
68 | *level = rule->level; | |
69 | end: | |
70 | return status; | |
71 | } | |
72 | ||
73 | struct lttng_log_level_rule * | |
74 | lttng_log_level_rule_at_least_as_severe_as_create(int level) | |
75 | { | |
76 | struct lttng_log_level_rule *rule = NULL; | |
77 | ||
78 | rule = zmalloc(sizeof(struct lttng_log_level_rule)); | |
79 | if (!rule) { | |
80 | goto end; | |
81 | } | |
82 | ||
83 | rule->type = LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS; | |
84 | rule->level = level; | |
85 | ||
86 | end: | |
87 | return rule; | |
88 | } | |
89 | ||
90 | enum lttng_log_level_rule_status | |
91 | lttng_log_level_rule_at_least_as_severe_as_get_level( | |
92 | const struct lttng_log_level_rule *rule, int *level) | |
93 | { | |
94 | enum lttng_log_level_rule_status status = LTTNG_LOG_LEVEL_RULE_STATUS_OK; | |
95 | if (!rule || !level || !is_log_level_rule_at_least_as_severe_type(rule)) { | |
96 | status = LTTNG_LOG_LEVEL_RULE_STATUS_INVALID; | |
97 | goto end; | |
98 | } | |
99 | ||
100 | *level = rule->level; | |
101 | end: | |
102 | return status; | |
103 | } | |
104 | ||
105 | void lttng_log_level_rule_destroy(struct lttng_log_level_rule *log_level_rule) | |
106 | { | |
107 | free(log_level_rule); | |
108 | } | |
109 | ||
110 | LTTNG_HIDDEN | |
111 | ssize_t lttng_log_level_rule_create_from_payload( | |
112 | struct lttng_payload_view *view, | |
113 | struct lttng_log_level_rule **_rule) | |
114 | { | |
115 | ssize_t ret; | |
116 | size_t offset = 0; | |
117 | struct lttng_log_level_rule *rule = NULL; | |
118 | const struct lttng_log_level_rule_comm *comm = | |
119 | (const struct lttng_log_level_rule_comm *) | |
120 | view->buffer.data; | |
121 | ||
122 | offset += sizeof(*comm); | |
123 | ||
124 | if (!_rule) { | |
125 | ret = -1; | |
126 | goto end; | |
127 | } | |
128 | ||
129 | if (view->buffer.size < sizeof(*comm)) { | |
130 | ret = -1; | |
131 | goto end; | |
132 | } | |
133 | ||
134 | switch (comm->type) { | |
135 | case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY: | |
136 | rule = lttng_log_level_rule_exactly_create((int) comm->level); | |
137 | break; | |
138 | case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS: | |
139 | rule = lttng_log_level_rule_at_least_as_severe_as_create( | |
140 | (int) comm->level); | |
141 | break; | |
142 | default: | |
143 | abort(); | |
144 | } | |
145 | ||
146 | if (!rule) { | |
147 | ret = -1; | |
148 | goto end; | |
149 | } | |
150 | ||
151 | *_rule = rule; | |
152 | ret = offset; | |
153 | ||
154 | end: | |
155 | return ret; | |
156 | } | |
157 | ||
158 | LTTNG_HIDDEN | |
159 | int lttng_log_level_rule_serialize(const struct lttng_log_level_rule *rule, | |
160 | struct lttng_payload *payload) | |
161 | { | |
162 | int ret; | |
163 | struct lttng_log_level_rule_comm comm; | |
164 | ||
165 | ||
166 | if (!rule) { | |
167 | ret = 0; | |
168 | goto end; | |
169 | } | |
170 | ||
171 | comm.type = (int8_t) rule->type; | |
172 | comm.level = (int32_t) rule->level; | |
173 | ||
174 | DBG("Serializing log level rule of type %d", rule->type); | |
175 | ret = lttng_dynamic_buffer_append(&payload->buffer, &comm, | |
176 | sizeof(comm)); | |
177 | if (ret) { | |
178 | goto end; | |
179 | } | |
180 | ||
181 | end: | |
182 | return ret; | |
183 | } | |
184 | ||
185 | LTTNG_HIDDEN | |
186 | bool lttng_log_level_rule_is_equal(const struct lttng_log_level_rule *a, | |
187 | const struct lttng_log_level_rule *b) | |
188 | { | |
189 | bool is_equal = false; | |
190 | ||
191 | if (a == NULL && b == NULL) { | |
192 | /* Both are null. */ | |
193 | is_equal = true; | |
194 | goto end; | |
195 | } | |
196 | ||
197 | if (a == NULL || b == NULL) { | |
198 | /* One is NULL.*/ | |
199 | goto end; | |
200 | } | |
201 | ||
202 | if (a == b) { | |
203 | /* Same object.*/ | |
204 | is_equal = true; | |
205 | goto end; | |
206 | } | |
207 | ||
208 | if (a->type != b->type) { | |
209 | goto end; | |
210 | } | |
211 | ||
212 | if (a->level != b->level) { | |
213 | goto end; | |
214 | } | |
215 | ||
216 | is_equal = true; | |
217 | ||
218 | end: | |
219 | return is_equal; | |
220 | } | |
221 | ||
222 | LTTNG_HIDDEN | |
223 | struct lttng_log_level_rule * lttng_log_level_rule_copy(const struct lttng_log_level_rule *source) | |
224 | { | |
225 | struct lttng_log_level_rule *copy = NULL; | |
226 | ||
227 | assert(source); | |
228 | ||
229 | copy = zmalloc(sizeof(struct lttng_log_level_rule)); | |
230 | if (!copy) { | |
231 | goto end; | |
232 | } | |
233 | ||
234 | copy->type = source->type; | |
235 | copy->level = source->level; | |
236 | end: | |
237 | return copy; | |
238 | } | |
239 | ||
240 | LTTNG_HIDDEN | |
241 | void lttng_log_level_rule_to_loglevel( | |
242 | const struct lttng_log_level_rule *log_level_rule, | |
243 | enum lttng_loglevel_type *loglevel_type, | |
244 | int *loglevel_value) | |
245 | { | |
246 | assert(log_level_rule); | |
247 | ||
248 | switch(log_level_rule->type) | |
249 | { | |
250 | case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY: | |
251 | *loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE; | |
252 | break; | |
253 | case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS: | |
254 | *loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE; | |
255 | break; | |
256 | default: | |
257 | abort(); | |
258 | } | |
259 | ||
260 | *loglevel_value = log_level_rule->level; | |
261 | } | |
262 | ||
263 | LTTNG_HIDDEN | |
264 | unsigned long lttng_log_level_rule_hash( | |
265 | const struct lttng_log_level_rule *log_level_rule) | |
266 | { | |
267 | unsigned long hash; | |
268 | enum lttng_log_level_rule_status llr_status; | |
269 | int log_level_value; | |
270 | enum lttng_log_level_rule_type type; | |
271 | ||
272 | assert(log_level_rule); | |
273 | ||
274 | type = lttng_log_level_rule_get_type(log_level_rule); | |
275 | ||
276 | switch (type) { | |
277 | case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY: | |
278 | llr_status = lttng_log_level_rule_exactly_get_level( | |
279 | log_level_rule, &log_level_value); | |
280 | break; | |
281 | case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS: | |
282 | llr_status = lttng_log_level_rule_at_least_as_severe_as_get_level( | |
283 | log_level_rule, &log_level_value); | |
284 | break; | |
285 | default: | |
286 | abort(); | |
287 | break; | |
288 | } | |
289 | ||
290 | assert(llr_status == LTTNG_LOG_LEVEL_RULE_STATUS_OK); | |
291 | ||
292 | hash = hash_key_ulong((void *) (unsigned long) type, lttng_ht_seed); | |
293 | ||
294 | hash ^= hash_key_ulong((void *) (unsigned long) log_level_value, | |
295 | lttng_ht_seed); | |
296 | ||
297 | return hash; | |
298 | } |