Russell King | 112f38a4 | 2010-12-15 19:23:07 +0000 | [diff] [blame] | 1 | /* |
| 2 | * sched_clock.c: support for extending counters to full 64-bit ns counter |
| 3 | * |
| 4 | * This program is free software; you can redistribute it and/or modify |
| 5 | * it under the terms of the GNU General Public License version 2 as |
| 6 | * published by the Free Software Foundation. |
| 7 | */ |
| 8 | #include <linux/clocksource.h> |
| 9 | #include <linux/init.h> |
| 10 | #include <linux/jiffies.h> |
Stephen Boyd | a08ca5d | 2013-07-18 16:21:16 -0700 | [diff] [blame] | 11 | #include <linux/ktime.h> |
Russell King | 112f38a4 | 2010-12-15 19:23:07 +0000 | [diff] [blame] | 12 | #include <linux/kernel.h> |
Russell King | a42c362 | 2012-09-09 18:39:28 +0100 | [diff] [blame] | 13 | #include <linux/moduleparam.h> |
Russell King | 112f38a4 | 2010-12-15 19:23:07 +0000 | [diff] [blame] | 14 | #include <linux/sched.h> |
Russell King | f153d01 | 2012-02-04 12:31:27 +0000 | [diff] [blame] | 15 | #include <linux/syscore_ops.h> |
Stephen Boyd | a08ca5d | 2013-07-18 16:21:16 -0700 | [diff] [blame] | 16 | #include <linux/hrtimer.h> |
Stephen Boyd | 38ff87f | 2013-06-01 23:39:40 -0700 | [diff] [blame] | 17 | #include <linux/sched_clock.h> |
Stephen Boyd | 85c3d2d | 2013-07-18 16:21:15 -0700 | [diff] [blame] | 18 | #include <linux/seqlock.h> |
Stephen Boyd | e7e3ff1 | 2013-07-18 16:21:17 -0700 | [diff] [blame] | 19 | #include <linux/bitops.h> |
Russell King | 112f38a4 | 2010-12-15 19:23:07 +0000 | [diff] [blame] | 20 | |
Daniel Thompson | cf7c9c1 | 2015-03-26 12:23:23 -0700 | [diff] [blame] | 21 | /** |
| 22 | * struct clock_read_data - data required to read from sched_clock |
| 23 | * |
| 24 | * @epoch_ns: sched_clock value at last update |
| 25 | * @epoch_cyc: Clock cycle value at last update |
| 26 | * @sched_clock_mask: Bitmask for two's complement subtraction of non 64bit |
| 27 | * clocks |
| 28 | * @read_sched_clock: Current clock source (or dummy source when suspended) |
| 29 | * @mult: Multipler for scaled math conversion |
| 30 | * @shift: Shift value for scaled math conversion |
Daniel Thompson | cf7c9c1 | 2015-03-26 12:23:23 -0700 | [diff] [blame] | 31 | * |
| 32 | * Care must be taken when updating this structure; it is read by |
Daniel Thompson | 13dbeb3 | 2015-03-26 12:23:24 -0700 | [diff] [blame] | 33 | * some very hot code paths. It occupies <=40 bytes and, when combined |
Daniel Thompson | cf7c9c1 | 2015-03-26 12:23:23 -0700 | [diff] [blame] | 34 | * with the seqcount used to synchronize access, comfortably fits into |
| 35 | * a 64 byte cache line. |
| 36 | */ |
| 37 | struct clock_read_data { |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 38 | u64 epoch_ns; |
Stephen Boyd | e7e3ff1 | 2013-07-18 16:21:17 -0700 | [diff] [blame] | 39 | u64 epoch_cyc; |
Daniel Thompson | cf7c9c1 | 2015-03-26 12:23:23 -0700 | [diff] [blame] | 40 | u64 sched_clock_mask; |
| 41 | u64 (*read_sched_clock)(void); |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 42 | u32 mult; |
| 43 | u32 shift; |
| 44 | }; |
| 45 | |
Daniel Thompson | cf7c9c1 | 2015-03-26 12:23:23 -0700 | [diff] [blame] | 46 | /** |
| 47 | * struct clock_data - all data needed for sched_clock (including |
| 48 | * registration of a new clock source) |
| 49 | * |
| 50 | * @seq: Sequence counter for protecting updates. |
| 51 | * @read_data: Data required to read from sched_clock. |
| 52 | * @wrap_kt: Duration for which clock can run before wrapping |
| 53 | * @rate: Tick rate of the registered clock |
| 54 | * @actual_read_sched_clock: Registered clock read function |
| 55 | * |
| 56 | * The ordering of this structure has been chosen to optimize cache |
| 57 | * performance. In particular seq and read_data (combined) should fit |
| 58 | * into a single 64 byte cache line. |
| 59 | */ |
| 60 | struct clock_data { |
| 61 | seqcount_t seq; |
| 62 | struct clock_read_data read_data; |
| 63 | ktime_t wrap_kt; |
| 64 | unsigned long rate; |
Daniel Thompson | 13dbeb3 | 2015-03-26 12:23:24 -0700 | [diff] [blame] | 65 | u64 (*actual_read_sched_clock)(void); |
Daniel Thompson | cf7c9c1 | 2015-03-26 12:23:23 -0700 | [diff] [blame] | 66 | }; |
| 67 | |
Stephen Boyd | a08ca5d | 2013-07-18 16:21:16 -0700 | [diff] [blame] | 68 | static struct hrtimer sched_clock_timer; |
Russell King | a42c362 | 2012-09-09 18:39:28 +0100 | [diff] [blame] | 69 | static int irqtime = -1; |
| 70 | |
| 71 | core_param(irqtime, irqtime, int, 0400); |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 72 | |
Stephen Boyd | e7e3ff1 | 2013-07-18 16:21:17 -0700 | [diff] [blame] | 73 | static u64 notrace jiffy_sched_clock_read(void) |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 74 | { |
Stephen Boyd | e7e3ff1 | 2013-07-18 16:21:17 -0700 | [diff] [blame] | 75 | /* |
| 76 | * We don't need to use get_jiffies_64 on 32-bit arches here |
| 77 | * because we register with BITS_PER_LONG |
| 78 | */ |
| 79 | return (u64)(jiffies - INITIAL_JIFFIES); |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 80 | } |
| 81 | |
Daniel Thompson | cf7c9c1 | 2015-03-26 12:23:23 -0700 | [diff] [blame] | 82 | static struct clock_data cd ____cacheline_aligned = { |
| 83 | .read_data = { .mult = NSEC_PER_SEC / HZ, |
| 84 | .read_sched_clock = jiffy_sched_clock_read, }, |
Daniel Thompson | 13dbeb3 | 2015-03-26 12:23:24 -0700 | [diff] [blame] | 85 | .actual_read_sched_clock = jiffy_sched_clock_read, |
| 86 | |
Daniel Thompson | cf7c9c1 | 2015-03-26 12:23:23 -0700 | [diff] [blame] | 87 | }; |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 88 | |
Stephen Boyd | cea1509 | 2013-04-18 17:33:40 +0100 | [diff] [blame] | 89 | static inline u64 notrace cyc_to_ns(u64 cyc, u32 mult, u32 shift) |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 90 | { |
| 91 | return (cyc * mult) >> shift; |
| 92 | } |
| 93 | |
Stephen Boyd | b4042ce | 2013-07-18 16:21:19 -0700 | [diff] [blame] | 94 | unsigned long long notrace sched_clock(void) |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 95 | { |
Daniel Thompson | 8710e91 | 2015-03-26 12:23:22 -0700 | [diff] [blame] | 96 | u64 cyc, res; |
Stephen Boyd | 85c3d2d | 2013-07-18 16:21:15 -0700 | [diff] [blame] | 97 | unsigned long seq; |
Daniel Thompson | cf7c9c1 | 2015-03-26 12:23:23 -0700 | [diff] [blame] | 98 | struct clock_read_data *rd = &cd.read_data; |
Stephen Boyd | 336ae11 | 2013-06-17 15:40:58 -0700 | [diff] [blame] | 99 | |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 100 | do { |
John Stultz | 7a06c41 | 2014-01-02 15:11:14 -0800 | [diff] [blame] | 101 | seq = raw_read_seqcount_begin(&cd.seq); |
Daniel Thompson | 8710e91 | 2015-03-26 12:23:22 -0700 | [diff] [blame] | 102 | |
Daniel Thompson | 13dbeb3 | 2015-03-26 12:23:24 -0700 | [diff] [blame] | 103 | cyc = (rd->read_sched_clock() - rd->epoch_cyc) & |
| 104 | rd->sched_clock_mask; |
| 105 | res = rd->epoch_ns + cyc_to_ns(cyc, rd->mult, rd->shift); |
Stephen Boyd | 85c3d2d | 2013-07-18 16:21:15 -0700 | [diff] [blame] | 106 | } while (read_seqcount_retry(&cd.seq, seq)); |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 107 | |
Daniel Thompson | 8710e91 | 2015-03-26 12:23:22 -0700 | [diff] [blame] | 108 | return res; |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 109 | } |
| 110 | |
| 111 | /* |
| 112 | * Atomically update the sched_clock epoch. |
| 113 | */ |
Daniel Thompson | 9fee69a | 2015-03-26 12:23:25 -0700 | [diff] [blame^] | 114 | static void update_sched_clock(void) |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 115 | { |
| 116 | unsigned long flags; |
Stephen Boyd | e7e3ff1 | 2013-07-18 16:21:17 -0700 | [diff] [blame] | 117 | u64 cyc; |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 118 | u64 ns; |
Daniel Thompson | cf7c9c1 | 2015-03-26 12:23:23 -0700 | [diff] [blame] | 119 | struct clock_read_data *rd = &cd.read_data; |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 120 | |
Daniel Thompson | 13dbeb3 | 2015-03-26 12:23:24 -0700 | [diff] [blame] | 121 | cyc = cd.actual_read_sched_clock(); |
Daniel Thompson | cf7c9c1 | 2015-03-26 12:23:23 -0700 | [diff] [blame] | 122 | ns = rd->epoch_ns + |
| 123 | cyc_to_ns((cyc - rd->epoch_cyc) & rd->sched_clock_mask, |
| 124 | rd->mult, rd->shift); |
Stephen Boyd | 85c3d2d | 2013-07-18 16:21:15 -0700 | [diff] [blame] | 125 | |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 126 | raw_local_irq_save(flags); |
John Stultz | 7a06c41 | 2014-01-02 15:11:14 -0800 | [diff] [blame] | 127 | raw_write_seqcount_begin(&cd.seq); |
Daniel Thompson | cf7c9c1 | 2015-03-26 12:23:23 -0700 | [diff] [blame] | 128 | rd->epoch_ns = ns; |
| 129 | rd->epoch_cyc = cyc; |
John Stultz | 7a06c41 | 2014-01-02 15:11:14 -0800 | [diff] [blame] | 130 | raw_write_seqcount_end(&cd.seq); |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 131 | raw_local_irq_restore(flags); |
| 132 | } |
Russell King | 112f38a4 | 2010-12-15 19:23:07 +0000 | [diff] [blame] | 133 | |
Stephen Boyd | a08ca5d | 2013-07-18 16:21:16 -0700 | [diff] [blame] | 134 | static enum hrtimer_restart sched_clock_poll(struct hrtimer *hrt) |
Russell King | 112f38a4 | 2010-12-15 19:23:07 +0000 | [diff] [blame] | 135 | { |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 136 | update_sched_clock(); |
Stephen Boyd | a08ca5d | 2013-07-18 16:21:16 -0700 | [diff] [blame] | 137 | hrtimer_forward_now(hrt, cd.wrap_kt); |
| 138 | return HRTIMER_RESTART; |
Russell King | 112f38a4 | 2010-12-15 19:23:07 +0000 | [diff] [blame] | 139 | } |
| 140 | |
Stephen Boyd | e7e3ff1 | 2013-07-18 16:21:17 -0700 | [diff] [blame] | 141 | void __init sched_clock_register(u64 (*read)(void), int bits, |
| 142 | unsigned long rate) |
Russell King | 112f38a4 | 2010-12-15 19:23:07 +0000 | [diff] [blame] | 143 | { |
Stephen Boyd | 5ae8aab | 2014-02-17 10:45:36 -0800 | [diff] [blame] | 144 | u64 res, wrap, new_mask, new_epoch, cyc, ns; |
| 145 | u32 new_mult, new_shift; |
Stephen Boyd | a08ca5d | 2013-07-18 16:21:16 -0700 | [diff] [blame] | 146 | unsigned long r; |
Russell King | 112f38a4 | 2010-12-15 19:23:07 +0000 | [diff] [blame] | 147 | char r_unit; |
Daniel Thompson | cf7c9c1 | 2015-03-26 12:23:23 -0700 | [diff] [blame] | 148 | struct clock_read_data *rd = &cd.read_data; |
Russell King | 112f38a4 | 2010-12-15 19:23:07 +0000 | [diff] [blame] | 149 | |
Rob Herring | c115739 | 2013-02-08 16:14:59 -0600 | [diff] [blame] | 150 | if (cd.rate > rate) |
| 151 | return; |
| 152 | |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 153 | WARN_ON(!irqs_disabled()); |
Russell King | 112f38a4 | 2010-12-15 19:23:07 +0000 | [diff] [blame] | 154 | |
| 155 | /* calculate the mult/shift to convert counter ticks to ns. */ |
Stephen Boyd | 5ae8aab | 2014-02-17 10:45:36 -0800 | [diff] [blame] | 156 | clocks_calc_mult_shift(&new_mult, &new_shift, rate, NSEC_PER_SEC, 3600); |
| 157 | |
| 158 | new_mask = CLOCKSOURCE_MASK(bits); |
Daniel Thompson | 8710e91 | 2015-03-26 12:23:22 -0700 | [diff] [blame] | 159 | cd.rate = rate; |
Stephen Boyd | 5ae8aab | 2014-02-17 10:45:36 -0800 | [diff] [blame] | 160 | |
John Stultz | 362fde0 | 2015-03-11 21:16:30 -0700 | [diff] [blame] | 161 | /* calculate how many nanosecs until we risk wrapping */ |
John Stultz | fb82fe2 | 2015-03-11 21:16:31 -0700 | [diff] [blame] | 162 | wrap = clocks_calc_max_nsecs(new_mult, new_shift, 0, new_mask, NULL); |
Daniel Thompson | 8710e91 | 2015-03-26 12:23:22 -0700 | [diff] [blame] | 163 | cd.wrap_kt = ns_to_ktime(wrap); |
Stephen Boyd | 5ae8aab | 2014-02-17 10:45:36 -0800 | [diff] [blame] | 164 | |
| 165 | /* update epoch for new counter and update epoch_ns from old counter*/ |
| 166 | new_epoch = read(); |
Daniel Thompson | 13dbeb3 | 2015-03-26 12:23:24 -0700 | [diff] [blame] | 167 | cyc = cd.actual_read_sched_clock(); |
Daniel Thompson | cf7c9c1 | 2015-03-26 12:23:23 -0700 | [diff] [blame] | 168 | ns = rd->epoch_ns + |
| 169 | cyc_to_ns((cyc - rd->epoch_cyc) & rd->sched_clock_mask, |
| 170 | rd->mult, rd->shift); |
Daniel Thompson | 13dbeb3 | 2015-03-26 12:23:24 -0700 | [diff] [blame] | 171 | cd.actual_read_sched_clock = read; |
Stephen Boyd | 5ae8aab | 2014-02-17 10:45:36 -0800 | [diff] [blame] | 172 | |
| 173 | raw_write_seqcount_begin(&cd.seq); |
Daniel Thompson | cf7c9c1 | 2015-03-26 12:23:23 -0700 | [diff] [blame] | 174 | rd->read_sched_clock = read; |
| 175 | rd->sched_clock_mask = new_mask; |
| 176 | rd->mult = new_mult; |
| 177 | rd->shift = new_shift; |
| 178 | rd->epoch_cyc = new_epoch; |
| 179 | rd->epoch_ns = ns; |
Stephen Boyd | 5ae8aab | 2014-02-17 10:45:36 -0800 | [diff] [blame] | 180 | raw_write_seqcount_end(&cd.seq); |
Russell King | 112f38a4 | 2010-12-15 19:23:07 +0000 | [diff] [blame] | 181 | |
| 182 | r = rate; |
| 183 | if (r >= 4000000) { |
| 184 | r /= 1000000; |
| 185 | r_unit = 'M'; |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 186 | } else if (r >= 1000) { |
Russell King | 112f38a4 | 2010-12-15 19:23:07 +0000 | [diff] [blame] | 187 | r /= 1000; |
| 188 | r_unit = 'k'; |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 189 | } else |
| 190 | r_unit = ' '; |
Russell King | 112f38a4 | 2010-12-15 19:23:07 +0000 | [diff] [blame] | 191 | |
Russell King | 112f38a4 | 2010-12-15 19:23:07 +0000 | [diff] [blame] | 192 | /* calculate the ns resolution of this counter */ |
Stephen Boyd | 5ae8aab | 2014-02-17 10:45:36 -0800 | [diff] [blame] | 193 | res = cyc_to_ns(1ULL, new_mult, new_shift); |
| 194 | |
Stephen Boyd | a08ca5d | 2013-07-18 16:21:16 -0700 | [diff] [blame] | 195 | pr_info("sched_clock: %u bits at %lu%cHz, resolution %lluns, wraps every %lluns\n", |
| 196 | bits, r, r_unit, res, wrap); |
Russell King | 112f38a4 | 2010-12-15 19:23:07 +0000 | [diff] [blame] | 197 | |
Russell King | a42c362 | 2012-09-09 18:39:28 +0100 | [diff] [blame] | 198 | /* Enable IRQ time accounting if we have a fast enough sched_clock */ |
| 199 | if (irqtime > 0 || (irqtime == -1 && rate >= 1000000)) |
| 200 | enable_sched_clock_irqtime(); |
| 201 | |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 202 | pr_debug("Registered %pF as sched_clock source\n", read); |
| 203 | } |
| 204 | |
Russell King | 211baa70 | 2011-01-11 16:23:04 +0000 | [diff] [blame] | 205 | void __init sched_clock_postinit(void) |
| 206 | { |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 207 | /* |
| 208 | * If no sched_clock function has been provided at that point, |
| 209 | * make it the final one one. |
| 210 | */ |
Daniel Thompson | 13dbeb3 | 2015-03-26 12:23:24 -0700 | [diff] [blame] | 211 | if (cd.actual_read_sched_clock == jiffy_sched_clock_read) |
Stephen Boyd | e7e3ff1 | 2013-07-18 16:21:17 -0700 | [diff] [blame] | 212 | sched_clock_register(jiffy_sched_clock_read, BITS_PER_LONG, HZ); |
Marc Zyngier | 2f0778af | 2011-12-15 12:19:23 +0100 | [diff] [blame] | 213 | |
Stephen Boyd | a08ca5d | 2013-07-18 16:21:16 -0700 | [diff] [blame] | 214 | update_sched_clock(); |
| 215 | |
| 216 | /* |
| 217 | * Start the timer to keep sched_clock() properly updated and |
| 218 | * sets the initial epoch. |
| 219 | */ |
| 220 | hrtimer_init(&sched_clock_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); |
| 221 | sched_clock_timer.function = sched_clock_poll; |
| 222 | hrtimer_start(&sched_clock_timer, cd.wrap_kt, HRTIMER_MODE_REL); |
Russell King | 211baa70 | 2011-01-11 16:23:04 +0000 | [diff] [blame] | 223 | } |
Russell King | f153d01 | 2012-02-04 12:31:27 +0000 | [diff] [blame] | 224 | |
Daniel Thompson | 13dbeb3 | 2015-03-26 12:23:24 -0700 | [diff] [blame] | 225 | /* |
| 226 | * Clock read function for use when the clock is suspended. |
| 227 | * |
| 228 | * This function makes it appear to sched_clock() as if the clock |
| 229 | * stopped counting at its last update. |
| 230 | */ |
| 231 | static u64 notrace suspended_sched_clock_read(void) |
| 232 | { |
| 233 | return cd.read_data.epoch_cyc; |
| 234 | } |
| 235 | |
Russell King | f153d01 | 2012-02-04 12:31:27 +0000 | [diff] [blame] | 236 | static int sched_clock_suspend(void) |
| 237 | { |
Daniel Thompson | cf7c9c1 | 2015-03-26 12:23:23 -0700 | [diff] [blame] | 238 | struct clock_read_data *rd = &cd.read_data; |
| 239 | |
Stephen Boyd | f723aa1 | 2014-07-23 21:03:50 -0700 | [diff] [blame] | 240 | update_sched_clock(); |
| 241 | hrtimer_cancel(&sched_clock_timer); |
Daniel Thompson | 13dbeb3 | 2015-03-26 12:23:24 -0700 | [diff] [blame] | 242 | rd->read_sched_clock = suspended_sched_clock_read; |
Russell King | f153d01 | 2012-02-04 12:31:27 +0000 | [diff] [blame] | 243 | return 0; |
| 244 | } |
| 245 | |
Colin Cross | 237ec6f | 2012-08-07 19:05:10 +0100 | [diff] [blame] | 246 | static void sched_clock_resume(void) |
| 247 | { |
Daniel Thompson | cf7c9c1 | 2015-03-26 12:23:23 -0700 | [diff] [blame] | 248 | struct clock_read_data *rd = &cd.read_data; |
| 249 | |
Daniel Thompson | 13dbeb3 | 2015-03-26 12:23:24 -0700 | [diff] [blame] | 250 | rd->epoch_cyc = cd.actual_read_sched_clock(); |
Stephen Boyd | f723aa1 | 2014-07-23 21:03:50 -0700 | [diff] [blame] | 251 | hrtimer_start(&sched_clock_timer, cd.wrap_kt, HRTIMER_MODE_REL); |
Daniel Thompson | 13dbeb3 | 2015-03-26 12:23:24 -0700 | [diff] [blame] | 252 | rd->read_sched_clock = cd.actual_read_sched_clock; |
Colin Cross | 237ec6f | 2012-08-07 19:05:10 +0100 | [diff] [blame] | 253 | } |
| 254 | |
Russell King | f153d01 | 2012-02-04 12:31:27 +0000 | [diff] [blame] | 255 | static struct syscore_ops sched_clock_ops = { |
| 256 | .suspend = sched_clock_suspend, |
Colin Cross | 237ec6f | 2012-08-07 19:05:10 +0100 | [diff] [blame] | 257 | .resume = sched_clock_resume, |
Russell King | f153d01 | 2012-02-04 12:31:27 +0000 | [diff] [blame] | 258 | }; |
| 259 | |
| 260 | static int __init sched_clock_syscore_init(void) |
| 261 | { |
| 262 | register_syscore_ops(&sched_clock_ops); |
| 263 | return 0; |
| 264 | } |
| 265 | device_initcall(sched_clock_syscore_init); |