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

TOMOYO Linux Cross Reference
Linux/arch/s390/kernel/time.c

Version: ~ [ linux-6.2-rc3 ] ~ [ linux-6.1.5 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.87 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.162 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.228 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.269 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.302 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 /*
  3  *    Time of day based timer functions.
  4  *
  5  *  S390 version
  6  *    Copyright IBM Corp. 1999, 2008
  7  *    Author(s): Hartmut Penner (hp@de.ibm.com),
  8  *               Martin Schwidefsky (schwidefsky@de.ibm.com),
  9  *               Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
 10  *
 11  *  Derived from "arch/i386/kernel/time.c"
 12  *    Copyright (C) 1991, 1992, 1995  Linus Torvalds
 13  */
 14 
 15 #define KMSG_COMPONENT "time"
 16 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 17 
 18 #include <linux/kernel_stat.h>
 19 #include <linux/errno.h>
 20 #include <linux/export.h>
 21 #include <linux/sched.h>
 22 #include <linux/sched/clock.h>
 23 #include <linux/kernel.h>
 24 #include <linux/param.h>
 25 #include <linux/string.h>
 26 #include <linux/mm.h>
 27 #include <linux/interrupt.h>
 28 #include <linux/cpu.h>
 29 #include <linux/stop_machine.h>
 30 #include <linux/time.h>
 31 #include <linux/device.h>
 32 #include <linux/delay.h>
 33 #include <linux/init.h>
 34 #include <linux/smp.h>
 35 #include <linux/types.h>
 36 #include <linux/profile.h>
 37 #include <linux/timex.h>
 38 #include <linux/notifier.h>
 39 #include <linux/timekeeper_internal.h>
 40 #include <linux/clockchips.h>
 41 #include <linux/gfp.h>
 42 #include <linux/kprobes.h>
 43 #include <linux/uaccess.h>
 44 #include <asm/facility.h>
 45 #include <asm/delay.h>
 46 #include <asm/div64.h>
 47 #include <asm/vdso.h>
 48 #include <asm/irq.h>
 49 #include <asm/irq_regs.h>
 50 #include <asm/vtimer.h>
 51 #include <asm/stp.h>
 52 #include <asm/cio.h>
 53 #include "entry.h"
 54 
 55 unsigned char tod_clock_base[16] __aligned(8) = {
 56         /* Force to data section. */
 57         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 58         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
 59 };
 60 EXPORT_SYMBOL_GPL(tod_clock_base);
 61 
 62 u64 clock_comparator_max = -1ULL;
 63 EXPORT_SYMBOL_GPL(clock_comparator_max);
 64 
 65 static DEFINE_PER_CPU(struct clock_event_device, comparators);
 66 
 67 ATOMIC_NOTIFIER_HEAD(s390_epoch_delta_notifier);
 68 EXPORT_SYMBOL(s390_epoch_delta_notifier);
 69 
 70 unsigned char ptff_function_mask[16];
 71 
 72 static unsigned long long lpar_offset;
 73 static unsigned long long initial_leap_seconds;
 74 static unsigned long long tod_steering_end;
 75 static long long tod_steering_delta;
 76 
 77 /*
 78  * Get time offsets with PTFF
 79  */
 80 void __init time_early_init(void)
 81 {
 82         struct ptff_qto qto;
 83         struct ptff_qui qui;
 84 
 85         /* Initialize TOD steering parameters */
 86         tod_steering_end = *(unsigned long long *) &tod_clock_base[1];
 87         vdso_data->ts_end = tod_steering_end;
 88 
 89         if (!test_facility(28))
 90                 return;
 91 
 92         ptff(&ptff_function_mask, sizeof(ptff_function_mask), PTFF_QAF);
 93 
 94         /* get LPAR offset */
 95         if (ptff_query(PTFF_QTO) && ptff(&qto, sizeof(qto), PTFF_QTO) == 0)
 96                 lpar_offset = qto.tod_epoch_difference;
 97 
 98         /* get initial leap seconds */
 99         if (ptff_query(PTFF_QUI) && ptff(&qui, sizeof(qui), PTFF_QUI) == 0)
100                 initial_leap_seconds = (unsigned long long)
101                         ((long) qui.old_leap * 4096000000L);
102 }
103 
104 /*
105  * Scheduler clock - returns current time in nanosec units.
106  */
107 unsigned long long notrace sched_clock(void)
108 {
109         return tod_to_ns(get_tod_clock_monotonic());
110 }
111 NOKPROBE_SYMBOL(sched_clock);
112 
113 /*
114  * Monotonic_clock - returns # of nanoseconds passed since time_init()
115  */
116 unsigned long long monotonic_clock(void)
117 {
118         return sched_clock();
119 }
120 EXPORT_SYMBOL(monotonic_clock);
121 
122 static void ext_to_timespec64(unsigned char *clk, struct timespec64 *xt)
123 {
124         unsigned long long high, low, rem, sec, nsec;
125 
126         /* Split extendnd TOD clock to micro-seconds and sub-micro-seconds */
127         high = (*(unsigned long long *) clk) >> 4;
128         low = (*(unsigned long long *)&clk[7]) << 4;
129         /* Calculate seconds and nano-seconds */
130         sec = high;
131         rem = do_div(sec, 1000000);
132         nsec = (((low >> 32) + (rem << 32)) * 1000) >> 32;
133 
134         xt->tv_sec = sec;
135         xt->tv_nsec = nsec;
136 }
137 
138 void clock_comparator_work(void)
139 {
140         struct clock_event_device *cd;
141 
142         S390_lowcore.clock_comparator = clock_comparator_max;
143         cd = this_cpu_ptr(&comparators);
144         cd->event_handler(cd);
145 }
146 
147 static int s390_next_event(unsigned long delta,
148                            struct clock_event_device *evt)
149 {
150         S390_lowcore.clock_comparator = get_tod_clock() + delta;
151         set_clock_comparator(S390_lowcore.clock_comparator);
152         return 0;
153 }
154 
155 /*
156  * Set up lowcore and control register of the current cpu to
157  * enable TOD clock and clock comparator interrupts.
158  */
159 void init_cpu_timer(void)
160 {
161         struct clock_event_device *cd;
162         int cpu;
163 
164         S390_lowcore.clock_comparator = clock_comparator_max;
165         set_clock_comparator(S390_lowcore.clock_comparator);
166 
167         cpu = smp_processor_id();
168         cd = &per_cpu(comparators, cpu);
169         cd->name                = "comparator";
170         cd->features            = CLOCK_EVT_FEAT_ONESHOT;
171         cd->mult                = 16777;
172         cd->shift               = 12;
173         cd->min_delta_ns        = 1;
174         cd->min_delta_ticks     = 1;
175         cd->max_delta_ns        = LONG_MAX;
176         cd->max_delta_ticks     = ULONG_MAX;
177         cd->rating              = 400;
178         cd->cpumask             = cpumask_of(cpu);
179         cd->set_next_event      = s390_next_event;
180 
181         clockevents_register_device(cd);
182 
183         /* Enable clock comparator timer interrupt. */
184         __ctl_set_bit(0,11);
185 
186         /* Always allow the timing alert external interrupt. */
187         __ctl_set_bit(0, 4);
188 }
189 
190 static void clock_comparator_interrupt(struct ext_code ext_code,
191                                        unsigned int param32,
192                                        unsigned long param64)
193 {
194         inc_irq_stat(IRQEXT_CLK);
195         if (S390_lowcore.clock_comparator == clock_comparator_max)
196                 set_clock_comparator(S390_lowcore.clock_comparator);
197 }
198 
199 static void stp_timing_alert(struct stp_irq_parm *);
200 
201 static void timing_alert_interrupt(struct ext_code ext_code,
202                                    unsigned int param32, unsigned long param64)
203 {
204         inc_irq_stat(IRQEXT_TLA);
205         if (param32 & 0x00038000)
206                 stp_timing_alert((struct stp_irq_parm *) &param32);
207 }
208 
209 static void stp_reset(void);
210 
211 void read_persistent_clock64(struct timespec64 *ts)
212 {
213         unsigned char clk[STORE_CLOCK_EXT_SIZE];
214         __u64 delta;
215 
216         delta = initial_leap_seconds + TOD_UNIX_EPOCH;
217         get_tod_clock_ext(clk);
218         *(__u64 *) &clk[1] -= delta;
219         if (*(__u64 *) &clk[1] > delta)
220                 clk[0]--;
221         ext_to_timespec64(clk, ts);
222 }
223 
224 void __init read_persistent_wall_and_boot_offset(struct timespec64 *wall_time,
225                                                  struct timespec64 *boot_offset)
226 {
227         unsigned char clk[STORE_CLOCK_EXT_SIZE];
228         struct timespec64 boot_time;
229         __u64 delta;
230 
231         delta = initial_leap_seconds + TOD_UNIX_EPOCH;
232         memcpy(clk, tod_clock_base, STORE_CLOCK_EXT_SIZE);
233         *(__u64 *)&clk[1] -= delta;
234         if (*(__u64 *)&clk[1] > delta)
235                 clk[0]--;
236         ext_to_timespec64(clk, &boot_time);
237 
238         read_persistent_clock64(wall_time);
239         *boot_offset = timespec64_sub(*wall_time, boot_time);
240 }
241 
242 static u64 read_tod_clock(struct clocksource *cs)
243 {
244         unsigned long long now, adj;
245 
246         preempt_disable(); /* protect from changes to steering parameters */
247         now = get_tod_clock();
248         adj = tod_steering_end - now;
249         if (unlikely((s64) adj >= 0))
250                 /*
251                  * manually steer by 1 cycle every 2^16 cycles. This
252                  * corresponds to shifting the tod delta by 15. 1s is
253                  * therefore steered in ~9h. The adjust will decrease
254                  * over time, until it finally reaches 0.
255                  */
256                 now += (tod_steering_delta < 0) ? (adj >> 15) : -(adj >> 15);
257         preempt_enable();
258         return now;
259 }
260 
261 static struct clocksource clocksource_tod = {
262         .name           = "tod",
263         .rating         = 400,
264         .read           = read_tod_clock,
265         .mask           = -1ULL,
266         .mult           = 1000,
267         .shift          = 12,
268         .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
269 };
270 
271 struct clocksource * __init clocksource_default_clock(void)
272 {
273         return &clocksource_tod;
274 }
275 
276 void update_vsyscall(struct timekeeper *tk)
277 {
278         u64 nsecps;
279 
280         if (tk->tkr_mono.clock != &clocksource_tod)
281                 return;
282 
283         /* Make userspace gettimeofday spin until we're done. */
284         ++vdso_data->tb_update_count;
285         smp_wmb();
286         vdso_data->xtime_tod_stamp = tk->tkr_mono.cycle_last;
287         vdso_data->xtime_clock_sec = tk->xtime_sec;
288         vdso_data->xtime_clock_nsec = tk->tkr_mono.xtime_nsec;
289         vdso_data->wtom_clock_sec =
290                 tk->xtime_sec + tk->wall_to_monotonic.tv_sec;
291         vdso_data->wtom_clock_nsec = tk->tkr_mono.xtime_nsec +
292                 + ((u64) tk->wall_to_monotonic.tv_nsec << tk->tkr_mono.shift);
293         nsecps = (u64) NSEC_PER_SEC << tk->tkr_mono.shift;
294         while (vdso_data->wtom_clock_nsec >= nsecps) {
295                 vdso_data->wtom_clock_nsec -= nsecps;
296                 vdso_data->wtom_clock_sec++;
297         }
298 
299         vdso_data->xtime_coarse_sec = tk->xtime_sec;
300         vdso_data->xtime_coarse_nsec =
301                 (long)(tk->tkr_mono.xtime_nsec >> tk->tkr_mono.shift);
302         vdso_data->wtom_coarse_sec =
303                 vdso_data->xtime_coarse_sec + tk->wall_to_monotonic.tv_sec;
304         vdso_data->wtom_coarse_nsec =
305                 vdso_data->xtime_coarse_nsec + tk->wall_to_monotonic.tv_nsec;
306         while (vdso_data->wtom_coarse_nsec >= NSEC_PER_SEC) {
307                 vdso_data->wtom_coarse_nsec -= NSEC_PER_SEC;
308                 vdso_data->wtom_coarse_sec++;
309         }
310 
311         vdso_data->tk_mult = tk->tkr_mono.mult;
312         vdso_data->tk_shift = tk->tkr_mono.shift;
313         smp_wmb();
314         ++vdso_data->tb_update_count;
315 }
316 
317 extern struct timezone sys_tz;
318 
319 void update_vsyscall_tz(void)
320 {
321         vdso_data->tz_minuteswest = sys_tz.tz_minuteswest;
322         vdso_data->tz_dsttime = sys_tz.tz_dsttime;
323 }
324 
325 /*
326  * Initialize the TOD clock and the CPU timer of
327  * the boot cpu.
328  */
329 void __init time_init(void)
330 {
331         /* Reset time synchronization interfaces. */
332         stp_reset();
333 
334         /* request the clock comparator external interrupt */
335         if (register_external_irq(EXT_IRQ_CLK_COMP, clock_comparator_interrupt))
336                 panic("Couldn't request external interrupt 0x1004");
337 
338         /* request the timing alert external interrupt */
339         if (register_external_irq(EXT_IRQ_TIMING_ALERT, timing_alert_interrupt))
340                 panic("Couldn't request external interrupt 0x1406");
341 
342         if (__clocksource_register(&clocksource_tod) != 0)
343                 panic("Could not register TOD clock source");
344 
345         /* Enable TOD clock interrupts on the boot cpu. */
346         init_cpu_timer();
347 
348         /* Enable cpu timer interrupts on the boot cpu. */
349         vtime_init();
350 }
351 
352 static DEFINE_PER_CPU(atomic_t, clock_sync_word);
353 static DEFINE_MUTEX(clock_sync_mutex);
354 static unsigned long clock_sync_flags;
355 
356 #define CLOCK_SYNC_HAS_STP      0
357 #define CLOCK_SYNC_STP          1
358 
359 /*
360  * The get_clock function for the physical clock. It will get the current
361  * TOD clock, subtract the LPAR offset and write the result to *clock.
362  * The function returns 0 if the clock is in sync with the external time
363  * source. If the clock mode is local it will return -EOPNOTSUPP and
364  * -EAGAIN if the clock is not in sync with the external reference.
365  */
366 int get_phys_clock(unsigned long *clock)
367 {
368         atomic_t *sw_ptr;
369         unsigned int sw0, sw1;
370 
371         sw_ptr = &get_cpu_var(clock_sync_word);
372         sw0 = atomic_read(sw_ptr);
373         *clock = get_tod_clock() - lpar_offset;
374         sw1 = atomic_read(sw_ptr);
375         put_cpu_var(clock_sync_word);
376         if (sw0 == sw1 && (sw0 & 0x80000000U))
377                 /* Success: time is in sync. */
378                 return 0;
379         if (!test_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags))
380                 return -EOPNOTSUPP;
381         if (!test_bit(CLOCK_SYNC_STP, &clock_sync_flags))
382                 return -EACCES;
383         return -EAGAIN;
384 }
385 EXPORT_SYMBOL(get_phys_clock);
386 
387 /*
388  * Make get_phys_clock() return -EAGAIN.
389  */
390 static void disable_sync_clock(void *dummy)
391 {
392         atomic_t *sw_ptr = this_cpu_ptr(&clock_sync_word);
393         /*
394          * Clear the in-sync bit 2^31. All get_phys_clock calls will
395          * fail until the sync bit is turned back on. In addition
396          * increase the "sequence" counter to avoid the race of an
397          * stp event and the complete recovery against get_phys_clock.
398          */
399         atomic_andnot(0x80000000, sw_ptr);
400         atomic_inc(sw_ptr);
401 }
402 
403 /*
404  * Make get_phys_clock() return 0 again.
405  * Needs to be called from a context disabled for preemption.
406  */
407 static void enable_sync_clock(void)
408 {
409         atomic_t *sw_ptr = this_cpu_ptr(&clock_sync_word);
410         atomic_or(0x80000000, sw_ptr);
411 }
412 
413 /*
414  * Function to check if the clock is in sync.
415  */
416 static inline int check_sync_clock(void)
417 {
418         atomic_t *sw_ptr;
419         int rc;
420 
421         sw_ptr = &get_cpu_var(clock_sync_word);
422         rc = (atomic_read(sw_ptr) & 0x80000000U) != 0;
423         put_cpu_var(clock_sync_word);
424         return rc;
425 }
426 
427 /*
428  * Apply clock delta to the global data structures.
429  * This is called once on the CPU that performed the clock sync.
430  */
431 static void clock_sync_global(unsigned long long delta)
432 {
433         unsigned long now, adj;
434         struct ptff_qto qto;
435 
436         /* Fixup the monotonic sched clock. */
437         *(unsigned long long *) &tod_clock_base[1] += delta;
438         if (*(unsigned long long *) &tod_clock_base[1] < delta)
439                 /* Epoch overflow */
440                 tod_clock_base[0]++;
441         /* Adjust TOD steering parameters. */
442         vdso_data->tb_update_count++;
443         now = get_tod_clock();
444         adj = tod_steering_end - now;
445         if (unlikely((s64) adj >= 0))
446                 /* Calculate how much of the old adjustment is left. */
447                 tod_steering_delta = (tod_steering_delta < 0) ?
448                         -(adj >> 15) : (adj >> 15);
449         tod_steering_delta += delta;
450         if ((abs(tod_steering_delta) >> 48) != 0)
451                 panic("TOD clock sync offset %lli is too large to drift\n",
452                       tod_steering_delta);
453         tod_steering_end = now + (abs(tod_steering_delta) << 15);
454         vdso_data->ts_dir = (tod_steering_delta < 0) ? 0 : 1;
455         vdso_data->ts_end = tod_steering_end;
456         vdso_data->tb_update_count++;
457         /* Update LPAR offset. */
458         if (ptff_query(PTFF_QTO) && ptff(&qto, sizeof(qto), PTFF_QTO) == 0)
459                 lpar_offset = qto.tod_epoch_difference;
460         /* Call the TOD clock change notifier. */
461         atomic_notifier_call_chain(&s390_epoch_delta_notifier, 0, &delta);
462 }
463 
464 /*
465  * Apply clock delta to the per-CPU data structures of this CPU.
466  * This is called for each online CPU after the call to clock_sync_global.
467  */
468 static void clock_sync_local(unsigned long long delta)
469 {
470         /* Add the delta to the clock comparator. */
471         if (S390_lowcore.clock_comparator != clock_comparator_max) {
472                 S390_lowcore.clock_comparator += delta;
473                 set_clock_comparator(S390_lowcore.clock_comparator);
474         }
475         /* Adjust the last_update_clock time-stamp. */
476         S390_lowcore.last_update_clock += delta;
477 }
478 
479 /* Single threaded workqueue used for stp sync events */
480 static struct workqueue_struct *time_sync_wq;
481 
482 static void __init time_init_wq(void)
483 {
484         if (time_sync_wq)
485                 return;
486         time_sync_wq = create_singlethread_workqueue("timesync");
487 }
488 
489 struct clock_sync_data {
490         atomic_t cpus;
491         int in_sync;
492         unsigned long long clock_delta;
493 };
494 
495 /*
496  * Server Time Protocol (STP) code.
497  */
498 static bool stp_online;
499 static struct stp_sstpi stp_info;
500 static void *stp_page;
501 
502 static void stp_work_fn(struct work_struct *work);
503 static DEFINE_MUTEX(stp_work_mutex);
504 static DECLARE_WORK(stp_work, stp_work_fn);
505 static struct timer_list stp_timer;
506 
507 static int __init early_parse_stp(char *p)
508 {
509         return kstrtobool(p, &stp_online);
510 }
511 early_param("stp", early_parse_stp);
512 
513 /*
514  * Reset STP attachment.
515  */
516 static void __init stp_reset(void)
517 {
518         int rc;
519 
520         stp_page = (void *) get_zeroed_page(GFP_ATOMIC);
521         rc = chsc_sstpc(stp_page, STP_OP_CTRL, 0x0000, NULL);
522         if (rc == 0)
523                 set_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags);
524         else if (stp_online) {
525                 pr_warn("The real or virtual hardware system does not provide an STP interface\n");
526                 free_page((unsigned long) stp_page);
527                 stp_page = NULL;
528                 stp_online = false;
529         }
530 }
531 
532 static void stp_timeout(struct timer_list *unused)
533 {
534         queue_work(time_sync_wq, &stp_work);
535 }
536 
537 static int __init stp_init(void)
538 {
539         if (!test_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags))
540                 return 0;
541         timer_setup(&stp_timer, stp_timeout, 0);
542         time_init_wq();
543         if (!stp_online)
544                 return 0;
545         queue_work(time_sync_wq, &stp_work);
546         return 0;
547 }
548 
549 arch_initcall(stp_init);
550 
551 /*
552  * STP timing alert. There are three causes:
553  * 1) timing status change
554  * 2) link availability change
555  * 3) time control parameter change
556  * In all three cases we are only interested in the clock source state.
557  * If a STP clock source is now available use it.
558  */
559 static void stp_timing_alert(struct stp_irq_parm *intparm)
560 {
561         if (intparm->tsc || intparm->lac || intparm->tcpc)
562                 queue_work(time_sync_wq, &stp_work);
563 }
564 
565 /*
566  * STP sync check machine check. This is called when the timing state
567  * changes from the synchronized state to the unsynchronized state.
568  * After a STP sync check the clock is not in sync. The machine check
569  * is broadcasted to all cpus at the same time.
570  */
571 int stp_sync_check(void)
572 {
573         disable_sync_clock(NULL);
574         return 1;
575 }
576 
577 /*
578  * STP island condition machine check. This is called when an attached
579  * server  attempts to communicate over an STP link and the servers
580  * have matching CTN ids and have a valid stratum-1 configuration
581  * but the configurations do not match.
582  */
583 int stp_island_check(void)
584 {
585         disable_sync_clock(NULL);
586         return 1;
587 }
588 
589 void stp_queue_work(void)
590 {
591         queue_work(time_sync_wq, &stp_work);
592 }
593 
594 static int stp_sync_clock(void *data)
595 {
596         struct clock_sync_data *sync = data;
597         unsigned long long clock_delta;
598         static int first;
599         int rc;
600 
601         enable_sync_clock();
602         if (xchg(&first, 1) == 0) {
603                 /* Wait until all other cpus entered the sync function. */
604                 while (atomic_read(&sync->cpus) != 0)
605                         cpu_relax();
606                 rc = 0;
607                 if (stp_info.todoff[0] || stp_info.todoff[1] ||
608                     stp_info.todoff[2] || stp_info.todoff[3] ||
609                     stp_info.tmd != 2) {
610                         rc = chsc_sstpc(stp_page, STP_OP_SYNC, 0,
611                                         &clock_delta);
612                         if (rc == 0) {
613                                 sync->clock_delta = clock_delta;
614                                 clock_sync_global(clock_delta);
615                                 rc = chsc_sstpi(stp_page, &stp_info,
616                                                 sizeof(struct stp_sstpi));
617                                 if (rc == 0 && stp_info.tmd != 2)
618                                         rc = -EAGAIN;
619                         }
620                 }
621                 sync->in_sync = rc ? -EAGAIN : 1;
622                 xchg(&first, 0);
623         } else {
624                 /* Slave */
625                 atomic_dec(&sync->cpus);
626                 /* Wait for in_sync to be set. */
627                 while (READ_ONCE(sync->in_sync) == 0)
628                         __udelay(1);
629         }
630         if (sync->in_sync != 1)
631                 /* Didn't work. Clear per-cpu in sync bit again. */
632                 disable_sync_clock(NULL);
633         /* Apply clock delta to per-CPU fields of this CPU. */
634         clock_sync_local(sync->clock_delta);
635 
636         return 0;
637 }
638 
639 /*
640  * STP work. Check for the STP state and take over the clock
641  * synchronization if the STP clock source is usable.
642  */
643 static void stp_work_fn(struct work_struct *work)
644 {
645         struct clock_sync_data stp_sync;
646         int rc;
647 
648         /* prevent multiple execution. */
649         mutex_lock(&stp_work_mutex);
650 
651         if (!stp_online) {
652                 chsc_sstpc(stp_page, STP_OP_CTRL, 0x0000, NULL);
653                 del_timer_sync(&stp_timer);
654                 goto out_unlock;
655         }
656 
657         rc = chsc_sstpc(stp_page, STP_OP_CTRL, 0xb0e0, NULL);
658         if (rc)
659                 goto out_unlock;
660 
661         rc = chsc_sstpi(stp_page, &stp_info, sizeof(struct stp_sstpi));
662         if (rc || stp_info.c == 0)
663                 goto out_unlock;
664 
665         /* Skip synchronization if the clock is already in sync. */
666         if (check_sync_clock())
667                 goto out_unlock;
668 
669         memset(&stp_sync, 0, sizeof(stp_sync));
670         cpus_read_lock();
671         atomic_set(&stp_sync.cpus, num_online_cpus() - 1);
672         stop_machine_cpuslocked(stp_sync_clock, &stp_sync, cpu_online_mask);
673         cpus_read_unlock();
674 
675         if (!check_sync_clock())
676                 /*
677                  * There is a usable clock but the synchonization failed.
678                  * Retry after a second.
679                  */
680                 mod_timer(&stp_timer, jiffies + HZ);
681 
682 out_unlock:
683         mutex_unlock(&stp_work_mutex);
684 }
685 
686 /*
687  * STP subsys sysfs interface functions
688  */
689 static struct bus_type stp_subsys = {
690         .name           = "stp",
691         .dev_name       = "stp",
692 };
693 
694 static ssize_t stp_ctn_id_show(struct device *dev,
695                                 struct device_attribute *attr,
696                                 char *buf)
697 {
698         if (!stp_online)
699                 return -ENODATA;
700         return sprintf(buf, "%016llx\n",
701                        *(unsigned long long *) stp_info.ctnid);
702 }
703 
704 static DEVICE_ATTR(ctn_id, 0400, stp_ctn_id_show, NULL);
705 
706 static ssize_t stp_ctn_type_show(struct device *dev,
707                                 struct device_attribute *attr,
708                                 char *buf)
709 {
710         if (!stp_online)
711                 return -ENODATA;
712         return sprintf(buf, "%i\n", stp_info.ctn);
713 }
714 
715 static DEVICE_ATTR(ctn_type, 0400, stp_ctn_type_show, NULL);
716 
717 static ssize_t stp_dst_offset_show(struct device *dev,
718                                    struct device_attribute *attr,
719                                    char *buf)
720 {
721         if (!stp_online || !(stp_info.vbits & 0x2000))
722                 return -ENODATA;
723         return sprintf(buf, "%i\n", (int)(s16) stp_info.dsto);
724 }
725 
726 static DEVICE_ATTR(dst_offset, 0400, stp_dst_offset_show, NULL);
727 
728 static ssize_t stp_leap_seconds_show(struct device *dev,
729                                         struct device_attribute *attr,
730                                         char *buf)
731 {
732         if (!stp_online || !(stp_info.vbits & 0x8000))
733                 return -ENODATA;
734         return sprintf(buf, "%i\n", (int)(s16) stp_info.leaps);
735 }
736 
737 static DEVICE_ATTR(leap_seconds, 0400, stp_leap_seconds_show, NULL);
738 
739 static ssize_t stp_stratum_show(struct device *dev,
740                                 struct device_attribute *attr,
741                                 char *buf)
742 {
743         if (!stp_online)
744                 return -ENODATA;
745         return sprintf(buf, "%i\n", (int)(s16) stp_info.stratum);
746 }
747 
748 static DEVICE_ATTR(stratum, 0400, stp_stratum_show, NULL);
749 
750 static ssize_t stp_time_offset_show(struct device *dev,
751                                 struct device_attribute *attr,
752                                 char *buf)
753 {
754         if (!stp_online || !(stp_info.vbits & 0x0800))
755                 return -ENODATA;
756         return sprintf(buf, "%i\n", (int) stp_info.tto);
757 }
758 
759 static DEVICE_ATTR(time_offset, 0400, stp_time_offset_show, NULL);
760 
761 static ssize_t stp_time_zone_offset_show(struct device *dev,
762                                 struct device_attribute *attr,
763                                 char *buf)
764 {
765         if (!stp_online || !(stp_info.vbits & 0x4000))
766                 return -ENODATA;
767         return sprintf(buf, "%i\n", (int)(s16) stp_info.tzo);
768 }
769 
770 static DEVICE_ATTR(time_zone_offset, 0400,
771                          stp_time_zone_offset_show, NULL);
772 
773 static ssize_t stp_timing_mode_show(struct device *dev,
774                                 struct device_attribute *attr,
775                                 char *buf)
776 {
777         if (!stp_online)
778                 return -ENODATA;
779         return sprintf(buf, "%i\n", stp_info.tmd);
780 }
781 
782 static DEVICE_ATTR(timing_mode, 0400, stp_timing_mode_show, NULL);
783 
784 static ssize_t stp_timing_state_show(struct device *dev,
785                                 struct device_attribute *attr,
786                                 char *buf)
787 {
788         if (!stp_online)
789                 return -ENODATA;
790         return sprintf(buf, "%i\n", stp_info.tst);
791 }
792 
793 static DEVICE_ATTR(timing_state, 0400, stp_timing_state_show, NULL);
794 
795 static ssize_t stp_online_show(struct device *dev,
796                                 struct device_attribute *attr,
797                                 char *buf)
798 {
799         return sprintf(buf, "%i\n", stp_online);
800 }
801 
802 static ssize_t stp_online_store(struct device *dev,
803                                 struct device_attribute *attr,
804                                 const char *buf, size_t count)
805 {
806         unsigned int value;
807 
808         value = simple_strtoul(buf, NULL, 0);
809         if (value != 0 && value != 1)
810                 return -EINVAL;
811         if (!test_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags))
812                 return -EOPNOTSUPP;
813         mutex_lock(&clock_sync_mutex);
814         stp_online = value;
815         if (stp_online)
816                 set_bit(CLOCK_SYNC_STP, &clock_sync_flags);
817         else
818                 clear_bit(CLOCK_SYNC_STP, &clock_sync_flags);
819         queue_work(time_sync_wq, &stp_work);
820         mutex_unlock(&clock_sync_mutex);
821         return count;
822 }
823 
824 /*
825  * Can't use DEVICE_ATTR because the attribute should be named
826  * stp/online but dev_attr_online already exists in this file ..
827  */
828 static struct device_attribute dev_attr_stp_online = {
829         .attr = { .name = "online", .mode = 0600 },
830         .show   = stp_online_show,
831         .store  = stp_online_store,
832 };
833 
834 static struct device_attribute *stp_attributes[] = {
835         &dev_attr_ctn_id,
836         &dev_attr_ctn_type,
837         &dev_attr_dst_offset,
838         &dev_attr_leap_seconds,
839         &dev_attr_stp_online,
840         &dev_attr_stratum,
841         &dev_attr_time_offset,
842         &dev_attr_time_zone_offset,
843         &dev_attr_timing_mode,
844         &dev_attr_timing_state,
845         NULL
846 };
847 
848 static int __init stp_init_sysfs(void)
849 {
850         struct device_attribute **attr;
851         int rc;
852 
853         rc = subsys_system_register(&stp_subsys, NULL);
854         if (rc)
855                 goto out;
856         for (attr = stp_attributes; *attr; attr++) {
857                 rc = device_create_file(stp_subsys.dev_root, *attr);
858                 if (rc)
859                         goto out_unreg;
860         }
861         return 0;
862 out_unreg:
863         for (; attr >= stp_attributes; attr--)
864                 device_remove_file(stp_subsys.dev_root, *attr);
865         bus_unregister(&stp_subsys);
866 out:
867         return rc;
868 }
869 
870 device_initcall(stp_init_sysfs);
871 

~ [ 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