~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/power/qos.c

Version: ~ [ linux-5.3-rc5 ] ~ [ linux-5.2.9 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.67 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.139 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.72 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * This module exposes the interface to kernel space for specifying
  3  * QoS dependencies.  It provides infrastructure for registration of:
  4  *
  5  * Dependents on a QoS value : register requests
  6  * Watchers of QoS value : get notified when target QoS value changes
  7  *
  8  * This QoS design is best effort based.  Dependents register their QoS needs.
  9  * Watchers register to keep track of the current QoS needs of the system.
 10  *
 11  * There are 3 basic classes of QoS parameter: latency, timeout, throughput
 12  * each have defined units:
 13  * latency: usec
 14  * timeout: usec <-- currently not used.
 15  * throughput: kbs (kilo byte / sec)
 16  *
 17  * There are lists of pm_qos_objects each one wrapping requests, notifiers
 18  *
 19  * User mode requests on a QOS parameter register themselves to the
 20  * subsystem by opening the device node /dev/... and writing there request to
 21  * the node.  As long as the process holds a file handle open to the node the
 22  * client continues to be accounted for.  Upon file release the usermode
 23  * request is removed and a new qos target is computed.  This way when the
 24  * request that the application has is cleaned up when closes the file
 25  * pointer or exits the pm_qos_object will get an opportunity to clean up.
 26  *
 27  * Mark Gross <mgross@linux.intel.com>
 28  */
 29 
 30 /*#define DEBUG*/
 31 
 32 #include <linux/pm_qos.h>
 33 #include <linux/sched.h>
 34 #include <linux/spinlock.h>
 35 #include <linux/slab.h>
 36 #include <linux/time.h>
 37 #include <linux/fs.h>
 38 #include <linux/device.h>
 39 #include <linux/miscdevice.h>
 40 #include <linux/string.h>
 41 #include <linux/platform_device.h>
 42 #include <linux/init.h>
 43 #include <linux/kernel.h>
 44 
 45 #include <linux/uaccess.h>
 46 #include <linux/export.h>
 47 
 48 /*
 49  * locking rule: all changes to constraints or notifiers lists
 50  * or pm_qos_object list and pm_qos_objects need to happen with pm_qos_lock
 51  * held, taken with _irqsave.  One lock to rule them all
 52  */
 53 struct pm_qos_object {
 54         struct pm_qos_constraints *constraints;
 55         struct miscdevice pm_qos_power_miscdev;
 56         char *name;
 57 };
 58 
 59 static DEFINE_SPINLOCK(pm_qos_lock);
 60 
 61 static struct pm_qos_object null_pm_qos;
 62 
 63 static BLOCKING_NOTIFIER_HEAD(cpu_dma_lat_notifier);
 64 static struct pm_qos_constraints cpu_dma_constraints = {
 65         .list = PLIST_HEAD_INIT(cpu_dma_constraints.list),
 66         .target_value = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE,
 67         .default_value = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE,
 68         .type = PM_QOS_MIN,
 69         .notifiers = &cpu_dma_lat_notifier,
 70 };
 71 static struct pm_qos_object cpu_dma_pm_qos = {
 72         .constraints = &cpu_dma_constraints,
 73         .name = "cpu_dma_latency",
 74 };
 75 
 76 static BLOCKING_NOTIFIER_HEAD(network_lat_notifier);
 77 static struct pm_qos_constraints network_lat_constraints = {
 78         .list = PLIST_HEAD_INIT(network_lat_constraints.list),
 79         .target_value = PM_QOS_NETWORK_LAT_DEFAULT_VALUE,
 80         .default_value = PM_QOS_NETWORK_LAT_DEFAULT_VALUE,
 81         .type = PM_QOS_MIN,
 82         .notifiers = &network_lat_notifier,
 83 };
 84 static struct pm_qos_object network_lat_pm_qos = {
 85         .constraints = &network_lat_constraints,
 86         .name = "network_latency",
 87 };
 88 
 89 
 90 static BLOCKING_NOTIFIER_HEAD(network_throughput_notifier);
 91 static struct pm_qos_constraints network_tput_constraints = {
 92         .list = PLIST_HEAD_INIT(network_tput_constraints.list),
 93         .target_value = PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE,
 94         .default_value = PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE,
 95         .type = PM_QOS_MAX,
 96         .notifiers = &network_throughput_notifier,
 97 };
 98 static struct pm_qos_object network_throughput_pm_qos = {
 99         .constraints = &network_tput_constraints,
100         .name = "network_throughput",
101 };
102 
103 
104 static struct pm_qos_object *pm_qos_array[] = {
105         &null_pm_qos,
106         &cpu_dma_pm_qos,
107         &network_lat_pm_qos,
108         &network_throughput_pm_qos
109 };
110 
111 static ssize_t pm_qos_power_write(struct file *filp, const char __user *buf,
112                 size_t count, loff_t *f_pos);
113 static ssize_t pm_qos_power_read(struct file *filp, char __user *buf,
114                 size_t count, loff_t *f_pos);
115 static int pm_qos_power_open(struct inode *inode, struct file *filp);
116 static int pm_qos_power_release(struct inode *inode, struct file *filp);
117 
118 static const struct file_operations pm_qos_power_fops = {
119         .write = pm_qos_power_write,
120         .read = pm_qos_power_read,
121         .open = pm_qos_power_open,
122         .release = pm_qos_power_release,
123         .llseek = noop_llseek,
124 };
125 
126 /* unlocked internal variant */
127 static inline int pm_qos_get_value(struct pm_qos_constraints *c)
128 {
129         if (plist_head_empty(&c->list))
130                 return c->default_value;
131 
132         switch (c->type) {
133         case PM_QOS_MIN:
134                 return plist_first(&c->list)->prio;
135 
136         case PM_QOS_MAX:
137                 return plist_last(&c->list)->prio;
138 
139         default:
140                 /* runtime check for not using enum */
141                 BUG();
142         }
143 }
144 
145 s32 pm_qos_read_value(struct pm_qos_constraints *c)
146 {
147         return c->target_value;
148 }
149 
150 static inline void pm_qos_set_value(struct pm_qos_constraints *c, s32 value)
151 {
152         c->target_value = value;
153 }
154 
155 /**
156  * pm_qos_update_target - manages the constraints list and calls the notifiers
157  *  if needed
158  * @c: constraints data struct
159  * @node: request to add to the list, to update or to remove
160  * @action: action to take on the constraints list
161  * @value: value of the request to add or update
162  *
163  * This function returns 1 if the aggregated constraint value has changed, 0
164  *  otherwise.
165  */
166 int pm_qos_update_target(struct pm_qos_constraints *c, struct plist_node *node,
167                          enum pm_qos_req_action action, int value)
168 {
169         unsigned long flags;
170         int prev_value, curr_value, new_value;
171 
172         spin_lock_irqsave(&pm_qos_lock, flags);
173         prev_value = pm_qos_get_value(c);
174         if (value == PM_QOS_DEFAULT_VALUE)
175                 new_value = c->default_value;
176         else
177                 new_value = value;
178 
179         switch (action) {
180         case PM_QOS_REMOVE_REQ:
181                 plist_del(node, &c->list);
182                 break;
183         case PM_QOS_UPDATE_REQ:
184                 /*
185                  * to change the list, we atomically remove, reinit
186                  * with new value and add, then see if the extremal
187                  * changed
188                  */
189                 plist_del(node, &c->list);
190         case PM_QOS_ADD_REQ:
191                 plist_node_init(node, new_value);
192                 plist_add(node, &c->list);
193                 break;
194         default:
195                 /* no action */
196                 ;
197         }
198 
199         curr_value = pm_qos_get_value(c);
200         pm_qos_set_value(c, curr_value);
201 
202         spin_unlock_irqrestore(&pm_qos_lock, flags);
203 
204         if (prev_value != curr_value) {
205                 blocking_notifier_call_chain(c->notifiers,
206                                              (unsigned long)curr_value,
207                                              NULL);
208                 return 1;
209         } else {
210                 return 0;
211         }
212 }
213 
214 /**
215  * pm_qos_request - returns current system wide qos expectation
216  * @pm_qos_class: identification of which qos value is requested
217  *
218  * This function returns the current target value.
219  */
220 int pm_qos_request(int pm_qos_class)
221 {
222         return pm_qos_read_value(pm_qos_array[pm_qos_class]->constraints);
223 }
224 EXPORT_SYMBOL_GPL(pm_qos_request);
225 
226 int pm_qos_request_active(struct pm_qos_request *req)
227 {
228         return req->pm_qos_class != 0;
229 }
230 EXPORT_SYMBOL_GPL(pm_qos_request_active);
231 
232 /**
233  * pm_qos_work_fn - the timeout handler of pm_qos_update_request_timeout
234  * @work: work struct for the delayed work (timeout)
235  *
236  * This cancels the timeout request by falling back to the default at timeout.
237  */
238 static void pm_qos_work_fn(struct work_struct *work)
239 {
240         struct pm_qos_request *req = container_of(to_delayed_work(work),
241                                                   struct pm_qos_request,
242                                                   work);
243 
244         pm_qos_update_request(req, PM_QOS_DEFAULT_VALUE);
245 }
246 
247 /**
248  * pm_qos_add_request - inserts new qos request into the list
249  * @req: pointer to a preallocated handle
250  * @pm_qos_class: identifies which list of qos request to use
251  * @value: defines the qos request
252  *
253  * This function inserts a new entry in the pm_qos_class list of requested qos
254  * performance characteristics.  It recomputes the aggregate QoS expectations
255  * for the pm_qos_class of parameters and initializes the pm_qos_request
256  * handle.  Caller needs to save this handle for later use in updates and
257  * removal.
258  */
259 
260 void pm_qos_add_request(struct pm_qos_request *req,
261                         int pm_qos_class, s32 value)
262 {
263         if (!req) /*guard against callers passing in null */
264                 return;
265 
266         if (pm_qos_request_active(req)) {
267                 WARN(1, KERN_ERR "pm_qos_add_request() called for already added request\n");
268                 return;
269         }
270         req->pm_qos_class = pm_qos_class;
271         INIT_DELAYED_WORK(&req->work, pm_qos_work_fn);
272         pm_qos_update_target(pm_qos_array[pm_qos_class]->constraints,
273                              &req->node, PM_QOS_ADD_REQ, value);
274 }
275 EXPORT_SYMBOL_GPL(pm_qos_add_request);
276 
277 /**
278  * pm_qos_update_request - modifies an existing qos request
279  * @req : handle to list element holding a pm_qos request to use
280  * @value: defines the qos request
281  *
282  * Updates an existing qos request for the pm_qos_class of parameters along
283  * with updating the target pm_qos_class value.
284  *
285  * Attempts are made to make this code callable on hot code paths.
286  */
287 void pm_qos_update_request(struct pm_qos_request *req,
288                            s32 new_value)
289 {
290         if (!req) /*guard against callers passing in null */
291                 return;
292 
293         if (!pm_qos_request_active(req)) {
294                 WARN(1, KERN_ERR "pm_qos_update_request() called for unknown object\n");
295                 return;
296         }
297 
298         if (delayed_work_pending(&req->work))
299                 cancel_delayed_work_sync(&req->work);
300 
301         if (new_value != req->node.prio)
302                 pm_qos_update_target(
303                         pm_qos_array[req->pm_qos_class]->constraints,
304                         &req->node, PM_QOS_UPDATE_REQ, new_value);
305 }
306 EXPORT_SYMBOL_GPL(pm_qos_update_request);
307 
308 /**
309  * pm_qos_update_request_timeout - modifies an existing qos request temporarily.
310  * @req : handle to list element holding a pm_qos request to use
311  * @new_value: defines the temporal qos request
312  * @timeout_us: the effective duration of this qos request in usecs.
313  *
314  * After timeout_us, this qos request is cancelled automatically.
315  */
316 void pm_qos_update_request_timeout(struct pm_qos_request *req, s32 new_value,
317                                    unsigned long timeout_us)
318 {
319         if (!req)
320                 return;
321         if (WARN(!pm_qos_request_active(req),
322                  "%s called for unknown object.", __func__))
323                 return;
324 
325         if (delayed_work_pending(&req->work))
326                 cancel_delayed_work_sync(&req->work);
327 
328         if (new_value != req->node.prio)
329                 pm_qos_update_target(
330                         pm_qos_array[req->pm_qos_class]->constraints,
331                         &req->node, PM_QOS_UPDATE_REQ, new_value);
332 
333         schedule_delayed_work(&req->work, usecs_to_jiffies(timeout_us));
334 }
335 
336 /**
337  * pm_qos_remove_request - modifies an existing qos request
338  * @req: handle to request list element
339  *
340  * Will remove pm qos request from the list of constraints and
341  * recompute the current target value for the pm_qos_class.  Call this
342  * on slow code paths.
343  */
344 void pm_qos_remove_request(struct pm_qos_request *req)
345 {
346         if (!req) /*guard against callers passing in null */
347                 return;
348                 /* silent return to keep pcm code cleaner */
349 
350         if (!pm_qos_request_active(req)) {
351                 WARN(1, KERN_ERR "pm_qos_remove_request() called for unknown object\n");
352                 return;
353         }
354 
355         if (delayed_work_pending(&req->work))
356                 cancel_delayed_work_sync(&req->work);
357 
358         pm_qos_update_target(pm_qos_array[req->pm_qos_class]->constraints,
359                              &req->node, PM_QOS_REMOVE_REQ,
360                              PM_QOS_DEFAULT_VALUE);
361         memset(req, 0, sizeof(*req));
362 }
363 EXPORT_SYMBOL_GPL(pm_qos_remove_request);
364 
365 /**
366  * pm_qos_add_notifier - sets notification entry for changes to target value
367  * @pm_qos_class: identifies which qos target changes should be notified.
368  * @notifier: notifier block managed by caller.
369  *
370  * will register the notifier into a notification chain that gets called
371  * upon changes to the pm_qos_class target value.
372  */
373 int pm_qos_add_notifier(int pm_qos_class, struct notifier_block *notifier)
374 {
375         int retval;
376 
377         retval = blocking_notifier_chain_register(
378                         pm_qos_array[pm_qos_class]->constraints->notifiers,
379                         notifier);
380 
381         return retval;
382 }
383 EXPORT_SYMBOL_GPL(pm_qos_add_notifier);
384 
385 /**
386  * pm_qos_remove_notifier - deletes notification entry from chain.
387  * @pm_qos_class: identifies which qos target changes are notified.
388  * @notifier: notifier block to be removed.
389  *
390  * will remove the notifier from the notification chain that gets called
391  * upon changes to the pm_qos_class target value.
392  */
393 int pm_qos_remove_notifier(int pm_qos_class, struct notifier_block *notifier)
394 {
395         int retval;
396 
397         retval = blocking_notifier_chain_unregister(
398                         pm_qos_array[pm_qos_class]->constraints->notifiers,
399                         notifier);
400 
401         return retval;
402 }
403 EXPORT_SYMBOL_GPL(pm_qos_remove_notifier);
404 
405 /* User space interface to PM QoS classes via misc devices */
406 static int register_pm_qos_misc(struct pm_qos_object *qos)
407 {
408         qos->pm_qos_power_miscdev.minor = MISC_DYNAMIC_MINOR;
409         qos->pm_qos_power_miscdev.name = qos->name;
410         qos->pm_qos_power_miscdev.fops = &pm_qos_power_fops;
411 
412         return misc_register(&qos->pm_qos_power_miscdev);
413 }
414 
415 static int find_pm_qos_object_by_minor(int minor)
416 {
417         int pm_qos_class;
418 
419         for (pm_qos_class = 0;
420                 pm_qos_class < PM_QOS_NUM_CLASSES; pm_qos_class++) {
421                 if (minor ==
422                         pm_qos_array[pm_qos_class]->pm_qos_power_miscdev.minor)
423                         return pm_qos_class;
424         }
425         return -1;
426 }
427 
428 static int pm_qos_power_open(struct inode *inode, struct file *filp)
429 {
430         long pm_qos_class;
431 
432         pm_qos_class = find_pm_qos_object_by_minor(iminor(inode));
433         if (pm_qos_class >= 0) {
434                 struct pm_qos_request *req = kzalloc(sizeof(*req), GFP_KERNEL);
435                 if (!req)
436                         return -ENOMEM;
437 
438                 pm_qos_add_request(req, pm_qos_class, PM_QOS_DEFAULT_VALUE);
439                 filp->private_data = req;
440 
441                 return 0;
442         }
443         return -EPERM;
444 }
445 
446 static int pm_qos_power_release(struct inode *inode, struct file *filp)
447 {
448         struct pm_qos_request *req;
449 
450         req = filp->private_data;
451         pm_qos_remove_request(req);
452         kfree(req);
453 
454         return 0;
455 }
456 
457 
458 static ssize_t pm_qos_power_read(struct file *filp, char __user *buf,
459                 size_t count, loff_t *f_pos)
460 {
461         s32 value;
462         unsigned long flags;
463         struct pm_qos_request *req = filp->private_data;
464 
465         if (!req)
466                 return -EINVAL;
467         if (!pm_qos_request_active(req))
468                 return -EINVAL;
469 
470         spin_lock_irqsave(&pm_qos_lock, flags);
471         value = pm_qos_get_value(pm_qos_array[req->pm_qos_class]->constraints);
472         spin_unlock_irqrestore(&pm_qos_lock, flags);
473 
474         return simple_read_from_buffer(buf, count, f_pos, &value, sizeof(s32));
475 }
476 
477 static ssize_t pm_qos_power_write(struct file *filp, const char __user *buf,
478                 size_t count, loff_t *f_pos)
479 {
480         s32 value;
481         struct pm_qos_request *req;
482 
483         if (count == sizeof(s32)) {
484                 if (copy_from_user(&value, buf, sizeof(s32)))
485                         return -EFAULT;
486         } else if (count <= 11) { /* ASCII perhaps? */
487                 char ascii_value[11];
488                 unsigned long int ulval;
489                 int ret;
490 
491                 if (copy_from_user(ascii_value, buf, count))
492                         return -EFAULT;
493 
494                 if (count > 10) {
495                         if (ascii_value[10] == '\n')
496                                 ascii_value[10] = '\0';
497                         else
498                                 return -EINVAL;
499                 } else {
500                         ascii_value[count] = '\0';
501                 }
502                 ret = strict_strtoul(ascii_value, 16, &ulval);
503                 if (ret) {
504                         pr_debug("%s, 0x%lx, 0x%x\n", ascii_value, ulval, ret);
505                         return -EINVAL;
506                 }
507                 value = (s32)lower_32_bits(ulval);
508         } else {
509                 return -EINVAL;
510         }
511 
512         req = filp->private_data;
513         pm_qos_update_request(req, value);
514 
515         return count;
516 }
517 
518 
519 static int __init pm_qos_power_init(void)
520 {
521         int ret = 0;
522         int i;
523 
524         BUILD_BUG_ON(ARRAY_SIZE(pm_qos_array) != PM_QOS_NUM_CLASSES);
525 
526         for (i = 1; i < PM_QOS_NUM_CLASSES; i++) {
527                 ret = register_pm_qos_misc(pm_qos_array[i]);
528                 if (ret < 0) {
529                         printk(KERN_ERR "pm_qos_param: %s setup failed\n",
530                                pm_qos_array[i]->name);
531                         return ret;
532                 }
533         }
534 
535         return ret;
536 }
537 
538 late_initcall(pm_qos_power_init);
539 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp