/
load_conf.h
212 lines (175 loc) · 4.5 KB
/
load_conf.h
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
/*
* Copyright (C) 2018 Intel Corporation
* SPDX-License-Identifier: BSD-3-Clause
*/
#ifndef __LOAD_CONF_H__
#define __LOAD_CONF_H__
#include <stdio.h>
#include <sys/queue.h>
#include <openssl/sha.h>
#include "event_queue.h"
#define CONTENT_MAX 10
#define EXPRESSION_MAX 5
#define LOG_MAX 20
#define TRIGGER_MAX 20
#define SENDER_MAX 3
#define DATA_MAX 3
#define CRASH_MAX 20
#define INFO_MAX 20
#define VM_MAX 4
#define VM_EVENT_TYPE_MAX 20
struct trigger_t {
char *name;
char *type;
char *path;
};
struct vm_t {
char *name;
char *channel;
char *interval;
char *syncevent[VM_EVENT_TYPE_MAX];
int online;
unsigned long history_size[SENDER_MAX];
char last_synced_line_key[SENDER_MAX][SHA_DIGEST_LENGTH + 1];
};
struct log_t {
char *name;
char *type;
char *path;
char *lines;
void (*get)(struct log_t *, void *);
};
struct crash_t {
char *name;
char *channel;
char *interval;
struct trigger_t *trigger;
char *content[CONTENT_MAX];
char *mightcontent[EXPRESSION_MAX][CONTENT_MAX];
struct log_t *log[LOG_MAX];
char *data[DATA_MAX];
struct crash_t *parents;
TAILQ_ENTRY(crash_t) entries;
TAILQ_HEAD(, crash_t) children;
int wd;
int level;
struct crash_t *(*reclassify)(struct crash_t *, char*, char**, char**,
char**);
};
struct info_t {
char *name;
char *channel;
char *interval;
struct trigger_t *trigger;
struct log_t *log[LOG_MAX];
};
struct uptime_t {
char *name;
char *frequency;
char *eventhours;
int wd;
char *path;
};
struct sender_t {
char *name;
char *outdir;
char *maxcrashdirs;
char *maxlines;
char *spacequota;
struct uptime_t *uptime;
void (*send)(struct event_t *);
char *log_vmrecordid;
int sw_updated; /* each sender has their own record */
};
struct conf_t {
struct sender_t *sender[SENDER_MAX];
struct vm_t *vm[VM_MAX];
struct trigger_t *trigger[TRIGGER_MAX];
struct log_t *log[LOG_MAX];
struct crash_t *crash[CRASH_MAX];
struct info_t *info[INFO_MAX];
};
struct conf_t conf;
#define for_each_sender(id, sender, conf) \
for (id = 0, sender = conf.sender[0]; \
id < SENDER_MAX; \
id++, sender = conf.sender[id])
#define for_each_trigger(id, trigger, conf) \
for (id = 0, trigger = conf.trigger[0]; \
id < TRIGGER_MAX; \
id++, trigger = conf.trigger[id])
#define for_each_vm(id, vm, conf) \
for (id = 0, vm = conf.vm[0]; \
id < VM_MAX; \
id++, vm = conf.vm[id])
#define for_each_syncevent_vm(id, event, vm) \
for (id = 0, event = vm->syncevent[0]; \
id < VM_EVENT_TYPE_MAX; \
id++, event = vm->syncevent[id])
#define for_each_info(id, info, conf) \
for (id = 0, info = conf.info[0]; \
id < INFO_MAX; \
id++, info = conf.info[id])
#define for_each_log(id, log, conf) \
for (id = 0, log = conf.log[0]; \
id < LOG_MAX; \
id++, log = conf.log[id])
#define for_each_crash(id, crash, conf) \
for (id = 0, crash = conf.crash[0]; \
id < CRASH_MAX; \
id++, crash = conf.crash[id])
#define for_each_log_collect(id, log, type) \
for (id = 0, log = type->log[0]; \
id < LOG_MAX; \
id++, log = type->log[id])
#define for_each_content_crash(id, content, crash) \
for (id = 0, content = crash->content[0]; \
id < CONTENT_MAX; \
id++, content = crash->content[id])
#define for_each_content_expression(id, content, exp) \
for (id = 0, content = exp[0]; \
id < CONTENT_MAX; \
id++, content = exp[id])
#define exp_valid(exp) \
(__extension__ \
({ \
int _ret = 0; \
int _id; \
char *content; \
for_each_content_expression(_id, content, exp) { \
if (content) \
_ret = 1; \
} \
_ret; \
}) \
)
#define for_each_expression_crash(id, exp, crash) \
for (id = 0, exp = crash->mightcontent[0]; \
id < EXPRESSION_MAX; \
id++, exp = crash->mightcontent[id])
#define for_crash_children(crash, tcrash) \
TAILQ_FOREACH(crash, &tcrash->children, entries)
#define is_leaf_crash(crash) \
(crash && TAILQ_EMPTY(&crash->children))
#define is_root_crash(crash) \
(crash && crash->parents == NULL)
#define to_collect_logs(type) \
(__extension__ \
({ \
int _id; \
int _ret = 0; \
for (_id = 0; _id < LOG_MAX; _id++) \
if (type->log[_id]) \
_ret = 1; \
_ret; \
}) \
)
int load_conf(char *path);
struct trigger_t *get_trigger_by_name(char *name);
struct log_t *get_log_by_name(char *name);
int sender_id(struct sender_t *sender);
struct sender_t *get_sender_by_name(char *name);
enum event_type_t get_conf_by_wd(int wd, void **private);
struct crash_t *get_crash_by_wd(int wd);
int crash_depth(struct crash_t *tcrash);
#endif