1 #include <sys/types.h>
2 #include <sys/stat.h>
3 #include <fcntl.h>
4 #include <stdio.h>
5 #include <stdlib.h>
6 #include <string.h>
7 #include <errno.h>
8 #include <locale.h>
9 #include <stddef.h>
10 #include <limits.h>
11 #include <rctl.h>
12 #include <regex.h>
13 #include <ctype.h>
14
15 #include <sys/debug.h>
16
17 #include "attrib.h"
18 #include "resctl.h"
19 #include "util.h"
20
21 #define BOSTR_REG_EXP "^"
22 #define EOSTR_REG_EXP "$"
23 #define EQUAL_REG_EXP "="
24 #define STRN0_REG_EXP "(.*)"
25 #define IDENT_REG_EXP "[[:alpha:]][[:alnum:]_.-]*"
26 #define INTNM_REG_EXP "[[:digit:]]+"
27 #define SIGAC_REG_EXP "sig(nal)?(=.*)?"
28 #define SIGHD_REG_EXP "(signal|sig)"
29 #define SIGVL_REG_EXP "(([[:digit:]]+)|((SIG)?([[:upper:]]+)([+-][123])?))"
30 #define SIGNL_REG_EXP SIGHD_REG_EXP EQUAL_REG_EXP SIGVL_REG_EXP
31 #define STOCK_REG_EXP "([[:upper:]]{1,5}(.[[:upper:]]{1,5})?,)?"
32 #define ATTRB_REG_EXP "(" STOCK_REG_EXP IDENT_REG_EXP ")"
33 #define ATVAL_REG_EXP ATTRB_REG_EXP EQUAL_REG_EXP STRN0_REG_EXP
34
35 #define TO_EXP(X) BOSTR_REG_EXP X EOSTR_REG_EXP
36
37 #define POOLN_EXP TO_EXP(IDENT_REG_EXP)
38 #define INTNM_EXP TO_EXP(INTNM_REG_EXP)
39 #define SIGAC_EXP TO_EXP(SIGAC_REG_EXP)
40 #define SIGNL_EXP TO_EXP(SIGNL_REG_EXP)
41 #define ATTRB_EXP TO_EXP(ATTRB_REG_EXP)
42 #define ATVAL_EXP TO_EXP(ATVAL_REG_EXP)
43
44 #define MAX_OF(X, Y) (((X) > (Y)) ? (X) : (Y))
45
46 #define SEQU(X, Y) (strcmp((X), (Y)) == 0)
47 #define SIN1(X, S1) ((SEQU((X), (S1))))
48 #define SIN2(X, S1, S2) ((SEQU((X), (S1))) || (SIN1((X), (S2))))
49 #define SIN3(X, S1, S2, S3) ((SEQU((X), (S1))) || (SIN2((X), (S2), (S3))))
50
51 #define ATT_VAL_TYPE_NULL 0
52 #define ATT_VAL_TYPE_VALUE 1
53 #define ATT_VAL_TYPE_LIST 2
54
55 #define ATT_ALLOC() attrib_alloc()
56 #define ATT_VAL_ALLOC(T, V) attrib_val_alloc((T), (V))
57 #define ATT_VAL_ALLOC_NULL() ATT_VAL_ALLOC(ATT_VAL_TYPE_NULL, NULL)
58 #define ATT_VAL_ALLOC_VALUE(V) ATT_VAL_ALLOC(ATT_VAL_TYPE_VALUE, (V))
59 #define ATT_VAL_ALLOC_LIST(L) ATT_VAL_ALLOC(ATT_VAL_TYPE_LIST, (L))
60
61 typedef struct attrib_val_s {
62 int att_val_type;
63 /*LINTED*/
64 union {
65 char *att_val_value;
66 lst_t *att_val_values;
67 };
68 } attrib_val_t;
69
70 typedef struct attrib_s {
71 char *att_name;
72 attrib_val_t *att_value;
73 } attrib_t;
74
75
76 attrib_t *attrib_alloc();
77 attrib_val_t *attrib_val_alloc(int, void *);
78 char *attrib_val_tostring(attrib_val_t *, boolean_t);
79
80 int
81 attrib_validate_rctl(attrib_t *att, resctlrule_t *rule, lst_t *errlst)
82 {
83 int ret = 0;
84 char *atname = att->att_name;
85 attrib_val_t *atv, *atval = att->att_value;
86 attrib_val_t *priv, *val, *action;
87 char *vpriv, *vval, *vaction, *sigstr;
88 int atv_type = atval->att_val_type;
89 char *str;
90 int i, j, k;
91
92 int nmatch;
93 uint8_t rpriv, raction, sigval;
94 uint64_t rmax;
95 regex_t pintexp, sigacexp, signlexp;
96 regmatch_t *mat;
97
98 int nonecount, denycount, sigcount;
99
100 if (regcomp(&pintexp, INTNM_EXP, REG_EXTENDED) != 0) {
101 util_add_errmsg(errlst, gettext(
102 "Failed to compile regex for pos. integer"));
103 return (1);
104 }
105
106 if (regcomp(&sigacexp, SIGAC_EXP, REG_EXTENDED) != 0) {
107 util_add_errmsg(errlst, gettext(
108 "Failed to compile regex for sigaction"));
109 regfree(&pintexp);
110 return (1);
111 }
112
113 if (regcomp(&signlexp, SIGNL_EXP, REG_EXTENDED) != 0) {
114 util_add_errmsg(errlst, gettext(
115 "Failed to compile regex for signal"));
116 regfree(&pintexp);
117 regfree(&sigacexp);
118 return (1);
119 }
120
121 nmatch = signlexp.re_nsub + 1;
122 mat = util_safe_zmalloc(nmatch * sizeof (regmatch_t));
123
124 if (atv_type != ATT_VAL_TYPE_LIST) {
125 util_add_errmsg(errlst, gettext(
126 "rctl \"%s\" missing value"), atname);
127 ret = 1;
128 goto out;
129 }
130
131 for (i = 0; i < lst_size(atval->att_val_values); i++) {
132 atv = lst_at(atval->att_val_values, i);
133 if (atv->att_val_type != ATT_VAL_TYPE_LIST) {
134 if ((str = attrib_val_tostring(atv, B_FALSE)) != NULL) {
135 util_add_errmsg(errlst, gettext(
136 "rctl \"%s\" value \"%s\" "
137 "should be in ()"), atname, str);
138 free(str);
139 } else {
140 util_add_errmsg(errlst, gettext(
141 "rctl \"%s\" value "
142 "should be in ()"), atname);
143 }
144 ret = 1;
145 continue;
146 }
147 /* Values should be in the form (priv, val, actions) */
148 if (lst_size(atv->att_val_values) < 3) {
149 util_add_errmsg(errlst, gettext(
150 "rctl \"%s\" value should be in the form "
151 "(priv, val, action[,...])[,....]"), atname);
152 ret = 1;
153 continue;
154 }
155
156 priv = lst_at(atv->att_val_values, 0);
157 val = lst_at(atv->att_val_values, 1);
158 /* actions = el[2], el[3], ... */
159
160 vpriv = priv->att_val_value;
161 rpriv = rule->resctl_privs;
162
163 if (priv->att_val_type != ATT_VAL_TYPE_VALUE) {
164 util_add_errmsg(errlst, gettext(
165 "rctl \"%s\" invalid privilege"), atname);
166 ret = 1;
167 } else if (!SIN3(vpriv, "basic", "privileged", "priv")) {
168 util_add_errmsg(errlst, gettext(
169 "rctl \"%s\" unknown privilege \"%s\""),
170 atname, vpriv);
171 ret = 1;
172 } else if (!(
173 ((rpriv & RESCTL_PRIV_PRIVE) &&
174 SEQU(vpriv, "priv")) ||
175 ((rpriv & RESCTL_PRIV_PRIVD) &&
176 SEQU(vpriv, "privileged")) ||
177 ((rpriv & RESCTL_PRIV_BASIC) &&
178 SEQU(vpriv, "basic")))) {
179 util_add_errmsg(errlst, gettext(
180 "rctl \"%s\" privilege not allowed \"%s\""),
181 atname, vpriv);
182 ret = 1;
183 }
184
185 vval = val->att_val_value;
186 rmax = rule->resctl_max;
187
188 if (val->att_val_type != ATT_VAL_TYPE_VALUE) {
189 util_add_errmsg(errlst, gettext(
190 "rctl \"%s\" invalid value"), atname);
191 ret = 1;
192 } else if (regexec(&pintexp, vval, 0, NULL, 0) != 0) {
193 util_add_errmsg(errlst, gettext(
194 "rctl \"%s\" value \"%s\" is not an integer"),
195 atname, vval);
196 ret = 1;
197 } else if (strtoll(vval, NULL, 0) > rmax) {
198 util_add_errmsg(errlst, gettext(
199 "rctl \"%s\" value \"%s\" exceeds system limit"),
200 atname, vval);
201 ret = 1;
202 }
203
204 nonecount = 0;
205 denycount = 0;
206 sigcount = 0;
207
208 for (j = 2; j < lst_size(atv->att_val_values); j++) {
209 action = lst_at(atv->att_val_values, j);
210
211 if (action->att_val_type != ATT_VAL_TYPE_VALUE) {
212 util_add_errmsg(errlst, gettext(
213 "rctl \"%s\" invalid action"), atname);
214 ret = 1;
215 continue;
216 }
217
218 vaction = action->att_val_value;
219
220 if (regexec(&sigacexp, vaction, 0, NULL, 0) != 0 &&
221 !SIN2(vaction, "none", "deny")) {
222 util_add_errmsg(errlst, gettext(
223 "rctl \"%s\" unknown action \"%s\""),
224 atname, vaction);
225 ret = 1;
226 continue;
227 }
228
229 raction = rule->resctl_action;
230 if (!(((raction & RESCTL_ACTN_SIGN) &&
231 regexec(&sigacexp, vaction, 0, NULL, 0) == 0) ||
232 ((raction & RESCTL_ACTN_NONE) &&
233 SEQU(vaction, "none")) ||
234 ((raction & RESCTL_ACTN_DENY) &&
235 SEQU(vaction, "deny")))) {
236 util_add_errmsg(errlst, gettext(
237 "rctl \"%s\" action not allowed \"%s\""),
238 atname, vaction);
239 ret = 1;
240 continue;
241 }
242
243 if (SEQU(vaction, "none")) {
244 if (nonecount >= 1) {
245 util_add_errmsg(errlst, gettext(
246 "rctl \"%s\" duplicate action "
247 "none"), atname);
248 ret = 1;
249 }
250 nonecount++;
251 continue;
252 }
253
254 if (SEQU(vaction, "deny")) {
255 if (denycount >= 1) {
256 util_add_errmsg(errlst, gettext(
257 "rctl \"%s\" duplicate action "
258 "deny"), atname);
259 ret = 1;
260 }
261 denycount++;
262 continue;
263 }
264
265 /* At this point, the action must be signal. */
266 if (sigcount >= 1) {
267 util_add_errmsg(errlst, gettext(
268 "rctl \"%s\" duplicate action sig"),
269 atname);
270 ret = 1;
271 }
272 sigcount++;
273
274 /*
275 * Make sure signal is correct format, on of:
276 * sig=##
277 * signal=##
278 * sig=SIGXXX
279 * signal=SIGXXX
280 * sig=XXX
281 * signal=XXX
282 */
283
284 if (regexec(&signlexp, vaction, nmatch, mat, 0) != 0 ||
285 (sigstr = util_substr(&signlexp, mat, vaction, 2))
286 == NULL) {
287 util_add_errmsg(errlst, gettext(
288 "rctl \"%s\" invalid signal \"%s\""),
289 atname, vaction);
290 ret = 1;
291 continue;
292 }
293
294 /* Our version of sigstr =~ s/SIG// */
295 if (strstr(sigstr, "SIG") != NULL)
296 sigstr = strstr(sigstr, "SIG") + 3;
297
298 sigval = 0;
299 for (k = 0; k < SIGS_CNT; k++) {
300 if (SEQU(sigs[k].sig, sigstr))
301 sigval = sigs[k].mask;
302 }
303 free(sigstr);
304
305 if (sigval == 0) {
306 util_add_errmsg(errlst, gettext(
307 "rctl \"%s\" invalid signal \"%s\""),
308 atname, vaction);
309 ret = 1;
310 continue;
311 }
312
313 if (!(sigval & rule->resctl_sigs)) {
314 util_add_errmsg(errlst, gettext(
315 "rctl \"%s\" signal not allowed \"%s\""),
316 atname, vaction);
317 ret = 1;
318 continue;
319 }
320 }
321 if (nonecount > 0 && (denycount > 0 || sigcount > 0)) {
322 util_add_errmsg(errlst, gettext(
323 "rctl \"%s\" action \"none\" specified with "
324 "other actions"),
325 atname);
326 ret = 1;
327 }
328 }
329
330 out:
331 free(mat);
332 regfree(&signlexp);
333 regfree(&sigacexp);
334 regfree(&pintexp);
335 return (ret);
336 }
337
338 int
339 attrib_validate(attrib_t *att, lst_t *errlst)
340 {
341 int ret = 0;
342 char *atname = att->att_name;
343 attrib_val_t *atv = att->att_value;
344 int atv_type = atv->att_val_type;
345 char *str, *eptr;
346 long long ll;
347
348 resctl_info_t rinfo;
349 resctlrule_t rrule;
350
351 regex_t poolnexp;
352 if (regcomp(&poolnexp, POOLN_EXP, REG_EXTENDED) != 0) {
353 util_add_errmsg(errlst, gettext(
354 "Failed to compile poolname regular expression:"));
355 return (1);
356 }
357
358 if (SEQU(atname, "task.final")) {
359 if (atv_type != ATT_VAL_TYPE_NULL) {
360 util_add_errmsg(errlst, gettext(
361 "task.final should not have value"));
362 ret = 1;
363 }
364 } else if (SEQU(atname, "rcap.max-rss")) {
365 if (atv_type == ATT_VAL_TYPE_NULL) {
366 util_add_errmsg(errlst, gettext(
367 "rcap.max-rss missing value"));
368 ret = 1;
369 } else if (atv_type == ATT_VAL_TYPE_LIST) {
370 util_add_errmsg(errlst, gettext(
371 "rcap.max-rss should have single value"));
372 ret = 1;
373 } else if (atv_type == ATT_VAL_TYPE_VALUE) {
374 if ((str = attrib_val_tostring(atv, B_FALSE)) != NULL) {
375 ll = strtoll(str, &eptr, 0);
376 if (*eptr != '\0') {
377 util_add_errmsg(errlst, gettext(
378 "rcap.max-rss is not an integer "
379 "value: \"%s\""), str);
380 ret = 1;
381 } else if (ll == LLONG_MIN && errno == ERANGE) {
382 util_add_errmsg(errlst, gettext(
383 "rcap.max-rss too small"));
384 ret = 1;
385 } else if (ll == LLONG_MAX && errno == ERANGE) {
386 util_add_errmsg(errlst, gettext(
387 "rcap.max-rss too large"));
388 ret = 1;
389 } else if (ll < 0) {
390 util_add_errmsg(errlst, gettext(
391 "rcap.max-rss should not have "
392 "negative value: \"%s\""), str);
393 ret = 1;
394 }
395 free(str);
396 } else {
397 util_add_errmsg(errlst, gettext(
398 "rcap.max-rss has invalid value"));
399 ret = 1;
400 }
401 }
402 } else if (SEQU(atname, "project.pool")) {
403 if (atv_type == ATT_VAL_TYPE_NULL) {
404 util_add_errmsg(errlst, gettext(
405 "project.pool missing value"));
406 ret = 1;
407 } else if (atv_type == ATT_VAL_TYPE_LIST) {
408 util_add_errmsg(errlst, gettext(
409 "project.pool should have single value"));
410 ret = 1;
411 } else if (atv_type == ATT_VAL_TYPE_VALUE) {
412 if ((str = attrib_val_tostring(atv, B_FALSE)) != NULL) {
413 if (regexec(&poolnexp, str, 0, NULL, 0) != 0) {
414 util_add_errmsg(errlst, gettext(
415 "project.pool: invalid pool "
416 "name \"%s\""), str);
417 ret = 1;
418 } else if (resctl_pool_exist(str) != 0) {
419 util_add_errmsg(errlst, gettext(
420 "project.pool: pools not enabled "
421 "or pool does not exist: \"%s\""),
422 str);
423 ret = 1;
424 }
425 free(str);
426 } else {
427 util_add_errmsg(errlst, gettext(
428 "project.pool has invalid value "));
429 ret = 1;
430 }
431 }
432 } else if (resctl_get_info(atname, &rinfo) == 0) {
433 resctl_get_rule(&rinfo, &rrule);
434 if (attrib_validate_rctl(att, &rrule, errlst) != 0) {
435 ret = 1;
436 }
437 }
438
439 regfree(&poolnexp);
440 return (ret);
441 }
442
443 int
444 attrib_validate_lst(lst_t *attribs, lst_t *errlst)
445 {
446 int i, j;
447 attrib_t *att;
448 char **atnames, **atlast;
449 char *atname;
450 int ret = 0;
451
452 atlast = atnames = util_safe_zmalloc(
453 (lst_size(attribs) + 1) * sizeof (char *));
454 for (i = 0; i < lst_size(attribs); i++) {
455 att = lst_at(attribs, i);
456
457 /* Validate this attribute */
458 if (attrib_validate(att, errlst) != 0)
459 ret = 1;
460 /* Make sure it is not duplicated */
461 for (j = 0; (atname = atnames[j]) != NULL; j++) {
462 if (strcmp(atname, att->att_name) == 0) {
463 util_add_errmsg(errlst, gettext(
464 "Duplicate attributes \"%s\""), atname);
465 ret = 1;
466 }
467 }
468 /*
469 * Add it to the attribute name to the
470 * temporary list if not found
471 */
472 if (atname == NULL) {
473 *atlast++ = att->att_name;
474 }
475 }
476 free(atnames);
477 return (ret);
478 }
479
480 attrib_t *
481 attrib_alloc()
482 {
483 return (util_safe_zmalloc(sizeof (attrib_t)));
484 }
485
486 attrib_val_t *
487 attrib_val_alloc(int type, void *val)
488 {
489 attrib_val_t *ret;
490
491 ret = util_safe_malloc(sizeof (attrib_val_t));
492 ret->att_val_type = type;
493 ret->att_val_value = val;
494 return (ret);
495 }
496
497 char *
498 attrib_val_tostring(attrib_val_t *val, boolean_t innerlist)
499 {
500 char *ret = NULL;
501 char *vstring;
502 int i;
503 attrib_val_t *v;
504 switch (val->att_val_type) {
505 case ATT_VAL_TYPE_NULL:
506 return (util_safe_strdup(""));
507 case ATT_VAL_TYPE_VALUE:
508 return (util_safe_strdup(val->att_val_value));
509 case ATT_VAL_TYPE_LIST:
510 /* Only innerlists need to be betweeen ( and ) */
511 if (innerlist)
512 ret = UTIL_STR_APPEND1(ret, "(");
513 for (i = 0; i < lst_size(val->att_val_values);
514 i++) {
515 v = lst_at(val->att_val_values, i);
516 if (i > 0) {
517 ret = UTIL_STR_APPEND1(ret, ",");
518 }
519 if ((vstring =
520 attrib_val_tostring(v, B_TRUE)) == NULL) {
521 UTIL_FREE_SNULL(ret);
522 goto out;
523 }
524 ret = UTIL_STR_APPEND1(ret, vstring);
525 free(vstring);
526 }
527 if (innerlist)
528 ret = UTIL_STR_APPEND1(ret, ")");
529 return (ret);
530 }
531
532 out:
533 return (ret);
534 }
535
536 char *
537 attrib_tostring(void *at)
538 {
539 attrib_t *att;
540 char *ret = NULL, *vstring;
541
542 att = (attrib_t *)at;
543 ret = UTIL_STR_APPEND1(ret, att->att_name);
544 if ((vstring = attrib_val_tostring(att->att_value, B_FALSE)) != NULL) {
545 if (strlen(vstring) > 0)
546 ret = UTIL_STR_APPEND2(ret, "=", vstring);
547 free(vstring);
548 return (ret);
549 }
550 UTIL_FREE_SNULL(ret);
551 return (ret);
552 }
553
554 char *
555 attrib_lst_tostring(lst_t *attrs)
556 {
557 int i;
558 attrib_t *att;
559 char *ret = NULL;
560 char *str;
561
562 ret = UTIL_STR_APPEND1(ret, "");
563 for (i = 0; i < lst_size(attrs); i++) {
564 att = lst_at(attrs, i);
565
566 if ((str = attrib_tostring(att)) != NULL) {
567 if (i > 0)
568 ret = UTIL_STR_APPEND1(ret, ";");
569
570 ret = UTIL_STR_APPEND1(ret, str);
571 free(str);
572 continue;
573 }
574
575 free(ret);
576 return (NULL);
577 }
578 return (ret);
579 }
580
581 void
582 attrib_val_free(attrib_val_t *atv)
583 {
584 attrib_val_t *val;
585
586 if (atv->att_val_type == ATT_VAL_TYPE_VALUE) {
587 free(atv->att_val_value);
588 } else if (atv->att_val_type == ATT_VAL_TYPE_LIST) {
589 while (!lst_is_empty(atv->att_val_values)) {
590 val = lst_at(atv->att_val_values, 0);
591 (void) lst_remove(atv->att_val_values, val);
592 attrib_val_free(val);
593 free(val);
594 }
595 free(atv->att_val_values);
596 }
597 }
598
599 void
600 attrib_free(attrib_t *att)
601 {
602 free(att->att_name);
603 if (att->att_value != NULL) {
604 attrib_val_free(att->att_value);
605 free(att->att_value);
606 }
607 }
608 void
609 attrib_free_lst(lst_t *attribs)
610 {
611 attrib_t *att;
612
613 if (attribs == NULL)
614 return;
615
616 while (!lst_is_empty(attribs)) {
617 att = lst_at(attribs, 0);
618 (void) lst_remove(attribs, att);
619 attrib_free(att);
620 free(att);
621 }
622 }
623
624 void
625 attrib_sort_lst(lst_t *attribs)
626 {
627 int i, j, n;
628 attrib_t *atti, *attj;
629
630 if (attribs == NULL)
631 return;
632
633 n = lst_size(attribs);
634 for (i = 0; i < n - 1; i++) {
635 for (j = i + 1; j < n; j++) {
636 atti = lst_at(attribs, i);
637 attj = lst_at(attribs, j);
638 if (strcmp(attj->att_name, atti->att_name) < 0) {
639 (void) lst_replace_at(attribs, i, attj);
640 (void) lst_replace_at(attribs, j, atti);
641 }
642 }
643 }
644 }
645
646 void
647 attrib_val_to_list(attrib_val_t *atv)
648 {
649 void *val;
650 int type;
651 attrib_val_t *mat;
652
653 if (atv->att_val_type == ATT_VAL_TYPE_LIST)
654 return;
655
656 val = atv->att_val_value;
657 type = atv->att_val_type;
658
659 atv->att_val_type = ATT_VAL_TYPE_LIST;
660 atv->att_val_values = util_safe_malloc(sizeof (lst_t));
661 lst_create(atv->att_val_values);
662
663 if (type == ATT_VAL_TYPE_VALUE && val != NULL) {
664 mat = ATT_VAL_ALLOC_VALUE(val);
665 lst_insert_tail(atv->att_val_values, mat);
666 }
667 }
668
669 void
670 attrib_val_append(attrib_val_t *atv, char *token)
671 {
672 attrib_val_t *nat;
673 if (atv->att_val_type == ATT_VAL_TYPE_VALUE) {
674 /* convert this to LIST attribute */
675 attrib_val_to_list(atv);
676 }
677
678 if (atv->att_val_type == ATT_VAL_TYPE_NULL) {
679 /* convert this to VALUE attribute */
680 atv->att_val_type = ATT_VAL_TYPE_VALUE;
681 atv->att_val_value = util_safe_strdup(token);
682 } else if (atv->att_val_type == ATT_VAL_TYPE_LIST) {
683 /* append token to the list */
684 nat = ATT_VAL_ALLOC_VALUE(util_safe_strdup(token));
685 lst_insert_tail(atv->att_val_values, nat);
686 }
687 }
688
689 attrib_val_t *
690 attrib_val_parse(char *values, lst_t *errlst)
691 {
692 attrib_val_t *ret = NULL;
693 attrib_val_t *at;
694 attrib_val_t *nat;
695 lst_t stk;
696
697 char **tokens, *token, *usedtokens, *prev;
698 int i, error, parendepth;
699
700 error = parendepth = 0;
701 prev = "";
702
703 if ((tokens = util_tokenize(values, errlst)) == NULL) {
704 goto out1;
705 }
706
707 lst_create(&stk);
708 usedtokens = UTIL_STR_APPEND1(NULL, "");
709
710 at = ret = ATT_VAL_ALLOC_NULL();
711
712 for (i = 0; (token = tokens[i]) != NULL; i++) {
713
714 usedtokens = UTIL_STR_APPEND1(usedtokens, token);
715
716 if (SEQU(token, ",")) {
717 if (SIN3(prev, ",", "(", "")) {
718 attrib_val_append(at, "");
719 }
720 attrib_val_to_list(at);
721 prev = ",";
722 } else if (SEQU(token, "(")) {
723 if (!(SIN3(prev, "(", ",", ""))) {
724 util_add_errmsg(errlst, gettext(
725 "\"%s\" <- \"(\" unexpected"), usedtokens);
726 error = 1;
727 goto out;
728 }
729
730 switch (at->att_val_type) {
731 case ATT_VAL_TYPE_VALUE:
732 util_add_errmsg(errlst, gettext(
733 "\"%s\" <- \"%s\" unexpected"),
734 usedtokens, token);
735 error = 1;
736 goto out;
737 case ATT_VAL_TYPE_NULL:
738 /* Make is a LIST attrib */
739 attrib_val_to_list(at);
740 /*FALLTHROUGH*/
741 case ATT_VAL_TYPE_LIST:
742 /* Allocate NULL node */
743 nat = ATT_VAL_ALLOC_NULL();
744 attrib_val_to_list(nat);
745 lst_insert_tail(
746 at->att_val_values, nat);
747 /* push at down one level */
748 lst_insert_head(&stk, at);
749 at = nat;
750 break;
751 }
752 parendepth++;
753 prev = "(";
754 } else if (SEQU(token, ")")) {
755 if (parendepth <= 0) {
756 util_add_errmsg(errlst, gettext(
757 "\"%s\" <- \")\" unexpected"), usedtokens);
758 error = 1;
759 goto out;
760 }
761 if (SIN2(prev, ",", "(")) {
762 attrib_val_append(at, "");
763 }
764
765 if (!lst_is_empty(&stk)) {
766 at = lst_at(&stk, 0);
767 (void) lst_remove(&stk, at);
768 }
769 parendepth--;
770 prev = ")";
771 } else {
772 if (!(SIN3(prev, ",", "(", ""))) {
773 util_add_errmsg(errlst, gettext(
774 "\"%s\" <- \"%s\" unexpected"),
775 usedtokens, token);
776 error = 1;
777 goto out;
778 }
779
780 attrib_val_append(at, token);
781 prev = token;
782 }
783 }
784
785 if (parendepth != 0) {
786 util_add_errmsg(errlst, gettext(
787 "\"%s\" <- \")\" missing"),
788 usedtokens);
789 error = 1;
790 goto out;
791 }
792
793 if (SIN2(prev, ",", "")) {
794 switch (at->att_val_type) {
795 case ATT_VAL_TYPE_NULL:
796 util_add_errmsg(errlst, gettext(
797 "\"%s\" unexpected"),
798 usedtokens);
799 error = 1;
800 goto out;
801 case ATT_VAL_TYPE_VALUE:
802 case ATT_VAL_TYPE_LIST:
803 attrib_val_append(at, "");
804 break;
805 }
806 }
807
808 out:
809 while (!lst_is_empty(&stk)) {
810 at = lst_at(&stk, 0);
811 (void) lst_remove(&stk, at);
812 }
813
814 util_free_tokens(tokens);
815 free(tokens);
816 free(usedtokens);
817 if (error) {
818 attrib_val_free(ret);
819 UTIL_FREE_SNULL(ret);
820 }
821 out1:
822 return (ret);
823 }
824
825 attrib_t *
826 attrib_parse(regex_t *attrbexp, regex_t *atvalexp, char *att, int flags,
827 lst_t *errlst)
828 {
829 int nmatch = MAX_OF(attrbexp->re_nsub, atvalexp->re_nsub) + 1;
830 attrib_t *ret = NULL;
831 attrib_val_t *retv, *atv, *atvl;
832 char *values = NULL;
833 int vidx, nidx, vlen;
834 int scale;
835
836 char *num, *mod, *unit;
837 int i;
838
839 resctl_info_t rinfo;
840 resctlrule_t rrule;
841
842 regmatch_t *mat = util_safe_malloc(nmatch * sizeof (regmatch_t));
843 ret = ATT_ALLOC();
844
845 if (regexec(attrbexp, att, attrbexp->re_nsub + 1, mat, 0) == 0) {
846 ret->att_name = util_safe_strdup(att);
847 ret->att_value = ATT_VAL_ALLOC_NULL();
848 } else if (regexec(atvalexp, att,
849 atvalexp->re_nsub + 1, mat, 0) == 0) {
850 vidx = atvalexp->re_nsub;
851 vlen = mat[vidx].rm_eo - mat[vidx].rm_so;
852 nidx = atvalexp->re_nsub - 3;
853 ret->att_name = util_substr(atvalexp, mat, att, nidx);
854
855 if (vlen > 0) {
856 values = util_substr(atvalexp, mat, att, vidx);
857 ret->att_value = attrib_val_parse(values, errlst);
858 free(values);
859 if (ret->att_value == NULL) {
860 util_add_errmsg(errlst, gettext(
861 "Invalid value on attribute \"%s\""),
862 ret->att_name);
863 attrib_free(ret);
864 UTIL_FREE_SNULL(ret);
865 goto out;
866 }
867 } else {
868 /* the value is an empty string */
869 ret->att_value = ATT_VAL_ALLOC_NULL();
870 }
871 } else {
872 util_add_errmsg(errlst, gettext(
873 "Invalid attribute \"%s\""), att);
874 attrib_free(ret);
875 UTIL_FREE_SNULL(ret);
876 goto out;
877 }
878
879 if (!(flags & F_PAR_UNT))
880 goto out;
881
882 if (SEQU(ret->att_name, "rcap.max-rss")) {
883 values = attrib_val_tostring(ret->att_value, B_FALSE);
884 if (util_val2num(values, BYTES_SCALE, errlst,
885 &num, &mod, &unit) == 0) {
886 attrib_val_free(ret->att_value);
887 ret->att_value = ATT_VAL_ALLOC_VALUE(num);
888 free(mod);
889 free(unit);
890 } else {
891 attrib_free(ret);
892 UTIL_FREE_SNULL(ret);
893 goto out;
894 }
895 free(values);
896 }
897
898 if (resctl_get_info(ret->att_name, &rinfo) == 0) {
899 resctl_get_rule(&rinfo, &rrule);
900 retv = ret->att_value;
901
902 switch (rrule.resctl_type) {
903 case RESCTL_TYPE_BYTES:
904 scale = BYTES_SCALE;
905 break;
906 case RESCTL_TYPE_SCNDS:
907 scale = SCNDS_SCALE;
908 break;
909 case RESCTL_TYPE_COUNT:
910 scale = COUNT_SCALE;
911 break;
912 default:
913 scale = UNKWN_SCALE;
914 break;
915 }
916
917 if (retv->att_val_type != ATT_VAL_TYPE_LIST)
918 goto out;
919
920
921 for (i = 0; i < lst_size(retv->att_val_values); i++) {
922 atvl = atv = lst_at(retv->att_val_values, i);
923
924 /*
925 * Continue if not a list and the second value
926 * is not a scaler value
927 */
928 if (atv->att_val_type != ATT_VAL_TYPE_LIST ||
929 lst_size(atv->att_val_values) < 3 ||
930 (atv = lst_at(atv->att_val_values, 1)) == NULL ||
931 atv->att_val_type != ATT_VAL_TYPE_VALUE) {
932 continue;
933 }
934 values = attrib_val_tostring(atv, B_FALSE);
935 if (util_val2num(values, scale, errlst,
936 &num, &mod, &unit) == 0) {
937 attrib_val_free(atv);
938 atv = ATT_VAL_ALLOC_VALUE(num);
939 (void) lst_replace_at(atvl->att_val_values, 1,
940 atv);
941 free(mod);
942 free(unit);
943
944 } else {
945 free(values);
946 attrib_free(ret);
947 UTIL_FREE_SNULL(ret);
948 goto out;
949 }
950 free(values);
951 }
952 }
953
954 out:
955 free(mat);
956 return (ret);
957 }
958
959 lst_t *
960 attrib_parse_attributes(char *attribs, int flags, lst_t *errlst)
961 {
962 char *sattrs, *attrs, *att;
963 regex_t attrbexp, atvalexp;
964
965 attrib_t *natt = NULL;
966 lst_t *ret = NULL;
967
968 ret = util_safe_malloc(sizeof (lst_t));
969 lst_create(ret);
970
971 if (regcomp(&attrbexp, ATTRB_EXP, REG_EXTENDED) != 0)
972 goto out1;
973 if (regcomp(&atvalexp, ATVAL_EXP, REG_EXTENDED) != 0)
974 goto out2;
975
976 sattrs = attrs = util_safe_strdup(attribs);
977 while ((att = strsep(&attrs, ";")) != NULL) {
978 if (*att == '\0')
979 continue;
980 if ((natt = attrib_parse(&attrbexp,
981 &atvalexp, att, flags, errlst)) == NULL) {
982 attrib_free_lst(ret);
983 UTIL_FREE_SNULL(ret);
984 break;
985 }
986
987 lst_insert_tail(ret, natt);
988 }
989
990 free(sattrs);
991 regfree(&atvalexp);
992 out2:
993 regfree(&attrbexp);
994 out1:
995 return (ret);
996 }
997
998 attrib_val_t *
999 attrib_val_duplicate(attrib_val_t *atv)
1000 {
1001 int i;
1002 lst_t *values;
1003 attrib_val_t *val;
1004 attrib_val_t *natv;
1005
1006 switch (atv->att_val_type) {
1007 case ATT_VAL_TYPE_NULL:
1008 natv = ATT_VAL_ALLOC_NULL();
1009 break;
1010 case ATT_VAL_TYPE_VALUE:
1011 natv = ATT_VAL_ALLOC_VALUE(
1012 util_safe_strdup(atv->att_val_value));
1013 break;
1014 case ATT_VAL_TYPE_LIST:
1015 values = util_safe_malloc(sizeof (lst_t));
1016 lst_create(values);
1017 for (i = 0; i < lst_size(atv->att_val_values);
1018 i++) {
1019 val = lst_at(atv->att_val_values, i);
1020 lst_insert_tail(values,
1021 attrib_val_duplicate(val));
1022 }
1023 natv = ATT_VAL_ALLOC_LIST(values);
1024 break;
1025 }
1026
1027 return (natv);
1028 }
1029
1030 attrib_t *
1031 attrib_duplicate(attrib_t *att)
1032 {
1033 attrib_t *natt = ATT_ALLOC();
1034 natt->att_name = util_safe_strdup(att->att_name);
1035 natt->att_value = attrib_val_duplicate(att->att_value);
1036 return (natt);
1037 }
1038
1039 attrib_t *
1040 attrib_merge_add(attrib_t *eatt, attrib_t *natt)
1041 {
1042 int i;
1043 attrib_t *att;
1044 attrib_val_t *atv, *eatv, *natv;
1045 lst_t *values;
1046
1047 eatv = eatt->att_value;
1048 natv = natt->att_value;
1049 att = ATT_ALLOC();
1050 att->att_name = util_safe_strdup(eatt->att_name);
1051
1052 if (eatv->att_val_type == ATT_VAL_TYPE_NULL) {
1053
1054 /* NULL + X -> X */
1055 atv = attrib_val_duplicate(natv);
1056
1057 } else if (natv->att_val_type == ATT_VAL_TYPE_NULL) {
1058
1059 /* X + NULL -> X */
1060 atv = attrib_val_duplicate(eatv);
1061
1062 } else if (eatv->att_val_type == ATT_VAL_TYPE_VALUE &&
1063 natv->att_val_type == ATT_VAL_TYPE_VALUE) {
1064
1065 /* VALUE + VALUE -> LIST */
1066 values = util_safe_malloc(sizeof (lst_t));
1067 lst_create(values);
1068 lst_insert_tail(values, attrib_val_duplicate(eatv));
1069 lst_insert_tail(values, attrib_val_duplicate(natv));
1070 atv = ATT_VAL_ALLOC_LIST(values);
1071
1072 } else if (eatv->att_val_type == ATT_VAL_TYPE_VALUE &&
1073 natv->att_val_type == ATT_VAL_TYPE_LIST) {
1074
1075 /* VALUE + LIST -> LIST */
1076 atv = attrib_val_duplicate(natv);
1077 lst_insert_head(atv->att_val_values,
1078 attrib_val_duplicate(eatv));
1079
1080 } else if (eatv->att_val_type == ATT_VAL_TYPE_LIST &&
1081 natv->att_val_type == ATT_VAL_TYPE_VALUE) {
1082
1083 /* LIST + VALUE -> LIST */
1084 atv = attrib_val_duplicate(eatv);
1085 lst_insert_tail(atv->att_val_values,
1086 attrib_val_duplicate(natv));
1087
1088 } else if (eatv->att_val_type == ATT_VAL_TYPE_LIST &&
1089 natv->att_val_type == ATT_VAL_TYPE_LIST) {
1090
1091 /* LIST + LIST -> LIST */
1092 atv = attrib_val_duplicate(eatv);
1093 for (i = 0; i < lst_size(natv->att_val_values); i++) {
1094 lst_insert_tail(atv->att_val_values,
1095 attrib_val_duplicate(
1096 lst_at(natv->att_val_values, i)));
1097 }
1098 }
1099
1100 att->att_value = atv;
1101 return (att);
1102 }
1103
1104 int
1105 attrib_val_equal(attrib_val_t *xatv, attrib_val_t *yatv)
1106 {
1107 int i;
1108 attrib_val_t *xv, *yv;
1109
1110 if (xatv->att_val_type != yatv->att_val_type)
1111 return (1);
1112
1113 switch (xatv->att_val_type) {
1114 case ATT_VAL_TYPE_NULL:
1115 return (0);
1116 case ATT_VAL_TYPE_VALUE:
1117 if (SEQU(xatv->att_val_value, yatv->att_val_value)) {
1118 return (0);
1119 }
1120 return (1);
1121 case ATT_VAL_TYPE_LIST:
1122 if (lst_size(xatv->att_val_values) !=
1123 lst_size(yatv->att_val_values))
1124 return (1);
1125 for (i = 0; i < lst_size(xatv->att_val_values);
1126 i++) {
1127 xv = lst_at(xatv->att_val_values, i);
1128 yv = lst_at(yatv->att_val_values, i);
1129 if (attrib_val_equal(xv, yv) != 0) {
1130 return (1);
1131 }
1132 }
1133 break;
1134 }
1135 return (0);
1136 }
1137
1138 attrib_t *
1139 attrib_merge_remove(attrib_t *eatt, attrib_t *natt, lst_t *errlst)
1140 {
1141
1142 int i, j;
1143 attrib_t *att = NULL;
1144 attrib_val_t *eatv, *natv;
1145 attrib_val_t *ev, *nv1, *nv2;
1146 lst_t *values;
1147 boolean_t found;
1148
1149 eatv = eatt->att_value;
1150 natv = natt->att_value;
1151
1152 if (eatv->att_val_type == ATT_VAL_TYPE_NULL &&
1153 natv->att_val_type == ATT_VAL_TYPE_NULL) {
1154
1155 /* NULL - NULL -> EMPTY */
1156 att = attrib_duplicate(eatt);
1157 (void) strcpy(att->att_name, "");
1158
1159 } else if (eatv->att_val_type == ATT_VAL_TYPE_NULL ||
1160 (eatv->att_val_type == ATT_VAL_TYPE_VALUE &&
1161 natv->att_val_type == ATT_VAL_TYPE_LIST) ||
1162 (eatv->att_val_type == ATT_VAL_TYPE_LIST &&
1163 natv->att_val_type == ATT_VAL_TYPE_VALUE)) {
1164
1165 /* NULL - X -> ERR, VALUE - LIST -> ERR, LIST - VALUE -> ERR */
1166 util_add_errmsg(errlst, gettext(
1167 "Can not remove attribute \"%s\""),
1168 eatt->att_name);
1169
1170 } else if (natv->att_val_type == ATT_VAL_TYPE_NULL) {
1171
1172 /* X - NULL -> X */
1173 att = attrib_duplicate(eatt);
1174
1175 } else if (eatv->att_val_type == ATT_VAL_TYPE_VALUE &&
1176 natv->att_val_type == ATT_VAL_TYPE_VALUE) {
1177
1178 /* VALUE - VALUE -> {EMPTY | ERR} */
1179 if (attrib_val_equal(eatv, natv) == 0) {
1180 att = ATT_ALLOC();
1181 att->att_name = util_safe_strdup("");
1182 att->att_value = ATT_VAL_ALLOC_NULL();
1183 } else {
1184 util_add_errmsg(errlst, gettext(
1185 "Can not remove attribute \"%s\""),
1186 eatt->att_name);
1187 }
1188
1189 } else if (eatv->att_val_type == ATT_VAL_TYPE_LIST &&
1190 natv->att_val_type == ATT_VAL_TYPE_LIST) {
1191 /* LIST - LIST -> {EMPTY | ERR | LIST} */
1192 if (attrib_val_equal(eatv, natv) == 0) {
1193 att = ATT_ALLOC();
1194 att->att_name = util_safe_strdup("");
1195 att->att_value = ATT_VAL_ALLOC_NULL();
1196 goto out;
1197 }
1198
1199 for (i = 0; i < lst_size(natv->att_val_values); i++) {
1200 nv1 = lst_at(natv->att_val_values, i);
1201 for (j = 0; j < lst_size(natv->att_val_values);
1202 j++) {
1203 nv2 = lst_at(natv->att_val_values, j);
1204 if (i != j && attrib_val_equal(nv1, nv2) == 0) {
1205 util_add_errmsg(errlst, gettext(
1206 "Duplicate values, can not remove"
1207 " attribute \"%s\""),
1208 eatt->att_name);
1209 goto out;
1210 }
1211 }
1212
1213 found = B_FALSE;
1214 for (j = 0; j < lst_size(eatv->att_val_values);
1215 j++) {
1216 ev = lst_at(eatv->att_val_values, j);
1217 if (attrib_val_equal(nv1, ev) == 0) {
1218 found = B_TRUE;
1219 break;
1220 }
1221 }
1222
1223 if (!found) {
1224 util_add_errmsg(errlst, gettext(
1225 "Value not found, can not remove"
1226 " attribute \"%s\""),
1227 eatt->att_name);
1228 goto out;
1229 }
1230 }
1231
1232 values = util_safe_malloc(sizeof (lst_t));
1233 lst_create(values);
1234 for (i = 0; i < lst_size(eatv->att_val_values); i++) {
1235 ev = lst_at(eatv->att_val_values, i);
1236 found = B_FALSE;
1237 for (j = 0; j < lst_size(natv->att_val_values);
1238 j++) {
1239 nv1 = lst_at(natv->att_val_values, j);
1240 if (attrib_val_equal(ev, nv1) == 0) {
1241 found = B_TRUE;
1242 break;
1243 }
1244 }
1245
1246 if (!found) {
1247 lst_insert_tail(values,
1248 attrib_val_duplicate(ev));
1249 }
1250 }
1251 att = ATT_ALLOC();
1252 att->att_name = util_safe_strdup(eatt->att_name);
1253 att->att_value = ATT_VAL_ALLOC_LIST(values);
1254 }
1255
1256 out:
1257 return (att);
1258 }
1259
1260 attrib_t *
1261 attrib_merge(attrib_t *eatt, attrib_t *natt, int flags, lst_t *errlst)
1262 {
1263 attrib_t *att = NULL;
1264
1265 VERIFY(SEQU(eatt->att_name, natt->att_name));
1266
1267 if (flags & F_MOD_ADD) {
1268 att = attrib_merge_add(eatt, natt);
1269 } else if (flags & F_MOD_REM) {
1270 att = attrib_merge_remove(eatt, natt, errlst);
1271 }
1272
1273 return (att);
1274 }
1275
1276 void
1277 attrib_merge_attrib_lst(lst_t **eattrs, lst_t *nattrs, int flags,
1278 lst_t *errlst)
1279 {
1280
1281 lst_t *attrs = NULL;
1282 int i, j;
1283 attrib_t *att, *natt, *eatt;
1284 boolean_t found;
1285
1286 if (flags & F_MOD_ADD) {
1287 attrs = util_safe_malloc(sizeof (lst_t));
1288 lst_create(attrs);
1289
1290 for (i = 0; i < lst_size(*eattrs); i++) {
1291 eatt = lst_at(*eattrs, i);
1292 found = B_FALSE;
1293 for (j = 0; j < lst_size(nattrs); j++) {
1294 natt = lst_at(nattrs, j);
1295 if (SEQU(eatt->att_name, natt->att_name)) {
1296 found = B_TRUE;
1297 break;
1298 }
1299 }
1300
1301 att = found ? attrib_merge(eatt, natt, flags, errlst) :
1302 attrib_duplicate(eatt);
1303 if (att == NULL) {
1304 attrib_free_lst(attrs);
1305 UTIL_FREE_SNULL(attrs);
1306 goto out;
1307 }
1308 lst_insert_tail(attrs, att);
1309 }
1310
1311 for (i = 0; i < lst_size(nattrs); i++) {
1312 natt = lst_at(nattrs, i);
1313 found = B_FALSE;
1314 for (j = 0; j < lst_size(*eattrs); j++) {
1315 eatt = lst_at(*eattrs, j);
1316 if (SEQU(natt->att_name, eatt->att_name)) {
1317 found = B_TRUE;
1318 break;
1319 }
1320 }
1321 if (found)
1322 continue;
1323 lst_insert_tail(attrs, attrib_duplicate(natt));
1324 }
1325
1326 } else if (flags & (F_MOD_REM | F_MOD_SUB)) {
1327
1328 for (i = 0; i < lst_size(nattrs); i++) {
1329 natt = lst_at(nattrs, i);
1330 for (j = 0; j < lst_size(nattrs); j++) {
1331 att = lst_at(nattrs, j);
1332 if (SEQU(natt->att_name, att->att_name) &&
1333 i != j) {
1334 util_add_errmsg(errlst, gettext(
1335 "Duplicate Attributes \"%s\""),
1336 natt->att_name);
1337 goto out;
1338 }
1339 }
1340
1341 found = B_FALSE;
1342 for (j = 0; j < lst_size(*eattrs); j++) {
1343 eatt = lst_at(*eattrs, j);
1344 if (SEQU(eatt->att_name, natt->att_name)) {
1345 found = B_TRUE;
1346 break;
1347 }
1348 }
1349 if (!found) {
1350 util_add_errmsg(errlst, gettext(
1351 "Project does not contain \"%s\""),
1352 natt->att_name);
1353 goto out;
1354 }
1355 }
1356
1357 attrs = util_safe_malloc(sizeof (lst_t));
1358 lst_create(attrs);
1359
1360 for (i = 0; i < lst_size(*eattrs); i++) {
1361 eatt = lst_at(*eattrs, i);
1362 found = B_FALSE;
1363 for (j = 0; j < lst_size(nattrs); j++) {
1364 natt = lst_at(nattrs, j);
1365 if (SEQU(eatt->att_name, natt->att_name)) {
1366 found = B_TRUE;
1367 break;
1368 }
1369 }
1370
1371 if (flags & F_MOD_REM) {
1372 att = found ?
1373 attrib_merge(eatt, natt, flags, errlst) :
1374 attrib_duplicate(eatt);
1375 } else if (flags & F_MOD_SUB) {
1376 att = attrib_duplicate(found ? natt : eatt);
1377 }
1378
1379 if (att == NULL) {
1380 attrib_free_lst(attrs);
1381 UTIL_FREE_SNULL(attrs);
1382 goto out;
1383 } else if (SEQU(att->att_name, "")) {
1384 attrib_free(att);
1385 } else {
1386 lst_insert_tail(attrs, att);
1387 }
1388 }
1389
1390 } else if (flags & F_MOD_REP) {
1391 attrs = util_safe_malloc(sizeof (lst_t));
1392 lst_create(attrs);
1393 for (i = 0; i < lst_size(nattrs); i++) {
1394 natt = lst_at(nattrs, i);
1395 lst_insert_tail(attrs, attrib_duplicate(natt));
1396 }
1397 }
1398 out:
1399 if (attrs != NULL) {
1400 attrib_free_lst(*eattrs);
1401 free(*eattrs);
1402 *eattrs = attrs;
1403 }
1404 }