Merge tag 'fortglx/4.19/time-part2' of... (e5af5ff3) · Commits · 戴 / test

include/linux/clocksource.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -194,6 +194,9 @@ extern void clocksource_suspend(void);
		extern void clocksource_resume(void);
		extern struct clocksource * __init clocksource_default_clock(void);
		extern void clocksource_mark_unstable(struct clocksource *cs);
		extern void
		clocksource_start_suspend_timing(struct clocksource *cs, u64 start_cycles);
		extern u64 clocksource_stop_suspend_timing(struct clocksource *cs, u64 now);

		extern u64
		clocks_calc_max_nsecs(u32 mult, u32 shift, u32 maxadj, u64 mask, u64 *max_cycles);

include/linux/timekeeping.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -177,7 +177,7 @@ static inline time64_t ktime_get_clocktai_seconds(void)
		extern bool timekeeping_rtc_skipsuspend(void);
		extern bool timekeeping_rtc_skipresume(void);

		extern void timekeeping_inject_sleeptime64(struct timespec64 *delta);
		extern void timekeeping_inject_sleeptime64(const struct timespec64 *delta);

		/*
		* struct system_time_snapshot - simultaneous raw/real time capture with

kernel/time/clocksource.c

+149 −0

Original line number	Diff line number	Diff line
		@@ -94,6 +94,8 @@ EXPORT_SYMBOL_GPL(clocks_calc_mult_shift);
		/*[Clocksource internal variables]---------
		* curr_clocksource:
		* currently selected clocksource.
		* suspend_clocksource:
		* used to calculate the suspend time.
		* clocksource_list:
		* linked list with the registered clocksources
		* clocksource_mutex:
		@@ -102,10 +104,12 @@ EXPORT_SYMBOL_GPL(clocks_calc_mult_shift);
		* Name of the user-specified clocksource.
		*/
		static struct clocksource *curr_clocksource;
		static struct clocksource *suspend_clocksource;
		static LIST_HEAD(clocksource_list);
		static DEFINE_MUTEX(clocksource_mutex);
		static char override_name[CS_NAME_LEN];
		static int finished_booting;
		static u64 suspend_start;

		#ifdef CONFIG_CLOCKSOURCE_WATCHDOG
		static void clocksource_watchdog_work(struct work_struct *work);
		@@ -447,6 +451,140 @@ static inline void clocksource_watchdog_unlock(unsigned long *flags) { }

		#endif /* CONFIG_CLOCKSOURCE_WATCHDOG */

		static bool clocksource_is_suspend(struct clocksource *cs)
		{
		return cs == suspend_clocksource;
		}

		static void __clocksource_suspend_select(struct clocksource *cs)
		{
		/*
		* Skip the clocksource which will be stopped in suspend state.
		*/
		if (!(cs->flags & CLOCK_SOURCE_SUSPEND_NONSTOP))
		return;

		/*
		* The nonstop clocksource can be selected as the suspend clocksource to
		* calculate the suspend time, so it should not supply suspend/resume
		* interfaces to suspend the nonstop clocksource when system suspends.
		*/
		if (cs->suspend \|\| cs->resume) {
		pr_warn("Nonstop clocksource %s should not supply suspend/resume interfaces\n",
		cs->name);
		}

		/* Pick the best rating. */
		if (!suspend_clocksource \|\| cs->rating > suspend_clocksource->rating)
		suspend_clocksource = cs;
		}

		/**
		* clocksource_suspend_select - Select the best clocksource for suspend timing
		* @fallback: if select a fallback clocksource
		*/
		static void clocksource_suspend_select(bool fallback)
		{
		struct clocksource cs, old_suspend;

		old_suspend = suspend_clocksource;
		if (fallback)
		suspend_clocksource = NULL;

		list_for_each_entry(cs, &clocksource_list, list) {
		/* Skip current if we were requested for a fallback. */
		if (fallback && cs == old_suspend)
		continue;

		__clocksource_suspend_select(cs);
		}
		}

		/**
		* clocksource_start_suspend_timing - Start measuring the suspend timing
		* @cs: current clocksource from timekeeping
		* @start_cycles: current cycles from timekeeping
		*
		* This function will save the start cycle values of suspend timer to calculate
		* the suspend time when resuming system.
		*
		* This function is called late in the suspend process from timekeeping_suspend(),
		* that means processes are freezed, non-boot cpus and interrupts are disabled
		* now. It is therefore possible to start the suspend timer without taking the
		* clocksource mutex.
		*/
		void clocksource_start_suspend_timing(struct clocksource *cs, u64 start_cycles)
		{
		if (!suspend_clocksource)
		return;

		/*
		* If current clocksource is the suspend timer, we should use the
		* tkr_mono.cycle_last value as suspend_start to avoid same reading
		* from suspend timer.
		*/
		if (clocksource_is_suspend(cs)) {
		suspend_start = start_cycles;
		return;
		}

		if (suspend_clocksource->enable &&
		suspend_clocksource->enable(suspend_clocksource)) {
		pr_warn_once("Failed to enable the non-suspend-able clocksource.\n");
		return;
		}

		suspend_start = suspend_clocksource->read(suspend_clocksource);
		}

		/**
		* clocksource_stop_suspend_timing - Stop measuring the suspend timing
		* @cs: current clocksource from timekeeping
		* @cycle_now: current cycles from timekeeping
		*
		* This function will calculate the suspend time from suspend timer.
		*
		* Returns nanoseconds since suspend started, 0 if no usable suspend clocksource.
		*
		* This function is called early in the resume process from timekeeping_resume(),
		* that means there is only one cpu, no processes are running and the interrupts
		* are disabled. It is therefore possible to stop the suspend timer without
		* taking the clocksource mutex.
		*/
		u64 clocksource_stop_suspend_timing(struct clocksource *cs, u64 cycle_now)
		{
		u64 now, delta, nsec = 0;

		if (!suspend_clocksource)
		return 0;

		/*
		* If current clocksource is the suspend timer, we should use the
		* tkr_mono.cycle_last value from timekeeping as current cycle to
		* avoid same reading from suspend timer.
		*/
		if (clocksource_is_suspend(cs))
		now = cycle_now;
		else
		now = suspend_clocksource->read(suspend_clocksource);

		if (now > suspend_start) {
		delta = clocksource_delta(now, suspend_start,
		suspend_clocksource->mask);
		nsec = mul_u64_u32_shr(delta, suspend_clocksource->mult,
		suspend_clocksource->shift);
		}

		/*
		* Disable the suspend timer to save power if current clocksource is
		* not the suspend timer.
		*/
		if (!clocksource_is_suspend(cs) && suspend_clocksource->disable)
		suspend_clocksource->disable(suspend_clocksource);

		return nsec;
		}

		/**
		* clocksource_suspend - suspend the clocksource(s)
		*/
		@@ -792,6 +930,7 @@ int __clocksource_register_scale(struct clocksource *cs, u32 scale, u32 freq)

		clocksource_select();
		clocksource_select_watchdog(false);
		__clocksource_suspend_select(cs);
		mutex_unlock(&clocksource_mutex);
		return 0;
		}
		@@ -820,6 +959,7 @@ void clocksource_change_rating(struct clocksource *cs, int rating)

		clocksource_select();
		clocksource_select_watchdog(false);
		clocksource_suspend_select(false);
		mutex_unlock(&clocksource_mutex);
		}
		EXPORT_SYMBOL(clocksource_change_rating);
		@@ -845,6 +985,15 @@ static int clocksource_unbind(struct clocksource *cs)
		return -EBUSY;
		}

		if (clocksource_is_suspend(cs)) {
		/*
		* Select and try to install a replacement suspend clocksource.
		* If no replacement suspend clocksource, we will just let the
		* clocksource go and have no suspend clocksource.
		*/
		clocksource_suspend_select(true);
		}

		clocksource_watchdog_lock(&flags);
		clocksource_dequeue_watchdog(cs);
		list_del_init(&cs->list);

kernel/time/ntp.c

+7 −10

Original line number	Diff line number	Diff line
		@@ -642,7 +642,7 @@ void ntp_notify_cmos_timer(void)
		/*
		* Propagate a new txc->status value into the NTP state:
		*/
		static inline void process_adj_status(struct timex txc, struct timespec64 ts)
		static inline void process_adj_status(const struct timex *txc)
		{
		if ((time_status & STA_PLL) && !(txc->status & STA_PLL)) {
		time_state = TIME_OK;
		@@ -665,12 +665,10 @@ static inline void process_adj_status(struct timex txc, struct timespec64 ts)
		}


		static inline void process_adjtimex_modes(struct timex *txc,
		struct timespec64 *ts,
		s32 *time_tai)
		static inline void process_adjtimex_modes(const struct timex txc, s32 time_tai)
		{
		if (txc->modes & ADJ_STATUS)
		process_adj_status(txc, ts);
		process_adj_status(txc);

		if (txc->modes & ADJ_NANO)
		time_status \|= STA_NANO;
		@@ -718,7 +716,7 @@ static inline void process_adjtimex_modes(struct timex *txc,
		* adjtimex mainly allows reading (and writing, if superuser) of
		* kernel time-keeping variables. used by xntpd.
		*/
		int __do_adjtimex(struct timex txc, struct timespec64 ts, s32 *time_tai)
		int __do_adjtimex(struct timex txc, const struct timespec64 ts, s32 *time_tai)
		{
		int result;

		@@ -735,7 +733,7 @@ int __do_adjtimex(struct timex txc, struct timespec64 ts, s32 *time_tai)

		/* If there are input parameters, then process them: */
		if (txc->modes)
		process_adjtimex_modes(txc, ts, time_tai);
		process_adjtimex_modes(txc, time_tai);

		txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ,
		NTP_SCALE_SHIFT);
		@@ -1022,12 +1020,11 @@ void __hardpps(const struct timespec64 phase_ts, const struct timespec64 raw_t

		static int __init ntp_tick_adj_setup(char *str)
		{
		int rc = kstrtol(str, 0, (long *)&ntp_tick_adj);

		int rc = kstrtos64(str, 0, &ntp_tick_adj);
		if (rc)
		return rc;
		ntp_tick_adj <<= NTP_SCALE_SHIFT;

		ntp_tick_adj <<= NTP_SCALE_SHIFT;
		return 1;
		}

kernel/time/ntp_internal.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -8,6 +8,6 @@ extern void ntp_clear(void);
		extern u64 ntp_tick_length(void);
		extern ktime_t ntp_get_next_leap(void);
		extern int second_overflow(time64_t secs);
		extern int __do_adjtimex(struct timex , struct timespec64 , s32 *);
		extern void __hardpps(const struct timespec64 , const struct timespec64 );
		extern int __do_adjtimex(struct timex txc, const struct timespec64 ts, s32 *time_tai);
		extern void __hardpps(const struct timespec64 phase_ts, const struct timespec64 raw_ts);
		#endif /* _LINUX_NTP_INTERNAL_H */

Admin message