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             nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TEMP, p->temp))
 126                 return -EMSGSIZE;
 127
 128         return 0;
 129 }
 130
 131 static int thermal_genl_event_tz_trip_add(struct param *p)
 132 {
 133         if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) ||
 134             nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_ID, p->trip_id) ||
 135             nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_TYPE, p->trip_type) ||
 136             nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_TEMP, p->trip_temp) ||
 137             nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_HYST, p->trip_hyst))
 138                 return -EMSGSIZE;
 139
 140         return 0;
 141 }
 142
 143 static int thermal_genl_event_tz_trip_delete(struct param *p)
 144 {
 145         if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) ||
 146             nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_ID, p->trip_id))
 147                 return -EMSGSIZE;
 148
 149         return 0;
 150 }
 151
 152 static int thermal_genl_event_cdev_add(struct param *p)
 153 {
 154         if (nla_put_string(p->msg, THERMAL_GENL_ATTR_CDEV_NAME,
 155                            p->name) ||
 156             nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_ID,
 157                         p->cdev_id) ||
 158             nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_MAX_STATE,
 159                         p->cdev_max_state))
 160                 return -EMSGSIZE;
 161
 162         return 0;
 163 }
 164
 165 static int thermal_genl_event_cdev_delete(struct param *p)
 166 {
 167         if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_ID, p->cdev_id))
 168                 return -EMSGSIZE;
 169
 170         return 0;
 171 }
 172
 173 static int thermal_genl_event_cdev_state_update(struct param *p)
 174 {
 175         if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_ID,
 176                         p->cdev_id) ||
 177             nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_CUR_STATE,
 178                         p->cdev_state))
 179                 return -EMSGSIZE;
 180
 181         return 0;
 182 }
 183
 184 static int thermal_genl_event_gov_change(struct param *p)
 185 {
 186         if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) ||
 187             nla_put_string(p->msg, THERMAL_GENL_ATTR_GOV_NAME, p->name))
 188                 return -EMSGSIZE;
 189
 190         return 0;
 191 }
 192
 193 int thermal_genl_event_tz_delete(struct param *p)
 194         __attribute__((alias("thermal_genl_event_tz")));
 195
 196 int thermal_genl_event_tz_enable(struct param *p)
 197         __attribute__((alias("thermal_genl_event_tz")));
 198
 199 int thermal_genl_event_tz_disable(struct param *p)
 200         __attribute__((alias("thermal_genl_event_tz")));
 201
 202 int thermal_genl_event_tz_trip_down(struct param *p)
 203         __attribute__((alias("thermal_genl_event_tz_trip_up")));
 204
 205 int thermal_genl_event_tz_trip_change(struct param *p)
 206         __attribute__((alias("thermal_genl_event_tz_trip_add")));
 207
 208 static cb_t event_cb[] = {
 209         [THERMAL_GENL_EVENT_TZ_CREATE]          = thermal_genl_event_tz_create,
 210         [THERMAL_GENL_EVENT_TZ_DELETE]          = thermal_genl_event_tz_delete,
 211         [THERMAL_GENL_EVENT_TZ_ENABLE]          = thermal_genl_event_tz_enable,
 212         [THERMAL_GENL_EVENT_TZ_DISABLE]         = thermal_genl_event_tz_disable,
 213         [THERMAL_GENL_EVENT_TZ_TRIP_UP]         = thermal_genl_event_tz_trip_up,
 214         [THERMAL_GENL_EVENT_TZ_TRIP_DOWN]       = thermal_genl_event_tz_trip_down,
 215         [THERMAL_GENL_EVENT_TZ_TRIP_CHANGE]     = thermal_genl_event_tz_trip_change,
 216         [THERMAL_GENL_EVENT_TZ_TRIP_ADD]        = thermal_genl_event_tz_trip_add,
 217         [THERMAL_GENL_EVENT_TZ_TRIP_DELETE]     = thermal_genl_event_tz_trip_delete,
 218         [THERMAL_GENL_EVENT_CDEV_ADD]           = thermal_genl_event_cdev_add,
 219         [THERMAL_GENL_EVENT_CDEV_DELETE]        = thermal_genl_event_cdev_delete,
 220         [THERMAL_GENL_EVENT_CDEV_STATE_UPDATE]  = thermal_genl_event_cdev_state_update,
 221         [THERMAL_GENL_EVENT_TZ_GOV_CHANGE]      = thermal_genl_event_gov_change,
 222 };
 223
 224 /*
 225  * Generic netlink event encoding
 226  */
 227 static int thermal_genl_send_event(enum thermal_genl_event event,
 228                                    struct param *p)
 229 {
 230         struct sk_buff *msg;
 231         int ret = -EMSGSIZE;
 232         void *hdr;
 233
 234         msg = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 235         if (!msg)
 236                 return -ENOMEM;
 237         p->msg = msg;
 238
 239         hdr = genlmsg_put(msg, 0, 0, &thermal_gnl_family, 0, event);
 240         if (!hdr)
 241                 goto out_free_msg;
 242
 243         ret = event_cb[event](p);
 244         if (ret)
 245                 goto out_cancel_msg;
 246
 247         genlmsg_end(msg, hdr);
 248
 249         genlmsg_multicast(&thermal_gnl_family, msg, 0, 1, GFP_KERNEL);
 250
 251         return 0;
 252
 253 out_cancel_msg:
 254         genlmsg_cancel(msg, hdr);
 255 out_free_msg:
 256         nlmsg_free(msg);
 257
 258         return ret;
 259 }
 260
 261 int thermal_notify_tz_create(int tz_id, const char *name)
 262 {
 263         struct param p = { .tz_id = tz_id, .name = name };
 264
 265         return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_CREATE, &p);
 266 }
 267
 268 int thermal_notify_tz_delete(int tz_id)
 269 {
 270         struct param p = { .tz_id = tz_id };
 271
 272         return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_DELETE, &p);
 273 }
 274
 275 int thermal_notify_tz_enable(int tz_id)
 276 {
 277         struct param p = { .tz_id = tz_id };
 278
 279         return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_ENABLE, &p);
 280 }
 281
 282 int thermal_notify_tz_disable(int tz_id)
 283 {
 284         struct param p = { .tz_id = tz_id };
 285
 286         return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_DISABLE, &p);
 287 }
 288
 289 int thermal_notify_tz_trip_down(int tz_id, int trip_id, int temp)
 290 {
 291         struct param p = { .tz_id = tz_id, .trip_id = trip_id, .temp = temp };
 292
 293         return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_DOWN, &p);
 294 }
 295
 296 int thermal_notify_tz_trip_up(int tz_id, int trip_id, int temp)
 297 {
 298         struct param p = { .tz_id = tz_id, .trip_id = trip_id, .temp = temp };
 299
 300         return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_UP, &p);
 301 }
 302
 303 int thermal_notify_tz_trip_add(int tz_id, int trip_id, int trip_type,
 304                                int trip_temp, int trip_hyst)
 305 {
 306         struct param p = { .tz_id = tz_id, .trip_id = trip_id,
 307                            .trip_type = trip_type, .trip_temp = trip_temp,
 308                            .trip_hyst = trip_hyst };
 309
 310         return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_ADD, &p);
 311 }
 312
 313 int thermal_notify_tz_trip_delete(int tz_id, int trip_id)
 314 {
 315         struct param p = { .tz_id = tz_id, .trip_id = trip_id };
 316
 317         return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_DELETE, &p);
 318 }
 319
 320 int thermal_notify_tz_trip_change(int tz_id, int trip_id, int trip_type,
 321                                   int trip_temp, int trip_hyst)
 322 {
 323         struct param p = { .tz_id = tz_id, .trip_id = trip_id,
 324                            .trip_type = trip_type, .trip_temp = trip_temp,
 325                            .trip_hyst = trip_hyst };
 326
 327         return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_CHANGE, &p);
 328 }
 329
 330 int thermal_notify_cdev_state_update(int cdev_id, int cdev_state)
 331 {
 332         struct param p = { .cdev_id = cdev_id, .cdev_state = cdev_state };
 333
 334         return thermal_genl_send_event(THERMAL_GENL_EVENT_CDEV_STATE_UPDATE, &p);
 335 }
 336
 337 int thermal_notify_cdev_add(int cdev_id, const char *name, int cdev_max_state)
 338 {
 339         struct param p = { .cdev_id = cdev_id, .name = name,
 340                            .cdev_max_state = cdev_max_state };
 341
 342         return thermal_genl_send_event(THERMAL_GENL_EVENT_CDEV_ADD, &p);
 343 }
 344
 345 int thermal_notify_cdev_delete(int cdev_id)
 346 {
 347         struct param p = { .cdev_id = cdev_id };
 348
 349         return thermal_genl_send_event(THERMAL_GENL_EVENT_CDEV_DELETE, &p);
 350 }
 351
 352 int thermal_notify_tz_gov_change(int tz_id, const char *name)
 353 {
 354         struct param p = { .tz_id = tz_id, .name = name };
 355
 356         return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_GOV_CHANGE, &p);
 357 }
 358
 359 /*************************** Command encoding ********************************/
 360
 361 static int __thermal_genl_cmd_tz_get_id(struct thermal_zone_device *tz,
 362                                         void *data)
 363 {
 364         struct sk_buff *msg = data;
 365
 366         if (nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_ID, tz->id) ||
 367             nla_put_string(msg, THERMAL_GENL_ATTR_TZ_NAME, tz->type))
 368                 return -EMSGSIZE;
 369
 370         return 0;
 371 }
 372
 373 static int thermal_genl_cmd_tz_get_id(struct param *p)
 374 {
 375         struct sk_buff *msg = p->msg;
 376         struct nlattr *start_tz;
 377         int ret;
 378
 379         start_tz = nla_nest_start(msg, THERMAL_GENL_ATTR_TZ);
 380         if (!start_tz)
 381                 return -EMSGSIZE;
 382
 383         ret = for_each_thermal_zone(__thermal_genl_cmd_tz_get_id, msg);
 384         if (ret)
 385                 goto out_cancel_nest;
 386
 387         nla_nest_end(msg, start_tz);
 388
 389         return 0;
 390
 391 out_cancel_nest:
 392         nla_nest_cancel(msg, start_tz);
 393
 394         return ret;
 395 }
 396
 397 static int thermal_genl_cmd_tz_get_trip(struct param *p)
 398 {
 399         struct sk_buff *msg = p->msg;
 400         struct thermal_zone_device *tz;
 401         struct nlattr *start_trip;
 402         int i, id;
 403
 404         if (!p->attrs[THERMAL_GENL_ATTR_TZ_ID])
 405                 return -EINVAL;
 406
 407         id = nla_get_u32(p->attrs[THERMAL_GENL_ATTR_TZ_ID]);
 408
 409         tz = thermal_zone_get_by_id(id);
 410         if (!tz)
 411                 return -EINVAL;
 412
 413         start_trip = nla_nest_start(msg, THERMAL_GENL_ATTR_TZ_TRIP);
 414         if (!start_trip)
 415                 return -EMSGSIZE;
 416
 417         mutex_lock(&tz->lock);
 418
 419         for (i = 0; i < tz->trips; i++) {
 420
 421                 enum thermal_trip_type type;
 422                 int temp, hyst;
 423
 424                 tz->ops->get_trip_type(tz, i, &type);
 425                 tz->ops->get_trip_temp(tz, i, &temp);
 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 }