LCOV - code coverage report
Current view: top level - drivers/cpuidle - sysfs.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 3 215 1.4 %
Date: 2022-04-01 14:58:12 Functions: 1 34 2.9 %
Branches: 1 64 1.6 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * sysfs.c - sysfs support
       3                 :            :  *
       4                 :            :  * (C) 2006-2007 Shaohua Li <shaohua.li@intel.com>
       5                 :            :  *
       6                 :            :  * This code is licenced under the GPL.
       7                 :            :  */
       8                 :            : 
       9                 :            : #include <linux/kernel.h>
      10                 :            : #include <linux/cpuidle.h>
      11                 :            : #include <linux/sysfs.h>
      12                 :            : #include <linux/slab.h>
      13                 :            : #include <linux/cpu.h>
      14                 :            : #include <linux/completion.h>
      15                 :            : #include <linux/capability.h>
      16                 :            : #include <linux/device.h>
      17                 :            : #include <linux/kobject.h>
      18                 :            : 
      19                 :            : #include "cpuidle.h"
      20                 :            : 
      21                 :            : static unsigned int sysfs_switch;
      22                 :          0 : static int __init cpuidle_sysfs_setup(char *unused)
      23                 :            : {
      24                 :          0 :         sysfs_switch = 1;
      25                 :          0 :         return 1;
      26                 :            : }
      27                 :            : __setup("cpuidle_sysfs_switch", cpuidle_sysfs_setup);
      28                 :            : 
      29                 :          0 : static ssize_t show_available_governors(struct device *dev,
      30                 :            :                                         struct device_attribute *attr,
      31                 :            :                                         char *buf)
      32                 :            : {
      33                 :          0 :         ssize_t i = 0;
      34                 :          0 :         struct cpuidle_governor *tmp;
      35                 :            : 
      36                 :          0 :         mutex_lock(&cpuidle_lock);
      37         [ #  # ]:          0 :         list_for_each_entry(tmp, &cpuidle_governors, governor_list) {
      38         [ #  # ]:          0 :                 if (i >= (ssize_t) ((PAGE_SIZE/sizeof(char)) -
      39                 :            :                                     CPUIDLE_NAME_LEN - 2))
      40                 :          0 :                         goto out;
      41                 :          0 :                 i += scnprintf(&buf[i], CPUIDLE_NAME_LEN, "%s ", tmp->name);
      42                 :            :         }
      43                 :            : 
      44                 :          0 : out:
      45                 :          0 :         i+= sprintf(&buf[i], "\n");
      46                 :          0 :         mutex_unlock(&cpuidle_lock);
      47                 :          0 :         return i;
      48                 :            : }
      49                 :            : 
      50                 :          0 : static ssize_t show_current_driver(struct device *dev,
      51                 :            :                                    struct device_attribute *attr,
      52                 :            :                                    char *buf)
      53                 :            : {
      54                 :          0 :         ssize_t ret;
      55                 :          0 :         struct cpuidle_driver *drv;
      56                 :            : 
      57                 :          0 :         spin_lock(&cpuidle_driver_lock);
      58                 :          0 :         drv = cpuidle_get_driver();
      59         [ #  # ]:          0 :         if (drv)
      60                 :          0 :                 ret = sprintf(buf, "%s\n", drv->name);
      61                 :            :         else
      62                 :          0 :                 ret = sprintf(buf, "none\n");
      63                 :          0 :         spin_unlock(&cpuidle_driver_lock);
      64                 :            : 
      65                 :          0 :         return ret;
      66                 :            : }
      67                 :            : 
      68                 :          0 : static ssize_t show_current_governor(struct device *dev,
      69                 :            :                                      struct device_attribute *attr,
      70                 :            :                                      char *buf)
      71                 :            : {
      72                 :          0 :         ssize_t ret;
      73                 :            : 
      74                 :          0 :         mutex_lock(&cpuidle_lock);
      75         [ #  # ]:          0 :         if (cpuidle_curr_governor)
      76                 :          0 :                 ret = sprintf(buf, "%s\n", cpuidle_curr_governor->name);
      77                 :            :         else
      78                 :          0 :                 ret = sprintf(buf, "none\n");
      79                 :          0 :         mutex_unlock(&cpuidle_lock);
      80                 :            : 
      81                 :          0 :         return ret;
      82                 :            : }
      83                 :            : 
      84                 :          0 : static ssize_t store_current_governor(struct device *dev,
      85                 :            :                                       struct device_attribute *attr,
      86                 :            :                                       const char *buf, size_t count)
      87                 :            : {
      88                 :          0 :         char gov_name[CPUIDLE_NAME_LEN];
      89                 :          0 :         int ret = -EINVAL;
      90                 :          0 :         size_t len = count;
      91                 :          0 :         struct cpuidle_governor *gov;
      92                 :            : 
      93         [ #  # ]:          0 :         if (!len || len >= sizeof(gov_name))
      94                 :            :                 return -EINVAL;
      95                 :            : 
      96                 :          0 :         memcpy(gov_name, buf, len);
      97                 :          0 :         gov_name[len] = '\0';
      98         [ #  # ]:          0 :         if (gov_name[len - 1] == '\n')
      99                 :          0 :                 gov_name[--len] = '\0';
     100                 :            : 
     101                 :          0 :         mutex_lock(&cpuidle_lock);
     102                 :            : 
     103         [ #  # ]:          0 :         list_for_each_entry(gov, &cpuidle_governors, governor_list) {
     104   [ #  #  #  # ]:          0 :                 if (strlen(gov->name) == len && !strcmp(gov->name, gov_name)) {
     105                 :          0 :                         ret = cpuidle_switch_governor(gov);
     106                 :          0 :                         break;
     107                 :            :                 }
     108                 :            :         }
     109                 :            : 
     110                 :          0 :         mutex_unlock(&cpuidle_lock);
     111                 :            : 
     112         [ #  # ]:          0 :         if (ret)
     113                 :          0 :                 return ret;
     114                 :            :         else
     115                 :          0 :                 return count;
     116                 :            : }
     117                 :            : 
     118                 :            : static DEVICE_ATTR(current_driver, 0444, show_current_driver, NULL);
     119                 :            : static DEVICE_ATTR(current_governor_ro, 0444, show_current_governor, NULL);
     120                 :            : 
     121                 :            : static struct attribute *cpuidle_default_attrs[] = {
     122                 :            :         &dev_attr_current_driver.attr,
     123                 :            :         &dev_attr_current_governor_ro.attr,
     124                 :            :         NULL
     125                 :            : };
     126                 :            : 
     127                 :            : static DEVICE_ATTR(available_governors, 0444, show_available_governors, NULL);
     128                 :            : static DEVICE_ATTR(current_governor, 0644, show_current_governor,
     129                 :            :                    store_current_governor);
     130                 :            : 
     131                 :            : static struct attribute *cpuidle_switch_attrs[] = {
     132                 :            :         &dev_attr_available_governors.attr,
     133                 :            :         &dev_attr_current_driver.attr,
     134                 :            :         &dev_attr_current_governor.attr,
     135                 :            :         NULL
     136                 :            : };
     137                 :            : 
     138                 :            : static struct attribute_group cpuidle_attr_group = {
     139                 :            :         .attrs = cpuidle_default_attrs,
     140                 :            :         .name = "cpuidle",
     141                 :            : };
     142                 :            : 
     143                 :            : /**
     144                 :            :  * cpuidle_add_interface - add CPU global sysfs attributes
     145                 :            :  * @dev: the target device
     146                 :            :  */
     147                 :          3 : int cpuidle_add_interface(struct device *dev)
     148                 :            : {
     149         [ -  + ]:          3 :         if (sysfs_switch)
     150                 :          0 :                 cpuidle_attr_group.attrs = cpuidle_switch_attrs;
     151                 :            : 
     152                 :          3 :         return sysfs_create_group(&dev->kobj, &cpuidle_attr_group);
     153                 :            : }
     154                 :            : 
     155                 :            : /**
     156                 :            :  * cpuidle_remove_interface - remove CPU global sysfs attributes
     157                 :            :  * @dev: the target device
     158                 :            :  */
     159                 :          0 : void cpuidle_remove_interface(struct device *dev)
     160                 :            : {
     161                 :          0 :         sysfs_remove_group(&dev->kobj, &cpuidle_attr_group);
     162                 :          0 : }
     163                 :            : 
     164                 :            : struct cpuidle_attr {
     165                 :            :         struct attribute attr;
     166                 :            :         ssize_t (*show)(struct cpuidle_device *, char *);
     167                 :            :         ssize_t (*store)(struct cpuidle_device *, const char *, size_t count);
     168                 :            : };
     169                 :            : 
     170                 :            : #define define_one_ro(_name, show) \
     171                 :            :         static struct cpuidle_attr attr_##_name = __ATTR(_name, 0444, show, NULL)
     172                 :            : #define define_one_rw(_name, show, store) \
     173                 :            :         static struct cpuidle_attr attr_##_name = __ATTR(_name, 0644, show, store)
     174                 :            : 
     175                 :            : #define attr_to_cpuidleattr(a) container_of(a, struct cpuidle_attr, attr)
     176                 :            : 
     177                 :            : struct cpuidle_device_kobj {
     178                 :            :         struct cpuidle_device *dev;
     179                 :            :         struct completion kobj_unregister;
     180                 :            :         struct kobject kobj;
     181                 :            : };
     182                 :            : 
     183                 :          0 : static inline struct cpuidle_device *to_cpuidle_device(struct kobject *kobj)
     184                 :            : {
     185                 :          0 :         struct cpuidle_device_kobj *kdev =
     186                 :          0 :                 container_of(kobj, struct cpuidle_device_kobj, kobj);
     187                 :            : 
     188                 :          0 :         return kdev->dev;
     189                 :            : }
     190                 :            : 
     191                 :          0 : static ssize_t cpuidle_show(struct kobject *kobj, struct attribute *attr,
     192                 :            :                             char *buf)
     193                 :            : {
     194                 :          0 :         int ret = -EIO;
     195                 :          0 :         struct cpuidle_device *dev = to_cpuidle_device(kobj);
     196                 :          0 :         struct cpuidle_attr *cattr = attr_to_cpuidleattr(attr);
     197                 :            : 
     198         [ #  # ]:          0 :         if (cattr->show) {
     199                 :          0 :                 mutex_lock(&cpuidle_lock);
     200                 :          0 :                 ret = cattr->show(dev, buf);
     201                 :          0 :                 mutex_unlock(&cpuidle_lock);
     202                 :            :         }
     203                 :          0 :         return ret;
     204                 :            : }
     205                 :            : 
     206                 :          0 : static ssize_t cpuidle_store(struct kobject *kobj, struct attribute *attr,
     207                 :            :                              const char *buf, size_t count)
     208                 :            : {
     209                 :          0 :         int ret = -EIO;
     210                 :          0 :         struct cpuidle_device *dev = to_cpuidle_device(kobj);
     211                 :          0 :         struct cpuidle_attr *cattr = attr_to_cpuidleattr(attr);
     212                 :            : 
     213         [ #  # ]:          0 :         if (cattr->store) {
     214                 :          0 :                 mutex_lock(&cpuidle_lock);
     215                 :          0 :                 ret = cattr->store(dev, buf, count);
     216                 :          0 :                 mutex_unlock(&cpuidle_lock);
     217                 :            :         }
     218                 :          0 :         return ret;
     219                 :            : }
     220                 :            : 
     221                 :            : static const struct sysfs_ops cpuidle_sysfs_ops = {
     222                 :            :         .show = cpuidle_show,
     223                 :            :         .store = cpuidle_store,
     224                 :            : };
     225                 :            : 
     226                 :          0 : static void cpuidle_sysfs_release(struct kobject *kobj)
     227                 :            : {
     228                 :          0 :         struct cpuidle_device_kobj *kdev =
     229                 :          0 :                 container_of(kobj, struct cpuidle_device_kobj, kobj);
     230                 :            : 
     231                 :          0 :         complete(&kdev->kobj_unregister);
     232                 :          0 : }
     233                 :            : 
     234                 :            : static struct kobj_type ktype_cpuidle = {
     235                 :            :         .sysfs_ops = &cpuidle_sysfs_ops,
     236                 :            :         .release = cpuidle_sysfs_release,
     237                 :            : };
     238                 :            : 
     239                 :            : struct cpuidle_state_attr {
     240                 :            :         struct attribute attr;
     241                 :            :         ssize_t (*show)(struct cpuidle_state *, \
     242                 :            :                                         struct cpuidle_state_usage *, char *);
     243                 :            :         ssize_t (*store)(struct cpuidle_state *, \
     244                 :            :                         struct cpuidle_state_usage *, const char *, size_t);
     245                 :            : };
     246                 :            : 
     247                 :            : #define define_one_state_ro(_name, show) \
     248                 :            : static struct cpuidle_state_attr attr_##_name = __ATTR(_name, 0444, show, NULL)
     249                 :            : 
     250                 :            : #define define_one_state_rw(_name, show, store) \
     251                 :            : static struct cpuidle_state_attr attr_##_name = __ATTR(_name, 0644, show, store)
     252                 :            : 
     253                 :            : #define define_show_state_function(_name) \
     254                 :            : static ssize_t show_state_##_name(struct cpuidle_state *state, \
     255                 :            :                          struct cpuidle_state_usage *state_usage, char *buf) \
     256                 :            : { \
     257                 :            :         return sprintf(buf, "%u\n", state->_name);\
     258                 :            : }
     259                 :            : 
     260                 :            : #define define_show_state_ull_function(_name) \
     261                 :            : static ssize_t show_state_##_name(struct cpuidle_state *state, \
     262                 :            :                                   struct cpuidle_state_usage *state_usage, \
     263                 :            :                                   char *buf)                            \
     264                 :            : { \
     265                 :            :         return sprintf(buf, "%llu\n", state_usage->_name);\
     266                 :            : }
     267                 :            : 
     268                 :            : #define define_show_state_str_function(_name) \
     269                 :            : static ssize_t show_state_##_name(struct cpuidle_state *state, \
     270                 :            :                                   struct cpuidle_state_usage *state_usage, \
     271                 :            :                                   char *buf)                            \
     272                 :            : { \
     273                 :            :         if (state->_name[0] == '\0')\
     274                 :            :                 return sprintf(buf, "<null>\n");\
     275                 :            :         return sprintf(buf, "%s\n", state->_name);\
     276                 :            : }
     277                 :            : 
     278                 :            : #define define_show_state_time_function(_name) \
     279                 :            : static ssize_t show_state_##_name(struct cpuidle_state *state, \
     280                 :            :                                   struct cpuidle_state_usage *state_usage, \
     281                 :            :                                   char *buf) \
     282                 :            : { \
     283                 :            :         return sprintf(buf, "%llu\n", ktime_to_us(state->_name##_ns)); \
     284                 :            : }
     285                 :            : 
     286                 :          0 : define_show_state_time_function(exit_latency)
     287                 :          0 : define_show_state_time_function(target_residency)
     288                 :          0 : define_show_state_function(power_usage)
     289                 :          0 : define_show_state_ull_function(usage)
     290         [ #  # ]:          0 : define_show_state_str_function(name)
     291         [ #  # ]:          0 : define_show_state_str_function(desc)
     292                 :          0 : define_show_state_ull_function(above)
     293                 :          0 : define_show_state_ull_function(below)
     294                 :            : 
     295                 :          0 : static ssize_t show_state_time(struct cpuidle_state *state,
     296                 :            :                                struct cpuidle_state_usage *state_usage,
     297                 :            :                                char *buf)
     298                 :            : {
     299                 :          0 :         return sprintf(buf, "%llu\n", ktime_to_us(state_usage->time_ns));
     300                 :            : }
     301                 :            : 
     302                 :          0 : static ssize_t show_state_disable(struct cpuidle_state *state,
     303                 :            :                                   struct cpuidle_state_usage *state_usage,
     304                 :            :                                   char *buf)
     305                 :            : {
     306                 :          0 :         return sprintf(buf, "%llu\n",
     307                 :          0 :                        state_usage->disable & CPUIDLE_STATE_DISABLED_BY_USER);
     308                 :            : }
     309                 :            : 
     310                 :          0 : static ssize_t store_state_disable(struct cpuidle_state *state,
     311                 :            :                                    struct cpuidle_state_usage *state_usage,
     312                 :            :                                    const char *buf, size_t size)
     313                 :            : {
     314                 :          0 :         unsigned int value;
     315                 :          0 :         int err;
     316                 :            : 
     317         [ #  # ]:          0 :         if (!capable(CAP_SYS_ADMIN))
     318                 :            :                 return -EPERM;
     319                 :            : 
     320                 :          0 :         err = kstrtouint(buf, 0, &value);
     321         [ #  # ]:          0 :         if (err)
     322                 :          0 :                 return err;
     323                 :            : 
     324         [ #  # ]:          0 :         if (value)
     325                 :          0 :                 state_usage->disable |= CPUIDLE_STATE_DISABLED_BY_USER;
     326                 :            :         else
     327                 :          0 :                 state_usage->disable &= ~CPUIDLE_STATE_DISABLED_BY_USER;
     328                 :            : 
     329                 :          0 :         return size;
     330                 :            : }
     331                 :            : 
     332                 :          0 : static ssize_t show_state_default_status(struct cpuidle_state *state,
     333                 :            :                                           struct cpuidle_state_usage *state_usage,
     334                 :            :                                           char *buf)
     335                 :            : {
     336                 :          0 :         return sprintf(buf, "%s\n",
     337         [ #  # ]:          0 :                        state->flags & CPUIDLE_FLAG_OFF ? "disabled" : "enabled");
     338                 :            : }
     339                 :            : 
     340                 :            : define_one_state_ro(name, show_state_name);
     341                 :            : define_one_state_ro(desc, show_state_desc);
     342                 :            : define_one_state_ro(latency, show_state_exit_latency);
     343                 :            : define_one_state_ro(residency, show_state_target_residency);
     344                 :            : define_one_state_ro(power, show_state_power_usage);
     345                 :            : define_one_state_ro(usage, show_state_usage);
     346                 :            : define_one_state_ro(time, show_state_time);
     347                 :            : define_one_state_rw(disable, show_state_disable, store_state_disable);
     348                 :            : define_one_state_ro(above, show_state_above);
     349                 :            : define_one_state_ro(below, show_state_below);
     350                 :            : define_one_state_ro(default_status, show_state_default_status);
     351                 :            : 
     352                 :            : static struct attribute *cpuidle_state_default_attrs[] = {
     353                 :            :         &attr_name.attr,
     354                 :            :         &attr_desc.attr,
     355                 :            :         &attr_latency.attr,
     356                 :            :         &attr_residency.attr,
     357                 :            :         &attr_power.attr,
     358                 :            :         &attr_usage.attr,
     359                 :            :         &attr_time.attr,
     360                 :            :         &attr_disable.attr,
     361                 :            :         &attr_above.attr,
     362                 :            :         &attr_below.attr,
     363                 :            :         &attr_default_status.attr,
     364                 :            :         NULL
     365                 :            : };
     366                 :            : 
     367                 :            : struct cpuidle_state_kobj {
     368                 :            :         struct cpuidle_state *state;
     369                 :            :         struct cpuidle_state_usage *state_usage;
     370                 :            :         struct completion kobj_unregister;
     371                 :            :         struct kobject kobj;
     372                 :            :         struct cpuidle_device *device;
     373                 :            : };
     374                 :            : 
     375                 :            : #ifdef CONFIG_SUSPEND
     376                 :            : #define define_show_state_s2idle_ull_function(_name) \
     377                 :            : static ssize_t show_state_s2idle_##_name(struct cpuidle_state *state, \
     378                 :            :                                          struct cpuidle_state_usage *state_usage, \
     379                 :            :                                          char *buf)                             \
     380                 :            : { \
     381                 :            :         return sprintf(buf, "%llu\n", state_usage->s2idle_##_name);\
     382                 :            : }
     383                 :            : 
     384                 :          0 : define_show_state_s2idle_ull_function(usage);
     385                 :          0 : define_show_state_s2idle_ull_function(time);
     386                 :            : 
     387                 :            : #define define_one_state_s2idle_ro(_name, show) \
     388                 :            : static struct cpuidle_state_attr attr_s2idle_##_name = \
     389                 :            :         __ATTR(_name, 0444, show, NULL)
     390                 :            : 
     391                 :            : define_one_state_s2idle_ro(usage, show_state_s2idle_usage);
     392                 :            : define_one_state_s2idle_ro(time, show_state_s2idle_time);
     393                 :            : 
     394                 :            : static struct attribute *cpuidle_state_s2idle_attrs[] = {
     395                 :            :         &attr_s2idle_usage.attr,
     396                 :            :         &attr_s2idle_time.attr,
     397                 :            :         NULL
     398                 :            : };
     399                 :            : 
     400                 :            : static const struct attribute_group cpuidle_state_s2idle_group = {
     401                 :            :         .name   = "s2idle",
     402                 :            :         .attrs  = cpuidle_state_s2idle_attrs,
     403                 :            : };
     404                 :            : 
     405                 :          0 : static void cpuidle_add_s2idle_attr_group(struct cpuidle_state_kobj *kobj)
     406                 :            : {
     407                 :          0 :         int ret;
     408                 :            : 
     409                 :          0 :         if (!kobj->state->enter_s2idle)
     410                 :            :                 return;
     411                 :            : 
     412                 :          0 :         ret = sysfs_create_group(&kobj->kobj, &cpuidle_state_s2idle_group);
     413                 :          0 :         if (ret)
     414                 :            :                 pr_debug("%s: sysfs attribute group not created\n", __func__);
     415                 :            : }
     416                 :            : 
     417                 :          0 : static void cpuidle_remove_s2idle_attr_group(struct cpuidle_state_kobj *kobj)
     418                 :            : {
     419                 :          0 :         if (kobj->state->enter_s2idle)
     420                 :          0 :                 sysfs_remove_group(&kobj->kobj, &cpuidle_state_s2idle_group);
     421                 :            : }
     422                 :            : #else
     423                 :            : static inline void cpuidle_add_s2idle_attr_group(struct cpuidle_state_kobj *kobj) { }
     424                 :            : static inline void cpuidle_remove_s2idle_attr_group(struct cpuidle_state_kobj *kobj) { }
     425                 :            : #endif /* CONFIG_SUSPEND */
     426                 :            : 
     427                 :            : #define kobj_to_state_obj(k) container_of(k, struct cpuidle_state_kobj, kobj)
     428                 :            : #define kobj_to_state(k) (kobj_to_state_obj(k)->state)
     429                 :            : #define kobj_to_state_usage(k) (kobj_to_state_obj(k)->state_usage)
     430                 :            : #define kobj_to_device(k) (kobj_to_state_obj(k)->device)
     431                 :            : #define attr_to_stateattr(a) container_of(a, struct cpuidle_state_attr, attr)
     432                 :            : 
     433                 :          0 : static ssize_t cpuidle_state_show(struct kobject *kobj, struct attribute *attr,
     434                 :            :                                   char * buf)
     435                 :            : {
     436                 :          0 :         int ret = -EIO;
     437                 :          0 :         struct cpuidle_state *state = kobj_to_state(kobj);
     438                 :          0 :         struct cpuidle_state_usage *state_usage = kobj_to_state_usage(kobj);
     439                 :          0 :         struct cpuidle_state_attr * cattr = attr_to_stateattr(attr);
     440                 :            : 
     441         [ #  # ]:          0 :         if (cattr->show)
     442                 :          0 :                 ret = cattr->show(state, state_usage, buf);
     443                 :            : 
     444                 :          0 :         return ret;
     445                 :            : }
     446                 :            : 
     447                 :          0 : static ssize_t cpuidle_state_store(struct kobject *kobj, struct attribute *attr,
     448                 :            :                                    const char *buf, size_t size)
     449                 :            : {
     450                 :          0 :         int ret = -EIO;
     451                 :          0 :         struct cpuidle_state *state = kobj_to_state(kobj);
     452                 :          0 :         struct cpuidle_state_usage *state_usage = kobj_to_state_usage(kobj);
     453                 :          0 :         struct cpuidle_state_attr *cattr = attr_to_stateattr(attr);
     454                 :          0 :         struct cpuidle_device *dev = kobj_to_device(kobj);
     455                 :            : 
     456         [ #  # ]:          0 :         if (cattr->store)
     457                 :          0 :                 ret = cattr->store(state, state_usage, buf, size);
     458                 :            : 
     459                 :            :         /* reset poll time cache */
     460                 :          0 :         dev->poll_limit_ns = 0;
     461                 :            : 
     462                 :          0 :         return ret;
     463                 :            : }
     464                 :            : 
     465                 :            : static const struct sysfs_ops cpuidle_state_sysfs_ops = {
     466                 :            :         .show = cpuidle_state_show,
     467                 :            :         .store = cpuidle_state_store,
     468                 :            : };
     469                 :            : 
     470                 :          0 : static void cpuidle_state_sysfs_release(struct kobject *kobj)
     471                 :            : {
     472                 :          0 :         struct cpuidle_state_kobj *state_obj = kobj_to_state_obj(kobj);
     473                 :            : 
     474                 :          0 :         complete(&state_obj->kobj_unregister);
     475                 :          0 : }
     476                 :            : 
     477                 :            : static struct kobj_type ktype_state_cpuidle = {
     478                 :            :         .sysfs_ops = &cpuidle_state_sysfs_ops,
     479                 :            :         .default_attrs = cpuidle_state_default_attrs,
     480                 :            :         .release = cpuidle_state_sysfs_release,
     481                 :            : };
     482                 :            : 
     483                 :          0 : static inline void cpuidle_free_state_kobj(struct cpuidle_device *device, int i)
     484                 :            : {
     485         [ #  # ]:          0 :         cpuidle_remove_s2idle_attr_group(device->kobjs[i]);
     486                 :          0 :         kobject_put(&device->kobjs[i]->kobj);
     487                 :          0 :         wait_for_completion(&device->kobjs[i]->kobj_unregister);
     488                 :          0 :         kfree(device->kobjs[i]);
     489                 :          0 :         device->kobjs[i] = NULL;
     490                 :          0 : }
     491                 :            : 
     492                 :            : /**
     493                 :            :  * cpuidle_add_state_sysfs - adds cpuidle states sysfs attributes
     494                 :            :  * @device: the target device
     495                 :            :  */
     496                 :          0 : static int cpuidle_add_state_sysfs(struct cpuidle_device *device)
     497                 :            : {
     498                 :          0 :         int i, ret = -ENOMEM;
     499                 :          0 :         struct cpuidle_state_kobj *kobj;
     500                 :          0 :         struct cpuidle_device_kobj *kdev = device->kobj_dev;
     501                 :          0 :         struct cpuidle_driver *drv = cpuidle_get_cpu_driver(device);
     502                 :            : 
     503                 :            :         /* state statistics */
     504         [ #  # ]:          0 :         for (i = 0; i < drv->state_count; i++) {
     505                 :          0 :                 kobj = kzalloc(sizeof(struct cpuidle_state_kobj), GFP_KERNEL);
     506         [ #  # ]:          0 :                 if (!kobj) {
     507                 :          0 :                         ret = -ENOMEM;
     508                 :          0 :                         goto error_state;
     509                 :            :                 }
     510                 :          0 :                 kobj->state = &drv->states[i];
     511                 :          0 :                 kobj->state_usage = &device->states_usage[i];
     512                 :          0 :                 kobj->device = device;
     513                 :          0 :                 init_completion(&kobj->kobj_unregister);
     514                 :            : 
     515                 :          0 :                 ret = kobject_init_and_add(&kobj->kobj, &ktype_state_cpuidle,
     516                 :            :                                            &kdev->kobj, "state%d", i);
     517         [ #  # ]:          0 :                 if (ret) {
     518                 :          0 :                         kfree(kobj);
     519                 :          0 :                         goto error_state;
     520                 :            :                 }
     521         [ #  # ]:          0 :                 cpuidle_add_s2idle_attr_group(kobj);
     522                 :          0 :                 kobject_uevent(&kobj->kobj, KOBJ_ADD);
     523                 :          0 :                 device->kobjs[i] = kobj;
     524                 :            :         }
     525                 :            : 
     526                 :            :         return 0;
     527                 :            : 
     528                 :          0 : error_state:
     529         [ #  # ]:          0 :         for (i = i - 1; i >= 0; i--)
     530                 :          0 :                 cpuidle_free_state_kobj(device, i);
     531                 :            :         return ret;
     532                 :            : }
     533                 :            : 
     534                 :            : /**
     535                 :            :  * cpuidle_remove_driver_sysfs - removes the cpuidle states sysfs attributes
     536                 :            :  * @device: the target device
     537                 :            :  */
     538                 :          0 : static void cpuidle_remove_state_sysfs(struct cpuidle_device *device)
     539                 :            : {
     540                 :          0 :         struct cpuidle_driver *drv = cpuidle_get_cpu_driver(device);
     541                 :          0 :         int i;
     542                 :            : 
     543         [ #  # ]:          0 :         for (i = 0; i < drv->state_count; i++)
     544                 :          0 :                 cpuidle_free_state_kobj(device, i);
     545                 :          0 : }
     546                 :            : 
     547                 :            : #ifdef CONFIG_CPU_IDLE_MULTIPLE_DRIVERS
     548                 :            : #define kobj_to_driver_kobj(k) container_of(k, struct cpuidle_driver_kobj, kobj)
     549                 :            : #define attr_to_driver_attr(a) container_of(a, struct cpuidle_driver_attr, attr)
     550                 :            : 
     551                 :            : #define define_one_driver_ro(_name, show)                       \
     552                 :            :         static struct cpuidle_driver_attr attr_driver_##_name = \
     553                 :            :                 __ATTR(_name, 0444, show, NULL)
     554                 :            : 
     555                 :            : struct cpuidle_driver_kobj {
     556                 :            :         struct cpuidle_driver *drv;
     557                 :            :         struct completion kobj_unregister;
     558                 :            :         struct kobject kobj;
     559                 :            : };
     560                 :            : 
     561                 :            : struct cpuidle_driver_attr {
     562                 :            :         struct attribute attr;
     563                 :            :         ssize_t (*show)(struct cpuidle_driver *, char *);
     564                 :            :         ssize_t (*store)(struct cpuidle_driver *, const char *, size_t);
     565                 :            : };
     566                 :            : 
     567                 :            : static ssize_t show_driver_name(struct cpuidle_driver *drv, char *buf)
     568                 :            : {
     569                 :            :         ssize_t ret;
     570                 :            : 
     571                 :            :         spin_lock(&cpuidle_driver_lock);
     572                 :            :         ret = sprintf(buf, "%s\n", drv ? drv->name : "none");
     573                 :            :         spin_unlock(&cpuidle_driver_lock);
     574                 :            : 
     575                 :            :         return ret;
     576                 :            : }
     577                 :            : 
     578                 :            : static void cpuidle_driver_sysfs_release(struct kobject *kobj)
     579                 :            : {
     580                 :            :         struct cpuidle_driver_kobj *driver_kobj = kobj_to_driver_kobj(kobj);
     581                 :            :         complete(&driver_kobj->kobj_unregister);
     582                 :            : }
     583                 :            : 
     584                 :            : static ssize_t cpuidle_driver_show(struct kobject *kobj, struct attribute *attr,
     585                 :            :                                    char *buf)
     586                 :            : {
     587                 :            :         int ret = -EIO;
     588                 :            :         struct cpuidle_driver_kobj *driver_kobj = kobj_to_driver_kobj(kobj);
     589                 :            :         struct cpuidle_driver_attr *dattr = attr_to_driver_attr(attr);
     590                 :            : 
     591                 :            :         if (dattr->show)
     592                 :            :                 ret = dattr->show(driver_kobj->drv, buf);
     593                 :            : 
     594                 :            :         return ret;
     595                 :            : }
     596                 :            : 
     597                 :            : static ssize_t cpuidle_driver_store(struct kobject *kobj, struct attribute *attr,
     598                 :            :                                     const char *buf, size_t size)
     599                 :            : {
     600                 :            :         int ret = -EIO;
     601                 :            :         struct cpuidle_driver_kobj *driver_kobj = kobj_to_driver_kobj(kobj);
     602                 :            :         struct cpuidle_driver_attr *dattr = attr_to_driver_attr(attr);
     603                 :            : 
     604                 :            :         if (dattr->store)
     605                 :            :                 ret = dattr->store(driver_kobj->drv, buf, size);
     606                 :            : 
     607                 :            :         return ret;
     608                 :            : }
     609                 :            : 
     610                 :            : define_one_driver_ro(name, show_driver_name);
     611                 :            : 
     612                 :            : static const struct sysfs_ops cpuidle_driver_sysfs_ops = {
     613                 :            :         .show = cpuidle_driver_show,
     614                 :            :         .store = cpuidle_driver_store,
     615                 :            : };
     616                 :            : 
     617                 :            : static struct attribute *cpuidle_driver_default_attrs[] = {
     618                 :            :         &attr_driver_name.attr,
     619                 :            :         NULL
     620                 :            : };
     621                 :            : 
     622                 :            : static struct kobj_type ktype_driver_cpuidle = {
     623                 :            :         .sysfs_ops = &cpuidle_driver_sysfs_ops,
     624                 :            :         .default_attrs = cpuidle_driver_default_attrs,
     625                 :            :         .release = cpuidle_driver_sysfs_release,
     626                 :            : };
     627                 :            : 
     628                 :            : /**
     629                 :            :  * cpuidle_add_driver_sysfs - adds the driver name sysfs attribute
     630                 :            :  * @dev: the target device
     631                 :            :  */
     632                 :            : static int cpuidle_add_driver_sysfs(struct cpuidle_device *dev)
     633                 :            : {
     634                 :            :         struct cpuidle_driver_kobj *kdrv;
     635                 :            :         struct cpuidle_device_kobj *kdev = dev->kobj_dev;
     636                 :            :         struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev);
     637                 :            :         int ret;
     638                 :            : 
     639                 :            :         kdrv = kzalloc(sizeof(*kdrv), GFP_KERNEL);
     640                 :            :         if (!kdrv)
     641                 :            :                 return -ENOMEM;
     642                 :            : 
     643                 :            :         kdrv->drv = drv;
     644                 :            :         init_completion(&kdrv->kobj_unregister);
     645                 :            : 
     646                 :            :         ret = kobject_init_and_add(&kdrv->kobj, &ktype_driver_cpuidle,
     647                 :            :                                    &kdev->kobj, "driver");
     648                 :            :         if (ret) {
     649                 :            :                 kfree(kdrv);
     650                 :            :                 return ret;
     651                 :            :         }
     652                 :            : 
     653                 :            :         kobject_uevent(&kdrv->kobj, KOBJ_ADD);
     654                 :            :         dev->kobj_driver = kdrv;
     655                 :            : 
     656                 :            :         return ret;
     657                 :            : }
     658                 :            : 
     659                 :            : /**
     660                 :            :  * cpuidle_remove_driver_sysfs - removes the driver name sysfs attribute
     661                 :            :  * @dev: the target device
     662                 :            :  */
     663                 :            : static void cpuidle_remove_driver_sysfs(struct cpuidle_device *dev)
     664                 :            : {
     665                 :            :         struct cpuidle_driver_kobj *kdrv = dev->kobj_driver;
     666                 :            :         kobject_put(&kdrv->kobj);
     667                 :            :         wait_for_completion(&kdrv->kobj_unregister);
     668                 :            :         kfree(kdrv);
     669                 :            : }
     670                 :            : #else
     671                 :            : static inline int cpuidle_add_driver_sysfs(struct cpuidle_device *dev)
     672                 :            : {
     673                 :            :         return 0;
     674                 :            : }
     675                 :            : 
     676                 :          0 : static inline void cpuidle_remove_driver_sysfs(struct cpuidle_device *dev)
     677                 :            : {
     678                 :          0 :         ;
     679                 :            : }
     680                 :            : #endif
     681                 :            : 
     682                 :            : /**
     683                 :            :  * cpuidle_add_device_sysfs - adds device specific sysfs attributes
     684                 :            :  * @device: the target device
     685                 :            :  */
     686                 :          0 : int cpuidle_add_device_sysfs(struct cpuidle_device *device)
     687                 :            : {
     688                 :          0 :         int ret;
     689                 :            : 
     690                 :          0 :         ret = cpuidle_add_state_sysfs(device);
     691         [ #  # ]:          0 :         if (ret)
     692                 :          0 :                 return ret;
     693                 :            : 
     694                 :            :         ret = cpuidle_add_driver_sysfs(device);
     695                 :            :         if (ret)
     696                 :            :                 cpuidle_remove_state_sysfs(device);
     697                 :            :         return ret;
     698                 :            : }
     699                 :            : 
     700                 :            : /**
     701                 :            :  * cpuidle_remove_device_sysfs : removes device specific sysfs attributes
     702                 :            :  * @device : the target device
     703                 :            :  */
     704                 :          0 : void cpuidle_remove_device_sysfs(struct cpuidle_device *device)
     705                 :            : {
     706                 :          0 :         cpuidle_remove_driver_sysfs(device);
     707                 :          0 :         cpuidle_remove_state_sysfs(device);
     708                 :          0 : }
     709                 :            : 
     710                 :            : /**
     711                 :            :  * cpuidle_add_sysfs - creates a sysfs instance for the target device
     712                 :            :  * @dev: the target device
     713                 :            :  */
     714                 :          0 : int cpuidle_add_sysfs(struct cpuidle_device *dev)
     715                 :            : {
     716                 :          0 :         struct cpuidle_device_kobj *kdev;
     717                 :          0 :         struct device *cpu_dev = get_cpu_device((unsigned long)dev->cpu);
     718                 :          0 :         int error;
     719                 :            : 
     720                 :            :         /*
     721                 :            :          * Return if cpu_device is not setup for this CPU.
     722                 :            :          *
     723                 :            :          * This could happen if the arch did not set up cpu_device
     724                 :            :          * since this CPU is not in cpu_present mask and the
     725                 :            :          * driver did not send a correct CPU mask during registration.
     726                 :            :          * Without this check we would end up passing bogus
     727                 :            :          * value for &cpu_dev->kobj in kobject_init_and_add()
     728                 :            :          */
     729         [ #  # ]:          0 :         if (!cpu_dev)
     730                 :            :                 return -ENODEV;
     731                 :            : 
     732                 :          0 :         kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
     733         [ #  # ]:          0 :         if (!kdev)
     734                 :            :                 return -ENOMEM;
     735                 :          0 :         kdev->dev = dev;
     736                 :          0 :         dev->kobj_dev = kdev;
     737                 :            : 
     738                 :          0 :         init_completion(&kdev->kobj_unregister);
     739                 :            : 
     740                 :          0 :         error = kobject_init_and_add(&kdev->kobj, &ktype_cpuidle, &cpu_dev->kobj,
     741                 :            :                                    "cpuidle");
     742         [ #  # ]:          0 :         if (error) {
     743                 :          0 :                 kfree(kdev);
     744                 :          0 :                 return error;
     745                 :            :         }
     746                 :            : 
     747                 :          0 :         kobject_uevent(&kdev->kobj, KOBJ_ADD);
     748                 :            : 
     749                 :          0 :         return 0;
     750                 :            : }
     751                 :            : 
     752                 :            : /**
     753                 :            :  * cpuidle_remove_sysfs - deletes a sysfs instance on the target device
     754                 :            :  * @dev: the target device
     755                 :            :  */
     756                 :          0 : void cpuidle_remove_sysfs(struct cpuidle_device *dev)
     757                 :            : {
     758                 :          0 :         struct cpuidle_device_kobj *kdev = dev->kobj_dev;
     759                 :            : 
     760                 :          0 :         kobject_put(&kdev->kobj);
     761                 :          0 :         wait_for_completion(&kdev->kobj_unregister);
     762                 :          0 :         kfree(kdev);
     763                 :          0 : }

Generated by: LCOV version 1.14