Timekeeping items for 4.15
Hey Thomas,
Bit later then I'd like, but here's my current queue of
timekeeping items for 4.15.
Quoted 1 line
From Arnd's patchset, I'm missing the last patch as it didn't
apply properly, but the rest of it looked ok to me.
Please let me know if you have any objections.
thanks
-john
The following changes since commit 9e66317d3c92ddaab330c125dfe9d06eee268aff:
Linux 4.14-rc3 (2017-10-01 14:54:54 -0700)
are available in the git repository at:
https://git.linaro.org/people/john.stultz/linux.git 6546911ed369af8d747215ff8b6144618e91c6ab
for you to fetch changes up to 6546911ed369af8d747215ff8b6144618e91c6ab:
time: Move old timekeeping interfaces to timekeeping32.h (2017-10-30 15:17:20 -0700)
----------------------------------------------------------------
Arnd Bergmann (6):
timekeeping: Consolidate timekeeping_inject_offset code
timekeeping: Use timespec64 in timekeeping_inject_offset
time: Remove unused functions
time: Move time_t based interfaces to time32.h
time: Move time_t conversion helpers to time32.h
time: Move old timekeeping interfaces to timekeeping32.h
Jason Gunthorpe (1):
rtc: Allow rtc drivers to specify the tv_nsec value for ntp
drivers/rtc/class.c | 3 + drivers/rtc/systohc.c | 53 +++++++--- include/linux/ktime.h | 1 + include/linux/rtc.h | 43 +++++++- include/linux/time.h | 207 +------------------------------------- include/linux/time32.h | 221 ++++++++++++++++++++++++++++++++++++++++ include/linux/time64.h | 78 +-------------- include/linux/timekeeping.h | 137 +------------------------ include/linux/timekeeping32.h | 151 ++++++++++++++++++++++++++++ kernel/time/ntp.c | 227 +++++++++++++++++++++--------------------- kernel/time/ntp_internal.h | 1 - kernel/time/time.c | 59 +---------- kernel/time/timekeeping.c | 121 +++++++++++++++++++--- kernel/time/timekeeping.h | 2 +- 14 files changed, 687 insertions(+), 617 deletions(-) create mode 100644 include/linux/time32.h create mode 100644 include/linux/timekeeping32.h
Signature · 1 line
2.7.4
PATCH 1/7 rtc: Allow rtc drivers to specify the tv_nsec value for ntp
From: Jason Gunthorpe <[email protected]>
ntp is currently hardwired to try and call the rtc set when wall clock tv_nsec is 0.5 seconds. This historical behaviour works well with certain PC RTCs, but is not universal to all rtc hardware.
Change how this works by introducing the driver specific concept of set_offset_nsec, the delay between current wall clock time and the target time to set (with a 0 tv_nsecs).
For x86-style CMOS set_offset_nsec should be -0.5 s which causes the last second to be written 0.5 s after it has started.
For compat with the old rtc_set_ntp_time, the value is defaulted to
+ 0.5 s, which causes the next second to be written 0.5s before it starts, as things were before this patch.
Testing shows many non-x86 RTCs would like set_offset_nsec ~= 0, so ultimately each RTC driver should set the set_offset_nsec according to its needs, and non x86 architectures should stop using update_persistent_clock64 in order to access this feature. Future patches will revise the drivers as needed.
Since CMOS and RTC now have very different handling they are split into two dedicated code paths, sharing the support code, and ifdefs are replaced with IS_ENABLED.
--- drivers/rtc/class.c | 3 + drivers/rtc/systohc.c | 53 +++++++++++----- include/linux/rtc.h | 43 ++++++++++++- kernel/time/ntp.c | 166 ++++++++++++++++++++++++++++++++++---------------- 4 files changed, 196 insertions(+), 69 deletions(-)
drivers/rtc/class.c +3 -0
@@ -161,6 +161,9 @@ static struct rtc_device *rtc_allocate_device(void)device_initialize (&rtc->dev); +/* Drivers can revise this default after allocating the device. */ + rtc->set_offset_nsec =NSEC_PER_SEC /2 ; + rtc->irq_freq =1 ; rtc->max_user_freq =64 ; rtc->dev.class = rtc_class;
drivers/rtc/systohc.c +38 -15
74 lines not on this page · raw message
include/linux/rtc.h +42 -1
61 lines not on this page · raw message
kernel/time/ntp.c +113 -53
195 lines not on this page · raw message
Signature · 1 line
2.7.4
PATCH 2/7 timekeeping: Consolidate timekeeping_inject_offset code
In reply to John StultzFrom: Arnd Bergmann <[email protected]>
The code to check the adjtimex() or clock_adjtime() arguments is spread out across multiple files for presumably only historic reasons. As a preparatation for a rework to get rid of the use of 'struct timeval' and 'struct timespec' in there, this moves all the portions into kernel/time/timekeeping.c and marks them as 'static'.
The warp_clock() function here is not as closely related as the others, but I feel it still makes sense to move it here in order to consolidate all callers of timekeeping_inject_offset().
--- include/linux/time.h | 26 ---------- kernel/time/ntp.c | 61 ---------------------- kernel/time/ntp_internal.h | 1 - kernel/time/time.c | 36 +------------ kernel/time/timekeeping.c | 123 ++++++++++++++++++++++++++++++++++++++++++++- kernel/time/timekeeping.h | 2 +- 6 files changed, 123 insertions(+), 126 deletions(-)
include/linux/time.h +0 -26
@@ -134,32 +134,6 @@ static inline bool timeval_valid(const struct timeval *tv)extern struct timespec timespec_trunc (struct timespec t,unsigned gran); -/* -* Validates if a timespec/timeval used to inject a time offset is valid. -* Offsets can be postive or negative. The value of the timeval/timespec -* is the sum of its fields, but *NOTE*: the field tv_usec/tv_nsec must -* always be non-negative. -*/ -static inline bool timeval_inject_offset_valid (const struct timeval *tv) -{ -/* We don't check the tv_sec as it can be positive or negative */ - -/* Can't have more microseconds then a second */ -if (tv->tv_usec <0 || tv->tv_usec >=USEC_PER_SEC ) -return false; -return true; -} - -static inline bool timespec_inject_offset_valid (const struct timespec *ts) -{ -/* We don't check the tv_sec as it can be positive or negative */ - -/* Can't have more nanoseconds then a second */ -if (ts->tv_nsec <0 || ts->tv_nsec >=NSEC_PER_SEC ) -return false; -return true; -} -/* Some architectures do not supply their own clocksource. * This is mainly the case in architectures that get their * inter-tick times by reading the counter on their interval
kernel/time/ntp.c +0 -61
67 lines not on this page · raw message
kernel/time/ntp_internal.h +0 -1
@@ -7,7 +7,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 ntp_validate_timex (struct timex *);extern int __do_adjtimex (struct timex *,struct timespec64 *,s32 *);extern void __hardpps (const struct timespec64 *,const struct timespec64 *);#endif /* _LINUX_NTP_INTERNAL_H */
kernel/time/time.c +1 -35
@@ -158,40 +158,6 @@ SYSCALL_DEFINE2(gettimeofday, struct timeval __user *, tv, }/* -* Indicates if there is an offset between the system clock and the hardware -* clock/persistent clock/rtc. -*/ -int persistent_clock_is_local; - -/* -* Adjust the time obtained from the CMOS to be UTC time instead of -* local time. -* -* This is ugly, but preferable to the alternatives. Otherwise we -* would either need to write a program to do it in /etc/rc (and risk -* confusion if the program gets run more than once; it would also be -* hard to make the program warp the clock precisely n hours) or -* compile in the timezone information into the kernel. Bad, bad.... -* -* - TYT, 1992-01-01 -* -* The best thing to do is to keep the CMOS clock in universal time (UTC) -* as real UNIX machines always do it. This avoids all headaches about -* daylight saving times and warping kernel clocks. -*/ -static inline void warp_clock (void ) -{ -if (sys_tz.tz_minuteswest !=0 ) { -struct timespec adjust; - - persistent_clock_is_local =1 ; - adjust.tv_sec = sys_tz.tz_minuteswest *60 ; - adjust.tv_nsec =0 ; -timekeeping_inject_offset (&adjust); - } -} - -/* * In case for some reason the CMOS clock has not already been running * in UTC, but in some local time: The first time we set the timezone, * we will warp the clock so that it is ticking UTC time instead of
@@ -224,7 +190,7 @@ int do_sys_settimeofday64(const struct timespec64 *tv, const struct timezone *tzif (firsttime) { firsttime =0 ;if (!tv) -warp_clock (); +timekeeping_warp_clock (); } }if (tv)
kernel/time/timekeeping.c +121 -2
147 lines not on this page · raw message
kernel/time/timekeeping.h +1 -1
@@ -10,7 +10,7 @@ extern ktime_t ktime_get_update_offsets_now(unsigned int *cwsseq,extern int timekeeping_valid_for_hres (void );extern u64 timekeeping_max_deferment (void ); -extern int timekeeping_inject_offset (struct timespec *ts); +extern void timekeeping_warp_clock (void );extern int timekeeping_suspend (void );extern void timekeeping_resume (void );
Signature · 1 line
2.7.4
PATCH 3/7 timekeeping: Use timespec64 in timekeeping_inject_offset
In reply to John StultzFrom: Arnd Bergmann <[email protected]>
As part of changing all the timekeeping code to use 64-bit time_t consistently, this removes the uses of timeval and timespec as much as possible from do_adjtimex() and timekeeping_inject_offset(). The timeval_inject_offset_valid() and timespec_inject_offset_valid() just complicate this, so I'm folding them into the respective callers.
This leaves the actual 'struct timex' definition, which is part of the user-space ABI and should be dealt with separately when we have agreed on the ABI change.
--- kernel/time/timekeeping.c | 72 ++++++++++++++++------------------------------- 1 file changed, 25 insertions(+), 47 deletions(-)
kernel/time/timekeeping.c +25 -47
@@ -1258,65 +1258,37 @@ int do_settimeofday64(const struct timespec64 *ts) }EXPORT_SYMBOL (do_settimeofday64); -/* -* Validates if a timespec/timeval used to inject a time offset is valid. -* Offsets can be postive or negative. The value of the timeval/timespec -* is the sum of its fields, but *NOTE*: the field tv_usec/tv_nsec must -* always be non-negative. -*/ -static inline bool timeval_inject_offset_valid (const struct timeval *tv) -{ -/* We don't check the tv_sec as it can be positive or negative */ - -/* Can't have more microseconds then a second */ -if (tv->tv_usec <0 || tv->tv_usec >=USEC_PER_SEC ) -return false; -return true; -} - -static inline bool timespec_inject_offset_valid (const struct timespec *ts) -{ -/* We don't check the tv_sec as it can be positive or negative */ - -/* Can't have more nanoseconds then a second */ -if (ts->tv_nsec <0 || ts->tv_nsec >=NSEC_PER_SEC ) -return false; -return true; -} -/** * timekeeping_inject_offset - Adds or subtracts from the current time. * @tv: pointer to the timespec variable containing the offset * * Adds or subtracts an offset value from the current time. */ -static int timekeeping_inject_offset (struct timespec *ts) +static int timekeeping_inject_offset (struct timespec64 *ts) {struct timekeeper *tk = &tk_core.timekeeper;unsigned long flags; -struct timespec64 ts64, tmp; +struct timespec64 tmp;int ret =0 ; -if (!timespec_inject_offset_valid (ts)) +if (ts->tv_nsec <0 || ts->tv_nsec >=NSEC_PER_SEC )return -EINVAL ; - ts64 =timespec_to_timespec64 (*ts); -raw_spin_lock_irqsave (&timekeeper_lock, flags);write_seqcount_begin (&tk_core.seq);timekeeping_forward_now (tk);/* Make sure the proposed value is valid */ - tmp =timespec64_add (tk_xtime (tk), ts64); -if (timespec64_compare (&tk->wall_to_monotonic, &ts64) >0 || + tmp =timespec64_add (tk_xtime (tk), *ts); +if (timespec64_compare (&tk->wall_to_monotonic, ts) >0 || !timespec64_valid_strict (&tmp)) { ret = -EINVAL ; goto error; } -tk_xtime_add (tk, &ts64); -tk_set_wall_to_mono (tk,timespec64_sub (tk->wall_to_monotonic, ts64)); +tk_xtime_add (tk, ts); +tk_set_wall_to_mono (tk,timespec64_sub (tk->wall_to_monotonic, *ts)); error:/* even if we error out, we forwarded the time, so call update */ timekeeping_update (tk,TK_CLEAR_NTP |TK_MIRROR |TK_CLOCK_WAS_SET );
@@ -1355,7 +1327,7 @@ int persistent_clock_is_local;void timekeeping_warp_clock (void ) {if (sys_tz.tz_minuteswest !=0 ) { -struct timespec adjust; +struct timespec64 adjust; persistent_clock_is_local =1 ; adjust.tv_sec = sys_tz.tz_minuteswest *60 ;
@@ -2307,9 +2279,9 @@ ktime_t ktime_get_update_offsets_now(unsigned int *cwsseq, ktime_t *offs_real, }/** -* ntp_validate_timex - Ensures the timex is ok for use in do_adjtimex +* timekeeping_validate_timex - Ensures the timex is ok for use in do_adjtimex */ -static int ntp_validate_timex (struct timex *txc) +static int timekeeping_validate_timex (struct timex *txc) {if (txc->modes &ADJ_ADJTIME ) {/* singleshot must not be used with any other mode bits */
@@ -2337,16 +2309,22 @@ static int ntp_validate_timex(struct timex *txc)if (!capable (CAP_SYS_TIME ))return -EPERM ; -if (txc->modes &ADJ_NANO ) { -struct timespec ts; +/* +* Validate if a timespec/timeval used to inject a time +* offset is valid. Offsets can be postive or negative, so +* we don't check tv_sec. The value of the timeval/timespec +* is the sum of its fields,but *NOTE*: +* The field tv_usec/tv_nsec must always be non-negative and +* we can't have more nanoseconds/microseconds than a second. +*/ +if (txc->time.tv_usec <0 ) +return -EINVAL ; - ts.tv_sec = txc->time.tv_sec; - ts.tv_nsec = txc->time.tv_usec; -if (!timespec_inject_offset_valid (&ts)) +if (txc->modes &ADJ_NANO ) { +if (txc->time.tv_usec >=NSEC_PER_SEC )return -EINVAL ; - }else { -if (!timeval_inject_offset_valid (&txc->time)) +if (txc->time.tv_usec >=USEC_PER_SEC )return -EINVAL ; } }
@@ -2378,12 +2356,12 @@ int do_adjtimex(struct timex *txc)int ret;/* Validate the data before disabling interrupts */ - ret =ntp_validate_timex (txc); + ret =timekeeping_validate_timex (txc);if (ret)return ret;if (txc->modes &ADJ_SETOFFSET ) { -struct timespec delta; +struct timespec64 delta; delta.tv_sec = txc->time.tv_sec; delta.tv_nsec = txc->time.tv_usec;if (!(txc->modes &ADJ_NANO ))
Signature · 1 line
2.7.4
PATCH 4/7 time: Remove unused functions
In reply to John StultzFrom: Arnd Bergmann <[email protected]>
The (slow but) ongoing work on conversion from timespec to timespec64 has led some timespec based helper functions to become unused.
No new code should use them, so we can remove the functions entirely. I'm planning to obsolete additional interfaces next and remove more of these.
--- include/linux/time.h | 18 ------------------ include/linux/time64.h | 28 ---------------------------- kernel/time/time.c | 18 ------------------ 3 files changed, 64 deletions(-)
include/linux/time.h +0 -18
@@ -39,15 +39,6 @@ static inline int timespec_compare(const struct timespec *lhs, const struct timereturn lhs->tv_nsec - rhs->tv_nsec; } -static inline int timeval_compare (const struct timeval *lhs,const struct timeval *rhs) -{ -if (lhs->tv_sec < rhs->tv_sec) -return -1 ; -if (lhs->tv_sec > rhs->tv_sec) -return 1 ; -return lhs->tv_usec - rhs->tv_usec; -} -extern time64_t mktime64 (const unsigned int year,const unsigned int mon,const unsigned int day,const unsigned int hour,const unsigned int min,const unsigned int sec);
@@ -65,15 +56,6 @@ static inline unsigned long mktime(const unsigned int year,extern void set_normalized_timespec (struct timespec *ts,time_t sec,s64 nsec); -/* -* timespec_add_safe assumes both values are positive and checks -* for overflow. It will return TIME_T_MAX if the reutrn would be -* smaller then either of the arguments. -*/ -extern struct timespec timespec_add_safe (const struct timespec lhs, -const struct timespec rhs); - -static inline struct timespec timespec_add (struct timespec lhs,struct timespec rhs) {
include/linux/time64.h +0 -28
@@ -53,16 +53,6 @@ static inline struct timespec64 timespec_to_timespec64(const struct timespec ts)return ts; } -static inline struct itimerspec itimerspec64_to_itimerspec (struct itimerspec64 *its64) -{ -return *its64; -} - -static inline struct itimerspec64 itimerspec_to_itimerspec64 (struct itimerspec *its) -{ -return *its; -} -# define timespec64_equal timespec_equal# define timespec64_compare timespec_compare# define set_normalized_timespec64 set_normalized_timespec
@@ -94,24 +84,6 @@ static inline struct timespec64 timespec_to_timespec64(const struct timespec ts)return ret; } -static inline struct itimerspec itimerspec64_to_itimerspec (struct itimerspec64 *its64) -{ -struct itimerspec ret; - - ret.it_interval =timespec64_to_timespec (its64->it_interval); - ret.it_value =timespec64_to_timespec (its64->it_value); -return ret; -} - -static inline struct itimerspec64 itimerspec_to_itimerspec64 (struct itimerspec *its) -{ -struct itimerspec64 ret; - - ret.it_interval =timespec_to_timespec64 (its->it_interval); - ret.it_value =timespec_to_timespec64 (its->it_value); -return ret; -} -static inline int timespec64_equal (const struct timespec64 *a,const struct timespec64 *b) {
kernel/time/time.c +0 -18
@@ -819,24 +819,6 @@ unsigned long nsecs_to_jiffies(u64 n)EXPORT_SYMBOL_GPL (nsecs_to_jiffies);/* -* Add two timespec values and do a safety check for overflow. -* It's assumed that both values are valid (>= 0) -*/ -struct timespec timespec_add_safe (const struct timespec lhs, -const struct timespec rhs) -{ -struct timespec res; - -set_normalized_timespec (&res, lhs.tv_sec + rhs.tv_sec, - lhs.tv_nsec + rhs.tv_nsec); - -if (res.tv_sec < lhs.tv_sec || res.tv_sec < rhs.tv_sec) - res.tv_sec =TIME_T_MAX ; - -return res; -} - -/* * Add two timespec64 values and do a safety check for overflow. * It's assumed that both values are valid (>= 0). * And, each timespec64 is in normalized form.
Signature · 1 line
2.7.4
PATCH 5/7 time: Move time_t based interfaces to time32.h
In reply to John StultzFrom: Arnd Bergmann <[email protected]>
Interfaces based on 'struct timespec' or 'struct timeval' should no longer be used for new code, which can use either ktime_t or 'struct timespec64' instead.
To make this a little clearer, this moves the various helpers into a new time32.h header. For the moment, this gets included by the normal time.h, but we may be able to separate it entirely when most users of time32.h are gone.
Individual helpers in the new file can get removed once they become unused in the future.
Since the contents of time32.h look a lot like what's in time64.h, I'm reordering them during the move to make them more similar, and to allow a follow-up patch to redirect the 'timespec' based functions to thei 'timespec64' based counterparts on 64-bit architectures later.
--- include/linux/time.h | 163 +-------------------------------------------- include/linux/time32.h | 176 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 177 insertions(+), 162 deletions(-) create mode 100644 include/linux/time32.h
include/linux/time.h +1 -162
@@ -17,105 +17,10 @@ int get_itimerspec64(struct itimerspec64 *it,int put_itimerspec64 (const struct itimerspec64 *it,struct itimerspec __user *uit); -#define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1) - -static inline int timespec_equal (const struct timespec *a, -const struct timespec *b) -{ -return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec); -} - -/* -* lhs < rhs: return <0 -* lhs == rhs: return 0 -* lhs > rhs: return >0 -*/ -static inline int timespec_compare (const struct timespec *lhs,const struct timespec *rhs) -{ -if (lhs->tv_sec < rhs->tv_sec) -return -1 ; -if (lhs->tv_sec > rhs->tv_sec) -return 1 ; -return lhs->tv_nsec - rhs->tv_nsec; -} -extern time64_t mktime64 (const unsigned int year,const unsigned int mon,const unsigned int day,const unsigned int hour,const unsigned int min,const unsigned int sec); -/** -* Deprecated. Use mktime64(). -*/ -static inline unsigned long mktime (const unsigned int year, -const unsigned int mon,const unsigned int day, -const unsigned int hour,const unsigned int min, -const unsigned int sec) -{ -return mktime64 (year, mon, day, hour, min, sec); -} - -extern void set_normalized_timespec (struct timespec *ts,time_t sec,s64 nsec); - -static inline struct timespec timespec_add (struct timespec lhs, -struct timespec rhs) -{ -struct timespec ts_delta; -set_normalized_timespec (&ts_delta, lhs.tv_sec + rhs.tv_sec, - lhs.tv_nsec + rhs.tv_nsec); -return ts_delta; -} - -/* -* sub = lhs - rhs, in normalized form -*/ -static inline struct timespec timespec_sub (struct timespec lhs, -struct timespec rhs) -{ -struct timespec ts_delta; -set_normalized_timespec (&ts_delta, lhs.tv_sec - rhs.tv_sec, - lhs.tv_nsec - rhs.tv_nsec); -return ts_delta; -} - -/* -* Returns true if the timespec is norm, false if denorm: -*/ -static inline bool timespec_valid (const struct timespec *ts) -{ -/* Dates before 1970 are bogus */ -if (ts->tv_sec <0 ) -return false; -/* Can't have more nanoseconds then a second */ -if ((unsigned long )ts->tv_nsec >=NSEC_PER_SEC ) -return false; -return true; -} - -static inline bool timespec_valid_strict (const struct timespec *ts) -{ -if (!timespec_valid (ts)) -return false; -/* Disallow values that could overflow ktime_t */ -if ((unsigned long long )ts->tv_sec >=KTIME_SEC_MAX ) -return false; -return true; -} - -static inline bool timeval_valid (const struct timeval *tv) -{ -/* Dates before 1970 are bogus */ -if (tv->tv_sec <0 ) -return false; - -/* Can't have more microseconds then a second */ -if (tv->tv_usec <0 || tv->tv_usec >=USEC_PER_SEC ) -return false; - -return true; -} - -extern struct timespec timespec_trunc (struct timespec t,unsigned gran); -/* Some architectures do not supply their own clocksource. * This is mainly the case in architectures that get their * inter-tick times by reading the counter on their interval
@@ -164,73 +69,7 @@ struct tm {void time64_to_tm (time64_t totalsecs,int offset,struct tm *result); -/** -* time_to_tm - converts the calendar time to local broken-down time -* -* @totalsecs the number of seconds elapsed since 00:00:00 on January 1, 1970, -* Coordinated Universal Time (UTC). -* @offset offset seconds adding to totalsecs. -* @result pointer to struct tm variable to receive broken-down time -*/ -static inline void time_to_tm (time_t totalsecs,int offset,struct tm *result) -{ -time64_to_tm (totalsecs, offset, result); -} - -/** -* timespec_to_ns - Convert timespec to nanoseconds -* @ts: pointer to the timespec variable to be converted -* -* Returns the scalar nanosecond representation of the timespec -* parameter. -*/ -static inline s64 timespec_to_ns (const struct timespec *ts) -{ -return ((s64 ) ts->tv_sec *NSEC_PER_SEC ) + ts->tv_nsec; -} - -/** -* timeval_to_ns - Convert timeval to nanoseconds -* @ts: pointer to the timeval variable to be converted -* -* Returns the scalar nanosecond representation of the timeval -* parameter. -*/ -static inline s64 timeval_to_ns (const struct timeval *tv) -{ -return ((s64 ) tv->tv_sec *NSEC_PER_SEC ) + - tv->tv_usec *NSEC_PER_USEC ; -} - -/** -* ns_to_timespec - Convert nanoseconds to timespec -* @nsec: the nanoseconds value to be converted -* -* Returns the timespec representation of the nsec parameter. -*/ -extern struct timespec ns_to_timespec (const s64 nsec); - -/** -* ns_to_timeval - Convert nanoseconds to timeval -* @nsec: the nanoseconds value to be converted -* -* Returns the timeval representation of the nsec parameter. -*/ -extern struct timeval ns_to_timeval (const s64 nsec); - -/** -* timespec_add_ns - Adds nanoseconds to a timespec -* @a: pointer to timespec to be incremented -* @ns: unsigned nanoseconds value to be added -* -* This must always be inlined because its used from the x86-64 vdso, -* which cannot call other kernel functions. -*/ -static __always_inline void timespec_add_ns(struct timespec *a, u64 ns) -{ - a->tv_sec +=__iter_div_u64_rem (a->tv_nsec + ns,NSEC_PER_SEC , &ns); - a->tv_nsec = ns; -} +# include <linux/time32.h> static inline bool itimerspec64_valid (const struct itimerspec64 *its) {
include/linux/time32.h new file +176 -0
176 lines not on this page · raw message
Signature · 1 line
2.7.4
PATCH 6/7 time: Move time_t conversion helpers to time32.h
In reply to John StultzFrom: Arnd Bergmann <[email protected]>
On 64-bit architectures, the timespec64 based helpers in linux/time.h are defined as macros pointing to their timespec based counterparts. This made sense when they were first introduced, but as we are migrating away from timespec in general, it's much less intuitive now.
This changes the macros to work in the exact opposite way: we always provide the timespec64 based helpers and define the old interfaces as macros for them. Now we can move those macros into linux/time32.h, which already contains the respective helpers for 32-bit architectures.
--- include/linux/time32.h | 45 +++++++++++++++++++++++++++++++++++++++++++++ include/linux/time64.h | 50 +------------------------------------------------- kernel/time/time.c | 5 +++-- 3 files changed, 49 insertions(+), 51 deletions(-)
include/linux/time32.h +45 -0
@@ -13,6 +13,49 @@#define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1) +#if __BITS_PER_LONG ==64 + +/* timespec64 is defined as timespec here */ +static inline struct timespec timespec64_to_timespec (const struct timespec64 ts64) +{ +return ts64; +} + +static inline struct timespec64 timespec_to_timespec64 (const struct timespec ts) +{ +return ts; +} + +# define timespec_equal timespec64_equal +# define timespec_compare timespec64_compare +# define set_normalized_timespec set_normalized_timespec64 +# define timespec_add timespec64_add +# define timespec_sub timespec64_sub +# define timespec_valid timespec64_valid +# define timespec_valid_strict timespec64_valid_strict +# define timespec_to_ns timespec64_to_ns +# define ns_to_timespec ns_to_timespec64 +# define timespec_add_ns timespec64_add_ns + +#else +static inline struct timespec timespec64_to_timespec (const struct timespec64 ts64) +{ +struct timespec ret; + + ret.tv_sec = (time_t )ts64.tv_sec; + ret.tv_nsec = ts64.tv_nsec; +return ret; +} + +static inline struct timespec64 timespec_to_timespec64 (const struct timespec ts) +{ +struct timespec64 ret; + + ret.tv_sec = ts.tv_sec; + ret.tv_nsec = ts.tv_nsec; +return ret; +} +static inline int timespec_equal (const struct timespec *a,const struct timespec *b) {
@@ -116,6 +159,8 @@ static __always_inline void timespec_add_ns(struct timespec *a, u64 ns) a->tv_nsec = ns; } +#endif +/** * time_to_tm - converts the calendar time to local broken-down time *
include/linux/time64.h +1 -49
69 lines not on this page · raw message
kernel/time/time.c +3 -2
@@ -407,6 +407,7 @@ time64_t mktime64(const unsigned int year0, const unsigned int mon0, }EXPORT_SYMBOL (mktime64); +#if __BITS_PER_LONG ==32 /** * set_normalized_timespec - set timespec sec and nsec parts and normalize *
@@ -467,6 +468,7 @@ struct timespec ns_to_timespec(const s64 nsec) return ts; }EXPORT_SYMBOL (ns_to_timespec); +#endif /** * ns_to_timeval - Convert nanoseconds to timeval
@@ -486,7 +488,6 @@ struct timeval ns_to_timeval(const s64 nsec) }EXPORT_SYMBOL (ns_to_timeval); -#if BITS_PER_LONG ==32 /** * set_normalized_timespec - set timespec sec and nsec parts and normalize *
@@ -547,7 +548,7 @@ struct timespec64 ns_to_timespec64(const s64 nsec)return ts; }EXPORT_SYMBOL (ns_to_timespec64); -#endif +/** * msecs_to_jiffies: - convert milliseconds to jiffies * @m: time in milliseconds
Signature · 1 line
2.7.4
PATCH 7/7 time: Move old timekeeping interfaces to timekeeping32.h
In reply to John StultzFrom: Arnd Bergmann <[email protected]>
The interfaces based on 'struct timespec' and 'unsigned long' seconds are no longer recommended for new code, and we are trying to migrate to ktime_t based interfaces and other y2038-safe variants.
This moves all the legacy interfaces from linux/timekeeping.h into a new timekeeping32.h to better document this.
--- include/linux/ktime.h | 1 + include/linux/timekeeping.h | 137 +------------------------------------- include/linux/timekeeping32.h | 151 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 154 insertions(+), 135 deletions(-) create mode 100644 include/linux/timekeeping32.h
include/linux/ktime.h +1 -0
@@ -270,5 +270,6 @@ static inline ktime_t ms_to_ktime(u64 ms) }# include <linux/timekeeping.h> +# include <linux/timekeeping32.h> #endif
include/linux/timekeeping.h +2 -135
178 lines not on this page · raw message
include/linux/timekeeping32.h new file +151 -0
151 lines not on this page · raw message
Signature · 1 line
2.7.4
Quoted 21 lines · John Stultz
Hey Thomas,
Bit later then I'd like, but here's my current queue of
timekeeping items for 4.15.Quoted 1 line
From Arnd's patchset, I'm missing the last patch as it didn't
apply properly, but the rest of it looked ok to me.
Please let me know if you have any objections.
thanks
-johnCc Arnd Bergmann <[email protected]>Cc Jason Gunthorpe <[email protected]>Cc Thomas Gleixner <[email protected]>Cc Ingo Molnar <[email protected]>Cc Miroslav Lichvar <[email protected]>Cc Richard Cochran <[email protected]>Cc Prarit Bhargava <[email protected]>Cc Stephen Boyd <[email protected]>
Quoted 7 lines
The following changes since commit
9e66317d3c92ddaab330c125dfe9d06eee268aff:Linux 4.14-rc3 (2017-10-01 14:54:54 -0700)
are available in the git repository at:
https://git.linaro.org/people/john.stultz/linux.git
6546911ed369af8d747215ff8b6144618e91c6ab
That should have been fortglx/4.15/time instead of the sha1 of the top commit there.
Thanks,
tglx