Y2038

y2038@lists.linaro.org

1135 discussions

[PATCH 00/11] Convert the posix_clock_operations and k_clock structure to ready for 2038

by Baolin Wang

This patch series changes the 32-bit time type (timespec/itimerspec) to the 64-bit one (timespec64/itimerspec64), since 32-bit time types will break in the year 2038. This patch series introduces new methods with timespec64/itimerspec64 type, and removes the old ones with timespec/itimerspec type for posix_clock_operations and k_clock structure. Also introduces some new functions with timespec64/itimerspec64 type, like current_kernel_time64(), hrtimer_get_res64(), cputime_to_timespec64() and timespec64_to_cputime(). Baolin Wang (11): linux/time64.h:Introduce the 'struct itimerspec64' for 64bit timekeeping:Introduce the current_kernel_time64() function with timespec64 type time/hrtimer:Introduce hrtimer_get_res64() with timespec64 type for getting the timer resolution posix timers:Introduce the 64bit methods with timespec64 type for k_clock structure time/posix-timers:Convert to the 64bit methods for k_clock callback functions char/mmtimer:Convert to the 64bit methods for k_clock callback function time/alarmtimer:Convert to the new methods for k_clock structure time/posix-clock:Convert to the 64bit methods for k_clock and posix_clock_operations structure cputime:Introduce the cputime_to_timespec64/timespec64_to_cputime function time/posix-cpu-timers:Convert to the 64bit methods for k_clock structure k_clock:Remove the 32bit methods with timespec type arch/powerpc/include/asm/cputime.h | 6 +- arch/s390/include/asm/cputime.h | 8 +- drivers/char/mmtimer.c | 36 ++++---- drivers/ptp/ptp_clock.c | 26 ++---- include/asm-generic/cputime_jiffies.h | 10 +-- include/linux/cputime.h | 15 ++++ include/linux/hrtimer.h | 12 ++- include/linux/jiffies.h | 3 + include/linux/posix-clock.h | 10 +-- include/linux/posix-timers.h | 18 ++-- include/linux/time64.h | 13 +++ include/linux/timekeeping.h | 14 ++- kernel/time/alarmtimer.c | 43 ++++----- kernel/time/hrtimer.c | 10 +-- kernel/time/posix-clock.c | 20 ++--- kernel/time/posix-cpu-timers.c | 83 +++++++++-------- kernel/time/posix-timers.c | 157 +++++++++++++++++++-------------- kernel/time/time.c | 21 +++++ kernel/time/timekeeping.c | 6 +- kernel/time/timekeeping.h | 2 +- 20 files changed, 302 insertions(+), 211 deletions(-) -- 1.7.9.5

10 years, 2 months

Getting started

by Julian Gindi

Howdy, Looking for low-hanging fruit tasks that I can tackle. Any advice? -jhg

10 years, 2 months

[PATCH] Staging: rts5208: Remove timeval

by Ksenija Stanojevic

32-bit systems using struct timeval will break in the year 2038, so we have to replace that code with more appropriate types. ktime_get() is better than using do_gettimeofday(), because it uses the monotonic clock. ktime_to_us() is used to convert ktime to microseconds. Signed-off-by: Ksenija Stanojevic <ksenija.stanojevic(a)gmail.com> --- drivers/staging/rts5208/rtsx.h | 20 ++++++++------------ 1 file changed, 8 insertions(+), 12 deletions(-) diff --git a/drivers/staging/rts5208/rtsx.h b/drivers/staging/rts5208/rtsx.h index 9e6ecb7..5c79d7d 100644 --- a/drivers/staging/rts5208/rtsx.h +++ b/drivers/staging/rts5208/rtsx.h @@ -37,7 +37,7 @@ #include <linux/cdrom.h> #include <linux/workqueue.h> #include <linux/timer.h> -#include <linux/time.h> +#include <linux/ktime.h> #include <scsi/scsi.h> #include <scsi/scsi_cmnd.h> @@ -151,21 +151,17 @@ static inline struct rtsx_dev *host_to_rtsx(struct Scsi_Host *host) static inline void get_current_time(u8 *timeval_buf, int buf_len) { - struct timeval tv; + u64 us; - if (!timeval_buf || (buf_len < 8)) + if (!timeval_buf || (buf_len < 4)) return; - do_gettimeofday(&tv); + us = ktime_to_us(ktime_get()); - timeval_buf[0] = (u8)(tv.tv_sec >> 24); - timeval_buf[1] = (u8)(tv.tv_sec >> 16); - timeval_buf[2] = (u8)(tv.tv_sec >> 8); - timeval_buf[3] = (u8)(tv.tv_sec); - timeval_buf[4] = (u8)(tv.tv_usec >> 24); - timeval_buf[5] = (u8)(tv.tv_usec >> 16); - timeval_buf[6] = (u8)(tv.tv_usec >> 8); - timeval_buf[7] = (u8)(tv.tv_usec); + timeval_buf[0] = (u8)(us >> 24); + timeval_buf[1] = (u8)(us >> 16); + timeval_buf[2] = (u8)(us >> 8); + timeval_buf[3] = (u8)(us); } /* The scsi_lock() and scsi_unlock() macros protect the sm_state and the -- 1.9.1

10 years, 2 months

[PATCH v5 00/11] Convert the posix clock operation and k_clock structure to ready for 2038

by Baolin Wang

This patch series change the 32-bit time type (timespec/itimerspec) to the 64-bit one (timespec64/itimerspec64), since 32-bit time types will break in the year 2038. This patch series introduce new methods with timespec64/itimerspec64 type, and remove the old ones with timespec/itimerspec type for posix_clock_operations and k_clock structure. Changes since v4: - Modify the conversion between the itimerspec64 and itimerspec for 64bit. - Continue to split up and merge the patch. - Explain more for the patch log. - Re-order the patch of the patch series. Next step will replace the other callback pointers of k_clock structure. Baolin Wang (11): linux/time64.h:Introduce the 'struct itimerspec64' for 64bit timekeeping:Introduce the current_kernel_time64() function with timespec64 type time/hrtimer:Introduce hrtimer_get_res64() with timespec64 type for getting the timer resolution posix timers:Introduce the 64bit methods with timespec64 type for k_clock structure time/posix-timers:Convert to the 64bit methods for k_clock callback functions char/mmtimer:Convert to the 64bit methods for k_clock callback function time/alarmtimer:Convert to the new methods for k_clock structure time/posix-clock:Convert to the 64bit methods for k_clock and posix_clock_operations structure cputime:Introduce the cputime_to_timespec64/timespec64_to_cputime function time/posix-cpu-timers:Convert to the 64bit methods for k_clock structure k_clock:Remove the 32bit methods with timespec type arch/powerpc/include/asm/cputime.h | 24 +++++ arch/s390/include/asm/cputime.h | 26 ++++++ drivers/char/mmtimer.c | 36 ++++---- drivers/ptp/ptp_clock.c | 26 ++---- include/asm-generic/cputime_jiffies.h | 8 ++ include/linux/hrtimer.h | 12 ++- include/linux/jiffies.h | 3 + include/linux/posix-clock.h | 10 +-- include/linux/posix-timers.h | 18 ++-- include/linux/time64.h | 45 ++++++++++ include/linux/timekeeping.h | 14 ++- kernel/time/alarmtimer.c | 43 ++++----- kernel/time/hrtimer.c | 10 +-- kernel/time/posix-clock.c | 20 ++--- kernel/time/posix-cpu-timers.c | 83 +++++++++-------- kernel/time/posix-timers.c | 157 +++++++++++++++++++-------------- kernel/time/time.c | 21 +++++ kernel/time/timekeeping.c | 6 +- kernel/time/timekeeping.h | 2 +- 19 files changed, 365 insertions(+), 199 deletions(-) -- 1.7.9.5

10 years, 2 months

[PATCH v4 00/12] Convert the posix clock operation and k_clock structure to ready for 2038

by Baolin Wang

This patch series change the 32-bit time type (timespec/itimerspec) to the 64-bit one (timespec64/itimerspec64), since 32-bit time types will break in the year 2038. This patch series introduce new methods with timespec64/itimerspec64 type, and remove the old ones with timespec/itimerspec type for posix clock operation and k_clock structure. Changes since v3: - Introduce the new structure 'itimerspec64' for 64bit and the conversion function. - Separate original one patch into two patches. - Remove the 32bit unused code - Re-order the patch of the patch series. Next step will replace the other callback pointers of k_clock structure. Baolin Wang (12): linux/time64.h:Introduce the 'struct itimerspec64' for 64bit posix_clock:Introduce the new methods with explicit 64 bit seconds timekeeping:Introduce the current_kernel_time64() function with timespec64 type time/hrtimer:Introduce hrtimer_get_res64() with timespec64 type for getting the timer resolution posix timers:Introduce the 64bit methods with timespec64 type for k_clock structure time/posix-timers:Convert to the 64bit methods for k_clock callback functions char/mmtimer:Convert to the 64bit methods for k_clock callback function time/alarmtimer:Convert to the new methods for k_clock structure time/posix-clock:Convert to the 64bit methods for k_clock structure time:Introduce the cputime_to_timespec64/timespec64_to_cputime function time/posix-cpu-timers:Convert to the 64bit methods for k_clock structure k_clock:Remove the 32bit methods with timespec type arch/powerpc/include/asm/cputime.h | 24 +++++ arch/s390/include/asm/cputime.h | 26 ++++++ drivers/char/mmtimer.c | 38 ++++---- drivers/ptp/ptp_clock.c | 26 ++---- include/asm-generic/cputime_jiffies.h | 8 ++ include/linux/hrtimer.h | 12 ++- include/linux/jiffies.h | 3 + include/linux/posix-clock.h | 10 +-- include/linux/posix-timers.h | 18 ++-- include/linux/time64.h | 37 ++++++++ include/linux/timekeeping.h | 14 ++- kernel/time/alarmtimer.c | 43 ++++----- kernel/time/hrtimer.c | 10 +-- kernel/time/posix-clock.c | 21 ++--- kernel/time/posix-cpu-timers.c | 83 +++++++++-------- kernel/time/posix-timers.c | 159 +++++++++++++++++++-------------- kernel/time/time.c | 21 +++++ kernel/time/timekeeping.c | 6 +- kernel/time/timekeeping.h | 2 +- 19 files changed, 361 insertions(+), 200 deletions(-) -- 1.7.9.5

10 years, 2 months

Re: [Y2038] [RFC][PATCH] timekeeping: Limit system time to prevent 32-bit time_t overflow

by Arnd Bergmann

On Wednesday 15 April 2015 17:41:28 Miroslav Lichvar wrote: > On systems with 32-bit time_t, it seems there are quite a few problems > that applications may have with time overflowing in year 2038. Beside > getting in an unexpected state by not checking integer operations with > time_t variables, some system calls have unexpected behavior, e.g. the > system time can't be set back to the current time (negative value), > timers with the ABSTIME flag can't be set (negative value) or they > expire immediately (current time is always larger). > > It would be unrealistic to expect all applications to be able to handle > all these problems. Year 2038 is still many years away, but this can be > a problem even now. The clock can be set close to the overflow > accidentally or maliciously, e.g. when the clock is synchronized over > network by NTP or PTP. > > This patch sets a maximum value of the system time to prevent the system > time from getting too close to the overflow. The time can't be set to a > larger value. When the maximum is reached in normal time accumulation, > the clock will be stepped back by one week. > > A new kernel sysctl time_max is added to select the maximum time. It can > be set to 0 for no limit, 1 for one week before 32-bit time_t overflow, > and 2 for one week before ktime_t overflow. The default value is 1 with > 32-bit time_t and 2 with 64-bit time_t. This can be changed later to be > always 2 when 64-bit versions of system calls using 32-bit time_t are > available. > > Signed-off-by: Miroslav Lichvar <mlichvar(a)redhat.com> I have just created a y2038(a)lists.linaro.org mailing list, added to Cc in this reply. The patch looks basically ok to me, though I have no opinion on whether a sysctl is the best API for configuring this. Arnd > --- > Documentation/sysctl/kernel.txt | 19 +++++++++++++ > include/linux/timekeeping.h | 5 ++++ > include/uapi/linux/sysctl.h | 1 + > kernel/sysctl.c | 9 ++++++ > kernel/sysctl_binary.c | 1 + > kernel/time/timekeeping.c | 62 +++++++++++++++++++++++++++++++++++++---- > 6 files changed, 91 insertions(+), 6 deletions(-) > > diff --git a/Documentation/sysctl/kernel.txt b/Documentation/sysctl/kernel.txt > index 83ab256..08e4f28 100644 > --- a/Documentation/sysctl/kernel.txt > +++ b/Documentation/sysctl/kernel.txt > @@ -82,6 +82,7 @@ show up in /proc/sys/kernel: > - sysctl_writes_strict > - tainted > - threads-max > +- time_max > - unknown_nmi_panic > - watchdog_thresh > - version > @@ -847,6 +848,24 @@ can be ORed together: > > ============================================================== > > +time_max: > + > +Select the maximum allowed value of the system time. The system clock cannot be > +set to a larger value and when it reaches the maximum on its own, it will be > +stepped back by one week. > + > +0: No limit. > + > +1: One week before 32-bit time_t overflows, i.e. Jan 12 03:14:07 UTC 2038. > + This is currently the default value with 32-bit time_t, but it will likely > + change when 64-bit versions of system calls using time_t are available. > + > +2: One week before time in the internal kernel representation (ktime_t) > + overflows, i.e. Apr 4 23:47:16 UTC 2262. This is the default value with > + 64-bit time_t. > + > +============================================================== > + > unknown_nmi_panic: > > The value in this file affects behavior of handling NMI. When the > diff --git a/include/linux/timekeeping.h b/include/linux/timekeeping.h > index 99176af..51fc970 100644 > --- a/include/linux/timekeeping.h > +++ b/include/linux/timekeeping.h > @@ -5,6 +5,11 @@ > > void timekeeping_init(void); > extern int timekeeping_suspended; > +extern int sysctl_time_max; > + > +struct ctl_table; > +extern int sysctl_time_max_handler(struct ctl_table *table, int write, > + void __user *buffer, size_t *length, loff_t *ppos); > > /* > * Get and set timeofday > diff --git a/include/uapi/linux/sysctl.h b/include/uapi/linux/sysctl.h > index 0956373..8fd2aab 100644 > --- a/include/uapi/linux/sysctl.h > +++ b/include/uapi/linux/sysctl.h > @@ -154,6 +154,7 @@ enum > KERN_NMI_WATCHDOG=75, /* int: enable/disable nmi watchdog */ > KERN_PANIC_ON_NMI=76, /* int: whether we will panic on an unrecovered */ > KERN_PANIC_ON_WARN=77, /* int: call panic() in WARN() functions */ > + KERN_TIMEMAX=78, /* int: select maximum allowed system time */ > }; > > > diff --git a/kernel/sysctl.c b/kernel/sysctl.c > index ce410bb..6713a5b 100644 > --- a/kernel/sysctl.c > +++ b/kernel/sysctl.c > @@ -1120,6 +1120,15 @@ static struct ctl_table kern_table[] = { > .extra1 = &zero, > .extra2 = &one, > }, > + { > + .procname = "time_max", > + .data = &sysctl_time_max, > + .maxlen = sizeof(int), > + .mode = 0644, > + .proc_handler = sysctl_time_max_handler, > + .extra1 = &zero, > + .extra2 = &two, > + }, > { } > }; > > diff --git a/kernel/sysctl_binary.c b/kernel/sysctl_binary.c > index 7e7746a..66c0946 100644 > --- a/kernel/sysctl_binary.c > +++ b/kernel/sysctl_binary.c > @@ -138,6 +138,7 @@ static const struct bin_table bin_kern_table[] = { > { CTL_INT, KERN_MAX_LOCK_DEPTH, "max_lock_depth" }, > { CTL_INT, KERN_PANIC_ON_NMI, "panic_on_unrecovered_nmi" }, > { CTL_INT, KERN_PANIC_ON_WARN, "panic_on_warn" }, > + { CTL_INT, KERN_TIMEMAX, "time_max" }, > {} > }; > > diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c > index 946acb7..112932f 100644 > --- a/kernel/time/timekeeping.c > +++ b/kernel/time/timekeeping.c > @@ -32,6 +32,9 @@ > #define TK_MIRROR (1 << 1) > #define TK_CLOCK_WAS_SET (1 << 2) > > +#define SEC_PER_DAY (24 * 3600) > +#define SEC_PER_WEEK (7 * SEC_PER_DAY) > + > /* > * The most important data for readout fits into a single 64 byte > * cache line. > @@ -884,6 +887,37 @@ EXPORT_SYMBOL(getnstime_raw_and_real); > > #endif /* CONFIG_NTP_PPS */ > > +/* Maximum allowed system time as a sysctl setting and in seconds */ > +int sysctl_time_max __read_mostly; > +static u64 time_max_sec __read_mostly; > + > +static void update_time_max_sec(int tm) > +{ > + if (tm > 1) { > + /* One week before ktime_t overflow */ > + time_max_sec = KTIME_SEC_MAX - SEC_PER_WEEK; > + } else if (tm == 1) { > + /* One week before 32-bit time_t overflow */ > + time_max_sec = 0x7fffffff - SEC_PER_WEEK; > + } else { > + /* No limit */ > + time_max_sec = -1; > + } > +} > + > +int sysctl_time_max_handler(struct ctl_table *table, int write, > + void __user *buffer, size_t *length, loff_t *ppos) > +{ > + int rc; > + > + rc = proc_dointvec_minmax(table, write, buffer, length, ppos); > + if (rc) > + return rc; > + > + update_time_max_sec(sysctl_time_max); > + return 0; > +} > + > /** > * do_gettimeofday - Returns the time of day in a timeval > * @tv: pointer to the timeval to be set > @@ -912,7 +946,7 @@ int do_settimeofday64(const struct timespec64 *ts) > struct timespec64 ts_delta, xt; > unsigned long flags; > > - if (!timespec64_valid_strict(ts)) > + if (!timespec64_valid_strict(ts) || ts->tv_sec >= time_max_sec) > return -EINVAL; > > raw_spin_lock_irqsave(&timekeeper_lock, flags); > @@ -965,7 +999,7 @@ int timekeeping_inject_offset(struct timespec *ts) > > /* Make sure the proposed value is valid */ > tmp = timespec64_add(tk_xtime(tk), ts64); > - if (!timespec64_valid_strict(&tmp)) { > + if (!timespec64_valid_strict(&tmp) || tmp.tv_sec >= time_max_sec) { > ret = -EINVAL; > goto error; > } > @@ -1238,6 +1272,10 @@ void __init timekeeping_init(void) > write_seqcount_begin(&tk_core.seq); > ntp_init(); > > + /* For now, prevent 32-bit time_t overflow by default */ > + sysctl_time_max = sizeof(time_t) > 4 ? 2 : 1; > + update_time_max_sec(sysctl_time_max); > + > clock = clocksource_default_clock(); > if (clock->enable) > clock->enable(clock); > @@ -1687,23 +1725,35 @@ static inline unsigned int accumulate_nsecs_to_secs(struct timekeeper *tk) > > while (tk->tkr_mono.xtime_nsec >= nsecps) { > int leap; > + s64 step; > > tk->tkr_mono.xtime_nsec -= nsecps; > tk->xtime_sec++; > > /* Figure out if its a leap sec and apply if needed */ > leap = second_overflow(tk->xtime_sec); > - if (unlikely(leap)) { > + step = leap; > + > + /* If the system time reached the maximum, step it back */ > + if (unlikely(tk->xtime_sec >= time_max_sec)) { > + step = time_max_sec - tk->xtime_sec - SEC_PER_WEEK; > + printk(KERN_NOTICE > + "Clock: maximum time reached, stepping back\n"); > + } > + > + if (unlikely(step)) { > struct timespec64 ts; > > - tk->xtime_sec += leap; > + tk->xtime_sec += step; > > - ts.tv_sec = leap; > + ts.tv_sec = step; > ts.tv_nsec = 0; > tk_set_wall_to_mono(tk, > timespec64_sub(tk->wall_to_monotonic, ts)); > > - __timekeeping_set_tai_offset(tk, tk->tai_offset - leap); > + if (leap) > + __timekeeping_set_tai_offset(tk, > + tk->tai_offset - leap); > > clock_set = TK_CLOCK_WAS_SET; > } >

10 years, 2 months

new mailing list for y2038

by Arnd Bergmann

Hi, I've created a new mailing list on the Linaro mailing list server for discussing the kernel patches for y2038: https://lists.linaro.org/mailman/listinfo/y2038 Please join if you are interested in discussing these or want to send patches. The intention at the moment much to keep this list explicitly open to newbies, so we will get a lot of incorrect patches there along with other patches. Patches can get sent here for an initial review before they get sent to the real maintainers, or you can put the list on Cc when sending a patch that should be applied and you already know what you are doing. We already got a lot of patches last year through the Outreachy (then known as OPW) application process, and John and I also use this work as part of our Linaro job to train new kernel developers. There also a wiki page at http://kernelnewbies.org/y2038 to describe what we are doing, and anybody who wants to help out here is welcome to contribute patches on this list. Arnd

10 years, 2 months

Re: [Y2038] [PATCH v3 10/10] k_clock:Remove the 32bit methods with timespec type

by Arnd Bergmann

On Saturday 11 April 2015 18:46:56 Baolin Wang wrote: > All of the k_clock users have been converted to the new methods. This patch > removes the older methods with timepsec type. As a result, the k_clock > structure is ready for the year 2038. > > Signed-off-by: Baolin Wang <baolin.wang(a)linaro.org> > --- As mentioned in my earlier reply to an older thread, a better way to do this would be to just remove the unused function calls (clock_set, clock_get, clock_getres) and leave the newly introduced code in place. Otherwise the patch is technically correct as far as I can tell, so this is more of a style issue. Arnd > diff --git a/drivers/char/mmtimer.c b/drivers/char/mmtimer.c > index 1d64a0e..c70f82b 100644 > --- a/drivers/char/mmtimer.c > +++ b/drivers/char/mmtimer.c > @@ -773,9 +773,9 @@ static int sgi_clock_getres(const clockid_t which_clock, struct timespec64 *tp) > } > > static struct k_clock sgi_clock = { > - .clock_set64 = sgi_clock_set, > - .clock_get64 = sgi_clock_get, > - .clock_getres64 = sgi_clock_getres, > + .clock_set = sgi_clock_set, > + .clock_get = sgi_clock_get, > + .clock_getres = sgi_clock_getres, > .timer_create = sgi_timer_create, > .timer_set = sgi_timer_set, > .timer_del = sgi_timer_del, > diff --git a/include/linux/posix-timers.h b/include/linux/posix-timers.h > index ff0b81f..4059129 100644 > --- a/include/linux/posix-timers.h > +++ b/include/linux/posix-timers.h > @@ -97,15 +97,11 @@ struct k_itimer { > }; > > struct k_clock { > - int (*clock_getres) (const clockid_t which_clock, struct timespec *tp); > - int (*clock_getres64) (const clockid_t which_clock, > + int (*clock_getres) (const clockid_t which_clock, > struct timespec64 *tp); > int (*clock_set) (const clockid_t which_clock, > - const struct timespec *tp); > - int (*clock_set64) (const clockid_t which_clock, > const struct timespec64 *tp); > - int (*clock_get) (const clockid_t which_clock, struct timespec * tp); > - int (*clock_get64) (const clockid_t which_clock, struct timespec64 *tp); > + int (*clock_get) (const clockid_t which_clock, struct timespec64 *tp); > int (*clock_adj) (const clockid_t which_clock, struct timex *tx); > int (*timer_create) (struct k_itimer *timer); > int (*nsleep) (const clockid_t which_clock, int flags, > diff --git a/kernel/time/alarmtimer.c b/kernel/time/alarmtimer.c > index 7aefb7f..114e8fb 100644 > --- a/kernel/time/alarmtimer.c > +++ b/kernel/time/alarmtimer.c > @@ -825,8 +825,8 @@ static int __init alarmtimer_init(void) > int error = 0; > int i; > struct k_clock alarm_clock = { > - .clock_getres64 = alarm_clock_getres, > - .clock_get64 = alarm_clock_get, > + .clock_getres = alarm_clock_getres, > + .clock_get = alarm_clock_get, > .timer_create = alarm_timer_create, > .timer_set = alarm_timer_set, > .timer_del = alarm_timer_del, > diff --git a/kernel/time/posix-clock.c b/kernel/time/posix-clock.c > index f425caf..0a1eb98 100644 > --- a/kernel/time/posix-clock.c > +++ b/kernel/time/posix-clock.c > @@ -435,9 +435,9 @@ static int pc_timer_settime(struct k_itimer *kit, int flags, > } > > struct k_clock clock_posix_dynamic = { > - .clock_getres64 = pc_clock_getres, > - .clock_set64 = pc_clock_settime, > - .clock_get64 = pc_clock_gettime, > + .clock_getres = pc_clock_getres, > + .clock_set = pc_clock_settime, > + .clock_get = pc_clock_gettime, > .clock_adj = pc_clock_adjtime, > .timer_create = pc_timer_create, > .timer_set = pc_timer_settime, > diff --git a/kernel/time/posix-cpu-timers.c b/kernel/time/posix-cpu-timers.c > index 7bd88f6..d7fa1ab 100644 > --- a/kernel/time/posix-cpu-timers.c > +++ b/kernel/time/posix-cpu-timers.c > @@ -1446,9 +1446,9 @@ static int thread_cpu_timer_create(struct k_itimer *timer) > } > > struct k_clock clock_posix_cpu = { > - .clock_getres64 = posix_cpu_clock_getres, > - .clock_set64 = posix_cpu_clock_set, > - .clock_get64 = posix_cpu_clock_get, > + .clock_getres = posix_cpu_clock_getres, > + .clock_set = posix_cpu_clock_set, > + .clock_get = posix_cpu_clock_get, > .timer_create = posix_cpu_timer_create, > .nsleep = posix_cpu_nsleep, > .nsleep_restart = posix_cpu_nsleep_restart, > @@ -1460,15 +1460,15 @@ struct k_clock clock_posix_cpu = { > static __init int init_posix_cpu_timers(void) > { > struct k_clock process = { > - .clock_getres64 = process_cpu_clock_getres, > - .clock_get64 = process_cpu_clock_get, > + .clock_getres = process_cpu_clock_getres, > + .clock_get = process_cpu_clock_get, > .timer_create = process_cpu_timer_create, > .nsleep = process_cpu_nsleep, > .nsleep_restart = process_cpu_nsleep_restart, > }; > struct k_clock thread = { > - .clock_getres64 = thread_cpu_clock_getres, > - .clock_get64 = thread_cpu_clock_get, > + .clock_getres = thread_cpu_clock_getres, > + .clock_get = thread_cpu_clock_get, > .timer_create = thread_cpu_timer_create, > }; > struct timespec ts; > diff --git a/kernel/time/posix-timers.c b/kernel/time/posix-timers.c > index 2c55be1..1625541 100644 > --- a/kernel/time/posix-timers.c > +++ b/kernel/time/posix-timers.c > @@ -284,9 +284,9 @@ static int posix_get_tai(clockid_t which_clock, struct timespec64 *tp) > static __init int init_posix_timers(void) > { > struct k_clock clock_realtime = { > - .clock_getres64 = hrtimer_get_res64, > - .clock_get64 = posix_clock_realtime_get, > - .clock_set64 = posix_clock_realtime_set, > + .clock_getres = hrtimer_get_res64, > + .clock_get = posix_clock_realtime_get, > + .clock_set = posix_clock_realtime_set, > .clock_adj = posix_clock_realtime_adj, > .nsleep = common_nsleep, > .nsleep_restart = hrtimer_nanosleep_restart, > @@ -296,8 +296,8 @@ static __init int init_posix_timers(void) > .timer_del = common_timer_del, > }; > struct k_clock clock_monotonic = { > - .clock_getres64 = hrtimer_get_res64, > - .clock_get64 = posix_ktime_get_ts, > + .clock_getres = hrtimer_get_res64, > + .clock_get = posix_ktime_get_ts, > .nsleep = common_nsleep, > .nsleep_restart = hrtimer_nanosleep_restart, > .timer_create = common_timer_create, > @@ -306,20 +306,20 @@ static __init int init_posix_timers(void) > .timer_del = common_timer_del, > }; > struct k_clock clock_monotonic_raw = { > - .clock_getres64 = hrtimer_get_res64, > - .clock_get64 = posix_get_monotonic_raw, > + .clock_getres = hrtimer_get_res64, > + .clock_get = posix_get_monotonic_raw, > }; > struct k_clock clock_realtime_coarse = { > - .clock_getres64 = posix_get_coarse_res, > - .clock_get64 = posix_get_realtime_coarse, > + .clock_getres = posix_get_coarse_res, > + .clock_get = posix_get_realtime_coarse, > }; > struct k_clock clock_monotonic_coarse = { > - .clock_getres64 = posix_get_coarse_res, > - .clock_get64 = posix_get_monotonic_coarse, > + .clock_getres = posix_get_coarse_res, > + .clock_get = posix_get_monotonic_coarse, > }; > struct k_clock clock_tai = { > - .clock_getres64 = hrtimer_get_res64, > - .clock_get64 = posix_get_tai, > + .clock_getres = hrtimer_get_res64, > + .clock_get = posix_get_tai, > .nsleep = common_nsleep, > .nsleep_restart = hrtimer_nanosleep_restart, > .timer_create = common_timer_create, > @@ -328,8 +328,8 @@ static __init int init_posix_timers(void) > .timer_del = common_timer_del, > }; > struct k_clock clock_boottime = { > - .clock_getres64 = hrtimer_get_res64, > - .clock_get64 = posix_get_boottime, > + .clock_getres = hrtimer_get_res64, > + .clock_get = posix_get_boottime, > .nsleep = common_nsleep, > .nsleep_restart = hrtimer_nanosleep_restart, > .timer_create = common_timer_create, > @@ -1021,12 +1021,8 @@ SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock, > if (copy_from_user(&new_tp, tp, sizeof (*tp))) > return -EFAULT; > > - if (kc->clock_set64) { > - new_tp64 = timespec_to_timespec64(new_tp); > - return kc->clock_set64(which_clock, &new_tp64); > - } else { > - return kc->clock_set(which_clock, &new_tp); > - } > + new_tp64 = timespec_to_timespec64(new_tp); > + return kc->clock_set(which_clock, &new_tp64); > } > > SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock, > @@ -1040,14 +1036,13 @@ SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock, > if (!kc) > return -EINVAL; > > - if (kc->clock_get64) { > - error = kc->clock_get64(which_clock, &kernel_tp64); > - kernel_tp = timespec64_to_timespec(kernel_tp64); > - } else { > - error = kc->clock_get(which_clock, &kernel_tp); > - } > + error = kc->clock_get(which_clock, &kernel_tp64); > + if (!error) > + return error; > > - if (!error && copy_to_user(tp, &kernel_tp, sizeof (kernel_tp))) > + kernel_tp = timespec64_to_timespec(kernel_tp64); > + > + if (copy_to_user(tp, &kernel_tp, sizeof (kernel_tp))) > error = -EFAULT; > > return error; > @@ -1087,14 +1082,13 @@ SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock, > if (!kc) > return -EINVAL; > > - if (kc->clock_getres64) { > - error = kc->clock_getres64(which_clock, &rtn_tp64); > - rtn_tp = timespec64_to_timespec(rtn_tp64); > - } else { > - error = kc->clock_getres(which_clock, &rtn_tp); > - } > + error = kc->clock_getres(which_clock, &rtn_tp64); > + if (!error) > + return error; > + > + rtn_tp = timespec64_to_timespec(rtn_tp64); > > - if (!error && tp && copy_to_user(tp, &rtn_tp, sizeof (rtn_tp))) > + if (tp && copy_to_user(tp, &rtn_tp, sizeof (rtn_tp))) > error = -EFAULT; > > return error; >

10 years, 2 months

Re: [Y2038] [PATCH v3 09/10] time/posix-cpu-timers:Introduce the new methods with timespec64 type

by Arnd Bergmann

On Saturday 11 April 2015 18:46:55 Baolin Wang wrote: > This patch introduces the new methods of k_clock structure with timespec64 > type, converts the timespec type to timespec64 type for the callback function > in posix-cpu-timers.c file. > > Signed-off-by: Baolin Wang <baolin.wang(a)linaro.org> The patch looks correct, but it wasn't obvious at first why you are modifying some of the functions in here such as posix_cpu_timer_get. It would be helpful to explain that first. Arnd > kernel/time/posix-cpu-timers.c | 58 +++++++++++++++++++++++----------------- > 1 file changed, 34 insertions(+), 24 deletions(-) > > diff --git a/kernel/time/posix-cpu-timers.c b/kernel/time/posix-cpu-timers.c > index 0075da7..7bd88f6 100644 > --- a/kernel/time/posix-cpu-timers.c > +++ b/kernel/time/posix-cpu-timers.c > @@ -67,12 +67,12 @@ timespec_to_sample(const clockid_t which_clock, const struct timespec *tp) > > static void sample_to_timespec(const clockid_t which_clock, > unsigned long long expires, > - struct timespec *tp) > + struct timespec64 *tp) > { > if (CPUCLOCK_WHICH(which_clock) == CPUCLOCK_SCHED) > - *tp = ns_to_timespec(expires); > + *tp = ns_to_timespec64(expires); > else > - cputime_to_timespec((__force cputime_t)expires, tp); > + cputime_to_timespec64((__force cputime_t)expires, tp); > } > > /* > @@ -141,7 +141,7 @@ static inline unsigned long long virt_ticks(struct task_struct *p) > } > > static int > -posix_cpu_clock_getres(const clockid_t which_clock, struct timespec *tp) > +posix_cpu_clock_getres(const clockid_t which_clock, struct timespec64 *tp) > { > int error = check_clock(which_clock); > if (!error) { > @@ -160,7 +160,7 @@ posix_cpu_clock_getres(const clockid_t which_clock, struct timespec *tp) > } > > static int > -posix_cpu_clock_set(const clockid_t which_clock, const struct timespec *tp) > +posix_cpu_clock_set(const clockid_t which_clock, const struct timespec64 *tp) > { > /* > * You can never reset a CPU clock, but we check for other errors > @@ -263,7 +263,7 @@ static int cpu_clock_sample_group(const clockid_t which_clock, > > static int posix_cpu_clock_get_task(struct task_struct *tsk, > const clockid_t which_clock, > - struct timespec *tp) > + struct timespec64 *tp) > { > int err = -EINVAL; > unsigned long long rtn; > @@ -283,7 +283,8 @@ static int posix_cpu_clock_get_task(struct task_struct *tsk, > } > > > -static int posix_cpu_clock_get(const clockid_t which_clock, struct timespec *tp) > +static int posix_cpu_clock_get(const clockid_t which_clock, > + struct timespec64 *tp) > { > const pid_t pid = CPUCLOCK_PID(which_clock); > int err = -EINVAL; > @@ -604,6 +605,7 @@ static int posix_cpu_timer_set(struct k_itimer *timer, int timer_flags, > struct sighand_struct *sighand; > struct task_struct *p = timer->it.cpu.task; > unsigned long long old_expires, new_expires, old_incr, val; > + struct timespec64 ts64; > int ret; > > WARN_ON_ONCE(p == NULL); > @@ -671,7 +673,8 @@ static int posix_cpu_timer_set(struct k_itimer *timer, int timer_flags, > old_expires = timer->it.cpu.expires - val; > sample_to_timespec(timer->it_clock, > old_expires, > - &old->it_value); > + &ts64); > + old->it_value = timespec64_to_timespec(ts64); > } else { > old->it_value.tv_nsec = 1; > old->it_value.tv_sec = 0; > @@ -735,7 +738,8 @@ static int posix_cpu_timer_set(struct k_itimer *timer, int timer_flags, > out: > if (old) { > sample_to_timespec(timer->it_clock, > - old_incr, &old->it_interval); > + old_incr, &ts64); > + old->it_interval = timespec64_to_timespec(ts64); > } > if (!ret) > posix_cpu_timer_kick_nohz(); > @@ -746,6 +750,7 @@ static void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec *itp) > { > unsigned long long now; > struct task_struct *p = timer->it.cpu.task; > + struct timespec64 ts64; > > WARN_ON_ONCE(p == NULL); > > @@ -753,7 +758,8 @@ static void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec *itp) > * Easy part: convert the reload time. > */ > sample_to_timespec(timer->it_clock, > - timer->it.cpu.incr, &itp->it_interval); > + timer->it.cpu.incr, &ts64); > + itp->it_interval = timespec64_to_timespec(ts64); > > if (timer->it.cpu.expires == 0) { /* Timer not armed at all. */ > itp->it_value.tv_sec = itp->it_value.tv_nsec = 0; > @@ -783,7 +789,8 @@ static void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec *itp) > */ > timer->it.cpu.expires = 0; > sample_to_timespec(timer->it_clock, timer->it.cpu.expires, > - &itp->it_value); > + &ts64); > + itp->it_value = timespec64_to_timespec(ts64); > } else { > cpu_timer_sample_group(timer->it_clock, p, &now); > unlock_task_sighand(p, &flags); > @@ -793,7 +800,8 @@ static void posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec *itp) > if (now < timer->it.cpu.expires) { > sample_to_timespec(timer->it_clock, > timer->it.cpu.expires - now, > - &itp->it_value); > + &ts64); > + itp->it_value = timespec64_to_timespec(ts64); > } else { > /* > * The timer should have expired already, but the firing > @@ -1248,6 +1256,7 @@ static int do_cpu_nanosleep(const clockid_t which_clock, int flags, > struct timespec *rqtp, struct itimerspec *it) > { > struct k_itimer timer; > + struct timespec64 ts64; > int error; > > /* > @@ -1295,7 +1304,8 @@ static int do_cpu_nanosleep(const clockid_t which_clock, int flags, > /* > * We were interrupted by a signal. > */ > - sample_to_timespec(which_clock, timer.it.cpu.expires, rqtp); > + sample_to_timespec(which_clock, timer.it.cpu.expires, &ts64); > + *rqtp = timespec64_to_timespec(ts64); > error = posix_cpu_timer_set(&timer, 0, &zero_it, it); > if (!error) { > /* > @@ -1395,12 +1405,12 @@ static long posix_cpu_nsleep_restart(struct restart_block *restart_block) > #define THREAD_CLOCK MAKE_THREAD_CPUCLOCK(0, CPUCLOCK_SCHED) > > static int process_cpu_clock_getres(const clockid_t which_clock, > - struct timespec *tp) > + struct timespec64 *tp) > { > return posix_cpu_clock_getres(PROCESS_CLOCK, tp); > } > static int process_cpu_clock_get(const clockid_t which_clock, > - struct timespec *tp) > + struct timespec64 *tp) > { > return posix_cpu_clock_get(PROCESS_CLOCK, tp); > } > @@ -1420,12 +1430,12 @@ static long process_cpu_nsleep_restart(struct restart_block *restart_block) > return -EINVAL; > } > static int thread_cpu_clock_getres(const clockid_t which_clock, > - struct timespec *tp) > + struct timespec64 *tp) > { > return posix_cpu_clock_getres(THREAD_CLOCK, tp); > } > static int thread_cpu_clock_get(const clockid_t which_clock, > - struct timespec *tp) > + struct timespec64 *tp) > { > return posix_cpu_clock_get(THREAD_CLOCK, tp); > } > @@ -1436,9 +1446,9 @@ static int thread_cpu_timer_create(struct k_itimer *timer) > } > > struct k_clock clock_posix_cpu = { > - .clock_getres = posix_cpu_clock_getres, > - .clock_set = posix_cpu_clock_set, > - .clock_get = posix_cpu_clock_get, > + .clock_getres64 = posix_cpu_clock_getres, > + .clock_set64 = posix_cpu_clock_set, > + .clock_get64 = posix_cpu_clock_get, > .timer_create = posix_cpu_timer_create, > .nsleep = posix_cpu_nsleep, > .nsleep_restart = posix_cpu_nsleep_restart, > @@ -1450,15 +1460,15 @@ struct k_clock clock_posix_cpu = { > static __init int init_posix_cpu_timers(void) > { > struct k_clock process = { > - .clock_getres = process_cpu_clock_getres, > - .clock_get = process_cpu_clock_get, > + .clock_getres64 = process_cpu_clock_getres, > + .clock_get64 = process_cpu_clock_get, > .timer_create = process_cpu_timer_create, > .nsleep = process_cpu_nsleep, > .nsleep_restart = process_cpu_nsleep_restart, > }; > struct k_clock thread = { > - .clock_getres = thread_cpu_clock_getres, > - .clock_get = thread_cpu_clock_get, > + .clock_getres64 = thread_cpu_clock_getres, > + .clock_get64 = thread_cpu_clock_get, > .timer_create = thread_cpu_timer_create, > }; > struct timespec ts; >

10 years, 2 months

Re: [Y2038] [PATCH v3 08/10] time:Introduce the cputime_to_timespec64() function

by Arnd Bergmann

On Saturday 11 April 2015 18:46:54 Baolin Wang wrote: > This patch introduces the cputime_to_timespec64() function and > jiffies_to_timespec64() function for converting the jiffies > value to timespec64 value. > > Signed-off-by: Baolin Wang <baolin.wang(a)linaro.org> > --- > include/asm-generic/cputime_jiffies.h | 6 ++++++ > include/linux/jiffies.h | 2 ++ > kernel/time/time.c | 14 ++++++++++++++ > 3 files changed, 22 insertions(+) > > diff --git a/include/asm-generic/cputime_jiffies.h b/include/asm-generic/cputime_jiffies.h > index fe386fc..c0c4fcb 100644 > --- a/include/asm-generic/cputime_jiffies.h > +++ b/include/asm-generic/cputime_jiffies.h > @@ -52,6 +52,12 @@ typedef u64 __nocast cputime64_t; > jiffies_to_timespec(cputime_to_jiffies(__ct),__val) > > /* > + * Convert cputime to timespec64. > + */ > +#define cputime_to_timespec64(__ct,__val) \ > + jiffies_to_timespec64(cputime_to_jiffies(__ct),__val) > + > +/* > * Convert cputime to timeval and back. You missed an important piece here: cputime_to_timespec64 is architecture specific, and arch/s390 as well as arch/powerpc have their own implementations, so you have to introduce all three cputime_to_timespec64 implementations before using it. Arnd

10 years, 2 months

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

Y2038