Arjan van de Ven | 5c87579 | 2006-09-30 23:27:17 -0700 | [diff] [blame] | 1 | /* |
| 2 | * latency.c: Explicit system-wide latency-expectation infrastructure |
| 3 | * |
| 4 | * The purpose of this infrastructure is to allow device drivers to set |
| 5 | * latency constraint they have and to collect and summarize these |
| 6 | * expectations globally. The cummulated result can then be used by |
| 7 | * power management and similar users to make decisions that have |
| 8 | * tradoffs with a latency component. |
| 9 | * |
| 10 | * An example user of this are the x86 C-states; each higher C state saves |
| 11 | * more power, but has a higher exit latency. For the idle loop power |
| 12 | * code to make a good decision which C-state to use, information about |
| 13 | * acceptable latencies is required. |
| 14 | * |
| 15 | * An example announcer of latency is an audio driver that knowns it |
| 16 | * will get an interrupt when the hardware has 200 usec of samples |
| 17 | * left in the DMA buffer; in that case the driver can set a latency |
| 18 | * constraint of, say, 150 usec. |
| 19 | * |
| 20 | * Multiple drivers can each announce their maximum accepted latency, |
| 21 | * to keep these appart, a string based identifier is used. |
| 22 | * |
| 23 | * |
| 24 | * (C) Copyright 2006 Intel Corporation |
| 25 | * Author: Arjan van de Ven <arjan@linux.intel.com> |
| 26 | * |
| 27 | * This program is free software; you can redistribute it and/or |
| 28 | * modify it under the terms of the GNU General Public License |
| 29 | * as published by the Free Software Foundation; version 2 |
| 30 | * of the License. |
| 31 | */ |
| 32 | |
| 33 | #include <linux/latency.h> |
| 34 | #include <linux/list.h> |
| 35 | #include <linux/spinlock.h> |
| 36 | #include <linux/slab.h> |
| 37 | #include <linux/module.h> |
| 38 | #include <linux/notifier.h> |
| 39 | #include <asm/atomic.h> |
| 40 | |
| 41 | struct latency_info { |
| 42 | struct list_head list; |
| 43 | int usecs; |
| 44 | char *identifier; |
| 45 | }; |
| 46 | |
| 47 | /* |
| 48 | * locking rule: all modifications to current_max_latency and |
| 49 | * latency_list need to be done while holding the latency_lock. |
| 50 | * latency_lock needs to be taken _irqsave. |
| 51 | */ |
| 52 | static atomic_t current_max_latency; |
| 53 | static DEFINE_SPINLOCK(latency_lock); |
| 54 | |
| 55 | static LIST_HEAD(latency_list); |
| 56 | static BLOCKING_NOTIFIER_HEAD(latency_notifier); |
| 57 | |
| 58 | /* |
| 59 | * This function returns the maximum latency allowed, which |
| 60 | * happens to be the minimum of all maximum latencies on the |
| 61 | * list. |
| 62 | */ |
| 63 | static int __find_max_latency(void) |
| 64 | { |
| 65 | int min = INFINITE_LATENCY; |
| 66 | struct latency_info *info; |
| 67 | |
| 68 | list_for_each_entry(info, &latency_list, list) { |
| 69 | if (info->usecs < min) |
| 70 | min = info->usecs; |
| 71 | } |
| 72 | return min; |
| 73 | } |
| 74 | |
| 75 | /** |
| 76 | * set_acceptable_latency - sets the maximum latency acceptable |
| 77 | * @identifier: string that identifies this driver |
| 78 | * @usecs: maximum acceptable latency for this driver |
| 79 | * |
| 80 | * This function informs the kernel that this device(driver) |
| 81 | * can accept at most usecs latency. This setting is used for |
| 82 | * power management and similar tradeoffs. |
| 83 | * |
| 84 | * This function sleeps and can only be called from process |
| 85 | * context. |
| 86 | * Calling this function with an existing identifier is valid |
| 87 | * and will cause the existing latency setting to be changed. |
| 88 | */ |
| 89 | void set_acceptable_latency(char *identifier, int usecs) |
| 90 | { |
| 91 | struct latency_info *info, *iter; |
| 92 | unsigned long flags; |
| 93 | int found_old = 0; |
| 94 | |
| 95 | info = kzalloc(sizeof(struct latency_info), GFP_KERNEL); |
| 96 | if (!info) |
| 97 | return; |
| 98 | info->usecs = usecs; |
| 99 | info->identifier = kstrdup(identifier, GFP_KERNEL); |
| 100 | if (!info->identifier) |
| 101 | goto free_info; |
| 102 | |
| 103 | spin_lock_irqsave(&latency_lock, flags); |
| 104 | list_for_each_entry(iter, &latency_list, list) { |
| 105 | if (strcmp(iter->identifier, identifier)==0) { |
| 106 | found_old = 1; |
| 107 | iter->usecs = usecs; |
| 108 | break; |
| 109 | } |
| 110 | } |
| 111 | if (!found_old) |
| 112 | list_add(&info->list, &latency_list); |
| 113 | |
| 114 | if (usecs < atomic_read(¤t_max_latency)) |
| 115 | atomic_set(¤t_max_latency, usecs); |
| 116 | |
| 117 | spin_unlock_irqrestore(&latency_lock, flags); |
| 118 | |
| 119 | blocking_notifier_call_chain(&latency_notifier, |
| 120 | atomic_read(¤t_max_latency), NULL); |
| 121 | |
| 122 | /* |
| 123 | * if we inserted the new one, we're done; otherwise there was |
| 124 | * an existing one so we need to free the redundant data |
| 125 | */ |
| 126 | if (!found_old) |
| 127 | return; |
| 128 | |
| 129 | kfree(info->identifier); |
| 130 | free_info: |
| 131 | kfree(info); |
| 132 | } |
| 133 | EXPORT_SYMBOL_GPL(set_acceptable_latency); |
| 134 | |
| 135 | /** |
| 136 | * modify_acceptable_latency - changes the maximum latency acceptable |
| 137 | * @identifier: string that identifies this driver |
| 138 | * @usecs: maximum acceptable latency for this driver |
| 139 | * |
| 140 | * This function informs the kernel that this device(driver) |
| 141 | * can accept at most usecs latency. This setting is used for |
| 142 | * power management and similar tradeoffs. |
| 143 | * |
| 144 | * This function does not sleep and can be called in any context. |
| 145 | * Trying to use a non-existing identifier silently gets ignored. |
| 146 | * |
| 147 | * Due to the atomic nature of this function, the modified latency |
| 148 | * value will only be used for future decisions; past decisions |
| 149 | * can still lead to longer latencies in the near future. |
| 150 | */ |
| 151 | void modify_acceptable_latency(char *identifier, int usecs) |
| 152 | { |
| 153 | struct latency_info *iter; |
| 154 | unsigned long flags; |
| 155 | |
| 156 | spin_lock_irqsave(&latency_lock, flags); |
| 157 | list_for_each_entry(iter, &latency_list, list) { |
| 158 | if (strcmp(iter->identifier, identifier) == 0) { |
| 159 | iter->usecs = usecs; |
| 160 | break; |
| 161 | } |
| 162 | } |
| 163 | if (usecs < atomic_read(¤t_max_latency)) |
| 164 | atomic_set(¤t_max_latency, usecs); |
| 165 | spin_unlock_irqrestore(&latency_lock, flags); |
| 166 | } |
| 167 | EXPORT_SYMBOL_GPL(modify_acceptable_latency); |
| 168 | |
| 169 | /** |
| 170 | * remove_acceptable_latency - removes the maximum latency acceptable |
| 171 | * @identifier: string that identifies this driver |
| 172 | * |
| 173 | * This function removes a previously set maximum latency setting |
| 174 | * for the driver and frees up any resources associated with the |
| 175 | * bookkeeping needed for this. |
| 176 | * |
| 177 | * This function does not sleep and can be called in any context. |
| 178 | * Trying to use a non-existing identifier silently gets ignored. |
| 179 | */ |
| 180 | void remove_acceptable_latency(char *identifier) |
| 181 | { |
| 182 | unsigned long flags; |
| 183 | int newmax = 0; |
| 184 | struct latency_info *iter, *temp; |
| 185 | |
| 186 | spin_lock_irqsave(&latency_lock, flags); |
| 187 | |
| 188 | list_for_each_entry_safe(iter, temp, &latency_list, list) { |
| 189 | if (strcmp(iter->identifier, identifier) == 0) { |
| 190 | list_del(&iter->list); |
| 191 | newmax = iter->usecs; |
| 192 | kfree(iter->identifier); |
| 193 | kfree(iter); |
| 194 | break; |
| 195 | } |
| 196 | } |
| 197 | |
| 198 | /* If we just deleted the system wide value, we need to |
| 199 | * recalculate with a full search |
| 200 | */ |
| 201 | if (newmax == atomic_read(¤t_max_latency)) { |
| 202 | newmax = __find_max_latency(); |
| 203 | atomic_set(¤t_max_latency, newmax); |
| 204 | } |
| 205 | spin_unlock_irqrestore(&latency_lock, flags); |
| 206 | } |
| 207 | EXPORT_SYMBOL_GPL(remove_acceptable_latency); |
| 208 | |
| 209 | /** |
| 210 | * system_latency_constraint - queries the system wide latency maximum |
| 211 | * |
| 212 | * This function returns the system wide maximum latency in |
| 213 | * microseconds. |
| 214 | * |
| 215 | * This function does not sleep and can be called in any context. |
| 216 | */ |
| 217 | int system_latency_constraint(void) |
| 218 | { |
| 219 | return atomic_read(¤t_max_latency); |
| 220 | } |
| 221 | EXPORT_SYMBOL_GPL(system_latency_constraint); |
| 222 | |
| 223 | /** |
| 224 | * synchronize_acceptable_latency - recalculates all latency decisions |
| 225 | * |
| 226 | * This function will cause a callback to various kernel pieces that |
| 227 | * will make those pieces rethink their latency decisions. This implies |
| 228 | * that if there are overlong latencies in hardware state already, those |
| 229 | * latencies get taken right now. When this call completes no overlong |
| 230 | * latency decisions should be active anymore. |
| 231 | * |
| 232 | * Typical usecase of this is after a modify_acceptable_latency() call, |
| 233 | * which in itself is non-blocking and non-synchronizing. |
| 234 | * |
| 235 | * This function blocks and should not be called with locks held. |
| 236 | */ |
| 237 | |
| 238 | void synchronize_acceptable_latency(void) |
| 239 | { |
| 240 | blocking_notifier_call_chain(&latency_notifier, |
| 241 | atomic_read(¤t_max_latency), NULL); |
| 242 | } |
| 243 | EXPORT_SYMBOL_GPL(synchronize_acceptable_latency); |
| 244 | |
| 245 | /* |
| 246 | * Latency notifier: this notifier gets called when a non-atomic new |
| 247 | * latency value gets set. The expectation nof the caller of the |
| 248 | * non-atomic set is that when the call returns, future latencies |
| 249 | * are within bounds, so the functions on the notifier list are |
| 250 | * expected to take the overlong latencies immediately, inside the |
| 251 | * callback, and not make a overlong latency decision anymore. |
| 252 | * |
| 253 | * The callback gets called when the new latency value is made |
| 254 | * active so system_latency_constraint() returns the new latency. |
| 255 | */ |
| 256 | int register_latency_notifier(struct notifier_block * nb) |
| 257 | { |
| 258 | return blocking_notifier_chain_register(&latency_notifier, nb); |
| 259 | } |
| 260 | EXPORT_SYMBOL_GPL(register_latency_notifier); |
| 261 | |
| 262 | int unregister_latency_notifier(struct notifier_block * nb) |
| 263 | { |
| 264 | return blocking_notifier_chain_unregister(&latency_notifier, nb); |
| 265 | } |
| 266 | EXPORT_SYMBOL_GPL(unregister_latency_notifier); |
| 267 | |
| 268 | static __init int latency_init(void) |
| 269 | { |
| 270 | atomic_set(¤t_max_latency, INFINITE_LATENCY); |
| 271 | /* |
| 272 | * we don't want by default to have longer latencies than 2 ticks, |
| 273 | * since that would cause lost ticks |
| 274 | */ |
| 275 | set_acceptable_latency("kernel", 2*1000000/HZ); |
| 276 | return 0; |
| 277 | } |
| 278 | |
| 279 | module_init(latency_init); |