sysfs.c 11.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11
/*
 * sysfs.c - sysfs support
 *
 * (C) 2006-2007 Shaohua Li <shaohua.li@intel.com>
 *
 * This code is licenced under the GPL.
 */

#include <linux/kernel.h>
#include <linux/cpuidle.h>
#include <linux/sysfs.h>
12
#include <linux/slab.h>
13
#include <linux/cpu.h>
14
#include <linux/capability.h>
15 16 17 18 19 20 21 22 23 24 25

#include "cpuidle.h"

static unsigned int sysfs_switch;
static int __init cpuidle_sysfs_setup(char *unused)
{
	sysfs_switch = 1;
	return 1;
}
__setup("cpuidle_sysfs_switch", cpuidle_sysfs_setup);

26 27
static ssize_t show_available_governors(struct device *dev,
					struct device_attribute *attr,
28
					char *buf)
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
{
	ssize_t i = 0;
	struct cpuidle_governor *tmp;

	mutex_lock(&cpuidle_lock);
	list_for_each_entry(tmp, &cpuidle_governors, governor_list) {
		if (i >= (ssize_t) ((PAGE_SIZE/sizeof(char)) - CPUIDLE_NAME_LEN - 2))
			goto out;
		i += scnprintf(&buf[i], CPUIDLE_NAME_LEN, "%s ", tmp->name);
	}

out:
	i+= sprintf(&buf[i], "\n");
	mutex_unlock(&cpuidle_lock);
	return i;
}

46 47
static ssize_t show_current_driver(struct device *dev,
				   struct device_attribute *attr,
48
				   char *buf)
49 50
{
	ssize_t ret;
51
	struct cpuidle_driver *cpuidle_driver = cpuidle_get_driver();
52 53

	spin_lock(&cpuidle_driver_lock);
54 55
	if (cpuidle_driver)
		ret = sprintf(buf, "%s\n", cpuidle_driver->name);
56 57 58 59 60 61 62
	else
		ret = sprintf(buf, "none\n");
	spin_unlock(&cpuidle_driver_lock);

	return ret;
}

63 64
static ssize_t show_current_governor(struct device *dev,
				     struct device_attribute *attr,
65
				     char *buf)
66 67 68 69 70 71 72 73 74 75 76 77 78
{
	ssize_t ret;

	mutex_lock(&cpuidle_lock);
	if (cpuidle_curr_governor)
		ret = sprintf(buf, "%s\n", cpuidle_curr_governor->name);
	else
		ret = sprintf(buf, "none\n");
	mutex_unlock(&cpuidle_lock);

	return ret;
}

79 80
static ssize_t store_current_governor(struct device *dev,
				      struct device_attribute *attr,
81
				      const char *buf, size_t count)
82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
{
	char gov_name[CPUIDLE_NAME_LEN];
	int ret = -EINVAL;
	size_t len = count;
	struct cpuidle_governor *gov;

	if (!len || len >= sizeof(gov_name))
		return -EINVAL;

	memcpy(gov_name, buf, len);
	gov_name[len] = '\0';
	if (gov_name[len - 1] == '\n')
		gov_name[--len] = '\0';

	mutex_lock(&cpuidle_lock);

	list_for_each_entry(gov, &cpuidle_governors, governor_list) {
		if (strlen(gov->name) == len && !strcmp(gov->name, gov_name)) {
			ret = cpuidle_switch_governor(gov);
			break;
		}
	}

	mutex_unlock(&cpuidle_lock);

	if (ret)
		return ret;
	else
		return count;
}

113 114
static DEVICE_ATTR(current_driver, 0444, show_current_driver, NULL);
static DEVICE_ATTR(current_governor_ro, 0444, show_current_governor, NULL);
115

116 117 118
static struct attribute *cpuidle_default_attrs[] = {
	&dev_attr_current_driver.attr,
	&dev_attr_current_governor_ro.attr,
119 120 121
	NULL
};

122 123 124
static DEVICE_ATTR(available_governors, 0444, show_available_governors, NULL);
static DEVICE_ATTR(current_governor, 0644, show_current_governor,
		   store_current_governor);
125

126 127 128 129
static struct attribute *cpuidle_switch_attrs[] = {
	&dev_attr_available_governors.attr,
	&dev_attr_current_driver.attr,
	&dev_attr_current_governor.attr,
130 131 132
	NULL
};

133 134
static struct attribute_group cpuidle_attr_group = {
	.attrs = cpuidle_default_attrs,
135 136 137 138
	.name = "cpuidle",
};

/**
139
 * cpuidle_add_interface - add CPU global sysfs attributes
140
 */
141
int cpuidle_add_interface(struct device *dev)
142 143
{
	if (sysfs_switch)
144
		cpuidle_attr_group.attrs = cpuidle_switch_attrs;
145

146
	return sysfs_create_group(&dev->kobj, &cpuidle_attr_group);
147 148 149
}

/**
150
 * cpuidle_remove_interface - remove CPU global sysfs attributes
151
 */
152
void cpuidle_remove_interface(struct device *dev)
153
{
154
	sysfs_remove_group(&dev->kobj, &cpuidle_attr_group);
155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198
}

struct cpuidle_attr {
	struct attribute attr;
	ssize_t (*show)(struct cpuidle_device *, char *);
	ssize_t (*store)(struct cpuidle_device *, const char *, size_t count);
};

#define define_one_ro(_name, show) \
	static struct cpuidle_attr attr_##_name = __ATTR(_name, 0444, show, NULL)
#define define_one_rw(_name, show, store) \
	static struct cpuidle_attr attr_##_name = __ATTR(_name, 0644, show, store)

#define kobj_to_cpuidledev(k) container_of(k, struct cpuidle_device, kobj)
#define attr_to_cpuidleattr(a) container_of(a, struct cpuidle_attr, attr)
static ssize_t cpuidle_show(struct kobject * kobj, struct attribute * attr ,char * buf)
{
	int ret = -EIO;
	struct cpuidle_device *dev = kobj_to_cpuidledev(kobj);
	struct cpuidle_attr * cattr = attr_to_cpuidleattr(attr);

	if (cattr->show) {
		mutex_lock(&cpuidle_lock);
		ret = cattr->show(dev, buf);
		mutex_unlock(&cpuidle_lock);
	}
	return ret;
}

static ssize_t cpuidle_store(struct kobject * kobj, struct attribute * attr,
		     const char * buf, size_t count)
{
	int ret = -EIO;
	struct cpuidle_device *dev = kobj_to_cpuidledev(kobj);
	struct cpuidle_attr * cattr = attr_to_cpuidleattr(attr);

	if (cattr->store) {
		mutex_lock(&cpuidle_lock);
		ret = cattr->store(dev, buf, count);
		mutex_unlock(&cpuidle_lock);
	}
	return ret;
}

199
static const struct sysfs_ops cpuidle_sysfs_ops = {
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
	.show = cpuidle_show,
	.store = cpuidle_store,
};

static void cpuidle_sysfs_release(struct kobject *kobj)
{
	struct cpuidle_device *dev = kobj_to_cpuidledev(kobj);

	complete(&dev->kobj_unregister);
}

static struct kobj_type ktype_cpuidle = {
	.sysfs_ops = &cpuidle_sysfs_ops,
	.release = cpuidle_sysfs_release,
};

struct cpuidle_state_attr {
	struct attribute attr;
218 219
	ssize_t (*show)(struct cpuidle_state *, \
					struct cpuidle_state_usage *, char *);
220 221
	ssize_t (*store)(struct cpuidle_state *, \
			struct cpuidle_state_usage *, const char *, size_t);
222 223 224 225 226
};

#define define_one_state_ro(_name, show) \
static struct cpuidle_state_attr attr_##_name = __ATTR(_name, 0444, show, NULL)

227 228 229
#define define_one_state_rw(_name, show, store) \
static struct cpuidle_state_attr attr_##_name = __ATTR(_name, 0644, show, store)

230
#define define_show_state_function(_name) \
231 232
static ssize_t show_state_##_name(struct cpuidle_state *state, \
			 struct cpuidle_state_usage *state_usage, char *buf) \
233 234 235 236
{ \
	return sprintf(buf, "%u\n", state->_name);\
}

237
#define define_store_state_ull_function(_name) \
238
static ssize_t store_state_##_name(struct cpuidle_state *state, \
239
		struct cpuidle_state_usage *state_usage, \
240 241
		const char *buf, size_t size) \
{ \
242
	unsigned long long value; \
243 244 245
	int err; \
	if (!capable(CAP_SYS_ADMIN)) \
		return -EPERM; \
246
	err = kstrtoull(buf, 0, &value); \
247 248 249
	if (err) \
		return err; \
	if (value) \
250
		state_usage->_name = 1; \
251
	else \
252
		state_usage->_name = 0; \
253 254 255
	return size; \
}

256
#define define_show_state_ull_function(_name) \
257 258
static ssize_t show_state_##_name(struct cpuidle_state *state, \
			struct cpuidle_state_usage *state_usage, char *buf) \
259
{ \
260
	return sprintf(buf, "%llu\n", state_usage->_name);\
261 262
}

263
#define define_show_state_str_function(_name) \
264 265
static ssize_t show_state_##_name(struct cpuidle_state *state, \
			struct cpuidle_state_usage *state_usage, char *buf) \
266 267 268 269
{ \
	if (state->_name[0] == '\0')\
		return sprintf(buf, "<null>\n");\
	return sprintf(buf, "%s\n", state->_name);\
270 271 272 273
}

define_show_state_function(exit_latency)
define_show_state_function(power_usage)
274 275
define_show_state_ull_function(usage)
define_show_state_ull_function(time)
276 277
define_show_state_str_function(name)
define_show_state_str_function(desc)
278 279
define_show_state_ull_function(disable)
define_store_state_ull_function(disable)
280

281
define_one_state_ro(name, show_state_name);
282
define_one_state_ro(desc, show_state_desc);
283 284 285 286
define_one_state_ro(latency, show_state_exit_latency);
define_one_state_ro(power, show_state_power_usage);
define_one_state_ro(usage, show_state_usage);
define_one_state_ro(time, show_state_time);
287
define_one_state_rw(disable, show_state_disable, store_state_disable);
288 289 290

static struct attribute *cpuidle_state_default_attrs[] = {
	&attr_name.attr,
291
	&attr_desc.attr,
292 293 294 295
	&attr_latency.attr,
	&attr_power.attr,
	&attr_usage.attr,
	&attr_time.attr,
296
	&attr_disable.attr,
297 298 299 300 301
	NULL
};

#define kobj_to_state_obj(k) container_of(k, struct cpuidle_state_kobj, kobj)
#define kobj_to_state(k) (kobj_to_state_obj(k)->state)
302
#define kobj_to_state_usage(k) (kobj_to_state_obj(k)->state_usage)
303 304 305 306 307 308
#define attr_to_stateattr(a) container_of(a, struct cpuidle_state_attr, attr)
static ssize_t cpuidle_state_show(struct kobject * kobj,
	struct attribute * attr ,char * buf)
{
	int ret = -EIO;
	struct cpuidle_state *state = kobj_to_state(kobj);
309
	struct cpuidle_state_usage *state_usage = kobj_to_state_usage(kobj);
310 311 312
	struct cpuidle_state_attr * cattr = attr_to_stateattr(attr);

	if (cattr->show)
313
		ret = cattr->show(state, state_usage, buf);
314 315 316 317

	return ret;
}

318 319 320 321 322
static ssize_t cpuidle_state_store(struct kobject *kobj,
	struct attribute *attr, const char *buf, size_t size)
{
	int ret = -EIO;
	struct cpuidle_state *state = kobj_to_state(kobj);
323
	struct cpuidle_state_usage *state_usage = kobj_to_state_usage(kobj);
324 325 326
	struct cpuidle_state_attr *cattr = attr_to_stateattr(attr);

	if (cattr->store)
327
		ret = cattr->store(state, state_usage, buf, size);
328 329 330 331

	return ret;
}

332
static const struct sysfs_ops cpuidle_state_sysfs_ops = {
333
	.show = cpuidle_state_show,
334
	.store = cpuidle_state_store,
335 336 337 338 339 340 341 342 343 344 345 346 347 348 349
};

static void cpuidle_state_sysfs_release(struct kobject *kobj)
{
	struct cpuidle_state_kobj *state_obj = kobj_to_state_obj(kobj);

	complete(&state_obj->kobj_unregister);
}

static struct kobj_type ktype_state_cpuidle = {
	.sysfs_ops = &cpuidle_state_sysfs_ops,
	.default_attrs = cpuidle_state_default_attrs,
	.release = cpuidle_state_sysfs_release,
};

350
static inline void cpuidle_free_state_kobj(struct cpuidle_device *device, int i)
351
{
352
	kobject_put(&device->kobjs[i]->kobj);
353 354 355 356 357 358 359 360 361 362 363 364 365
	wait_for_completion(&device->kobjs[i]->kobj_unregister);
	kfree(device->kobjs[i]);
	device->kobjs[i] = NULL;
}

/**
 * cpuidle_add_driver_sysfs - adds driver-specific sysfs attributes
 * @device: the target device
 */
int cpuidle_add_state_sysfs(struct cpuidle_device *device)
{
	int i, ret = -ENOMEM;
	struct cpuidle_state_kobj *kobj;
366
	struct cpuidle_driver *drv = cpuidle_get_driver();
367 368 369 370 371 372

	/* state statistics */
	for (i = 0; i < device->state_count; i++) {
		kobj = kzalloc(sizeof(struct cpuidle_state_kobj), GFP_KERNEL);
		if (!kobj)
			goto error_state;
373
		kobj->state = &drv->states[i];
374
		kobj->state_usage = &device->states_usage[i];
375 376
		init_completion(&kobj->kobj_unregister);

377 378
		ret = kobject_init_and_add(&kobj->kobj, &ktype_state_cpuidle, &device->kobj,
					   "state%d", i);
379 380 381 382
		if (ret) {
			kfree(kobj);
			goto error_state;
		}
383
		kobject_uevent(&kobj->kobj, KOBJ_ADD);
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408
		device->kobjs[i] = kobj;
	}

	return 0;

error_state:
	for (i = i - 1; i >= 0; i--)
		cpuidle_free_state_kobj(device, i);
	return ret;
}

/**
 * cpuidle_remove_driver_sysfs - removes driver-specific sysfs attributes
 * @device: the target device
 */
void cpuidle_remove_state_sysfs(struct cpuidle_device *device)
{
	int i;

	for (i = 0; i < device->state_count; i++)
		cpuidle_free_state_kobj(device, i);
}

/**
 * cpuidle_add_sysfs - creates a sysfs instance for the target device
409
 * @dev: the target device
410
 */
411
int cpuidle_add_sysfs(struct device *cpu_dev)
412
{
413
	int cpu = cpu_dev->id;
414
	struct cpuidle_device *dev;
415
	int error;
416 417

	dev = per_cpu(cpuidle_devices, cpu);
418
	error = kobject_init_and_add(&dev->kobj, &ktype_cpuidle, &cpu_dev->kobj,
419 420 421 422
				     "cpuidle");
	if (!error)
		kobject_uevent(&dev->kobj, KOBJ_ADD);
	return error;
423 424 425 426
}

/**
 * cpuidle_remove_sysfs - deletes a sysfs instance on the target device
427
 * @dev: the target device
428
 */
429
void cpuidle_remove_sysfs(struct device *cpu_dev)
430
{
431
	int cpu = cpu_dev->id;
432 433 434
	struct cpuidle_device *dev;

	dev = per_cpu(cpuidle_devices, cpu);
435
	kobject_put(&dev->kobj);
436
}
新手
引导
客服 返回
顶部