serialize_bp.c

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2021 Dhruv Maroo <dhruvmaru007@gmail.com>
// SPDX-License-Identifier: LGPL-3.0-only
 
#include <rz_util/rz_serialize.h>
#include <rz_bp.h>
 
RZ_API void rz_serialize_bp_save(RZ_NONNULL Sdb *db, RZ_NONNULL RzBreakpoint *bp) {
    rz_return_if_fail(db && bp);
 
    RzListIter *iter;
    RzBreakpointItem *bp_item;
    rz_list_foreach (bp->bps, iter, bp_item) {
        PJ *j = pj_new();
        if (!j) {
            return;
        }
        pj_o(j);
        if (bp_item->cond) {
            pj_ks(j, "cond", bp_item->cond);
        }
        if (bp_item->data) {
            pj_ks(j, "data", bp_item->data);
        }
        pj_kn(j, "delta", bp_item->delta);
        pj_ki(j, "enabled", bp_item->enabled);
        if (bp_item->expr) {
            pj_ks(j, "expr", bp_item->expr);
        }
        pj_ki(j, "hits", bp_item->hits);
        pj_ki(j, "hw", bp_item->hw);
        pj_ki(j, "internal", bp_item->internal);
        pj_kN(j, "module_delta", bp_item->module_delta);
        if (bp_item->module_name) {
            pj_ks(j, "module_name", bp_item->module_name);
        }
        if (bp_item->name) {
            pj_ks(j, "name", bp_item->name);
        }
        pj_ki(j, "perm", bp_item->perm);
 
        pj_ka(j, "pids");
        for (int i = 0; i < RZ_BP_MAXPIDS; i++) {
            pj_i(j, bp_item->pids[i]);
        }
        pj_end(j);
 
        pj_ki(j, "size", bp_item->size);
        pj_kb(j, "swstep", bp_item->swstep);
        pj_ki(j, "togglehits", bp_item->togglehits);
        pj_ki(j, "trace", bp_item->trace);
        pj_end(j);
 
        char key[19];
        sdb_set(db, rz_strf(key, "0x%" PFMT64x, bp_item->addr), pj_string(j), 0);
        pj_free(j);
    }
}
 
enum {
    BP_FIELD_NAME,
    BP_FIELD_MODULE_NAME,
    BP_FIELD_MODULE_DELTA,
    BP_FIELD_DELTA,
    BP_FIELD_SIZE,
    BP_FIELD_SWSTEP,
    BP_FIELD_PERM,
    BP_FIELD_HW,
    BP_FIELD_TRACE,
    BP_FIELD_INTERNAL,
    BP_FIELD_ENABLED,
    BP_FIELD_TOGGLEHITS,
    BP_FIELD_HITS,
    BP_FIELD_PIDS,
    BP_FIELD_DATA,
    BP_FIELD_COND,
    BP_FIELD_EXPR
};
 
RZ_API RzSerializeBpParser rz_serialize_bp_parser_new(void) {
    RzSerializeBpParser parser = rz_key_parser_new();
    if (!parser) {
        return NULL;
    }
 
    rz_key_parser_add(parser, "name", BP_FIELD_NAME);
    rz_key_parser_add(parser, "module_name", BP_FIELD_MODULE_NAME);
    rz_key_parser_add(parser, "module_delta", BP_FIELD_MODULE_DELTA);
    rz_key_parser_add(parser, "delta", BP_FIELD_DELTA);
    rz_key_parser_add(parser, "size", BP_FIELD_SIZE);
    rz_key_parser_add(parser, "swstep", BP_FIELD_SWSTEP);
    rz_key_parser_add(parser, "perm", BP_FIELD_PERM);
    rz_key_parser_add(parser, "hw", BP_FIELD_HW);
    rz_key_parser_add(parser, "trace", BP_FIELD_TRACE);
    rz_key_parser_add(parser, "internal", BP_FIELD_INTERNAL);
    rz_key_parser_add(parser, "enabled", BP_FIELD_ENABLED);
    rz_key_parser_add(parser, "togglehits", BP_FIELD_TOGGLEHITS);
    rz_key_parser_add(parser, "hits", BP_FIELD_HITS);
    rz_key_parser_add(parser, "pids", BP_FIELD_PIDS);
    rz_key_parser_add(parser, "data", BP_FIELD_DATA);
    rz_key_parser_add(parser, "cond", BP_FIELD_COND);
    rz_key_parser_add(parser, "expr", BP_FIELD_EXPR);
 
    return parser;
}
 
typedef struct {
    RzBreakpoint *bp;
    RzSerializeBpParser parser;
} BpLoadCtx;
 
static bool bp_load_cb(void *user, const char *k, const char *v) {
    bool ret = false;
    BpLoadCtx *ctx = user;
    char *json_str = strdup(v);
    if (!json_str) {
        return true;
    }
    RzJson *json = rz_json_parse(json_str);
    if (!json || json->type != RZ_JSON_OBJECT) {
        goto heaven;
    }
    RzBreakpointItem bp_item_temp = { 0 };
    bp_item_temp.addr = strtoull(k, NULL, 0);
 
    RZ_KEY_PARSER_JSON(ctx->parser, json, child, {
        case BP_FIELD_NAME:
            if (child->type != RZ_JSON_STRING) {
                break;
            }
            bp_item_temp.name = (char *)child->str_value;
            break;
        case BP_FIELD_MODULE_NAME:
            if (child->type != RZ_JSON_STRING) {
                break;
            }
            bp_item_temp.module_name = (char *)child->str_value;
            break;
        case BP_FIELD_MODULE_DELTA:
            if (child->type != RZ_JSON_INTEGER) {
                break;
            }
            bp_item_temp.module_delta = child->num.s_value;
            break;
        case BP_FIELD_DELTA:
            if (child->type != RZ_JSON_INTEGER) {
                break;
            }
            bp_item_temp.delta = child->num.u_value;
            break;
        case BP_FIELD_SIZE:
            if (child->type != RZ_JSON_INTEGER) {
                break;
            }
            bp_item_temp.size = (int)child->num.s_value;
            break;
        case BP_FIELD_SWSTEP:
            if (child->type != RZ_JSON_BOOLEAN) {
                break;
            }
            bp_item_temp.swstep = child->num.u_value ? true : false;
            break;
        case BP_FIELD_PERM:
            if (child->type != RZ_JSON_INTEGER) {
                break;
            }
            bp_item_temp.perm = (int)child->num.s_value;
            break;
        case BP_FIELD_HW:
            if (child->type != RZ_JSON_INTEGER) {
                break;
            }
            bp_item_temp.hw = (int)child->num.s_value;
            break;
        case BP_FIELD_TRACE:
            if (child->type != RZ_JSON_INTEGER) {
                break;
            }
            bp_item_temp.trace = (int)child->num.s_value;
            break;
        case BP_FIELD_INTERNAL:
            if (child->type != RZ_JSON_INTEGER) {
                break;
            }
            bp_item_temp.internal = (int)child->num.s_value;
            break;
        case BP_FIELD_ENABLED:
            if (child->type != RZ_JSON_INTEGER) {
                break;
            }
            bp_item_temp.enabled = (int)child->num.s_value;
            break;
        case BP_FIELD_TOGGLEHITS:
            if (child->type != RZ_JSON_INTEGER) {
                break;
            }
            bp_item_temp.togglehits = (int)child->num.s_value;
            break;
        case BP_FIELD_HITS:
            if (child->type != RZ_JSON_INTEGER) {
                break;
            }
            bp_item_temp.hits = (int)child->num.s_value;
            break;
        case BP_FIELD_PIDS:
            if (child->type != RZ_JSON_ARRAY) {
                break;
            }
            int index = 0;
            for (const RzJson *pid_child = child->children.first; pid_child; pid_child = pid_child->next) {
                if (index >= RZ_BP_MAXPIDS) {
                    break;
                }
                bp_item_temp.pids[index] = (int)pid_child->num.s_value;
                ++index;
            }
            break;
        case BP_FIELD_DATA:
            if (child->type != RZ_JSON_STRING) {
                break;
            }
            bp_item_temp.data = (char *)child->str_value;
            break;
        case BP_FIELD_COND:
            if (child->type != RZ_JSON_STRING) {
                break;
            }
            bp_item_temp.cond = (char *)child->str_value;
            break;
        case BP_FIELD_EXPR:
            if (child->type != RZ_JSON_STRING) {
                break;
            }
            bp_item_temp.expr = (char *)child->str_value;
            break;
    })
 
    RzBreakpointItem *bp_item = NULL;
    if (bp_item_temp.hw) {
        bp_item = rz_bp_add_hw(ctx->bp, bp_item_temp.addr, bp_item_temp.size, bp_item_temp.perm);
    } else {
        bp_item = rz_bp_add_sw(ctx->bp, bp_item_temp.addr, bp_item_temp.size, bp_item_temp.perm);
    }
    if (!bp_item) {
        goto beach;
    }
 
    if (bp_item_temp.name) {
        bp_item->name = strdup(bp_item_temp.name);
    }
    if (bp_item_temp.module_name) {
        bp_item->module_name = strdup(bp_item_temp.module_name);
    }
    bp_item->module_delta = bp_item_temp.module_delta;
    bp_item->delta = bp_item_temp.delta;
    bp_item->swstep = bp_item_temp.swstep;
    bp_item->hw = bp_item_temp.hw;
    bp_item->trace = bp_item_temp.trace;
    bp_item->internal = bp_item_temp.internal;
    bp_item->enabled = bp_item_temp.enabled;
    bp_item->togglehits = bp_item_temp.togglehits;
    bp_item->hits = bp_item_temp.hits;
    for (int i = 0; i < RZ_BP_MAXPIDS; i++) {
        bp_item->pids[i] = bp_item_temp.pids[i];
    }
    if (bp_item_temp.data) {
        bp_item->data = strdup(bp_item_temp.data);
    }
    if (bp_item_temp.cond) {
        bp_item->cond = strdup(bp_item_temp.cond);
    }
    if (bp_item_temp.expr) {
        bp_item->expr = strdup(bp_item_temp.expr);
    }
    ret = true;
 
beach:
    rz_json_free(json);
heaven:
    free(json_str);
    return ret;
}
 
RZ_API bool rz_serialize_bp_load(RZ_NONNULL Sdb *db, RZ_NONNULL RzBreakpoint *bp, RZ_NULLABLE RzSerializeResultInfo *res) {
    rz_return_val_if_fail(db && bp, false);
 
    bool ret = false;
    RzSerializeBpParser bp_parser = rz_serialize_bp_parser_new();
    if (!bp_parser) {
        goto heaven;
    }
    if (!rz_list_empty(bp->bps) && !rz_bp_del_all(bp)) {
        goto heaven;
    }
 
    BpLoadCtx ctx = {
        .bp = bp,
        .parser = bp_parser
    };
    ret = sdb_foreach(db, bp_load_cb, &ctx);
    if (!ret) {
        RZ_SERIALIZE_ERR(res, "failed to parse a breakpoint json");
    }
 
heaven:
    rz_key_parser_free(bp_parser);
    return ret;
}