drivers/thermal/thermal_netlink.c

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