]>
Commit | Line | Data |
---|---|---|
5c87579e AV |
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); |