diff --git a/tmp/ynl_build-tmp.wFT7ft/new-code/dev-energymodel-user.c b/tmp/ynl_build-tmp.wFT7ft/new-code/dev-energymodel-user.c new file mode 100644 index 000000000000..c5a2b2d09491 --- /dev/null +++ b/tmp/ynl_build-tmp.wFT7ft/new-code/dev-energymodel-user.c @@ -0,0 +1,504 @@ +// SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) +/* Do not edit directly, auto-generated from: */ +/* Documentation/netlink/specs/dev-energymodel.yaml */ +/* YNL-GEN user source */ +/* To regenerate run: tools/net/ynl/ynl-regen.sh */ + +#include +#include +#include "dev-energymodel-user.h" +#include "ynl.h" +#include + +#include + +/* Enums */ +static const char * const dev_energymodel_op_strmap[] = { + [DEV_ENERGYMODEL_CMD_GET_PERF_DOMAINS] = "get-perf-domains", + [DEV_ENERGYMODEL_CMD_GET_PERF_TABLE] = "get-perf-table", + [DEV_ENERGYMODEL_CMD_PERF_DOMAIN_CREATED] = "perf-domain-created", + [DEV_ENERGYMODEL_CMD_PERF_DOMAIN_UPDATED] = "perf-domain-updated", + [DEV_ENERGYMODEL_CMD_PERF_DOMAIN_DELETED] = "perf-domain-deleted", +}; + +const char *dev_energymodel_op_str(int op) +{ + if (op < 0 || op >= (int)YNL_ARRAY_SIZE(dev_energymodel_op_strmap)) + return NULL; + return dev_energymodel_op_strmap[op]; +} + +static const char * const dev_energymodel_perf_state_flags_strmap[] = { + [0] = "perf-state-inefficient", +}; + +const char * +dev_energymodel_perf_state_flags_str(enum dev_energymodel_perf_state_flags value) +{ + value = ffs(value) - 1; + if (value < 0 || value >= (int)YNL_ARRAY_SIZE(dev_energymodel_perf_state_flags_strmap)) + return NULL; + return dev_energymodel_perf_state_flags_strmap[value]; +} + +static const char * const dev_energymodel_perf_domain_flags_strmap[] = { + [0] = "perf-domain-microwatts", + [1] = "perf-domain-skip-inefficiencies", + [2] = "perf-domain-artificial", +}; + +const char * +dev_energymodel_perf_domain_flags_str(enum dev_energymodel_perf_domain_flags value) +{ + value = ffs(value) - 1; + if (value < 0 || value >= (int)YNL_ARRAY_SIZE(dev_energymodel_perf_domain_flags_strmap)) + return NULL; + return dev_energymodel_perf_domain_flags_strmap[value]; +} + +/* Policies */ +const struct ynl_policy_attr dev_energymodel_perf_domain_policy[DEV_ENERGYMODEL_A_PERF_DOMAIN_MAX + 1] = { + [DEV_ENERGYMODEL_A_PERF_DOMAIN_PAD] = { .name = "pad", .type = YNL_PT_IGNORE, }, + [DEV_ENERGYMODEL_A_PERF_DOMAIN_PERF_DOMAIN_ID] = { .name = "perf-domain-id", .type = YNL_PT_U32, }, + [DEV_ENERGYMODEL_A_PERF_DOMAIN_FLAGS] = { .name = "flags", .type = YNL_PT_U64, }, + [DEV_ENERGYMODEL_A_PERF_DOMAIN_CPUS] = { .name = "cpus", .type = YNL_PT_U64, }, +}; + +const struct ynl_policy_nest dev_energymodel_perf_domain_nest = { + .max_attr = DEV_ENERGYMODEL_A_PERF_DOMAIN_MAX, + .table = dev_energymodel_perf_domain_policy, +}; + +const struct ynl_policy_attr dev_energymodel_perf_state_policy[DEV_ENERGYMODEL_A_PERF_STATE_MAX + 1] = { + [DEV_ENERGYMODEL_A_PERF_STATE_PAD] = { .name = "pad", .type = YNL_PT_IGNORE, }, + [DEV_ENERGYMODEL_A_PERF_STATE_PERFORMANCE] = { .name = "performance", .type = YNL_PT_U64, }, + [DEV_ENERGYMODEL_A_PERF_STATE_FREQUENCY] = { .name = "frequency", .type = YNL_PT_U64, }, + [DEV_ENERGYMODEL_A_PERF_STATE_POWER] = { .name = "power", .type = YNL_PT_U64, }, + [DEV_ENERGYMODEL_A_PERF_STATE_COST] = { .name = "cost", .type = YNL_PT_U64, }, + [DEV_ENERGYMODEL_A_PERF_STATE_FLAGS] = { .name = "flags", .type = YNL_PT_U64, }, +}; + +const struct ynl_policy_nest dev_energymodel_perf_state_nest = { + .max_attr = DEV_ENERGYMODEL_A_PERF_STATE_MAX, + .table = dev_energymodel_perf_state_policy, +}; + +const struct ynl_policy_attr dev_energymodel_perf_domains_policy[DEV_ENERGYMODEL_A_PERF_DOMAINS_MAX + 1] = { + [DEV_ENERGYMODEL_A_PERF_DOMAINS_PERF_DOMAIN_ID] = { .name = "perf-domain-id", .type = YNL_PT_U32, }, + [DEV_ENERGYMODEL_A_PERF_DOMAINS_PERF_DOMAIN] = { .name = "perf-domain", .type = YNL_PT_NEST, .nest = &dev_energymodel_perf_domain_nest, }, +}; + +const struct ynl_policy_nest dev_energymodel_perf_domains_nest = { + .max_attr = DEV_ENERGYMODEL_A_PERF_DOMAINS_MAX, + .table = dev_energymodel_perf_domains_policy, +}; + +const struct ynl_policy_attr dev_energymodel_perf_table_policy[DEV_ENERGYMODEL_A_PERF_TABLE_MAX + 1] = { + [DEV_ENERGYMODEL_A_PERF_TABLE_PERF_DOMAIN_ID] = { .name = "perf-domain-id", .type = YNL_PT_U32, }, + [DEV_ENERGYMODEL_A_PERF_TABLE_PERF_STATE] = { .name = "perf-state", .type = YNL_PT_NEST, .nest = &dev_energymodel_perf_state_nest, }, +}; + +const struct ynl_policy_nest dev_energymodel_perf_table_nest = { + .max_attr = DEV_ENERGYMODEL_A_PERF_TABLE_MAX, + .table = dev_energymodel_perf_table_policy, +}; + +/* Common nested types */ +void dev_energymodel_perf_domain_free(struct dev_energymodel_perf_domain *obj) +{ + free(obj->cpus); +} + +int dev_energymodel_perf_domain_parse(struct ynl_parse_arg *yarg, + const struct nlattr *nested) +{ + struct dev_energymodel_perf_domain *dst = yarg->data; + const struct nlattr *attr; + unsigned int n_cpus = 0; + int i; + + if (dst->cpus) + return ynl_error_parse(yarg, "attribute already present (perf-domain.cpus)"); + + ynl_attr_for_each_nested(attr, nested) { + unsigned int type = ynl_attr_type(attr); + + if (type == DEV_ENERGYMODEL_A_PERF_DOMAIN_PERF_DOMAIN_ID) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.perf_domain_id = 1; + dst->perf_domain_id = ynl_attr_get_u32(attr); + } else if (type == DEV_ENERGYMODEL_A_PERF_DOMAIN_FLAGS) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.flags = 1; + dst->flags = ynl_attr_get_u64(attr); + } else if (type == DEV_ENERGYMODEL_A_PERF_DOMAIN_CPUS) { + n_cpus++; + } + } + + if (n_cpus) { + dst->cpus = calloc(n_cpus, sizeof(*dst->cpus)); + dst->_count.cpus = n_cpus; + i = 0; + ynl_attr_for_each_nested(attr, nested) { + if (ynl_attr_type(attr) == DEV_ENERGYMODEL_A_PERF_DOMAIN_CPUS) { + dst->cpus[i] = ynl_attr_get_u64(attr); + i++; + } + } + } + + return 0; +} + +void dev_energymodel_perf_state_free(struct dev_energymodel_perf_state *obj) +{ +} + +int dev_energymodel_perf_state_parse(struct ynl_parse_arg *yarg, + const struct nlattr *nested) +{ + struct dev_energymodel_perf_state *dst = yarg->data; + const struct nlattr *attr; + + ynl_attr_for_each_nested(attr, nested) { + unsigned int type = ynl_attr_type(attr); + + if (type == DEV_ENERGYMODEL_A_PERF_STATE_PERFORMANCE) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.performance = 1; + dst->performance = ynl_attr_get_u64(attr); + } else if (type == DEV_ENERGYMODEL_A_PERF_STATE_FREQUENCY) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.frequency = 1; + dst->frequency = ynl_attr_get_u64(attr); + } else if (type == DEV_ENERGYMODEL_A_PERF_STATE_POWER) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.power = 1; + dst->power = ynl_attr_get_u64(attr); + } else if (type == DEV_ENERGYMODEL_A_PERF_STATE_COST) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.cost = 1; + dst->cost = ynl_attr_get_u64(attr); + } else if (type == DEV_ENERGYMODEL_A_PERF_STATE_FLAGS) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.flags = 1; + dst->flags = ynl_attr_get_u64(attr); + } + } + + return 0; +} + +/* ============== DEV_ENERGYMODEL_CMD_GET_PERF_DOMAINS ============== */ +/* DEV_ENERGYMODEL_CMD_GET_PERF_DOMAINS - do */ +void +dev_energymodel_get_perf_domains_req_free(struct dev_energymodel_get_perf_domains_req *req) +{ + free(req); +} + +void +dev_energymodel_get_perf_domains_rsp_free(struct dev_energymodel_get_perf_domains_rsp *rsp) +{ + unsigned int i; + + for (i = 0; i < rsp->_count.perf_domain; i++) + dev_energymodel_perf_domain_free(&rsp->perf_domain[i]); + free(rsp->perf_domain); + free(rsp); +} + +int dev_energymodel_get_perf_domains_rsp_parse(const struct nlmsghdr *nlh, + struct ynl_parse_arg *yarg) +{ + struct dev_energymodel_get_perf_domains_rsp *dst; + unsigned int n_perf_domain = 0; + const struct nlattr *attr; + struct ynl_parse_arg parg; + int i; + + dst = yarg->data; + parg.ys = yarg->ys; + + if (dst->perf_domain) + return ynl_error_parse(yarg, "attribute already present (perf-domains.perf-domain)"); + + ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) { + unsigned int type = ynl_attr_type(attr); + + if (type == DEV_ENERGYMODEL_A_PERF_DOMAINS_PERF_DOMAIN) { + n_perf_domain++; + } + } + + if (n_perf_domain) { + dst->perf_domain = calloc(n_perf_domain, sizeof(*dst->perf_domain)); + dst->_count.perf_domain = n_perf_domain; + i = 0; + parg.rsp_policy = &dev_energymodel_perf_domain_nest; + ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) { + if (ynl_attr_type(attr) == DEV_ENERGYMODEL_A_PERF_DOMAINS_PERF_DOMAIN) { + parg.data = &dst->perf_domain[i]; + if (dev_energymodel_perf_domain_parse(&parg, attr)) + return YNL_PARSE_CB_ERROR; + i++; + } + } + } + + return YNL_PARSE_CB_OK; +} + +struct dev_energymodel_get_perf_domains_rsp * +dev_energymodel_get_perf_domains(struct ynl_sock *ys, + struct dev_energymodel_get_perf_domains_req *req) +{ + struct ynl_req_state yrs = { .yarg = { .ys = ys, }, }; + struct dev_energymodel_get_perf_domains_rsp *rsp; + struct nlmsghdr *nlh; + int err; + + nlh = ynl_gemsg_start_req(ys, ys->family_id, DEV_ENERGYMODEL_CMD_GET_PERF_DOMAINS, 1); + ys->req_policy = &dev_energymodel_perf_domains_nest; + ys->req_hdr_len = ys->family->hdr_len; + yrs.yarg.rsp_policy = &dev_energymodel_perf_domains_nest; + + if (req->_present.perf_domain_id) + ynl_attr_put_u32(nlh, DEV_ENERGYMODEL_A_PERF_DOMAINS_PERF_DOMAIN_ID, req->perf_domain_id); + + rsp = calloc(1, sizeof(*rsp)); + yrs.yarg.data = rsp; + yrs.cb = dev_energymodel_get_perf_domains_rsp_parse; + yrs.rsp_cmd = DEV_ENERGYMODEL_CMD_GET_PERF_DOMAINS; + + err = ynl_exec(ys, nlh, &yrs); + if (err < 0) + goto err_free; + + return rsp; + +err_free: + dev_energymodel_get_perf_domains_rsp_free(rsp); + return NULL; +} + +/* DEV_ENERGYMODEL_CMD_GET_PERF_DOMAINS - dump */ +void +dev_energymodel_get_perf_domains_list_free(struct dev_energymodel_get_perf_domains_list *rsp) +{ + struct dev_energymodel_get_perf_domains_list *next = rsp; + + while ((void *)next != YNL_LIST_END) { + unsigned int i; + + rsp = next; + next = rsp->next; + + for (i = 0; i < rsp->obj._count.perf_domain; i++) + dev_energymodel_perf_domain_free(&rsp->obj.perf_domain[i]); + free(rsp->obj.perf_domain); + free(rsp); + } +} + +struct dev_energymodel_get_perf_domains_list * +dev_energymodel_get_perf_domains_dump(struct ynl_sock *ys) +{ + struct ynl_dump_state yds = {}; + struct nlmsghdr *nlh; + int err; + + yds.yarg.ys = ys; + yds.yarg.rsp_policy = &dev_energymodel_perf_domains_nest; + yds.yarg.data = NULL; + yds.alloc_sz = sizeof(struct dev_energymodel_get_perf_domains_list); + yds.cb = dev_energymodel_get_perf_domains_rsp_parse; + yds.rsp_cmd = DEV_ENERGYMODEL_CMD_GET_PERF_DOMAINS; + + nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEV_ENERGYMODEL_CMD_GET_PERF_DOMAINS, 1); + + err = ynl_exec_dump(ys, nlh, &yds); + if (err < 0) + goto free_list; + + return yds.first; + +free_list: + dev_energymodel_get_perf_domains_list_free(yds.first); + return NULL; +} + +/* ============== DEV_ENERGYMODEL_CMD_GET_PERF_TABLE ============== */ +/* DEV_ENERGYMODEL_CMD_GET_PERF_TABLE - do */ +void +dev_energymodel_get_perf_table_req_free(struct dev_energymodel_get_perf_table_req *req) +{ + free(req); +} + +void +dev_energymodel_get_perf_table_rsp_free(struct dev_energymodel_get_perf_table_rsp *rsp) +{ + unsigned int i; + + for (i = 0; i < rsp->_count.perf_state; i++) + dev_energymodel_perf_state_free(&rsp->perf_state[i]); + free(rsp->perf_state); + free(rsp); +} + +int dev_energymodel_get_perf_table_rsp_parse(const struct nlmsghdr *nlh, + struct ynl_parse_arg *yarg) +{ + struct dev_energymodel_get_perf_table_rsp *dst; + unsigned int n_perf_state = 0; + const struct nlattr *attr; + struct ynl_parse_arg parg; + int i; + + dst = yarg->data; + parg.ys = yarg->ys; + + if (dst->perf_state) + return ynl_error_parse(yarg, "attribute already present (perf-table.perf-state)"); + + ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) { + unsigned int type = ynl_attr_type(attr); + + if (type == DEV_ENERGYMODEL_A_PERF_TABLE_PERF_DOMAIN_ID) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.perf_domain_id = 1; + dst->perf_domain_id = ynl_attr_get_u32(attr); + } else if (type == DEV_ENERGYMODEL_A_PERF_TABLE_PERF_STATE) { + n_perf_state++; + } + } + + if (n_perf_state) { + dst->perf_state = calloc(n_perf_state, sizeof(*dst->perf_state)); + dst->_count.perf_state = n_perf_state; + i = 0; + parg.rsp_policy = &dev_energymodel_perf_state_nest; + ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) { + if (ynl_attr_type(attr) == DEV_ENERGYMODEL_A_PERF_TABLE_PERF_STATE) { + parg.data = &dst->perf_state[i]; + if (dev_energymodel_perf_state_parse(&parg, attr)) + return YNL_PARSE_CB_ERROR; + i++; + } + } + } + + return YNL_PARSE_CB_OK; +} + +struct dev_energymodel_get_perf_table_rsp * +dev_energymodel_get_perf_table(struct ynl_sock *ys, + struct dev_energymodel_get_perf_table_req *req) +{ + struct ynl_req_state yrs = { .yarg = { .ys = ys, }, }; + struct dev_energymodel_get_perf_table_rsp *rsp; + struct nlmsghdr *nlh; + int err; + + nlh = ynl_gemsg_start_req(ys, ys->family_id, DEV_ENERGYMODEL_CMD_GET_PERF_TABLE, 1); + ys->req_policy = &dev_energymodel_perf_table_nest; + ys->req_hdr_len = ys->family->hdr_len; + yrs.yarg.rsp_policy = &dev_energymodel_perf_table_nest; + + if (req->_present.perf_domain_id) + ynl_attr_put_u32(nlh, DEV_ENERGYMODEL_A_PERF_TABLE_PERF_DOMAIN_ID, req->perf_domain_id); + + rsp = calloc(1, sizeof(*rsp)); + yrs.yarg.data = rsp; + yrs.cb = dev_energymodel_get_perf_table_rsp_parse; + yrs.rsp_cmd = DEV_ENERGYMODEL_CMD_GET_PERF_TABLE; + + err = ynl_exec(ys, nlh, &yrs); + if (err < 0) + goto err_free; + + return rsp; + +err_free: + dev_energymodel_get_perf_table_rsp_free(rsp); + return NULL; +} + +/* DEV_ENERGYMODEL_CMD_GET_PERF_TABLE - notify */ +void +dev_energymodel_get_perf_table_ntf_free(struct dev_energymodel_get_perf_table_ntf *rsp) +{ + unsigned int i; + + for (i = 0; i < rsp->obj._count.perf_state; i++) + dev_energymodel_perf_state_free(&rsp->obj.perf_state[i]); + free(rsp->obj.perf_state); + free(rsp); +} + +/* DEV_ENERGYMODEL_CMD_PERF_DOMAIN_DELETED - event */ +int dev_energymodel_perf_domain_deleted_rsp_parse(const struct nlmsghdr *nlh, + struct ynl_parse_arg *yarg) +{ + struct dev_energymodel_perf_domain_deleted_rsp *dst; + const struct nlattr *attr; + + dst = yarg->data; + + ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) { + unsigned int type = ynl_attr_type(attr); + + if (type == DEV_ENERGYMODEL_A_PERF_TABLE_PERF_DOMAIN_ID) { + if (ynl_attr_validate(yarg, attr)) + return YNL_PARSE_CB_ERROR; + dst->_present.perf_domain_id = 1; + dst->perf_domain_id = ynl_attr_get_u32(attr); + } + } + + return YNL_PARSE_CB_OK; +} + +void +dev_energymodel_perf_domain_deleted_free(struct dev_energymodel_perf_domain_deleted *rsp) +{ + free(rsp); +} + +static const struct ynl_ntf_info dev_energymodel_ntf_info[] = { + [DEV_ENERGYMODEL_CMD_PERF_DOMAIN_CREATED] = { + .alloc_sz = sizeof(struct dev_energymodel_get_perf_table_ntf), + .cb = dev_energymodel_get_perf_table_rsp_parse, + .policy = &dev_energymodel_perf_table_nest, + .free = (void *)dev_energymodel_get_perf_table_ntf_free, + }, + [DEV_ENERGYMODEL_CMD_PERF_DOMAIN_UPDATED] = { + .alloc_sz = sizeof(struct dev_energymodel_get_perf_table_ntf), + .cb = dev_energymodel_get_perf_table_rsp_parse, + .policy = &dev_energymodel_perf_table_nest, + .free = (void *)dev_energymodel_get_perf_table_ntf_free, + }, + [DEV_ENERGYMODEL_CMD_PERF_DOMAIN_DELETED] = { + .alloc_sz = sizeof(struct dev_energymodel_perf_domain_deleted), + .cb = dev_energymodel_perf_domain_deleted_rsp_parse, + .policy = &dev_energymodel_perf_table_nest, + .free = (void *)dev_energymodel_perf_domain_deleted_free, + }, +}; + +const struct ynl_family ynl_dev_energymodel_family = { + .name = "dev_energymodel", + .hdr_len = sizeof(struct genlmsghdr), + .ntf_info = dev_energymodel_ntf_info, + .ntf_info_size = YNL_ARRAY_SIZE(dev_energymodel_ntf_info), +}; diff --git a/tmp/ynl_build-tmp.wFT7ft/new-code/dev-energymodel-user.h b/tmp/ynl_build-tmp.wFT7ft/new-code/dev-energymodel-user.h new file mode 100644 index 000000000000..261ab7292d53 --- /dev/null +++ b/tmp/ynl_build-tmp.wFT7ft/new-code/dev-energymodel-user.h @@ -0,0 +1,193 @@ +/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ +/* Do not edit directly, auto-generated from: */ +/* Documentation/netlink/specs/dev-energymodel.yaml */ +/* YNL-GEN user header */ +/* To regenerate run: tools/net/ynl/ynl-regen.sh */ + +#ifndef _LINUX_DEV_ENERGYMODEL_GEN_H +#define _LINUX_DEV_ENERGYMODEL_GEN_H + +#include +#include +#include +#include + +struct ynl_sock; + +extern const struct ynl_family ynl_dev_energymodel_family; + +/* Enums */ +const char *dev_energymodel_op_str(int op); +const char * +dev_energymodel_perf_state_flags_str(enum dev_energymodel_perf_state_flags value); +const char * +dev_energymodel_perf_domain_flags_str(enum dev_energymodel_perf_domain_flags value); + +/* Common nested types */ +struct dev_energymodel_perf_domain { + struct { + __u32 perf_domain_id:1; + __u32 flags:1; + } _present; + struct { + __u32 cpus; + } _count; + + __u32 perf_domain_id; + __u64 flags; + __u64 *cpus; +}; + +struct dev_energymodel_perf_state { + struct { + __u32 performance:1; + __u32 frequency:1; + __u32 power:1; + __u32 cost:1; + __u32 flags:1; + } _present; + + __u64 performance; + __u64 frequency; + __u64 power; + __u64 cost; + __u64 flags; +}; + +/* ============== DEV_ENERGYMODEL_CMD_GET_PERF_DOMAINS ============== */ +/* DEV_ENERGYMODEL_CMD_GET_PERF_DOMAINS - do */ +struct dev_energymodel_get_perf_domains_req { + struct { + __u32 perf_domain_id:1; + } _present; + + __u32 perf_domain_id; +}; + +static inline struct dev_energymodel_get_perf_domains_req * +dev_energymodel_get_perf_domains_req_alloc(void) +{ + return calloc(1, sizeof(struct dev_energymodel_get_perf_domains_req)); +} +void +dev_energymodel_get_perf_domains_req_free(struct dev_energymodel_get_perf_domains_req *req); + +static inline void +dev_energymodel_get_perf_domains_req_set_perf_domain_id(struct dev_energymodel_get_perf_domains_req *req, + __u32 perf_domain_id) +{ + req->_present.perf_domain_id = 1; + req->perf_domain_id = perf_domain_id; +} + +struct dev_energymodel_get_perf_domains_rsp { + struct { + __u32 perf_domain; + } _count; + + struct dev_energymodel_perf_domain *perf_domain; +}; + +void +dev_energymodel_get_perf_domains_rsp_free(struct dev_energymodel_get_perf_domains_rsp *rsp); + +/* + * Get the list of information for all performance domains. + */ +struct dev_energymodel_get_perf_domains_rsp * +dev_energymodel_get_perf_domains(struct ynl_sock *ys, + struct dev_energymodel_get_perf_domains_req *req); + +/* DEV_ENERGYMODEL_CMD_GET_PERF_DOMAINS - dump */ +struct dev_energymodel_get_perf_domains_list { + struct dev_energymodel_get_perf_domains_list *next; + struct dev_energymodel_get_perf_domains_rsp obj __attribute__((aligned(8))); +}; + +void +dev_energymodel_get_perf_domains_list_free(struct dev_energymodel_get_perf_domains_list *rsp); + +struct dev_energymodel_get_perf_domains_list * +dev_energymodel_get_perf_domains_dump(struct ynl_sock *ys); + +/* ============== DEV_ENERGYMODEL_CMD_GET_PERF_TABLE ============== */ +/* DEV_ENERGYMODEL_CMD_GET_PERF_TABLE - do */ +struct dev_energymodel_get_perf_table_req { + struct { + __u32 perf_domain_id:1; + } _present; + + __u32 perf_domain_id; +}; + +static inline struct dev_energymodel_get_perf_table_req * +dev_energymodel_get_perf_table_req_alloc(void) +{ + return calloc(1, sizeof(struct dev_energymodel_get_perf_table_req)); +} +void +dev_energymodel_get_perf_table_req_free(struct dev_energymodel_get_perf_table_req *req); + +static inline void +dev_energymodel_get_perf_table_req_set_perf_domain_id(struct dev_energymodel_get_perf_table_req *req, + __u32 perf_domain_id) +{ + req->_present.perf_domain_id = 1; + req->perf_domain_id = perf_domain_id; +} + +struct dev_energymodel_get_perf_table_rsp { + struct { + __u32 perf_domain_id:1; + } _present; + struct { + __u32 perf_state; + } _count; + + __u32 perf_domain_id; + struct dev_energymodel_perf_state *perf_state; +}; + +void +dev_energymodel_get_perf_table_rsp_free(struct dev_energymodel_get_perf_table_rsp *rsp); + +/* + * Get the energy model table of a performance domain. + */ +struct dev_energymodel_get_perf_table_rsp * +dev_energymodel_get_perf_table(struct ynl_sock *ys, + struct dev_energymodel_get_perf_table_req *req); + +/* DEV_ENERGYMODEL_CMD_GET_PERF_TABLE - notify */ +struct dev_energymodel_get_perf_table_ntf { + __u16 family; + __u8 cmd; + struct ynl_ntf_base_type *next; + void (*free)(struct dev_energymodel_get_perf_table_ntf *ntf); + struct dev_energymodel_get_perf_table_rsp obj __attribute__((aligned(8))); +}; + +void +dev_energymodel_get_perf_table_ntf_free(struct dev_energymodel_get_perf_table_ntf *rsp); + +/* DEV_ENERGYMODEL_CMD_PERF_DOMAIN_DELETED - event */ +struct dev_energymodel_perf_domain_deleted_rsp { + struct { + __u32 perf_domain_id:1; + } _present; + + __u32 perf_domain_id; +}; + +struct dev_energymodel_perf_domain_deleted { + __u16 family; + __u8 cmd; + struct ynl_ntf_base_type *next; + void (*free)(struct dev_energymodel_perf_domain_deleted *ntf); + struct dev_energymodel_perf_domain_deleted_rsp obj __attribute__((aligned(8))); +}; + +void +dev_energymodel_perf_domain_deleted_free(struct dev_energymodel_perf_domain_deleted *rsp); + +#endif /* _LINUX_DEV_ENERGYMODEL_GEN_H */ diff --git a/tmp/ynl_build-tmp.wFT7ft/old-code/em-user.c b/tmp/ynl_build-tmp.wFT7ft/old-code/em-user.c deleted file mode 100644 index f2fddada9ffa..000000000000 --- a/tmp/ynl_build-tmp.wFT7ft/old-code/em-user.c +++ /dev/null @@ -1,401 +0,0 @@ -// SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) -/* Do not edit directly, auto-generated from: */ -/* Documentation/netlink/specs/em.yaml */ -/* YNL-GEN user source */ -/* To regenerate run: tools/net/ynl/ynl-regen.sh */ - -#include -#include -#include "em-user.h" -#include "ynl.h" -#include - -#include - -/* Enums */ -static const char * const em_op_strmap[] = { - [EM_CMD_GET_PDS] = "get-pds", - [EM_CMD_GET_PD_TABLE] = "get-pd-table", - [EM_CMD_PD_CREATED] = "pd-created", - [EM_CMD_PD_UPDATED] = "pd-updated", - [EM_CMD_PD_DELETED] = "pd-deleted", -}; - -const char *em_op_str(int op) -{ - if (op < 0 || op >= (int)YNL_ARRAY_SIZE(em_op_strmap)) - return NULL; - return em_op_strmap[op]; -} - -/* Policies */ -const struct ynl_policy_attr em_pd_policy[EM_A_PD_MAX + 1] = { - [EM_A_PD_PAD] = { .name = "pad", .type = YNL_PT_IGNORE, }, - [EM_A_PD_PD_ID] = { .name = "pd-id", .type = YNL_PT_U32, }, - [EM_A_PD_FLAGS] = { .name = "flags", .type = YNL_PT_U64, }, - [EM_A_PD_CPUS] = { .name = "cpus", .type = YNL_PT_NUL_STR, }, -}; - -const struct ynl_policy_nest em_pd_nest = { - .max_attr = EM_A_PD_MAX, - .table = em_pd_policy, -}; - -const struct ynl_policy_attr em_ps_policy[EM_A_PS_MAX + 1] = { - [EM_A_PS_PAD] = { .name = "pad", .type = YNL_PT_IGNORE, }, - [EM_A_PS_PERFORMANCE] = { .name = "performance", .type = YNL_PT_U64, }, - [EM_A_PS_FREQUENCY] = { .name = "frequency", .type = YNL_PT_U64, }, - [EM_A_PS_POWER] = { .name = "power", .type = YNL_PT_U64, }, - [EM_A_PS_COST] = { .name = "cost", .type = YNL_PT_U64, }, - [EM_A_PS_FLAGS] = { .name = "flags", .type = YNL_PT_U64, }, -}; - -const struct ynl_policy_nest em_ps_nest = { - .max_attr = EM_A_PS_MAX, - .table = em_ps_policy, -}; - -const struct ynl_policy_attr em_pds_policy[EM_A_PDS_MAX + 1] = { - [EM_A_PDS_PD] = { .name = "pd", .type = YNL_PT_NEST, .nest = &em_pd_nest, }, -}; - -const struct ynl_policy_nest em_pds_nest = { - .max_attr = EM_A_PDS_MAX, - .table = em_pds_policy, -}; - -const struct ynl_policy_attr em_pd_table_policy[EM_A_PD_TABLE_MAX + 1] = { - [EM_A_PD_TABLE_PD_ID] = { .name = "pd-id", .type = YNL_PT_U32, }, - [EM_A_PD_TABLE_PS] = { .name = "ps", .type = YNL_PT_NEST, .nest = &em_ps_nest, }, -}; - -const struct ynl_policy_nest em_pd_table_nest = { - .max_attr = EM_A_PD_TABLE_MAX, - .table = em_pd_table_policy, -}; - -/* Common nested types */ -void em_pd_free(struct em_pd *obj) -{ - free(obj->cpus); -} - -int em_pd_parse(struct ynl_parse_arg *yarg, const struct nlattr *nested) -{ - struct em_pd *dst = yarg->data; - const struct nlattr *attr; - unsigned int len; - - ynl_attr_for_each_nested(attr, nested) { - unsigned int type = ynl_attr_type(attr); - - if (type == EM_A_PD_PD_ID) { - if (ynl_attr_validate(yarg, attr)) - return YNL_PARSE_CB_ERROR; - dst->_present.pd_id = 1; - dst->pd_id = ynl_attr_get_u32(attr); - } else if (type == EM_A_PD_FLAGS) { - if (ynl_attr_validate(yarg, attr)) - return YNL_PARSE_CB_ERROR; - dst->_present.flags = 1; - dst->flags = ynl_attr_get_u64(attr); - } else if (type == EM_A_PD_CPUS) { - if (ynl_attr_validate(yarg, attr)) - return YNL_PARSE_CB_ERROR; - - len = strnlen(ynl_attr_get_str(attr), ynl_attr_data_len(attr)); - dst->_len.cpus = len; - dst->cpus = malloc(len + 1); - memcpy(dst->cpus, ynl_attr_get_str(attr), len); - dst->cpus[len] = 0; - } - } - - return 0; -} - -void em_ps_free(struct em_ps *obj) -{ -} - -int em_ps_parse(struct ynl_parse_arg *yarg, const struct nlattr *nested) -{ - struct em_ps *dst = yarg->data; - const struct nlattr *attr; - - ynl_attr_for_each_nested(attr, nested) { - unsigned int type = ynl_attr_type(attr); - - if (type == EM_A_PS_PERFORMANCE) { - if (ynl_attr_validate(yarg, attr)) - return YNL_PARSE_CB_ERROR; - dst->_present.performance = 1; - dst->performance = ynl_attr_get_u64(attr); - } else if (type == EM_A_PS_FREQUENCY) { - if (ynl_attr_validate(yarg, attr)) - return YNL_PARSE_CB_ERROR; - dst->_present.frequency = 1; - dst->frequency = ynl_attr_get_u64(attr); - } else if (type == EM_A_PS_POWER) { - if (ynl_attr_validate(yarg, attr)) - return YNL_PARSE_CB_ERROR; - dst->_present.power = 1; - dst->power = ynl_attr_get_u64(attr); - } else if (type == EM_A_PS_COST) { - if (ynl_attr_validate(yarg, attr)) - return YNL_PARSE_CB_ERROR; - dst->_present.cost = 1; - dst->cost = ynl_attr_get_u64(attr); - } else if (type == EM_A_PS_FLAGS) { - if (ynl_attr_validate(yarg, attr)) - return YNL_PARSE_CB_ERROR; - dst->_present.flags = 1; - dst->flags = ynl_attr_get_u64(attr); - } - } - - return 0; -} - -/* ============== EM_CMD_GET_PDS ============== */ -/* EM_CMD_GET_PDS - do */ -void em_get_pds_rsp_free(struct em_get_pds_rsp *rsp) -{ - unsigned int i; - - for (i = 0; i < rsp->_count.pd; i++) - em_pd_free(&rsp->pd[i]); - free(rsp->pd); - free(rsp); -} - -int em_get_pds_rsp_parse(const struct nlmsghdr *nlh, - struct ynl_parse_arg *yarg) -{ - struct em_get_pds_rsp *dst; - const struct nlattr *attr; - struct ynl_parse_arg parg; - unsigned int n_pd = 0; - int i; - - dst = yarg->data; - parg.ys = yarg->ys; - - if (dst->pd) - return ynl_error_parse(yarg, "attribute already present (pds.pd)"); - - ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) { - unsigned int type = ynl_attr_type(attr); - - if (type == EM_A_PDS_PD) { - n_pd++; - } - } - - if (n_pd) { - dst->pd = calloc(n_pd, sizeof(*dst->pd)); - dst->_count.pd = n_pd; - i = 0; - parg.rsp_policy = &em_pd_nest; - ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) { - if (ynl_attr_type(attr) == EM_A_PDS_PD) { - parg.data = &dst->pd[i]; - if (em_pd_parse(&parg, attr)) - return YNL_PARSE_CB_ERROR; - i++; - } - } - } - - return YNL_PARSE_CB_OK; -} - -struct em_get_pds_rsp *em_get_pds(struct ynl_sock *ys) -{ - struct ynl_req_state yrs = { .yarg = { .ys = ys, }, }; - struct em_get_pds_rsp *rsp; - struct nlmsghdr *nlh; - int err; - - nlh = ynl_gemsg_start_req(ys, ys->family_id, EM_CMD_GET_PDS, 1); - ys->req_policy = &em_pds_nest; - ys->req_hdr_len = ys->family->hdr_len; - yrs.yarg.rsp_policy = &em_pds_nest; - - rsp = calloc(1, sizeof(*rsp)); - yrs.yarg.data = rsp; - yrs.cb = em_get_pds_rsp_parse; - yrs.rsp_cmd = EM_CMD_GET_PDS; - - err = ynl_exec(ys, nlh, &yrs); - if (err < 0) - goto err_free; - - return rsp; - -err_free: - em_get_pds_rsp_free(rsp); - return NULL; -} - -/* ============== EM_CMD_GET_PD_TABLE ============== */ -/* EM_CMD_GET_PD_TABLE - do */ -void em_get_pd_table_req_free(struct em_get_pd_table_req *req) -{ - free(req); -} - -void em_get_pd_table_rsp_free(struct em_get_pd_table_rsp *rsp) -{ - unsigned int i; - - for (i = 0; i < rsp->_count.ps; i++) - em_ps_free(&rsp->ps[i]); - free(rsp->ps); - free(rsp); -} - -int em_get_pd_table_rsp_parse(const struct nlmsghdr *nlh, - struct ynl_parse_arg *yarg) -{ - struct em_get_pd_table_rsp *dst; - const struct nlattr *attr; - struct ynl_parse_arg parg; - unsigned int n_ps = 0; - int i; - - dst = yarg->data; - parg.ys = yarg->ys; - - if (dst->ps) - return ynl_error_parse(yarg, "attribute already present (pd-table.ps)"); - - ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) { - unsigned int type = ynl_attr_type(attr); - - if (type == EM_A_PD_TABLE_PD_ID) { - if (ynl_attr_validate(yarg, attr)) - return YNL_PARSE_CB_ERROR; - dst->_present.pd_id = 1; - dst->pd_id = ynl_attr_get_u32(attr); - } else if (type == EM_A_PD_TABLE_PS) { - n_ps++; - } - } - - if (n_ps) { - dst->ps = calloc(n_ps, sizeof(*dst->ps)); - dst->_count.ps = n_ps; - i = 0; - parg.rsp_policy = &em_ps_nest; - ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) { - if (ynl_attr_type(attr) == EM_A_PD_TABLE_PS) { - parg.data = &dst->ps[i]; - if (em_ps_parse(&parg, attr)) - return YNL_PARSE_CB_ERROR; - i++; - } - } - } - - return YNL_PARSE_CB_OK; -} - -struct em_get_pd_table_rsp * -em_get_pd_table(struct ynl_sock *ys, struct em_get_pd_table_req *req) -{ - struct ynl_req_state yrs = { .yarg = { .ys = ys, }, }; - struct em_get_pd_table_rsp *rsp; - struct nlmsghdr *nlh; - int err; - - nlh = ynl_gemsg_start_req(ys, ys->family_id, EM_CMD_GET_PD_TABLE, 1); - ys->req_policy = &em_pd_table_nest; - ys->req_hdr_len = ys->family->hdr_len; - yrs.yarg.rsp_policy = &em_pd_table_nest; - - if (req->_present.pd_id) - ynl_attr_put_u32(nlh, EM_A_PD_TABLE_PD_ID, req->pd_id); - - rsp = calloc(1, sizeof(*rsp)); - yrs.yarg.data = rsp; - yrs.cb = em_get_pd_table_rsp_parse; - yrs.rsp_cmd = EM_CMD_GET_PD_TABLE; - - err = ynl_exec(ys, nlh, &yrs); - if (err < 0) - goto err_free; - - return rsp; - -err_free: - em_get_pd_table_rsp_free(rsp); - return NULL; -} - -/* EM_CMD_GET_PD_TABLE - notify */ -void em_get_pd_table_ntf_free(struct em_get_pd_table_ntf *rsp) -{ - unsigned int i; - - for (i = 0; i < rsp->obj._count.ps; i++) - em_ps_free(&rsp->obj.ps[i]); - free(rsp->obj.ps); - free(rsp); -} - -/* EM_CMD_PD_DELETED - event */ -int em_pd_deleted_rsp_parse(const struct nlmsghdr *nlh, - struct ynl_parse_arg *yarg) -{ - struct em_pd_deleted_rsp *dst; - const struct nlattr *attr; - - dst = yarg->data; - - ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) { - unsigned int type = ynl_attr_type(attr); - - if (type == EM_A_PD_TABLE_PD_ID) { - if (ynl_attr_validate(yarg, attr)) - return YNL_PARSE_CB_ERROR; - dst->_present.pd_id = 1; - dst->pd_id = ynl_attr_get_u32(attr); - } - } - - return YNL_PARSE_CB_OK; -} - -void em_pd_deleted_free(struct em_pd_deleted *rsp) -{ - free(rsp); -} - -static const struct ynl_ntf_info em_ntf_info[] = { - [EM_CMD_PD_CREATED] = { - .alloc_sz = sizeof(struct em_get_pd_table_ntf), - .cb = em_get_pd_table_rsp_parse, - .policy = &em_pd_table_nest, - .free = (void *)em_get_pd_table_ntf_free, - }, - [EM_CMD_PD_UPDATED] = { - .alloc_sz = sizeof(struct em_get_pd_table_ntf), - .cb = em_get_pd_table_rsp_parse, - .policy = &em_pd_table_nest, - .free = (void *)em_get_pd_table_ntf_free, - }, - [EM_CMD_PD_DELETED] = { - .alloc_sz = sizeof(struct em_pd_deleted), - .cb = em_pd_deleted_rsp_parse, - .policy = &em_pd_table_nest, - .free = (void *)em_pd_deleted_free, - }, -}; - -const struct ynl_family ynl_em_family = { - .name = "em", - .hdr_len = sizeof(struct genlmsghdr), - .ntf_info = em_ntf_info, - .ntf_info_size = YNL_ARRAY_SIZE(em_ntf_info), -}; diff --git a/tmp/ynl_build-tmp.wFT7ft/old-code/em-user.h b/tmp/ynl_build-tmp.wFT7ft/old-code/em-user.h deleted file mode 100644 index 0cd702afc6ec..000000000000 --- a/tmp/ynl_build-tmp.wFT7ft/old-code/em-user.h +++ /dev/null @@ -1,144 +0,0 @@ -/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ -/* Do not edit directly, auto-generated from: */ -/* Documentation/netlink/specs/em.yaml */ -/* YNL-GEN user header */ -/* To regenerate run: tools/net/ynl/ynl-regen.sh */ - -#ifndef _LINUX_EM_GEN_H -#define _LINUX_EM_GEN_H - -#include -#include -#include -#include - -struct ynl_sock; - -extern const struct ynl_family ynl_em_family; - -/* Enums */ -const char *em_op_str(int op); - -/* Common nested types */ -struct em_pd { - struct { - __u32 pd_id:1; - __u32 flags:1; - } _present; - struct { - __u32 cpus; - } _len; - - __u32 pd_id; - __u64 flags; - char *cpus; -}; - -struct em_ps { - struct { - __u32 performance:1; - __u32 frequency:1; - __u32 power:1; - __u32 cost:1; - __u32 flags:1; - } _present; - - __u64 performance; - __u64 frequency; - __u64 power; - __u64 cost; - __u64 flags; -}; - -/* ============== EM_CMD_GET_PDS ============== */ -/* EM_CMD_GET_PDS - do */ - -struct em_get_pds_rsp { - struct { - __u32 pd; - } _count; - - struct em_pd *pd; -}; - -void em_get_pds_rsp_free(struct em_get_pds_rsp *rsp); - -/* - * Get the list of information for all performance domains. - */ -struct em_get_pds_rsp *em_get_pds(struct ynl_sock *ys); - -/* ============== EM_CMD_GET_PD_TABLE ============== */ -/* EM_CMD_GET_PD_TABLE - do */ -struct em_get_pd_table_req { - struct { - __u32 pd_id:1; - } _present; - - __u32 pd_id; -}; - -static inline struct em_get_pd_table_req *em_get_pd_table_req_alloc(void) -{ - return calloc(1, sizeof(struct em_get_pd_table_req)); -} -void em_get_pd_table_req_free(struct em_get_pd_table_req *req); - -static inline void -em_get_pd_table_req_set_pd_id(struct em_get_pd_table_req *req, __u32 pd_id) -{ - req->_present.pd_id = 1; - req->pd_id = pd_id; -} - -struct em_get_pd_table_rsp { - struct { - __u32 pd_id:1; - } _present; - struct { - __u32 ps; - } _count; - - __u32 pd_id; - struct em_ps *ps; -}; - -void em_get_pd_table_rsp_free(struct em_get_pd_table_rsp *rsp); - -/* - * Get the energy model table of a performance domain. - */ -struct em_get_pd_table_rsp * -em_get_pd_table(struct ynl_sock *ys, struct em_get_pd_table_req *req); - -/* EM_CMD_GET_PD_TABLE - notify */ -struct em_get_pd_table_ntf { - __u16 family; - __u8 cmd; - struct ynl_ntf_base_type *next; - void (*free)(struct em_get_pd_table_ntf *ntf); - struct em_get_pd_table_rsp obj __attribute__((aligned(8))); -}; - -void em_get_pd_table_ntf_free(struct em_get_pd_table_ntf *rsp); - -/* EM_CMD_PD_DELETED - event */ -struct em_pd_deleted_rsp { - struct { - __u32 pd_id:1; - } _present; - - __u32 pd_id; -}; - -struct em_pd_deleted { - __u16 family; - __u8 cmd; - struct ynl_ntf_base_type *next; - void (*free)(struct em_pd_deleted *ntf); - struct em_pd_deleted_rsp obj __attribute__((aligned(8))); -}; - -void em_pd_deleted_free(struct em_pd_deleted *rsp); - -#endif /* _LINUX_EM_GEN_H */