Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e5af5ff3 authored by Thomas Gleixner's avatar Thomas Gleixner
Browse files

Merge tag 'fortglx/4.19/time-part2' of... 

Merge tag 'fortglx/4.19/time-part2' of https://git.linaro.org/people/john.stultz/linux into timers/core

Pull the second set of timekeeping things for 4.19 from John Stultz

  * NTP argument clenaups and constification from Ondrej Mosnacek
  * Fix to avoid RTC injecting sleeptime when suspend fails from
    Mukesh Ojha
  * Broading suspsend-timing to include non-stop clocksources that
    aren't currently used for timekeeping from Baolin Wang
parents 30587589 39232ed5

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 */