1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright 2020 Linaro Limited 4 * 5 * Author: Daniel Lezcano <daniel.lezcano@linaro.org> 6 * 7 * Generic netlink for thermal management framework 8 */ 9 #include <linux/module.h> 10 #include <linux/kernel.h> 11 #include <net/genetlink.h> 12 #include <uapi/linux/thermal.h> 13 14 #include "thermal_core.h" 15 16 static const struct genl_multicast_group thermal_genl_mcgrps[] = { 17 { .name = THERMAL_GENL_SAMPLING_GROUP_NAME, }, 18 { .name = THERMAL_GENL_EVENT_GROUP_NAME, }, 19 }; 20 21 static const struct nla_policy thermal_genl_policy[THERMAL_GENL_ATTR_MAX + 1] = { 22 /* Thermal zone */ 23 [THERMAL_GENL_ATTR_TZ] = { .type = NLA_NESTED }, 24 [THERMAL_GENL_ATTR_TZ_ID] = { .type = NLA_U32 }, 25 [THERMAL_GENL_ATTR_TZ_TEMP] = { .type = NLA_U32 }, 26 [THERMAL_GENL_ATTR_TZ_TRIP] = { .type = NLA_NESTED }, 27 [THERMAL_GENL_ATTR_TZ_TRIP_ID] = { .type = NLA_U32 }, 28 [THERMAL_GENL_ATTR_TZ_TRIP_TEMP] = { .type = NLA_U32 }, 29 [THERMAL_GENL_ATTR_TZ_TRIP_TYPE] = { .type = NLA_U32 }, 30 [THERMAL_GENL_ATTR_TZ_TRIP_HYST] = { .type = NLA_U32 }, 31 [THERMAL_GENL_ATTR_TZ_MODE] = { .type = NLA_U32 }, 32 [THERMAL_GENL_ATTR_TZ_CDEV_WEIGHT] = { .type = NLA_U32 }, 33 [THERMAL_GENL_ATTR_TZ_NAME] = { .type = NLA_STRING, 34 .len = THERMAL_NAME_LENGTH }, 35 /* Governor(s) */ 36 [THERMAL_GENL_ATTR_TZ_GOV] = { .type = NLA_NESTED }, 37 [THERMAL_GENL_ATTR_TZ_GOV_NAME] = { .type = NLA_STRING, 38 .len = THERMAL_NAME_LENGTH }, 39 /* Cooling devices */ 40 [THERMAL_GENL_ATTR_CDEV] = { .type = NLA_NESTED }, 41 [THERMAL_GENL_ATTR_CDEV_ID] = { .type = NLA_U32 }, 42 [THERMAL_GENL_ATTR_CDEV_CUR_STATE] = { .type = NLA_U32 }, 43 [THERMAL_GENL_ATTR_CDEV_MAX_STATE] = { .type = NLA_U32 }, 44 [THERMAL_GENL_ATTR_CDEV_NAME] = { .type = NLA_STRING, 45 .len = THERMAL_NAME_LENGTH }, 46 /* CPU capabilities */ 47 [THERMAL_GENL_ATTR_CPU_CAPABILITY] = { .type = NLA_NESTED }, 48 [THERMAL_GENL_ATTR_CPU_CAPABILITY_ID] = { .type = NLA_U32 }, 49 [THERMAL_GENL_ATTR_CPU_CAPABILITY_PERFORMANCE] = { .type = NLA_U32 }, 50 [THERMAL_GENL_ATTR_CPU_CAPABILITY_EFFICIENCY] = { .type = NLA_U32 }, 51 }; 52 53 struct param { 54 struct nlattr **attrs; 55 struct sk_buff *msg; 56 const char *name; 57 int tz_id; 58 int cdev_id; 59 int trip_id; 60 int trip_temp; 61 int trip_type; 62 int trip_hyst; 63 int temp; 64 int cdev_state; 65 int cdev_max_state; 66 struct thermal_genl_cpu_caps *cpu_capabilities; 67 int cpu_capabilities_count; 68 }; 69 70 typedef int (*cb_t)(struct param *); 71 72 static struct genl_family thermal_gnl_family; 73 74 /************************** Sampling encoding *******************************/ 75 thermal_genl_sampling_temp(int id,int temp)76 int thermal_genl_sampling_temp(int id, int temp) 77 { 78 struct sk_buff *skb; 79 void *hdr; 80 81 skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL); 82 if (!skb) 83 return -ENOMEM; 84 85 hdr = genlmsg_put(skb, 0, 0, &thermal_gnl_family, 0, 86 THERMAL_GENL_SAMPLING_TEMP); 87 if (!hdr) 88 goto out_free; 89 90 if (nla_put_u32(skb, THERMAL_GENL_ATTR_TZ_ID, id)) 91 goto out_cancel; 92 93 if (nla_put_u32(skb, THERMAL_GENL_ATTR_TZ_TEMP, temp)) 94 goto out_cancel; 95 96 genlmsg_end(skb, hdr); 97 98 genlmsg_multicast(&thermal_gnl_family, skb, 0, 0, GFP_KERNEL); 99 100 return 0; 101 out_cancel: 102 genlmsg_cancel(skb, hdr); 103 out_free: 104 nlmsg_free(skb); 105 106 return -EMSGSIZE; 107 } 108 109 /**************************** Event encoding *********************************/ 110 thermal_genl_event_tz_create(struct param * p)111 static int thermal_genl_event_tz_create(struct param *p) 112 { 113 if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) || 114 nla_put_string(p->msg, THERMAL_GENL_ATTR_TZ_NAME, p->name)) 115 return -EMSGSIZE; 116 117 return 0; 118 } 119 thermal_genl_event_tz(struct param * p)120 static int thermal_genl_event_tz(struct param *p) 121 { 122 if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id)) 123 return -EMSGSIZE; 124 125 return 0; 126 } 127 thermal_genl_event_tz_trip_up(struct param * p)128 static int thermal_genl_event_tz_trip_up(struct param *p) 129 { 130 if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) || 131 nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_ID, p->trip_id) || 132 nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TEMP, p->temp)) 133 return -EMSGSIZE; 134 135 return 0; 136 } 137 thermal_genl_event_tz_trip_add(struct param * p)138 static int thermal_genl_event_tz_trip_add(struct param *p) 139 { 140 if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) || 141 nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_ID, p->trip_id) || 142 nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_TYPE, p->trip_type) || 143 nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_TEMP, p->trip_temp) || 144 nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_HYST, p->trip_hyst)) 145 return -EMSGSIZE; 146 147 return 0; 148 } 149 thermal_genl_event_tz_trip_delete(struct param * p)150 static int thermal_genl_event_tz_trip_delete(struct param *p) 151 { 152 if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) || 153 nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_ID, p->trip_id)) 154 return -EMSGSIZE; 155 156 return 0; 157 } 158 thermal_genl_event_cdev_add(struct param * p)159 static int thermal_genl_event_cdev_add(struct param *p) 160 { 161 if (nla_put_string(p->msg, THERMAL_GENL_ATTR_CDEV_NAME, 162 p->name) || 163 nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_ID, 164 p->cdev_id) || 165 nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_MAX_STATE, 166 p->cdev_max_state)) 167 return -EMSGSIZE; 168 169 return 0; 170 } 171 thermal_genl_event_cdev_delete(struct param * p)172 static int thermal_genl_event_cdev_delete(struct param *p) 173 { 174 if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_ID, p->cdev_id)) 175 return -EMSGSIZE; 176 177 return 0; 178 } 179 thermal_genl_event_cdev_state_update(struct param * p)180 static int thermal_genl_event_cdev_state_update(struct param *p) 181 { 182 if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_ID, 183 p->cdev_id) || 184 nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_CUR_STATE, 185 p->cdev_state)) 186 return -EMSGSIZE; 187 188 return 0; 189 } 190 thermal_genl_event_gov_change(struct param * p)191 static int thermal_genl_event_gov_change(struct param *p) 192 { 193 if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) || 194 nla_put_string(p->msg, THERMAL_GENL_ATTR_GOV_NAME, p->name)) 195 return -EMSGSIZE; 196 197 return 0; 198 } 199 thermal_genl_event_cpu_capability_change(struct param * p)200 static int thermal_genl_event_cpu_capability_change(struct param *p) 201 { 202 struct thermal_genl_cpu_caps *cpu_cap = p->cpu_capabilities; 203 struct sk_buff *msg = p->msg; 204 struct nlattr *start_cap; 205 int i; 206 207 start_cap = nla_nest_start(msg, THERMAL_GENL_ATTR_CPU_CAPABILITY); 208 if (!start_cap) 209 return -EMSGSIZE; 210 211 for (i = 0; i < p->cpu_capabilities_count; ++i) { 212 if (nla_put_u32(msg, THERMAL_GENL_ATTR_CPU_CAPABILITY_ID, 213 cpu_cap->cpu)) 214 goto out_cancel_nest; 215 216 if (nla_put_u32(msg, THERMAL_GENL_ATTR_CPU_CAPABILITY_PERFORMANCE, 217 cpu_cap->performance)) 218 goto out_cancel_nest; 219 220 if (nla_put_u32(msg, THERMAL_GENL_ATTR_CPU_CAPABILITY_EFFICIENCY, 221 cpu_cap->efficiency)) 222 goto out_cancel_nest; 223 224 ++cpu_cap; 225 } 226 227 nla_nest_end(msg, start_cap); 228 229 return 0; 230 out_cancel_nest: 231 nla_nest_cancel(msg, start_cap); 232 233 return -EMSGSIZE; 234 } 235 236 int thermal_genl_event_tz_delete(struct param *p) 237 __attribute__((alias("thermal_genl_event_tz"))); 238 239 int thermal_genl_event_tz_enable(struct param *p) 240 __attribute__((alias("thermal_genl_event_tz"))); 241 242 int thermal_genl_event_tz_disable(struct param *p) 243 __attribute__((alias("thermal_genl_event_tz"))); 244 245 int thermal_genl_event_tz_trip_down(struct param *p) 246 __attribute__((alias("thermal_genl_event_tz_trip_up"))); 247 248 int thermal_genl_event_tz_trip_change(struct param *p) 249 __attribute__((alias("thermal_genl_event_tz_trip_add"))); 250 251 static cb_t event_cb[] = { 252 [THERMAL_GENL_EVENT_TZ_CREATE] = thermal_genl_event_tz_create, 253 [THERMAL_GENL_EVENT_TZ_DELETE] = thermal_genl_event_tz_delete, 254 [THERMAL_GENL_EVENT_TZ_ENABLE] = thermal_genl_event_tz_enable, 255 [THERMAL_GENL_EVENT_TZ_DISABLE] = thermal_genl_event_tz_disable, 256 [THERMAL_GENL_EVENT_TZ_TRIP_UP] = thermal_genl_event_tz_trip_up, 257 [THERMAL_GENL_EVENT_TZ_TRIP_DOWN] = thermal_genl_event_tz_trip_down, 258 [THERMAL_GENL_EVENT_TZ_TRIP_CHANGE] = thermal_genl_event_tz_trip_change, 259 [THERMAL_GENL_EVENT_TZ_TRIP_ADD] = thermal_genl_event_tz_trip_add, 260 [THERMAL_GENL_EVENT_TZ_TRIP_DELETE] = thermal_genl_event_tz_trip_delete, 261 [THERMAL_GENL_EVENT_CDEV_ADD] = thermal_genl_event_cdev_add, 262 [THERMAL_GENL_EVENT_CDEV_DELETE] = thermal_genl_event_cdev_delete, 263 [THERMAL_GENL_EVENT_CDEV_STATE_UPDATE] = thermal_genl_event_cdev_state_update, 264 [THERMAL_GENL_EVENT_TZ_GOV_CHANGE] = thermal_genl_event_gov_change, 265 [THERMAL_GENL_EVENT_CPU_CAPABILITY_CHANGE] = thermal_genl_event_cpu_capability_change, 266 }; 267 268 /* 269 * Generic netlink event encoding 270 */ thermal_genl_send_event(enum thermal_genl_event event,struct param * p)271 static int thermal_genl_send_event(enum thermal_genl_event event, 272 struct param *p) 273 { 274 struct sk_buff *msg; 275 int ret = -EMSGSIZE; 276 void *hdr; 277 278 msg = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL); 279 if (!msg) 280 return -ENOMEM; 281 p->msg = msg; 282 283 hdr = genlmsg_put(msg, 0, 0, &thermal_gnl_family, 0, event); 284 if (!hdr) 285 goto out_free_msg; 286 287 ret = event_cb[event](p); 288 if (ret) 289 goto out_cancel_msg; 290 291 genlmsg_end(msg, hdr); 292 293 genlmsg_multicast(&thermal_gnl_family, msg, 0, 1, GFP_KERNEL); 294 295 return 0; 296 297 out_cancel_msg: 298 genlmsg_cancel(msg, hdr); 299 out_free_msg: 300 nlmsg_free(msg); 301 302 return ret; 303 } 304 thermal_notify_tz_create(int tz_id,const char * name)305 int thermal_notify_tz_create(int tz_id, const char *name) 306 { 307 struct param p = { .tz_id = tz_id, .name = name }; 308 309 return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_CREATE, &p); 310 } 311 thermal_notify_tz_delete(int tz_id)312 int thermal_notify_tz_delete(int tz_id) 313 { 314 struct param p = { .tz_id = tz_id }; 315 316 return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_DELETE, &p); 317 } 318 thermal_notify_tz_enable(int tz_id)319 int thermal_notify_tz_enable(int tz_id) 320 { 321 struct param p = { .tz_id = tz_id }; 322 323 return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_ENABLE, &p); 324 } 325 thermal_notify_tz_disable(int tz_id)326 int thermal_notify_tz_disable(int tz_id) 327 { 328 struct param p = { .tz_id = tz_id }; 329 330 return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_DISABLE, &p); 331 } 332 thermal_notify_tz_trip_down(int tz_id,int trip_id,int temp)333 int thermal_notify_tz_trip_down(int tz_id, int trip_id, int temp) 334 { 335 struct param p = { .tz_id = tz_id, .trip_id = trip_id, .temp = temp }; 336 337 return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_DOWN, &p); 338 } 339 thermal_notify_tz_trip_up(int tz_id,int trip_id,int temp)340 int thermal_notify_tz_trip_up(int tz_id, int trip_id, int temp) 341 { 342 struct param p = { .tz_id = tz_id, .trip_id = trip_id, .temp = temp }; 343 344 return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_UP, &p); 345 } 346 thermal_notify_tz_trip_add(int tz_id,int trip_id,int trip_type,int trip_temp,int trip_hyst)347 int thermal_notify_tz_trip_add(int tz_id, int trip_id, int trip_type, 348 int trip_temp, int trip_hyst) 349 { 350 struct param p = { .tz_id = tz_id, .trip_id = trip_id, 351 .trip_type = trip_type, .trip_temp = trip_temp, 352 .trip_hyst = trip_hyst }; 353 354 return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_ADD, &p); 355 } 356 thermal_notify_tz_trip_delete(int tz_id,int trip_id)357 int thermal_notify_tz_trip_delete(int tz_id, int trip_id) 358 { 359 struct param p = { .tz_id = tz_id, .trip_id = trip_id }; 360 361 return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_DELETE, &p); 362 } 363 thermal_notify_tz_trip_change(int tz_id,int trip_id,int trip_type,int trip_temp,int trip_hyst)364 int thermal_notify_tz_trip_change(int tz_id, int trip_id, int trip_type, 365 int trip_temp, int trip_hyst) 366 { 367 struct param p = { .tz_id = tz_id, .trip_id = trip_id, 368 .trip_type = trip_type, .trip_temp = trip_temp, 369 .trip_hyst = trip_hyst }; 370 371 return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_CHANGE, &p); 372 } 373 thermal_notify_cdev_state_update(int cdev_id,int cdev_state)374 int thermal_notify_cdev_state_update(int cdev_id, int cdev_state) 375 { 376 struct param p = { .cdev_id = cdev_id, .cdev_state = cdev_state }; 377 378 return thermal_genl_send_event(THERMAL_GENL_EVENT_CDEV_STATE_UPDATE, &p); 379 } 380 thermal_notify_cdev_add(int cdev_id,const char * name,int cdev_max_state)381 int thermal_notify_cdev_add(int cdev_id, const char *name, int cdev_max_state) 382 { 383 struct param p = { .cdev_id = cdev_id, .name = name, 384 .cdev_max_state = cdev_max_state }; 385 386 return thermal_genl_send_event(THERMAL_GENL_EVENT_CDEV_ADD, &p); 387 } 388 thermal_notify_cdev_delete(int cdev_id)389 int thermal_notify_cdev_delete(int cdev_id) 390 { 391 struct param p = { .cdev_id = cdev_id }; 392 393 return thermal_genl_send_event(THERMAL_GENL_EVENT_CDEV_DELETE, &p); 394 } 395 thermal_notify_tz_gov_change(int tz_id,const char * name)396 int thermal_notify_tz_gov_change(int tz_id, const char *name) 397 { 398 struct param p = { .tz_id = tz_id, .name = name }; 399 400 return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_GOV_CHANGE, &p); 401 } 402 thermal_genl_cpu_capability_event(int count,struct thermal_genl_cpu_caps * caps)403 int thermal_genl_cpu_capability_event(int count, 404 struct thermal_genl_cpu_caps *caps) 405 { 406 struct param p = { .cpu_capabilities_count = count, .cpu_capabilities = caps }; 407 408 return thermal_genl_send_event(THERMAL_GENL_EVENT_CPU_CAPABILITY_CHANGE, &p); 409 } 410 EXPORT_SYMBOL_GPL(thermal_genl_cpu_capability_event); 411 412 /*************************** Command encoding ********************************/ 413 __thermal_genl_cmd_tz_get_id(struct thermal_zone_device * tz,void * data)414 static int __thermal_genl_cmd_tz_get_id(struct thermal_zone_device *tz, 415 void *data) 416 { 417 struct sk_buff *msg = data; 418 419 if (nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_ID, tz->id) || 420 nla_put_string(msg, THERMAL_GENL_ATTR_TZ_NAME, tz->type)) 421 return -EMSGSIZE; 422 423 return 0; 424 } 425 thermal_genl_cmd_tz_get_id(struct param * p)426 static int thermal_genl_cmd_tz_get_id(struct param *p) 427 { 428 struct sk_buff *msg = p->msg; 429 struct nlattr *start_tz; 430 int ret; 431 432 start_tz = nla_nest_start(msg, THERMAL_GENL_ATTR_TZ); 433 if (!start_tz) 434 return -EMSGSIZE; 435 436 ret = for_each_thermal_zone(__thermal_genl_cmd_tz_get_id, msg); 437 if (ret) 438 goto out_cancel_nest; 439 440 nla_nest_end(msg, start_tz); 441 442 return 0; 443 444 out_cancel_nest: 445 nla_nest_cancel(msg, start_tz); 446 447 return ret; 448 } 449 thermal_genl_cmd_tz_get_trip(struct param * p)450 static int thermal_genl_cmd_tz_get_trip(struct param *p) 451 { 452 struct sk_buff *msg = p->msg; 453 struct thermal_zone_device *tz; 454 struct nlattr *start_trip; 455 struct thermal_trip trip; 456 int ret, i, id; 457 458 if (!p->attrs[THERMAL_GENL_ATTR_TZ_ID]) 459 return -EINVAL; 460 461 id = nla_get_u32(p->attrs[THERMAL_GENL_ATTR_TZ_ID]); 462 463 tz = thermal_zone_get_by_id(id); 464 if (!tz) 465 return -EINVAL; 466 467 start_trip = nla_nest_start(msg, THERMAL_GENL_ATTR_TZ_TRIP); 468 if (!start_trip) 469 return -EMSGSIZE; 470 471 mutex_lock(&tz->lock); 472 473 for (i = 0; i < tz->num_trips; i++) { 474 475 ret = __thermal_zone_get_trip(tz, i, &trip); 476 if (ret) 477 goto out_cancel_nest; 478 479 if (nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_ID, i) || 480 nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_TYPE, trip.type) || 481 nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_TEMP, trip.temperature) || 482 nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_HYST, trip.hysteresis)) 483 goto out_cancel_nest; 484 } 485 486 mutex_unlock(&tz->lock); 487 488 nla_nest_end(msg, start_trip); 489 490 return 0; 491 492 out_cancel_nest: 493 mutex_unlock(&tz->lock); 494 495 return -EMSGSIZE; 496 } 497 thermal_genl_cmd_tz_get_temp(struct param * p)498 static int thermal_genl_cmd_tz_get_temp(struct param *p) 499 { 500 struct sk_buff *msg = p->msg; 501 struct thermal_zone_device *tz; 502 int temp, ret, id; 503 504 if (!p->attrs[THERMAL_GENL_ATTR_TZ_ID]) 505 return -EINVAL; 506 507 id = nla_get_u32(p->attrs[THERMAL_GENL_ATTR_TZ_ID]); 508 509 tz = thermal_zone_get_by_id(id); 510 if (!tz) 511 return -EINVAL; 512 513 ret = thermal_zone_get_temp(tz, &temp); 514 if (ret) 515 return ret; 516 517 if (nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_ID, id) || 518 nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TEMP, temp)) 519 return -EMSGSIZE; 520 521 return 0; 522 } 523 thermal_genl_cmd_tz_get_gov(struct param * p)524 static int thermal_genl_cmd_tz_get_gov(struct param *p) 525 { 526 struct sk_buff *msg = p->msg; 527 struct thermal_zone_device *tz; 528 int id, ret = 0; 529 530 if (!p->attrs[THERMAL_GENL_ATTR_TZ_ID]) 531 return -EINVAL; 532 533 id = nla_get_u32(p->attrs[THERMAL_GENL_ATTR_TZ_ID]); 534 535 tz = thermal_zone_get_by_id(id); 536 if (!tz) 537 return -EINVAL; 538 539 mutex_lock(&tz->lock); 540 541 if (nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_ID, id) || 542 nla_put_string(msg, THERMAL_GENL_ATTR_TZ_GOV_NAME, 543 tz->governor->name)) 544 ret = -EMSGSIZE; 545 546 mutex_unlock(&tz->lock); 547 548 return ret; 549 } 550 __thermal_genl_cmd_cdev_get(struct thermal_cooling_device * cdev,void * data)551 static int __thermal_genl_cmd_cdev_get(struct thermal_cooling_device *cdev, 552 void *data) 553 { 554 struct sk_buff *msg = data; 555 556 if (nla_put_u32(msg, THERMAL_GENL_ATTR_CDEV_ID, cdev->id)) 557 return -EMSGSIZE; 558 559 if (nla_put_string(msg, THERMAL_GENL_ATTR_CDEV_NAME, cdev->type)) 560 return -EMSGSIZE; 561 562 return 0; 563 } 564 thermal_genl_cmd_cdev_get(struct param * p)565 static int thermal_genl_cmd_cdev_get(struct param *p) 566 { 567 struct sk_buff *msg = p->msg; 568 struct nlattr *start_cdev; 569 int ret; 570 571 start_cdev = nla_nest_start(msg, THERMAL_GENL_ATTR_CDEV); 572 if (!start_cdev) 573 return -EMSGSIZE; 574 575 ret = for_each_thermal_cooling_device(__thermal_genl_cmd_cdev_get, msg); 576 if (ret) 577 goto out_cancel_nest; 578 579 nla_nest_end(msg, start_cdev); 580 581 return 0; 582 out_cancel_nest: 583 nla_nest_cancel(msg, start_cdev); 584 585 return ret; 586 } 587 588 static cb_t cmd_cb[] = { 589 [THERMAL_GENL_CMD_TZ_GET_ID] = thermal_genl_cmd_tz_get_id, 590 [THERMAL_GENL_CMD_TZ_GET_TRIP] = thermal_genl_cmd_tz_get_trip, 591 [THERMAL_GENL_CMD_TZ_GET_TEMP] = thermal_genl_cmd_tz_get_temp, 592 [THERMAL_GENL_CMD_TZ_GET_GOV] = thermal_genl_cmd_tz_get_gov, 593 [THERMAL_GENL_CMD_CDEV_GET] = thermal_genl_cmd_cdev_get, 594 }; 595 thermal_genl_cmd_dumpit(struct sk_buff * skb,struct netlink_callback * cb)596 static int thermal_genl_cmd_dumpit(struct sk_buff *skb, 597 struct netlink_callback *cb) 598 { 599 struct param p = { .msg = skb }; 600 const struct genl_dumpit_info *info = genl_dumpit_info(cb); 601 int cmd = info->op.cmd; 602 int ret; 603 void *hdr; 604 605 hdr = genlmsg_put(skb, 0, 0, &thermal_gnl_family, 0, cmd); 606 if (!hdr) 607 return -EMSGSIZE; 608 609 ret = cmd_cb[cmd](&p); 610 if (ret) 611 goto out_cancel_msg; 612 613 genlmsg_end(skb, hdr); 614 615 return 0; 616 617 out_cancel_msg: 618 genlmsg_cancel(skb, hdr); 619 620 return ret; 621 } 622 thermal_genl_cmd_doit(struct sk_buff * skb,struct genl_info * info)623 static int thermal_genl_cmd_doit(struct sk_buff *skb, 624 struct genl_info *info) 625 { 626 struct param p = { .attrs = info->attrs }; 627 struct sk_buff *msg; 628 void *hdr; 629 int cmd = info->genlhdr->cmd; 630 int ret = -EMSGSIZE; 631 632 msg = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL); 633 if (!msg) 634 return -ENOMEM; 635 p.msg = msg; 636 637 hdr = genlmsg_put_reply(msg, info, &thermal_gnl_family, 0, cmd); 638 if (!hdr) 639 goto out_free_msg; 640 641 ret = cmd_cb[cmd](&p); 642 if (ret) 643 goto out_cancel_msg; 644 645 genlmsg_end(msg, hdr); 646 647 return genlmsg_reply(msg, info); 648 649 out_cancel_msg: 650 genlmsg_cancel(msg, hdr); 651 out_free_msg: 652 nlmsg_free(msg); 653 654 return ret; 655 } 656 657 static const struct genl_small_ops thermal_genl_ops[] = { 658 { 659 .cmd = THERMAL_GENL_CMD_TZ_GET_ID, 660 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 661 .dumpit = thermal_genl_cmd_dumpit, 662 }, 663 { 664 .cmd = THERMAL_GENL_CMD_TZ_GET_TRIP, 665 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 666 .doit = thermal_genl_cmd_doit, 667 }, 668 { 669 .cmd = THERMAL_GENL_CMD_TZ_GET_TEMP, 670 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 671 .doit = thermal_genl_cmd_doit, 672 }, 673 { 674 .cmd = THERMAL_GENL_CMD_TZ_GET_GOV, 675 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 676 .doit = thermal_genl_cmd_doit, 677 }, 678 { 679 .cmd = THERMAL_GENL_CMD_CDEV_GET, 680 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 681 .dumpit = thermal_genl_cmd_dumpit, 682 }, 683 }; 684 685 static struct genl_family thermal_gnl_family __ro_after_init = { 686 .hdrsize = 0, 687 .name = THERMAL_GENL_FAMILY_NAME, 688 .version = THERMAL_GENL_VERSION, 689 .maxattr = THERMAL_GENL_ATTR_MAX, 690 .policy = thermal_genl_policy, 691 .small_ops = thermal_genl_ops, 692 .n_small_ops = ARRAY_SIZE(thermal_genl_ops), 693 .resv_start_op = THERMAL_GENL_CMD_CDEV_GET + 1, 694 .mcgrps = thermal_genl_mcgrps, 695 .n_mcgrps = ARRAY_SIZE(thermal_genl_mcgrps), 696 }; 697 thermal_netlink_init(void)698 int __init thermal_netlink_init(void) 699 { 700 return genl_register_family(&thermal_gnl_family); 701 } 702 thermal_netlink_exit(void)703 void __init thermal_netlink_exit(void) 704 { 705 genl_unregister_family(&thermal_gnl_family); 706 } 707