1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright 2019 ARM Ltd. 4 * 5 * Generic implementation of update_vsyscall and update_vsyscall_tz. 6 * 7 * Based on the x86 specific implementation. 8 */ 9 10 #include <linux/hrtimer.h> 11 #include <linux/timekeeper_internal.h> 12 #include <linux/vdso_time.h> 13 #include <vdso/datapage.h> 14 #include <vdso/helpers.h> 15 #include <vdso/vsyscall.h> 16 17 #include "timekeeping_internal.h" 18 19 #ifndef __arch_update_vdso_clock 20 static __always_inline void __arch_update_vdso_clock(struct vdso_clock *vc) 21 { 22 } 23 #endif /* __arch_update_vdso_clock */ 24 25 #ifndef __arch_sync_vdso_time_data 26 static __always_inline void __arch_sync_vdso_time_data(struct vdso_time_data *vdata) 27 { 28 } 29 #endif /* __arch_sync_vdso_time_data */ 30 31 static inline void fill_clock_configuration(struct vdso_clock *vc, const struct tk_read_base *base) 32 { 33 vc->cycle_last = base->cycle_last; 34 #ifdef CONFIG_GENERIC_VDSO_OVERFLOW_PROTECT 35 vc->max_cycles = base->clock->max_cycles; 36 #endif 37 vc->mask = base->mask; 38 vc->mult = base->mult; 39 vc->shift = base->shift; 40 } 41 42 static inline void update_vdso_time_data(struct vdso_time_data *vdata, struct timekeeper *tk) 43 { 44 struct vdso_clock *vc = vdata->clock_data; 45 struct vdso_timestamp *vdso_ts; 46 u64 nsec, sec; 47 48 fill_clock_configuration(&vc[CS_HRES_COARSE], &tk->tkr_mono); 49 fill_clock_configuration(&vc[CS_RAW], &tk->tkr_raw); 50 51 /* CLOCK_MONOTONIC */ 52 vdso_ts = &vc[CS_HRES_COARSE].basetime[CLOCK_MONOTONIC]; 53 vdso_ts->sec = tk->xtime_sec + tk->wall_to_monotonic.tv_sec; 54 55 nsec = tk->tkr_mono.xtime_nsec; 56 nsec += ((u64)tk->wall_to_monotonic.tv_nsec << tk->tkr_mono.shift); 57 vdso_ts->sec += __iter_div64_u64_rem(nsec, (u64)NSEC_PER_SEC << tk->tkr_mono.shift, 58 &vdso_ts->nsec); 59 60 /* Copy MONOTONIC time for BOOTTIME */ 61 sec = vdso_ts->sec; 62 nsec = vdso_ts->nsec; 63 /* Add the boot offset */ 64 sec += tk->monotonic_to_boot.tv_sec; 65 nsec += (u64)tk->monotonic_to_boot.tv_nsec << tk->tkr_mono.shift; 66 67 /* CLOCK_BOOTTIME */ 68 vdso_ts = &vc[CS_HRES_COARSE].basetime[CLOCK_BOOTTIME]; 69 vdso_ts->sec = sec; 70 vdso_ts->sec += __iter_div64_u64_rem(nsec, (u64)NSEC_PER_SEC << tk->tkr_mono.shift, 71 &vdso_ts->nsec); 72 73 /* CLOCK_MONOTONIC_RAW */ 74 vdso_ts = &vc[CS_RAW].basetime[CLOCK_MONOTONIC_RAW]; 75 vdso_ts->sec = tk->raw_sec; 76 vdso_ts->nsec = tk->tkr_raw.xtime_nsec; 77 78 /* CLOCK_TAI */ 79 vdso_ts = &vc[CS_HRES_COARSE].basetime[CLOCK_TAI]; 80 vdso_ts->sec = tk->xtime_sec + (s64)tk->tai_offset; 81 vdso_ts->nsec = tk->tkr_mono.xtime_nsec; 82 } 83 84 void update_vsyscall(struct timekeeper *tk) 85 { 86 struct vdso_time_data *vdata = vdso_k_time_data; 87 struct vdso_clock *vc = vdata->clock_data; 88 struct vdso_timestamp *vdso_ts; 89 s32 clock_mode; 90 u64 nsec; 91 92 /* copy vsyscall data */ 93 vdso_write_begin(vdata); 94 95 clock_mode = tk->tkr_mono.clock->vdso_clock_mode; 96 vc[CS_HRES_COARSE].clock_mode = clock_mode; 97 vc[CS_RAW].clock_mode = clock_mode; 98 99 /* CLOCK_REALTIME also required for time() */ 100 vdso_ts = &vc[CS_HRES_COARSE].basetime[CLOCK_REALTIME]; 101 vdso_ts->sec = tk->xtime_sec; 102 vdso_ts->nsec = tk->tkr_mono.xtime_nsec; 103 104 /* CLOCK_REALTIME_COARSE */ 105 vdso_ts = &vc[CS_HRES_COARSE].basetime[CLOCK_REALTIME_COARSE]; 106 vdso_ts->sec = tk->xtime_sec; 107 vdso_ts->nsec = tk->coarse_nsec; 108 109 /* CLOCK_MONOTONIC_COARSE */ 110 vdso_ts = &vc[CS_HRES_COARSE].basetime[CLOCK_MONOTONIC_COARSE]; 111 vdso_ts->sec = tk->xtime_sec + tk->wall_to_monotonic.tv_sec; 112 nsec = tk->coarse_nsec; 113 nsec = nsec + tk->wall_to_monotonic.tv_nsec; 114 vdso_ts->sec += __iter_div_u64_rem(nsec, NSEC_PER_SEC, &vdso_ts->nsec); 115 116 /* 117 * Read without the seqlock held by clock_getres(). 118 */ 119 WRITE_ONCE(vdata->hrtimer_res, hrtimer_resolution); 120 121 /* 122 * If the current clocksource is not VDSO capable, then spare the 123 * update of the high resolution parts. 124 */ 125 if (clock_mode != VDSO_CLOCKMODE_NONE) 126 update_vdso_time_data(vdata, tk); 127 128 __arch_update_vdso_clock(&vc[CS_HRES_COARSE]); 129 __arch_update_vdso_clock(&vc[CS_RAW]); 130 131 vdso_write_end(vdata); 132 133 __arch_sync_vdso_time_data(vdata); 134 } 135 136 void update_vsyscall_tz(void) 137 { 138 struct vdso_time_data *vdata = vdso_k_time_data; 139 140 vdata->tz_minuteswest = sys_tz.tz_minuteswest; 141 vdata->tz_dsttime = sys_tz.tz_dsttime; 142 143 __arch_sync_vdso_time_data(vdata); 144 } 145 146 #ifdef CONFIG_POSIX_AUX_CLOCKS 147 void vdso_time_update_aux(struct timekeeper *tk) 148 { 149 struct vdso_time_data *vdata = vdso_k_time_data; 150 struct vdso_timestamp *vdso_ts; 151 struct vdso_clock *vc; 152 s32 clock_mode; 153 u64 nsec; 154 155 vc = &vdata->aux_clock_data[tk->id - TIMEKEEPER_AUX_FIRST]; 156 vdso_ts = &vc->basetime[VDSO_BASE_AUX]; 157 clock_mode = tk->tkr_mono.clock->vdso_clock_mode; 158 if (!tk->clock_valid) 159 clock_mode = VDSO_CLOCKMODE_NONE; 160 161 /* copy vsyscall data */ 162 vdso_write_begin_clock(vc); 163 164 vc->clock_mode = clock_mode; 165 166 if (clock_mode != VDSO_CLOCKMODE_NONE) { 167 fill_clock_configuration(vc, &tk->tkr_mono); 168 169 vdso_ts->sec = tk->xtime_sec + tk->monotonic_to_aux.tv_sec; 170 171 nsec = tk->tkr_mono.xtime_nsec; 172 nsec += (u64)tk->monotonic_to_aux.tv_nsec << tk->tkr_mono.shift; 173 vdso_ts->sec += __iter_div64_u64_rem(nsec, 174 (u64)NSEC_PER_SEC << tk->tkr_mono.shift, 175 &vdso_ts->nsec); 176 } 177 178 __arch_update_vdso_clock(vc); 179 180 vdso_write_end_clock(vc); 181 182 __arch_sync_vdso_time_data(vdata); 183 } 184 #endif 185 186 /** 187 * vdso_time_update_begin - Start of a VDSO update section 188 * 189 * Allows architecture code to safely update the architecture specific VDSO 190 * data. Disables interrupts, acquires timekeeper lock to serialize against 191 * concurrent updates from timekeeping and invalidates the VDSO data 192 * sequence counter to prevent concurrent readers from accessing 193 * inconsistent data. 194 * 195 * Returns: Saved interrupt flags which need to be handed in to 196 * vdso_time_update_end(). 197 */ 198 unsigned long vdso_time_update_begin(void) 199 { 200 struct vdso_time_data *vdata = vdso_k_time_data; 201 unsigned long flags = timekeeper_lock_irqsave(); 202 203 vdso_write_begin(vdata); 204 return flags; 205 } 206 207 /** 208 * vdso_time_update_end - End of a VDSO update section 209 * @flags: Interrupt flags as returned from vdso_time_update_begin() 210 * 211 * Pairs with vdso_time_update_begin(). Marks vdso data consistent, invokes data 212 * synchronization if the architecture requires it, drops timekeeper lock 213 * and restores interrupt flags. 214 */ 215 void vdso_time_update_end(unsigned long flags) 216 { 217 struct vdso_time_data *vdata = vdso_k_time_data; 218 219 vdso_write_end(vdata); 220 __arch_sync_vdso_time_data(vdata); 221 timekeeper_unlock_irqrestore(flags); 222 } 223