tc: u32: add support for json output

Currently u32 filter output does not support json. This commit uses
proper json functions to add support for it.

`sprint_u32_handle` adds an extra space after the raw check, remove the
extra space.

Signed-off-by: Wen Liang <liangwen12year@gmail.com>
Tested-by: Victor Nogueira <victor@mojatatu.com>
Signed-off-by: David Ahern <dsahern@kernel.org>

diff --git a/tc/f_u32.c b/tc/f_u32.c
index a5747f671e1eacc377883af2f3eb018494b6aa58..11da202e370ddbe46f6a2961a2b3889eb8a9fdc5 100644 (file)
--- a/tc/f_u32.c
+++ b/tc/f_u32.c
@@ -109,7 +109,7 @@ static char *sprint_u32_handle(__u32 handle, char *buf)
                }
        }
        if (show_raw)
-               snprintf(b, bsize, "[%08x] ", handle);
+               snprintf(b, bsize, "[%08x]", handle);
        return buf;
 }
 
@@ -1213,11 +1213,11 @@ static int u32_print_opt(struct filter_util *qu, FILE *f, struct rtattr *opt,
 
        if (handle) {
                SPRINT_BUF(b1);
-               fprintf(f, "fh %s ", sprint_u32_handle(handle, b1));
+               print_string(PRINT_ANY, "fh", "fh %s ", sprint_u32_handle(handle, b1));
        }
 
        if (TC_U32_NODE(handle))
-               fprintf(f, "order %d ", TC_U32_NODE(handle));
+               print_int(PRINT_ANY, "order", "order %d ", TC_U32_NODE(handle));
 
        if (tb[TCA_U32_SEL]) {
                if (RTA_PAYLOAD(tb[TCA_U32_SEL])  < sizeof(*sel))
@@ -1227,15 +1227,15 @@ static int u32_print_opt(struct filter_util *qu, FILE *f, struct rtattr *opt,
        }
 
        if (tb[TCA_U32_DIVISOR]) {
-               fprintf(f, "ht divisor %d ",
-                       rta_getattr_u32(tb[TCA_U32_DIVISOR]));
+               __u32 htdivisor = rta_getattr_u32(tb[TCA_U32_DIVISOR]);
+
+               print_int(PRINT_ANY, "ht_divisor", "ht divisor %d ", htdivisor);
        } else if (tb[TCA_U32_HASH]) {
                __u32 htid = rta_getattr_u32(tb[TCA_U32_HASH]);
-
-               fprintf(f, "key ht %x bkt %x ", TC_U32_USERHTID(htid),
-                       TC_U32_HASH(htid));
+               print_hex(PRINT_ANY, "key_ht", "key ht %x ", TC_U32_USERHTID(htid));
+               print_hex(PRINT_ANY, "bkt", "bkt %x ", TC_U32_HASH(htid));
        } else {
-               fprintf(f, "??? ");
+               fprintf(stderr, "divisor and hash missing ");
        }
        if (tb[TCA_U32_CLASSID]) {
                SPRINT_BUF(b1);
@@ -1244,27 +1244,27 @@ static int u32_print_opt(struct filter_util *qu, FILE *f, struct rtattr *opt,
                        sprint_tc_classid(rta_getattr_u32(tb[TCA_U32_CLASSID]),
                                          b1));
        } else if (sel && sel->flags & TC_U32_TERMINAL) {
-               fprintf(f, "terminal flowid ??? ");
+               print_string(PRINT_FP, NULL, "terminal flowid ", NULL);
        }
        if (tb[TCA_U32_LINK]) {
                SPRINT_BUF(b1);
-               fprintf(f, "link %s ",
-                       sprint_u32_handle(rta_getattr_u32(tb[TCA_U32_LINK]),
-                                         b1));
+               char *link = sprint_u32_handle(rta_getattr_u32(tb[TCA_U32_LINK]), b1);
+
+               print_string(PRINT_ANY, "link", "link %s ", link);
        }
 
        if (tb[TCA_U32_FLAGS]) {
                __u32 flags = rta_getattr_u32(tb[TCA_U32_FLAGS]);
 
                if (flags & TCA_CLS_FLAGS_SKIP_HW)
-                       fprintf(f, "skip_hw ");
+                       print_bool(PRINT_ANY, "skip_hw", "skip_hw ", true);
                if (flags & TCA_CLS_FLAGS_SKIP_SW)
-                       fprintf(f, "skip_sw ");
+                       print_bool(PRINT_ANY, "skip_sw", "skip_sw ", true);
 
                if (flags & TCA_CLS_FLAGS_IN_HW)
-                       fprintf(f, "in_hw ");
+                       print_bool(PRINT_ANY, "in_hw", "in_hw ", true);
                else if (flags & TCA_CLS_FLAGS_NOT_IN_HW)
-                       fprintf(f, "not_in_hw ");
+                       print_bool(PRINT_ANY, "not_in_hw", "not_in_hw ", true);
        }
 
        if (tb[TCA_U32_PCNT]) {
@@ -1275,10 +1275,10 @@ static int u32_print_opt(struct filter_util *qu, FILE *f, struct rtattr *opt,
                pf = RTA_DATA(tb[TCA_U32_PCNT]);
        }
 
-       if (sel && show_stats && NULL != pf)
-               fprintf(f, " (rule hit %llu success %llu)",
-                       (unsigned long long) pf->rcnt,
-                       (unsigned long long) pf->rhit);
+       if (sel && show_stats && NULL != pf) {
+               print_u64(PRINT_ANY, "rule_hit", "(rule hit %llu ", pf->rcnt);
+               print_u64(PRINT_ANY, "success", "success %llu)", pf->rhit);
+       }
 
        if (tb[TCA_U32_MARK]) {
                struct tc_u32_mark *mark = RTA_DATA(tb[TCA_U32_MARK]);
@@ -1286,8 +1286,10 @@ static int u32_print_opt(struct filter_util *qu, FILE *f, struct rtattr *opt,
                if (RTA_PAYLOAD(tb[TCA_U32_MARK]) < sizeof(*mark)) {
                        fprintf(f, "\n  Invalid mark (kernel&iproute2 mismatch)\n");
                } else {
-                       fprintf(f, "\n  mark 0x%04x 0x%04x (success %d)",
-                               mark->val, mark->mask, mark->success);
+                       print_nl();
+                       print_0xhex(PRINT_ANY, "fwmark_value", "  mark 0x%04x ", mark->val);
+                       print_0xhex(PRINT_ANY, "fwmark_mask", "0x%04x ", mark->mask);
+                       print_int(PRINT_ANY, "fwmark_success", "(success %d)", mark->success);
                }
        }
 
@@ -1298,38 +1300,45 @@ static int u32_print_opt(struct filter_util *qu, FILE *f, struct rtattr *opt,
                        for (i = 0; i < sel->nkeys; i++) {
                                show_keys(f, sel->keys + i);
                                if (show_stats && NULL != pf)
-                                       fprintf(f, " (success %llu ) ",
-                                               (unsigned long long) pf->kcnts[i]);
+                                       print_u64(PRINT_ANY, "success", " (success %llu ) ",
+                                                 pf->kcnts[i]);
                        }
                }
 
                if (sel->flags & (TC_U32_VAROFFSET | TC_U32_OFFSET)) {
-                       fprintf(f, "\n    offset ");
-                       if (sel->flags & TC_U32_VAROFFSET)
-                               fprintf(f, "%04x>>%d at %d ",
-                                       ntohs(sel->offmask),
-                                       sel->offshift,  sel->offoff);
+                       print_nl();
+                       print_string(PRINT_ANY, NULL, "%s", "    offset ");
+                       if (sel->flags & TC_U32_VAROFFSET) {
+                               print_hex(PRINT_ANY, "offset_mask", "%04x", ntohs(sel->offmask));
+                               print_int(PRINT_ANY, "offset_shift", ">>%d ", sel->offshift);
+                               print_int(PRINT_ANY, "offset_off", "at %d ", sel->offoff);
+                       }
                        if (sel->off)
-                               fprintf(f, "plus %d ", sel->off);
+                               print_int(PRINT_ANY, "plus", "plus %d ", sel->off);
                }
                if (sel->flags & TC_U32_EAT)
-                       fprintf(f, " eat ");
+                       print_string(PRINT_ANY, NULL, "%s", " eat ");
 
                if (sel->hmask) {
-                       fprintf(f, "\n    hash mask %08x at %d ",
-                               (unsigned int)htonl(sel->hmask), sel->hoff);
+                       print_nl();
+                       unsigned int hmask = (unsigned int)htonl(sel->hmask);
+
+                       print_hex(PRINT_ANY, "hash_mask", "    hash mask %08x ", hmask);
+                       print_int(PRINT_ANY, "hash_off", "at %d ", sel->hoff);
                }
        }
 
        if (tb[TCA_U32_POLICE]) {
-               fprintf(f, "\n");
+               print_nl();
                tc_print_police(f, tb[TCA_U32_POLICE]);
        }
 
        if (tb[TCA_U32_INDEV]) {
                struct rtattr *idev = tb[TCA_U32_INDEV];
-
-               fprintf(f, "\n  input dev %s\n", rta_getattr_str(idev));
+               print_nl();
+               print_string(PRINT_ANY, "input_dev", "  input dev %s",
+                            rta_getattr_str(idev));
+               print_nl();
        }
 
        if (tb[TCA_U32_ACT])