1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * 4 * Generic netlink for energy model. 5 * 6 * Copyright (c) 2025 Valve Corporation. 7 * Author: Changwoo Min <changwoo@igalia.com> 8 */ 9 10 #define pr_fmt(fmt) "energy_model: " fmt 11 12 #include <linux/energy_model.h> 13 #include <net/sock.h> 14 #include <net/genetlink.h> 15 #include <uapi/linux/dev_energymodel.h> 16 17 #include "em_netlink.h" 18 #include "em_netlink_autogen.h" 19 20 /*************************** Command encoding ********************************/ 21 struct dump_ctx { 22 int idx; 23 int start; 24 struct sk_buff *skb; 25 struct netlink_callback *cb; 26 }; 27 28 static int __em_nl_get_pd_size(struct em_perf_domain *pd, void *data) 29 { 30 int nr_cpus, msg_sz, cpus_sz; 31 int *tot_msg_sz = data; 32 33 nr_cpus = cpumask_weight(to_cpumask(pd->cpus)); 34 cpus_sz = nla_total_size_64bit(sizeof(u64)) * nr_cpus; 35 36 msg_sz = nla_total_size(0) + 37 /* DEV_ENERGYMODEL_A_PERF_DOMAINS_PERF_DOMAIN */ 38 nla_total_size(sizeof(u32)) + 39 /* DEV_ENERGYMODEL_A_PERF_DOMAIN_PERF_DOMAIN_ID */ 40 nla_total_size_64bit(sizeof(u64)) + 41 /* DEV_ENERGYMODEL_A_PERF_DOMAIN_FLAGS */ 42 nla_total_size(cpus_sz); 43 /* DEV_ENERGYMODEL_A_PERF_DOMAIN_CPUS */ 44 45 *tot_msg_sz += nlmsg_total_size(genlmsg_msg_size(msg_sz)); 46 return 0; 47 } 48 49 static int __em_nl_get_pd(struct em_perf_domain *pd, void *data) 50 { 51 struct sk_buff *msg = data; 52 struct cpumask *cpumask; 53 int cpu; 54 55 if (nla_put_u32(msg, DEV_ENERGYMODEL_A_PERF_DOMAIN_PERF_DOMAIN_ID, 56 pd->id)) 57 goto out_cancel_nest; 58 59 if (nla_put_u64_64bit(msg, DEV_ENERGYMODEL_A_PERF_DOMAIN_FLAGS, 60 pd->flags, DEV_ENERGYMODEL_A_PERF_DOMAIN_PAD)) 61 goto out_cancel_nest; 62 63 cpumask = to_cpumask(pd->cpus); 64 for_each_cpu(cpu, cpumask) { 65 if (nla_put_u64_64bit(msg, DEV_ENERGYMODEL_A_PERF_DOMAIN_CPUS, 66 cpu, DEV_ENERGYMODEL_A_PERF_DOMAIN_PAD)) 67 goto out_cancel_nest; 68 } 69 70 return 0; 71 72 out_cancel_nest: 73 return -EMSGSIZE; 74 } 75 76 static int __em_nl_get_pd_for_dump(struct em_perf_domain *pd, void *data) 77 { 78 const struct genl_info *info; 79 struct dump_ctx *ctx = data; 80 void *hdr; 81 int ret; 82 83 if (ctx->idx++ < ctx->start) 84 return 0; 85 86 info = genl_info_dump(ctx->cb); 87 hdr = genlmsg_iput(ctx->skb, info); 88 if (!hdr) { 89 genlmsg_cancel(ctx->skb, hdr); 90 return -EMSGSIZE; 91 } 92 93 ret = __em_nl_get_pd(pd, ctx->skb); 94 genlmsg_end(ctx->skb, hdr); 95 return ret; 96 } 97 98 struct em_nl_doit_ctx { 99 struct genl_info *info; 100 int cmd; 101 struct sk_buff *msg; 102 }; 103 104 static int __em_nl_get_pd_doit_fill(struct em_perf_domain *pd, void *data) 105 { 106 struct em_nl_doit_ctx *ctx = data; 107 void *hdr; 108 109 hdr = genlmsg_put_reply(ctx->msg, ctx->info, &dev_energymodel_nl_family, 0, 110 ctx->cmd); 111 if (!hdr) 112 return -EMSGSIZE; 113 114 if (__em_nl_get_pd(pd, ctx->msg)) { 115 genlmsg_cancel(ctx->msg, hdr); 116 return -EMSGSIZE; 117 } 118 119 genlmsg_end(ctx->msg, hdr); 120 return 0; 121 } 122 123 int dev_energymodel_nl_get_perf_domains_doit(struct sk_buff *skb, 124 struct genl_info *info) 125 { 126 struct em_nl_doit_ctx ctx = { 127 .info = info, 128 .cmd = info->genlhdr->cmd, 129 }; 130 struct sk_buff *msg; 131 int id, ret, msg_sz = 0; 132 133 if (!info->attrs[DEV_ENERGYMODEL_A_PERF_DOMAIN_PERF_DOMAIN_ID]) 134 return -EINVAL; 135 136 id = nla_get_u32(info->attrs[DEV_ENERGYMODEL_A_PERF_DOMAIN_PERF_DOMAIN_ID]); 137 138 /* Encode under em_pd_list_mutex, like the dumpit path. */ 139 ret = em_perf_domain_for_id(id, __em_nl_get_pd_size, &msg_sz); 140 if (ret) 141 return ret; 142 143 msg = genlmsg_new(msg_sz, GFP_KERNEL); 144 if (!msg) 145 return -ENOMEM; 146 147 ctx.msg = msg; 148 ret = em_perf_domain_for_id(id, __em_nl_get_pd_doit_fill, &ctx); 149 if (ret) 150 goto out_free_msg; 151 152 return genlmsg_reply(msg, info); 153 154 out_free_msg: 155 nlmsg_free(msg); 156 return ret; 157 } 158 159 int dev_energymodel_nl_get_perf_domains_dumpit(struct sk_buff *skb, 160 struct netlink_callback *cb) 161 { 162 struct dump_ctx ctx = { 163 .idx = 0, 164 .start = cb->args[0], 165 .skb = skb, 166 .cb = cb, 167 }; 168 169 return for_each_em_perf_domain(__em_nl_get_pd_for_dump, &ctx); 170 } 171 172 static int __em_nl_get_pd_table_size(const struct em_perf_domain *pd) 173 { 174 int id_sz, ps_sz; 175 176 id_sz = nla_total_size(sizeof(u32)); 177 /* DEV_ENERGYMODEL_A_PERF_TABLE_PERF_DOMAIN_ID */ 178 ps_sz = nla_total_size(0) + 179 /* DEV_ENERGYMODEL_A_PERF_TABLE_PERF_STATE */ 180 nla_total_size_64bit(sizeof(u64)) + 181 /* DEV_ENERGYMODEL_A_PERF_STATE_PERFORMANCE */ 182 nla_total_size_64bit(sizeof(u64)) + 183 /* DEV_ENERGYMODEL_A_PERF_STATE_FREQUENCY */ 184 nla_total_size_64bit(sizeof(u64)) + 185 /* DEV_ENERGYMODEL_A_PERF_STATE_POWER */ 186 nla_total_size_64bit(sizeof(u64)) + 187 /* DEV_ENERGYMODEL_A_PERF_STATE_COST */ 188 nla_total_size_64bit(sizeof(u64)); 189 /* DEV_ENERGYMODEL_A_PERF_STATE_FLAGS */ 190 ps_sz *= pd->nr_perf_states; 191 192 return nlmsg_total_size(genlmsg_msg_size(id_sz + ps_sz)); 193 } 194 195 static 196 int __em_nl_get_pd_table(struct sk_buff *msg, const struct em_perf_domain *pd) 197 { 198 struct em_perf_state *table, *ps; 199 struct nlattr *entry; 200 int i; 201 202 if (nla_put_u32(msg, DEV_ENERGYMODEL_A_PERF_TABLE_PERF_DOMAIN_ID, 203 pd->id)) 204 goto out_err; 205 206 rcu_read_lock(); 207 table = em_perf_state_from_pd((struct em_perf_domain *)pd); 208 209 for (i = 0; i < pd->nr_perf_states; i++) { 210 ps = &table[i]; 211 212 entry = nla_nest_start(msg, 213 DEV_ENERGYMODEL_A_PERF_TABLE_PERF_STATE); 214 if (!entry) 215 goto out_unlock_ps; 216 217 if (nla_put_u64_64bit(msg, 218 DEV_ENERGYMODEL_A_PERF_STATE_PERFORMANCE, 219 ps->performance, 220 DEV_ENERGYMODEL_A_PERF_STATE_PAD)) 221 goto out_cancel_ps_nest; 222 if (nla_put_u64_64bit(msg, 223 DEV_ENERGYMODEL_A_PERF_STATE_FREQUENCY, 224 ps->frequency, 225 DEV_ENERGYMODEL_A_PERF_STATE_PAD)) 226 goto out_cancel_ps_nest; 227 if (nla_put_u64_64bit(msg, 228 DEV_ENERGYMODEL_A_PERF_STATE_POWER, 229 ps->power, 230 DEV_ENERGYMODEL_A_PERF_STATE_PAD)) 231 goto out_cancel_ps_nest; 232 if (nla_put_u64_64bit(msg, 233 DEV_ENERGYMODEL_A_PERF_STATE_COST, 234 ps->cost, 235 DEV_ENERGYMODEL_A_PERF_STATE_PAD)) 236 goto out_cancel_ps_nest; 237 if (nla_put_u64_64bit(msg, 238 DEV_ENERGYMODEL_A_PERF_STATE_FLAGS, 239 ps->flags, 240 DEV_ENERGYMODEL_A_PERF_STATE_PAD)) 241 goto out_cancel_ps_nest; 242 243 nla_nest_end(msg, entry); 244 } 245 rcu_read_unlock(); 246 return 0; 247 248 out_cancel_ps_nest: 249 nla_nest_cancel(msg, entry); 250 out_unlock_ps: 251 rcu_read_unlock(); 252 out_err: 253 return -EMSGSIZE; 254 } 255 256 static int __em_nl_get_pd_table_size_cb(struct em_perf_domain *pd, void *data) 257 { 258 *(int *)data = __em_nl_get_pd_table_size(pd); 259 return 0; 260 } 261 262 static int __em_nl_get_pd_table_doit_fill(struct em_perf_domain *pd, 263 void *data) 264 { 265 struct em_nl_doit_ctx *ctx = data; 266 void *hdr; 267 268 hdr = genlmsg_put_reply(ctx->msg, ctx->info, &dev_energymodel_nl_family, 0, 269 ctx->cmd); 270 if (!hdr) 271 return -EMSGSIZE; 272 273 if (__em_nl_get_pd_table(ctx->msg, pd)) 274 return -EMSGSIZE; 275 276 genlmsg_end(ctx->msg, hdr); 277 return 0; 278 } 279 280 int dev_energymodel_nl_get_perf_table_doit(struct sk_buff *skb, 281 struct genl_info *info) 282 { 283 struct em_nl_doit_ctx ctx = { 284 .info = info, 285 .cmd = info->genlhdr->cmd, 286 }; 287 struct sk_buff *msg; 288 int id, ret, msg_sz; 289 290 if (!info->attrs[DEV_ENERGYMODEL_A_PERF_TABLE_PERF_DOMAIN_ID]) 291 return -EINVAL; 292 293 id = nla_get_u32(info->attrs[DEV_ENERGYMODEL_A_PERF_TABLE_PERF_DOMAIN_ID]); 294 295 ret = em_perf_domain_for_id(id, __em_nl_get_pd_table_size_cb, &msg_sz); 296 if (ret) 297 return ret; 298 299 msg = genlmsg_new(msg_sz, GFP_KERNEL); 300 if (!msg) 301 return -ENOMEM; 302 303 ctx.msg = msg; 304 ret = em_perf_domain_for_id(id, __em_nl_get_pd_table_doit_fill, &ctx); 305 if (ret) 306 goto out_free_msg; 307 308 return genlmsg_reply(msg, info); 309 310 out_free_msg: 311 nlmsg_free(msg); 312 return ret; 313 } 314 315 316 /**************************** Event encoding *********************************/ 317 static void __em_notify_pd_table(const struct em_perf_domain *pd, int ntf_type) 318 { 319 struct sk_buff *msg; 320 int msg_sz, ret = -EMSGSIZE; 321 void *hdr; 322 323 if (!genl_has_listeners(&dev_energymodel_nl_family, &init_net, DEV_ENERGYMODEL_NLGRP_EVENT)) 324 return; 325 326 msg_sz = __em_nl_get_pd_table_size(pd); 327 328 msg = genlmsg_new(msg_sz, GFP_KERNEL); 329 if (!msg) 330 return; 331 332 hdr = genlmsg_put(msg, 0, 0, &dev_energymodel_nl_family, 0, ntf_type); 333 if (!hdr) 334 goto out_free_msg; 335 336 ret = __em_nl_get_pd_table(msg, pd); 337 if (ret) 338 goto out_free_msg; 339 340 genlmsg_end(msg, hdr); 341 342 genlmsg_multicast(&dev_energymodel_nl_family, msg, 0, 343 DEV_ENERGYMODEL_NLGRP_EVENT, GFP_KERNEL); 344 345 return; 346 347 out_free_msg: 348 nlmsg_free(msg); 349 } 350 351 void em_notify_pd_created(const struct em_perf_domain *pd) 352 { 353 __em_notify_pd_table(pd, DEV_ENERGYMODEL_CMD_PERF_DOMAIN_CREATED); 354 } 355 356 void em_notify_pd_updated(const struct em_perf_domain *pd) 357 { 358 __em_notify_pd_table(pd, DEV_ENERGYMODEL_CMD_PERF_DOMAIN_UPDATED); 359 } 360 361 static int __em_notify_pd_deleted_size(const struct em_perf_domain *pd) 362 { 363 int id_sz = nla_total_size(sizeof(u32)); /* DEV_ENERGYMODEL_A_PERF_TABLE_PERF_DOMAIN_ID */ 364 365 return nlmsg_total_size(genlmsg_msg_size(id_sz)); 366 } 367 368 void em_notify_pd_deleted(const struct em_perf_domain *pd) 369 { 370 struct sk_buff *msg; 371 void *hdr; 372 int msg_sz; 373 374 if (!genl_has_listeners(&dev_energymodel_nl_family, &init_net, 375 DEV_ENERGYMODEL_NLGRP_EVENT)) 376 return; 377 378 msg_sz = __em_notify_pd_deleted_size(pd); 379 380 msg = genlmsg_new(msg_sz, GFP_KERNEL); 381 if (!msg) 382 return; 383 384 hdr = genlmsg_put(msg, 0, 0, &dev_energymodel_nl_family, 0, 385 DEV_ENERGYMODEL_CMD_PERF_DOMAIN_DELETED); 386 if (!hdr) 387 goto out_free_msg; 388 389 if (nla_put_u32(msg, DEV_ENERGYMODEL_A_PERF_TABLE_PERF_DOMAIN_ID, 390 pd->id)) 391 goto out_free_msg; 392 393 genlmsg_end(msg, hdr); 394 395 genlmsg_multicast(&dev_energymodel_nl_family, msg, 0, 396 DEV_ENERGYMODEL_NLGRP_EVENT, GFP_KERNEL); 397 398 return; 399 400 out_free_msg: 401 nlmsg_free(msg); 402 } 403 404 /**************************** Initialization *********************************/ 405 static int __init em_netlink_init(void) 406 { 407 return genl_register_family(&dev_energymodel_nl_family); 408 } 409 postcore_initcall(em_netlink_init); 410