![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to element.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bmon / src|
Return to element.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bmon / src |
1.1 misho 1: /*
2: * src/element.c Elements
3: *
4: * Copyright (c) 2001-2013 Thomas Graf <tgraf@suug.ch>
5: * Copyright (c) 2013 Red Hat, Inc.
6: *
7: * Permission is hereby granted, free of charge, to any person obtaining a
8: * copy of this software and associated documentation files (the "Software"),
9: * to deal in the Software without restriction, including without limitation
10: * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11: * and/or sell copies of the Software, and to permit persons to whom the
12: * Software is furnished to do so, subject to the following conditions:
13: *
14: * The above copyright notice and this permission notice shall be included
15: * in all copies or substantial portions of the Software.
16: *
17: * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18: * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19: * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20: * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21: * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22: * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23: * DEALINGS IN THE SOFTWARE.
24: */
25:
26: #include <bmon/bmon.h>
27: #include <bmon/conf.h>
28: #include <bmon/element.h>
29: #include <bmon/element_cfg.h>
30: #include <bmon/group.h>
31: #include <bmon/input.h>
32: #include <bmon/utils.h>
33:
34: static LIST_HEAD(allowed);
35: static LIST_HEAD(denied);
36:
37: static int match_mask(const struct policy *p, const char *str)
38: {
39: int i, n;
40: char c;
41:
42: if (!p || !str)
43: return 0;
44:
45: for (i = 0, n = 0; p->p_rule[i] != '\0'; i++) {
46: if (p->p_rule[i] == '*') {
47: c = tolower(p->p_rule[i + 1]);
48:
49: if (c == '\0')
50: return 1;
51:
52: while (tolower(str[n]) != c)
53: if (str[n++] == '\0')
54: return 0;
55: } else if (tolower(p->p_rule[i]) != tolower(str[n++]))
56: return 0;
57: }
58:
59: return str[n] == '\0' ? 1 : 0;
60: }
61:
62: int element_allowed(const char *name, struct element_cfg *cfg)
63: {
64: struct policy *p;
65:
66: if (cfg) {
67: if (cfg->ec_flags & ELEMENT_CFG_HIDE)
68: return 0;
69: else if (cfg->ec_flags & ELEMENT_CFG_SHOW)
70: return 1;
71: }
72:
73: list_for_each_entry(p, &denied, p_list)
74: if (match_mask(p, name))
75: return 0;
76:
77: if (!list_empty(&allowed)) {
78: list_for_each_entry(p, &allowed, p_list)
79: if (match_mask(p, name))
80: return 1;
81:
82: return 0;
83: }
84:
85: return 1;
86: }
87:
88: void element_parse_policy(const char *policy)
89: {
90: char *start, *copy, *save = NULL, *tok;
91: struct policy *p;
92:
93: if (!policy)
94: return;
95:
96: copy = strdup(policy);
97: start = copy;
98:
99: while ((tok = strtok_r(start, ",", &save)) != NULL) {
100: start = NULL;
101:
102: p = xcalloc(1, sizeof(*p));
103:
104: if (*tok == '!') {
105: p->p_rule = strdup(++tok);
106: list_add_tail(&p->p_list, &denied);
107: } else {
108: p->p_rule = strdup(tok);
109: list_add_tail(&p->p_list, &allowed);
110: }
111: }
112:
113: xfree(copy);
114: }
115:
116: struct element *__lookup_element(struct element_group *group, const char *name,
117: uint32_t id, struct element *parent)
118: {
119: struct list_head *list;
120: struct element *e;
121:
122: if (parent)
123: list = &parent->e_childs;
124: else
125: list = &group->g_elements;
126:
127: list_for_each_entry(e, list, e_list)
128: if (!strcmp(name, e->e_name) && e->e_id == id)
129: return e;
130:
131: return NULL;
132: }
133:
134: struct element *element_lookup(struct element_group *group, const char *name,
135: uint32_t id, struct element *parent, int flags)
136: {
137: struct element_cfg *cfg;
138: struct element *e;
139: int i;
140:
141: if (!group)
142: BUG();
143:
144: if ((e = __lookup_element(group, name, id, parent)))
145: return e;
146:
147: if (!(flags & ELEMENT_CREAT))
148: return NULL;
149:
150: cfg = element_cfg_lookup(name);
151: if (!element_allowed(name, cfg))
152: return NULL;
153:
154: DBG("Creating element %d \"%s\"", id, name);
155:
156: e = xcalloc(1, sizeof(*e));
157:
158: init_list_head(&e->e_list);
159: init_list_head(&e->e_childs);
160: init_list_head(&e->e_info_list);
161: init_list_head(&e->e_attr_sorted);
162:
163: for (i = 0; i < ATTR_HASH_SIZE; i++)
164: init_list_head(&e->e_attrhash[i]);
165:
166: e->e_name = strdup(name);
167: e->e_id = id;
168: e->e_parent = parent;
169: e->e_group = group;
170: e->e_lifecycles = get_lifecycles();
171: e->e_flags = ELEMENT_FLAG_CREATED;
172: e->e_cfg = cfg;
173:
174: if (e->e_cfg) {
175: if (e->e_cfg->ec_description)
176: element_update_info(e, "Description",
177: e->e_cfg->ec_description);
178:
179: element_set_rxmax(e, e->e_cfg->ec_rxmax);
180: element_set_txmax(e, e->e_cfg->ec_txmax);
181: }
182:
183: if (parent) {
184: DBG("Attached to parent %d \"%s\"", parent->e_id, parent->e_name);
185: list_add_tail(&e->e_list, &parent->e_childs);
186: } else {
187: DBG("Attached to group %s", group->g_name);
188: list_add_tail(&e->e_list, &group->g_elements);
189: }
190:
191: group->g_nelements++;
192:
193: return e;
194: }
195:
196: void element_free(struct element *e)
197: {
198: struct info *info, *ninfo;
199: struct element *c, *cnext;
200: struct attr *a, *an;
201: int i;
202:
203: if (e->e_group->g_current == e) {
204: element_select_prev();
205: if (e->e_group->g_current == e)
206: e->e_group->g_current = NULL;
207: }
208:
209: list_for_each_entry_safe(c, cnext, &e->e_childs, e_list)
210: element_free(c);
211:
212: list_for_each_entry_safe(info, ninfo, &e->e_info_list, i_list) {
213: xfree(info->i_name);
214: xfree(info->i_value);
215: list_del(&info->i_list);
216: xfree(info);
217: }
218:
219: for (i = 0; i < ATTR_HASH_SIZE; i++)
220: list_for_each_entry_safe(a, an, &e->e_attrhash[i], a_list)
221: attr_free(a);
222:
223: if (e->e_group) {
224: list_del(&e->e_list);
225: e->e_group->g_nelements--;
226: }
227:
228: xfree(e->e_name);
229: xfree(e);
230: }
231:
232: #if 0
233: if (item->i_group->g_selected == item) {
234: if (item_select_prev() == END_OF_LIST) {
235: if (group_select_prev() == END_OF_LIST) {
236: if (node_select_prev() != END_OF_LIST)
237: item_select_last();
238: } else
239: item_select_last();
240: }
241: }
242: #endif
243:
244: #if 0
245:
246: void item_delete(struct item *item)
247: {
248: int m;
249: struct item *child;
250:
251: for (m = 0; m < ATTR_HASH_MAX; m++) {
252: struct attr *a, *next;
253: for (a = item->i_attrs[m]; a; a = next) {
254: next = a->a_next;
255: xfree(a);
256: }
257: }
258:
259: if (item->i_group->g_selected == item) {
260: if (item_select_prev() == END_OF_LIST) {
261: if (group_select_prev() == END_OF_LIST) {
262: if (node_select_prev() != END_OF_LIST)
263: item_select_last();
264: } else
265: item_select_last();
266: }
267: }
268:
269: unlink_item(item);
270: item->i_group->g_nitems--;
271:
272: for (child = item->i_childs; child; child = child->i_next)
273: item_delete(child);
274:
275: if (item->i_path)
276: xfree(item->i_path);
277:
278: xfree(item);
279: }
280:
281: #endif
282:
283: void element_reset_update_flag(struct element_group *g,
284: struct element *e, void *arg)
285: {
286: DBG("Reseting update flag of %s", e->e_name);
287: e->e_flags &= ~ELEMENT_FLAG_UPDATED;
288: }
289:
290: /**
291: * Needs to be called after updating all attributes of an element
292: */
293: void element_notify_update(struct element *e, timestamp_t *ts)
294: {
295: struct attr *a;
296: int i;
297:
298: e->e_flags |= ELEMENT_FLAG_UPDATED;
299:
300: if (ts == NULL)
301: ts = &rtiming.rt_last_read;
302:
303: for (i = 0; i < ATTR_HASH_SIZE; i++)
304: list_for_each_entry(a, &e->e_attrhash[i], a_list)
305: attr_notify_update(a, ts);
306:
307: if (e->e_usage_attr && e->e_cfg &&
308: (a = attr_lookup(e, e->e_usage_attr->ad_id))) {
309: attr_calc_usage(a, &e->e_rx_usage, &e->e_tx_usage,
310: e->e_cfg->ec_rxmax, e->e_cfg->ec_txmax);
311: } else {
312: e->e_rx_usage = FLT_MAX;
313: e->e_tx_usage = FLT_MAX;
314: }
315: }
316:
317: void element_lifesign(struct element *e, int n)
318: {
319: e->e_lifecycles = n * get_lifecycles();
320: }
321:
322: void element_check_if_dead(struct element_group *g,
323: struct element *e, void *arg)
324: {
325: if (--(e->e_lifecycles) <= 0) {
326: element_free(e);
327: DBG("Deleting dead element %s", e->e_name);
328: }
329: }
330:
331: void element_foreach_attr(struct element *e,
332: void (*cb)(struct element *e,
333: struct attr *, void *),
334: void *arg)
335: {
336: struct attr *a;
337:
338: list_for_each_entry(a, &e->e_attr_sorted, a_sort_list)
339: cb(e, a, arg);
340: }
341:
342: int element_set_key_attr(struct element *e, const char *major,
343: const char * minor)
344: {
345: if (!(e->e_key_attr[GT_MAJOR] = attr_def_lookup(major)))
346: return -ENOENT;
347:
348: if (!(e->e_key_attr[GT_MINOR] = attr_def_lookup(minor)))
349: return -ENOENT;
350:
351: return 0;
352: }
353:
354: int element_set_usage_attr(struct element *e, const char *usage)
355: {
356: if (!(e->e_usage_attr = attr_def_lookup(usage)))
357: return -ENOENT;
358:
359: return 0;
360: }
361:
362: struct element *element_current(void)
363: {
364: struct element_group *g;
365:
366: if (!(g = group_current()))
367: return NULL;
368:
369: if (!g->g_current)
370: element_select_first();
371:
372: return g->g_current;
373: }
374:
375: struct element *element_select_first(void)
376: {
377: struct element_group *g;
378:
379: if (!(g = group_current()))
380: return NULL;
381:
382: if (list_empty(&g->g_elements))
383: g->g_current = NULL;
384: else
385: g->g_current = list_first_entry(&g->g_elements,
386: struct element, e_list);
387:
388: return g->g_current;
389: }
390:
391: struct element *element_select_last(void)
392: {
393: struct element_group *g;
394:
395: if (!(g = group_current()))
396: return NULL;
397:
398: if (list_empty(&g->g_elements))
399: g->g_current = NULL;
400: else {
401: struct element *e;
402:
403: e = list_entry(g->g_elements.prev, struct element, e_list);
404:
405: while (!list_empty(&e->e_childs))
406: e = list_entry(e->e_childs.prev, struct element,
407: e_list);
408:
409: g->g_current = e;
410: }
411:
412: return g->g_current;
413: }
414:
415: struct element *element_select_next(void)
416: {
417: struct element_group *g;
418: struct element *e;
419:
420: if (!(g = group_current()))
421: return NULL;
422:
423: if (!(e = g->g_current))
424: return element_select_first();
425:
426: if (!list_empty(&e->e_childs))
427: e = list_first_entry(&e->e_childs, struct element, e_list);
428: else {
429: /*
430: * move upwards until we have no parent or there is a next
431: * entry in the list
432: */
433: while (e->e_parent && e->e_list.next == &e->e_parent->e_childs)
434: e = e->e_parent;
435:
436: if (!e->e_parent && e->e_list.next == &g->g_elements) {
437: group_select_next();
438: return element_select_first();
439: } else
440: e = list_entry(e->e_list.next, struct element, e_list);
441: }
442:
443: g->g_current = e;
444:
445: return e;
446: }
447:
448: struct element *element_select_prev(void)
449: {
450: struct element_group *g;
451: struct element *e;
452:
453: if (!(g = group_current()))
454: return NULL;
455:
456: if (!(e = g->g_current))
457: return element_select_last();
458:
459: if (!e->e_parent && e->e_list.prev == &g->g_elements) {
460: group_select_prev();
461: return element_select_last();
462: }
463:
464: if (e->e_parent && e->e_list.prev == &e->e_parent->e_childs)
465: e = e->e_parent;
466: else {
467: e = list_entry(e->e_list.prev, struct element, e_list);
468:
469: while (!list_empty(&e->e_childs))
470: e = list_entry(e->e_childs.prev, struct element,
471: e_list);
472: }
473:
474: g->g_current = e;
475:
476: return e;
477: }
478:
479: static struct info *element_info_lookup(struct element *e, const char *name)
480: {
481: struct info *i;
482:
483: list_for_each_entry(i, &e->e_info_list, i_list)
484: if (!strcmp(i->i_name, name))
485: return i;
486:
487: return NULL;
488: }
489:
490: void element_update_info(struct element *e, const char *name, const char *value)
491: {
492: struct info *i;
493:
494: if ((i = element_info_lookup(e, name))) {
495: xfree(i->i_value);
496: i->i_value = strdup(value);
497: return;
498: }
499:
500: DBG("Created element info %s (\"%s\")", name, value);
501:
502: i = xcalloc(1, sizeof(*i));
503: i->i_name = strdup(name);
504: i->i_value = strdup(value);
505:
506: e->e_ninfo++;
507:
508: list_add_tail(&i->i_list, &e->e_info_list);
509: }
510:
511: void element_set_txmax(struct element *e, uint64_t max)
512: {
513: char buf[32];
514:
515: if (!e->e_cfg)
516: e->e_cfg = element_cfg_create(e->e_name);
517:
518: if (e->e_cfg->ec_txmax != max)
519: e->e_cfg->ec_txmax = max;
520:
521: unit_bit2str(e->e_cfg->ec_txmax * 8, buf, sizeof(buf));
522: element_update_info(e, "TxMax", buf);
523: }
524:
525: void element_set_rxmax(struct element *e, uint64_t max)
526: {
527: char buf[32];
528:
529: if (!e->e_cfg)
530: e->e_cfg = element_cfg_create(e->e_name);
531:
532: if (e->e_cfg->ec_rxmax != max)
533: e->e_cfg->ec_rxmax = max;
534:
535: unit_bit2str(e->e_cfg->ec_rxmax * 8, buf, sizeof(buf));
536: element_update_info(e, "RxMax", buf);
537: }