Y2038

y2038@lists.linaro.org

1132 discussions

[PATCH 0/9] converting system calls to 64-bit time_t, part 2

by Arnd Bergmann

This is a follow-up to the series posted at [1]. To make review a little easier, I'm focusing on just one class of system calls here, and this is one that is handled differently from all the others. In particular, for sys_msgctl, sys_semctl and sys_shmctl, I do not introduce a completely new set of replacement system calls, but instead extend the existing ones to return data in the reserved fields of the normal data structure. This should be completely transparent to any existing user space, and only after the 32-bit time_t wraps, it will make a difference in the returned data. libc implementations will consequently have to provide their own data structures when they move to 64-bit time_t, and convert the structures in user space from the ones returned by the kernel. There are three cases here: - little-endian architectures (except powerpc and mips) can use the normal layout and just cast the data structure to the user space type that contains 64-bit numbers. - parisc and sparc can do the same thing with big-endian user space - little-endian powerpc and most big-endian architectures have to flip the upper and lower 32-bit halves of the time_t value in memory, but can otherwise keep using the normal layout - mips and big-endian xtensa need to be more careful because they are not consistent in their definitions, and they have to provide custom libc implementations for the system calls to use 64-bit time_t. Please review. Arnd [1] http://lwn.net/Articles/643407/ Arnd Bergmann (8): y2038: asm-generic: extend sysvipc data structures y2038: mips: extend sysvipc data structures y2038: x86: extend sysvipc data structures y2038: parisc: extend sysvipc data structures y2038: sparc: extend sysvipc data structures y2038: powerpc: extend sysvipc data structures y2038: xtensa: extend sysvipc data structures y2038: ipc: report long times to user space arch/arm64/include/asm/compat.h | 32 +++++++++---------- arch/mips/include/asm/compat.h | 38 +++++++++++----------- arch/mips/include/uapi/asm/msgbuf.h | 56 +++++++++++++++++++++----------- arch/mips/include/uapi/asm/sembuf.h | 15 +++++++-- arch/mips/include/uapi/asm/shmbuf.h | 23 ++++++++++++-- arch/parisc/include/asm/compat.h | 32 +++++++++---------- arch/parisc/include/uapi/asm/msgbuf.h | 32 +++++++++---------- arch/parisc/include/uapi/asm/sembuf.h | 13 ++++---- arch/parisc/include/uapi/asm/shmbuf.h | 18 +++++------ arch/powerpc/include/asm/compat.h | 32 +++++++++---------- arch/powerpc/include/uapi/asm/msgbuf.h | 18 +++++------ arch/powerpc/include/uapi/asm/sembuf.h | 14 ++++---- arch/powerpc/include/uapi/asm/shmbuf.h | 18 +++++------ arch/sparc/include/asm/compat.h | 32 +++++++++---------- arch/sparc/include/uapi/asm/msgbuf.h | 21 ++++++------ arch/sparc/include/uapi/asm/sembuf.h | 15 ++++----- arch/sparc/include/uapi/asm/shmbuf.h | 20 ++++++------ arch/tile/include/asm/compat.h | 32 +++++++++---------- arch/x86/include/asm/compat.h | 32 +++++++++---------- arch/x86/include/uapi/asm/msgbuf.h | 41 +++++++++++++++++++++++- arch/x86/include/uapi/asm/sembuf.h | 10 ++++++ arch/x86/include/uapi/asm/shmbuf.h | 58 +++++++++++++++++++++++++++++++++- arch/xtensa/include/uapi/asm/msgbuf.h | 24 +++++++------- arch/xtensa/include/uapi/asm/sembuf.h | 16 +++++----- arch/xtensa/include/uapi/asm/shmbuf.h | 36 +++++---------------- include/linux/msg.h | 7 ++-- include/linux/sem.h | 3 +- include/linux/shm.h | 7 ++-- include/uapi/asm-generic/msgbuf.h | 16 +++++----- include/uapi/asm-generic/sembuf.h | 26 +++++++++------ include/uapi/asm-generic/shmbuf.h | 16 +++++----- ipc/compat.c | 8 +++++ ipc/msg.c | 23 ++++++++------ ipc/sem.c | 32 +++++++++++-------- ipc/shm.c | 21 +++++++----- 35 files changed, 499 insertions(+), 338 deletions(-) -- 2.1.0.rc2

9 years, 11 months

[PATCH v2] [media] dvb-frontend: Replace timeval with ktime_t

by Tina Ruchandani

struct timeval uses a 32-bit seconds representation which will overflow in the year 2038 and beyond. This patch replaces the usage of struct timeval with ktime_t which is a 64-bit timestamp and is year 2038 safe. This patch is part of a larger attempt to remove all instances of 32-bit timekeeping variables (timeval, timespec, time_t) which are not year 2038 safe, from the kernel. The patch is a work-in-progress - correctness of the following changes is unclear: (a) Usage of timeval_usec_diff - The function seems to subtract usec values without caring about the difference of the seconds field. There may be an implicit assumption in the original code that the time delta is always of the order of microseconds. The patch replaces the usage of timeval_usec_diff with ktime_to_us(ktime_sub()) which computes the real timestamp difference, not just the difference in the usec field. (b) printk diffing the tv[i] and tv[i-1] values. The original printk statement seems to get the order wrong. This patch preserves that order. Signed-off-by: Tina Ruchandani <ruchandani.tina(a)gmail.com> Suggested-by: Arnd Bergmann <arnd(a)arndb.de> -- Changes in v2: - Use the more concise ktime_us_delta - Preserve the waketime argument in dvb_frontend_sleep_until as a pointer, fixes bug introduced in v1 of the patch where the caller doesn't get its timestamp modified. --- drivers/media/dvb-core/dvb_frontend.c | 40 +++++++++-------------------------- drivers/media/dvb-core/dvb_frontend.h | 3 +-- drivers/media/dvb-frontends/stv0299.c | 11 +++++----- 3 files changed, 17 insertions(+), 37 deletions(-) diff --git a/drivers/media/dvb-core/dvb_frontend.c b/drivers/media/dvb-core/dvb_frontend.c index 882ca41..c110e37 100644 --- a/drivers/media/dvb-core/dvb_frontend.c +++ b/drivers/media/dvb-core/dvb_frontend.c @@ -40,6 +40,7 @@ #include <linux/freezer.h> #include <linux/jiffies.h> #include <linux/kthread.h> +#include <linux/ktime.h> #include <asm/processor.h> #include "dvb_frontend.h" @@ -889,42 +890,21 @@ static void dvb_frontend_stop(struct dvb_frontend *fe) fepriv->thread); } -s32 timeval_usec_diff(struct timeval lasttime, struct timeval curtime) -{ - return ((curtime.tv_usec < lasttime.tv_usec) ? - 1000000 - lasttime.tv_usec + curtime.tv_usec : - curtime.tv_usec - lasttime.tv_usec); -} -EXPORT_SYMBOL(timeval_usec_diff); - -static inline void timeval_usec_add(struct timeval *curtime, u32 add_usec) -{ - curtime->tv_usec += add_usec; - if (curtime->tv_usec >= 1000000) { - curtime->tv_usec -= 1000000; - curtime->tv_sec++; - } -} - /* * Sleep until gettimeofday() > waketime + add_usec * This needs to be as precise as possible, but as the delay is * usually between 2ms and 32ms, it is done using a scheduled msleep * followed by usleep (normally a busy-wait loop) for the remainder */ -void dvb_frontend_sleep_until(struct timeval *waketime, u32 add_usec) +void dvb_frontend_sleep_until(ktime_t *waketime, u32 add_usec) { - struct timeval lasttime; s32 delta, newdelta; - timeval_usec_add(waketime, add_usec); - - do_gettimeofday(&lasttime); - delta = timeval_usec_diff(lasttime, *waketime); + ktime_add_us(*waketime, add_usec); + delta = ktime_us_delta(ktime_get_real(), *waketime); if (delta > 2500) { msleep((delta - 1500) / 1000); - do_gettimeofday(&lasttime); - newdelta = timeval_usec_diff(lasttime, *waketime); + newdelta = ktime_us_delta(ktime_get_real(), *waketime); delta = (newdelta > delta) ? 0 : newdelta; } if (delta > 0) @@ -2458,13 +2438,13 @@ static int dvb_frontend_ioctl_legacy(struct file *file, * include the initialization or start bit */ unsigned long swcmd = ((unsigned long) parg) << 1; - struct timeval nexttime; - struct timeval tv[10]; + ktime_t nexttime; + ktime_t tv[10]; int i; u8 last = 1; if (dvb_frontend_debug) printk("%s switch command: 0x%04lx\n", __func__, swcmd); - do_gettimeofday(&nexttime); + nexttime = ktime_get_real(); if (dvb_frontend_debug) tv[0] = nexttime; /* before sending a command, initialize by sending @@ -2475,7 +2455,7 @@ static int dvb_frontend_ioctl_legacy(struct file *file, for (i = 0; i < 9; i++) { if (dvb_frontend_debug) - do_gettimeofday(&tv[i + 1]); + tv[i+1] = ktime_get_real(); if ((swcmd & 0x01) != last) { /* set voltage to (last ? 13V : 18V) */ fe->ops.set_voltage(fe, (last) ? SEC_VOLTAGE_13 : SEC_VOLTAGE_18); @@ -2489,7 +2469,7 @@ static int dvb_frontend_ioctl_legacy(struct file *file, printk("%s(%d): switch delay (should be 32k followed by all 8k\n", __func__, fe->dvb->num); for (i = 1; i < 10; i++) - printk("%d: %d\n", i, timeval_usec_diff(tv[i-1] , tv[i])); + printk("%d: %d\n", i, (int) ktime_to_us(ktime_sub(tv[i-1], tv[i]))); } err = 0; fepriv->state = FESTATE_DISEQC; diff --git a/drivers/media/dvb-core/dvb_frontend.h b/drivers/media/dvb-core/dvb_frontend.h index 816269e..5b64686 100644 --- a/drivers/media/dvb-core/dvb_frontend.h +++ b/drivers/media/dvb-core/dvb_frontend.h @@ -439,7 +439,6 @@ extern void dvb_frontend_reinitialise(struct dvb_frontend *fe); extern int dvb_frontend_suspend(struct dvb_frontend *fe); extern int dvb_frontend_resume(struct dvb_frontend *fe); -extern void dvb_frontend_sleep_until(struct timeval *waketime, u32 add_usec); -extern s32 timeval_usec_diff(struct timeval lasttime, struct timeval curtime); +extern void dvb_frontend_sleep_until(ktime_t *waketime, u32 add_usec); #endif diff --git a/drivers/media/dvb-frontends/stv0299.c b/drivers/media/dvb-frontends/stv0299.c index b57ecf4..70c8065 100644 --- a/drivers/media/dvb-frontends/stv0299.c +++ b/drivers/media/dvb-frontends/stv0299.c @@ -44,6 +44,7 @@ #include <linux/init.h> #include <linux/kernel.h> +#include <linux/ktime.h> #include <linux/module.h> #include <linux/string.h> #include <linux/slab.h> @@ -404,8 +405,8 @@ static int stv0299_send_legacy_dish_cmd (struct dvb_frontend* fe, unsigned long u8 lv_mask = 0x40; u8 last = 1; int i; - struct timeval nexttime; - struct timeval tv[10]; + ktime_t nexttime; + ktime_t tv[10]; reg0x08 = stv0299_readreg (state, 0x08); reg0x0c = stv0299_readreg (state, 0x0c); @@ -418,7 +419,7 @@ static int stv0299_send_legacy_dish_cmd (struct dvb_frontend* fe, unsigned long if (debug_legacy_dish_switch) printk ("%s switch command: 0x%04lx\n",__func__, cmd); - do_gettimeofday (&nexttime); + nexttime = ktime_get_real(); if (debug_legacy_dish_switch) tv[0] = nexttime; stv0299_writeregI (state, 0x0c, reg0x0c | 0x50); /* set LNB to 18V */ @@ -427,7 +428,7 @@ static int stv0299_send_legacy_dish_cmd (struct dvb_frontend* fe, unsigned long for (i=0; i<9; i++) { if (debug_legacy_dish_switch) - do_gettimeofday (&tv[i+1]); + tv[i+1] = ktime_get_real(); if((cmd & 0x01) != last) { /* set voltage to (last ? 13V : 18V) */ stv0299_writeregI (state, 0x0c, reg0x0c | (last ? lv_mask : 0x50)); @@ -443,7 +444,7 @@ static int stv0299_send_legacy_dish_cmd (struct dvb_frontend* fe, unsigned long printk ("%s(%d): switch delay (should be 32k followed by all 8k\n", __func__, fe->dvb->num); for (i = 1; i < 10; i++) - printk ("%d: %d\n", i, timeval_usec_diff(tv[i-1] , tv[i])); + printk("%d: %d\n", i, (int) ktime_to_us(ktime_sub(tv[i-1], tv[i]))); } return 0; -- 2.2.0.rc0.207.ga3a616c

9 years, 11 months

[PATCH v4] Staging: media: lirc: Replace timeval with ktime_t

by Ksenija Stanojevic

'struct timeval last_tv' is used to get the time of last signal change and 'struct timeval last_intr_tv' is used to get the time of last UART interrupt. 32-bit systems using 'struct timeval' will break in the year 2038, so we have to replace that code with more appropriate types. Here struct timeval is replaced with ktime_t. Signed-off-by: Ksenija Stanojevic <ksenija.stanojevic(a)gmail.com> --- Changes in v4: - add lirc in subject line. - remove delta function. - change variable names. Changes in v3: - delta function is changed to inline function. - change variable names. Changes in v2: - change subject line drivers/staging/media/lirc/lirc_sir.c | 75 ++++++++++++++--------------------- 1 file changed, 30 insertions(+), 45 deletions(-) diff --git a/drivers/staging/media/lirc/lirc_sir.c b/drivers/staging/media/lirc/lirc_sir.c index 29087f6..4f326e9 100644 --- a/drivers/staging/media/lirc/lirc_sir.c +++ b/drivers/staging/media/lirc/lirc_sir.c @@ -44,7 +44,7 @@ #include <linux/ioport.h> #include <linux/kernel.h> #include <linux/serial_reg.h> -#include <linux/time.h> +#include <linux/ktime.h> #include <linux/string.h> #include <linux/types.h> #include <linux/wait.h> @@ -127,9 +127,9 @@ static int threshold = 3; static DEFINE_SPINLOCK(timer_lock); static struct timer_list timerlist; /* time of last signal change detected */ -static struct timeval last_tv = {0, 0}; +static ktime_t last; /* time of last UART data ready interrupt */ -static struct timeval last_intr_tv = {0, 0}; +static ktime_t last_intr_time; static int last_value; static DECLARE_WAIT_QUEUE_HEAD(lirc_read_queue); @@ -400,20 +400,6 @@ static void drop_chrdev(void) } /* SECTION: Hardware */ -static long delta(struct timeval *tv1, struct timeval *tv2) -{ - unsigned long deltv; - - deltv = tv2->tv_sec - tv1->tv_sec; - if (deltv > 15) - deltv = 0xFFFFFF; - else - deltv = deltv*1000000 + - tv2->tv_usec - - tv1->tv_usec; - return deltv; -} - static void sir_timeout(unsigned long data) { /* @@ -432,12 +418,14 @@ static void sir_timeout(unsigned long data) /* clear unread bits in UART and restart */ outb(UART_FCR_CLEAR_RCVR, io + UART_FCR); /* determine 'virtual' pulse end: */ - pulse_end = delta(&last_tv, &last_intr_tv); + pulse_end = min_t(unsigned long, + ktime_us_delta(last, last_intr_time), + PULSE_MASK); dev_dbg(driver.dev, "timeout add %d for %lu usec\n", last_value, pulse_end); add_read_queue(last_value, pulse_end); last_value = 0; - last_tv = last_intr_tv; + last = last_intr_time; } spin_unlock_irqrestore(&timer_lock, flags); } @@ -445,9 +433,9 @@ static void sir_timeout(unsigned long data) static irqreturn_t sir_interrupt(int irq, void *dev_id) { unsigned char data; - struct timeval curr_tv; - static unsigned long deltv; - unsigned long deltintrtv; + ktime_t curr_time; + static unsigned long delt; + unsigned long deltintr; unsigned long flags; int iir, lsr; @@ -471,49 +459,46 @@ static irqreturn_t sir_interrupt(int irq, void *dev_id) do { del_timer(&timerlist); data = inb(io + UART_RX); - do_gettimeofday(&curr_tv); - deltv = delta(&last_tv, &curr_tv); - deltintrtv = delta(&last_intr_tv, &curr_tv); + curr_time = ktime_get(); + delt = min_t(unsigned long, + ktime_us_delta(last, curr_time), + PULSE_MASK); + deltintr = min_t(unsigned long, + ktime_us_delta(last_intr_time, + curr_time), + PULSE_MASK); dev_dbg(driver.dev, "t %lu, d %d\n", - deltintrtv, (int)data); + deltintr, (int)data); /* * if nothing came in last X cycles, * it was gap */ - if (deltintrtv > TIME_CONST * threshold) { + if (deltintr > TIME_CONST * threshold) { if (last_value) { dev_dbg(driver.dev, "GAP\n"); /* simulate signal change */ add_read_queue(last_value, - deltv - - deltintrtv); + delt - + deltintr); last_value = 0; - last_tv.tv_sec = - last_intr_tv.tv_sec; - last_tv.tv_usec = - last_intr_tv.tv_usec; - deltv = deltintrtv; + last = last_intr_time; + delt = deltintr; } } data = 1; if (data ^ last_value) { /* - * deltintrtv > 2*TIME_CONST, remember? + * deltintr > 2*TIME_CONST, remember? * the other case is timeout */ add_read_queue(last_value, - deltv-TIME_CONST); + delt-TIME_CONST); last_value = data; - last_tv = curr_tv; - if (last_tv.tv_usec >= TIME_CONST) { - last_tv.tv_usec -= TIME_CONST; - } else { - last_tv.tv_sec--; - last_tv.tv_usec += 1000000 - - TIME_CONST; - } + last = curr_time; + last = ktime_sub_us(last, + TIME_CONST); } - last_intr_tv = curr_tv; + last_intr_time = curr_time; if (data) { /* * start timer for end of -- 1.9.1

9 years, 11 months

[PATCH 00/19] converting system calls to 64-bit time_t, part 1

by Arnd Bergmann

This is my second draft of how we could modify the system call interface in Linux to support user space with 64-bit time_t in addition to the existing 32-bit time_t based interfaces. In order to avoid spamming people too much, I've picked the first half of the patches only now, and left some of the more complex ones for later. If you are interested in the big picture, see http://git.kernel.org/cgit/linux/kernel/git/arnd/playground.git/log/?h=y203… with currently 42 patches. That number may go up a bit over time, but only because I plan to split some of the patches into smaller chunks for review purposes, as opposed to adding more system calls. As part 1 of the series only switches over half the system calls, I've left out the bits that changes the ARM and x86 architectures. There are 24 additional architectures that need to moved over to the new system calls once the basic patches get merged. The main part I'm not sure about is how the header files should be structured in order to make it easy for every libc implementation to pick out the right definitions of the data structures I had to modify. Hopefully, people on libc-alpha can help me out here. The overall approach I have taken here is as follows: * Since 64-bit architectures already support two versions of each system call that passes a time value in order to run 32-bit user space, I'm not adding new system calls for the most part, but instead make 32-bit architectures use the same compat handlers that 64-bit architectures already use. * The existing syscall numbers are modified to point to the compat_sys_* functions, and new numbers are assigned to point to the existing handlers that now deal with 64-bit time_t based structures * This series does not touch any ioctl implementation, but should be otherwise complete regarding the system calls. We are still trying to find out exactly which ioctls are affected and have not come up with a complete list at this point. It's probably a good idea though to do at least the essential ioctls before merging the series, so we can have a better understanding of how it will be done in the end. * Each data structure we need to modify gets a new definition with a __kernel_ prefix, e.g. struct __kernel_timespec to replace struct timespec. This keeps the new structures out of the user libc namespace, but still allows the structure to be integrated into other data structures, e.g. for ioctl. * There is no #ifdef in the UAPI headers at this point that would check for the kind of user space that is in use. Unfortunately, I believe we will need to add that in order to do some of the particularly tricky ioctls later. * At first, all system call implementations are modified, but this is done in a way that is not supposed to have any ABI-visible effect on existing architectures. * After all system calls are converted, we can change one architecture at a time to select ARCH_HAS_COMPAT_TIME, and modify its system call table accordingly. In this version, I do it for ARM32, x86-32, and x86-64 for demonstration purposes. * A follow-up series changes over all other architectures. * The last patch in the series changes the CONFIG_COMPAT_TIME Kconfig symbol to be user visible. Disabling this symbol will get you a kernel that intentionally breaks support for old tasks in order to provide an interface that will survive 2038. This is meant mostly as a debugging help for now, to let people build a y2038 safe distro, but at some point in the 2030s, we should remove that option and all the compat handling. Arnd Bergmann (19): compat: remove compat_printk initramfs: use vfs_stat/lstat directly y2038: introduce linux/compat_time.h header y2038: introduce CONFIG_COMPAT_TIME y2038: make linux/compat_time.h usable on 32-bit y2038: compile compat time code even when CONFIG_COMPAT is not set y2038: add compat_sys_rt_sigtimedwait variants y2038: introduce struct __kernel_timespec y2038: introduce struct __kernel_stat y2038: use __kernel_stat for sys_newstat syscalls y2038: introduce and use struct __kernel_rusage y2038: add compat_{get,put}_timespec64 y2038: add compat handling for sys_semtimedop y2038: use __kernel_timespec for sys_mq_timed{send,receive} y2038: introduce timespec64_to_jiffies y2038: use __kernel_timespec in sys_rt_sigtimedwait y2038: use __kernel_timespec in sys_futex y2038: introduce jiffies_to_timespec64 y2038: use __kernel_timespec in sys_sched_rr_get_interval arch/Kconfig | 11 ++ arch/alpha/include/uapi/asm/stat.h | 4 + arch/alpha/kernel/osf_sys.c | 4 +- arch/arm/include/uapi/asm/stat.h | 2 + arch/arm64/include/asm/compat.h | 11 -- arch/avr32/include/uapi/asm/stat.h | 2 + arch/blackfin/include/uapi/asm/stat.h | 2 + arch/cris/include/uapi/asm/stat.h | 2 + arch/frv/include/uapi/asm/stat.h | 2 + arch/ia64/include/uapi/asm/stat.h | 4 + arch/m32r/include/uapi/asm/stat.h | 1 + arch/m68k/include/uapi/asm/stat.h | 2 + arch/mips/include/asm/compat.h | 11 -- arch/mips/include/uapi/asm/stat.h | 1 + arch/mn10300/include/uapi/asm/stat.h | 2 + arch/parisc/include/asm/compat.h | 11 -- arch/parisc/include/uapi/asm/stat.h | 1 + arch/powerpc/include/asm/compat.h | 11 -- arch/powerpc/include/uapi/asm/stat.h | 25 +++ arch/s390/include/asm/compat.h | 11 -- arch/s390/include/uapi/asm/stat.h | 24 +++ arch/sh/include/uapi/asm/stat.h | 2 + arch/sparc/include/asm/compat.h | 11 -- arch/sparc/include/uapi/asm/stat.h | 28 ++++ arch/tile/include/asm/compat.h | 11 -- arch/x86/include/asm/compat.h | 12 +- arch/x86/include/asm/ftrace.h | 2 +- arch/x86/include/asm/sys_ia32.h | 2 +- arch/x86/include/uapi/asm/stat.h | 49 ++++-- arch/x86/kernel/cpu/perf_event.c | 2 +- arch/xtensa/include/uapi/asm/stat.h | 2 + fs/Makefile | 1 + fs/compat.c | 26 ++- fs/stat.c | 12 +- include/linux/audit.h | 4 +- include/linux/compat.h | 232 +-------------------------- include/linux/compat_time.h | 285 +++++++++++++++++++++++++++++++++ include/linux/jiffies.h | 23 ++- include/linux/resource.h | 8 +- include/linux/signal.h | 3 +- include/linux/stat.h | 3 + include/linux/syscalls.h | 32 ++-- include/linux/thread_info.h | 2 +- include/linux/time64.h | 17 +- include/uapi/asm-generic/kernel_stat.h | 36 +++++ include/uapi/asm-generic/stat.h | 12 +- include/uapi/linux/resource.h | 32 ++++ include/uapi/linux/time.h | 17 ++ init/do_mounts.h | 22 +-- init/initramfs.c | 12 +- ipc/compat.c | 10 -- ipc/mqueue.c | 16 +- ipc/sem.c | 60 +++++-- ipc/syscall.c | 7 + kernel/Makefile | 1 + kernel/audit.h | 2 +- kernel/auditsc.c | 14 +- kernel/compat.c | 184 ++++++++++++++++++--- kernel/exit.c | 6 +- kernel/futex.c | 10 +- kernel/sched/core.c | 35 +++- kernel/signal.c | 13 +- kernel/sys.c | 23 +-- kernel/sysctl.c | 10 -- kernel/time/time.c | 45 ++++-- 65 files changed, 950 insertions(+), 530 deletions(-) create mode 100644 include/linux/compat_time.h create mode 100644 include/uapi/asm-generic/kernel_stat.h -- 2.1.0.rc2

9 years, 11 months

[PATCH] security/security: Convert to timespec64 type for "settime" pointer of struct security_operations

by Baolin Wang

This patch changes the "settime" pointer's argument with timespec64 type in security_operations structure, and also introduces the security_settime64() function with timespec64 type, meanwhile moves the security_settime() defined in security/security.c file to include/linux/security.h file as a static function. Also introduces a default security_settime64() function with timespec64 type when it doesn't define the CONFIG_SECURITY macro. And change the cap_settime() function's argument with timespec64 type, which is only used by security_settime64() function. Signed-off-by: Baolin Wang <baolin.wang(a)linaro.org> --- include/linux/security.h | 25 ++++++++++++++++++++----- security/commoncap.c | 2 +- security/security.c | 2 +- 3 files changed, 22 insertions(+), 7 deletions(-) diff --git a/include/linux/security.h b/include/linux/security.h index a1b7dbd..69ad545 100644 --- a/include/linux/security.h +++ b/include/linux/security.h @@ -75,7 +75,7 @@ struct timezone; */ extern int cap_capable(const struct cred *cred, struct user_namespace *ns, int cap, int audit); -extern int cap_settime(const struct timespec *ts, const struct timezone *tz); +extern int cap_settime(const struct timespec64 *ts, const struct timezone *tz); extern int cap_ptrace_access_check(struct task_struct *child, unsigned int mode); extern int cap_ptrace_traceme(struct task_struct *parent); extern int cap_capget(struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted); @@ -1353,7 +1353,8 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts) * Return 0 if permission is granted. * @settime: * Check permission to change the system time. - * struct timespec and timezone are defined in include/linux/time.h + * struct timespec64 is defined in include/linux/time64.h and timezone is + * defined in include/linux/time.h * @ts contains new time * @tz contains new timezone * Return 0 if permission is granted. @@ -1483,7 +1484,7 @@ struct security_operations { int (*quotactl) (int cmds, int type, int id, struct super_block *sb); int (*quota_on) (struct dentry *dentry); int (*syslog) (int type); - int (*settime) (const struct timespec *ts, const struct timezone *tz); + int (*settime) (const struct timespec64 *ts, const struct timezone *tz); int (*vm_enough_memory) (struct mm_struct *mm, long pages); int (*bprm_set_creds) (struct linux_binprm *bprm); @@ -1790,7 +1791,13 @@ int security_capable_noaudit(const struct cred *cred, struct user_namespace *ns, int security_quotactl(int cmds, int type, int id, struct super_block *sb); int security_quota_on(struct dentry *dentry); int security_syslog(int type); -int security_settime(const struct timespec *ts, const struct timezone *tz); +int security_settime64(const struct timespec64 *ts, const struct timezone *tz); +static int security_settime(const struct timespec *ts, const struct timezone *tz) +{ + struct timespec64 ts64 = timespec_to_timespec64(*ts); + + return security_settime64(&ts64, tz); +} int security_vm_enough_memory_mm(struct mm_struct *mm, long pages); int security_bprm_set_creds(struct linux_binprm *bprm); int security_bprm_check(struct linux_binprm *bprm); @@ -2040,10 +2047,18 @@ static inline int security_syslog(int type) return 0; } +static inline int security_settime64(const struct timespec64 *ts, + const struct timezone *tz) +{ + return cap_settime(ts, tz); +} + static inline int security_settime(const struct timespec *ts, const struct timezone *tz) { - return cap_settime(ts, tz); + struct timsepc64 ts64 = timespec_to_timespec64(*ts); + + return security_settime64(&ts64, tz); } static inline int security_vm_enough_memory_mm(struct mm_struct *mm, long pages) diff --git a/security/commoncap.c b/security/commoncap.c index f66713b..bdb8ec0 100644 --- a/security/commoncap.c +++ b/security/commoncap.c @@ -116,7 +116,7 @@ int cap_capable(const struct cred *cred, struct user_namespace *targ_ns, * Determine whether the current process may set the system clock and timezone * information, returning 0 if permission granted, -ve if denied. */ -int cap_settime(const struct timespec *ts, const struct timezone *tz) +int cap_settime(const struct timespec64 *ts, const struct timezone *tz) { if (!capable(CAP_SYS_TIME)) return -EPERM; diff --git a/security/security.c b/security/security.c index e81d5bb..0be5032 100644 --- a/security/security.c +++ b/security/security.c @@ -224,7 +224,7 @@ int security_syslog(int type) return security_ops->syslog(type); } -int security_settime(const struct timespec *ts, const struct timezone *tz) +int security_settime64(const struct timespec64 *ts, const struct timezone *tz) { return security_ops->settime(ts, tz); } -- 1.7.9.5

9 years, 11 months

[PATCH] aoe: Use 64-bit timestamp in frame

by Tina Ruchandani

'struct frame' uses two variables to store the sent timestamp - 'struct timeval' and jiffies. jiffies is used to avoid discrepancies caused by updates to system time. 'struct timeval' uses 32-bit representation for seconds which will overflow in year 2038. This patch does the following: - Replace the use of 'struct timeval' and jiffies with ktime_t, which is a 64-bit timestamp and is year 2038 safe. - ktime_t provides both long range (like jiffies) and high resolution (like timeval). Using ktime_get (monotonic time) instead of wall-clock time prevents any discprepancies caused by updates to system time. Signed-off-by: Tina Ruchandani <ruchandani.tina(a)gmail.com> --- drivers/block/aoe/aoe.h | 3 +-- drivers/block/aoe/aoecmd.c | 36 +++++++----------------------------- 2 files changed, 8 insertions(+), 31 deletions(-) diff --git a/drivers/block/aoe/aoe.h b/drivers/block/aoe/aoe.h index 9220f8e..4582b3c 100644 --- a/drivers/block/aoe/aoe.h +++ b/drivers/block/aoe/aoe.h @@ -112,8 +112,7 @@ enum frame_flags { struct frame { struct list_head head; u32 tag; - struct timeval sent; /* high-res time packet was sent */ - u32 sent_jiffs; /* low-res jiffies-based sent time */ + ktime_t sent; ulong waited; ulong waited_total; struct aoetgt *t; /* parent target I belong to */ diff --git a/drivers/block/aoe/aoecmd.c b/drivers/block/aoe/aoecmd.c index 422b7d8..7f78780 100644 --- a/drivers/block/aoe/aoecmd.c +++ b/drivers/block/aoe/aoecmd.c @@ -398,8 +398,7 @@ aoecmd_ata_rw(struct aoedev *d) skb = skb_clone(f->skb, GFP_ATOMIC); if (skb) { - do_gettimeofday(&f->sent); - f->sent_jiffs = (u32) jiffies; + f->sent = ktime_get(); __skb_queue_head_init(&queue); __skb_queue_tail(&queue, skb); aoenet_xmit(&queue); @@ -489,8 +488,7 @@ resend(struct aoedev *d, struct frame *f) skb = skb_clone(skb, GFP_ATOMIC); if (skb == NULL) return; - do_gettimeofday(&f->sent); - f->sent_jiffs = (u32) jiffies; + f->sent = ktime_get(); __skb_queue_head_init(&queue); __skb_queue_tail(&queue, skb); aoenet_xmit(&queue); @@ -499,32 +497,15 @@ resend(struct aoedev *d, struct frame *f) static int tsince_hr(struct frame *f) { - struct timeval now; + ktime_t now; int n; - do_gettimeofday(&now); - n = now.tv_usec - f->sent.tv_usec; - n += (now.tv_sec - f->sent.tv_sec) * USEC_PER_SEC; + now = ktime_get(); + n = ktime_to_us(ktime_sub(now, f->sent)); if (n < 0) n = -n; - /* For relatively long periods, use jiffies to avoid - * discrepancies caused by updates to the system time. - * - * On system with HZ of 1000, 32-bits is over 49 days - * worth of jiffies, or over 71 minutes worth of usecs. - * - * Jiffies overflow is handled by subtraction of unsigned ints: - * (gdb) print (unsigned) 2 - (unsigned) 0xfffffffe - * $3 = 4 - * (gdb) - */ - if (n > USEC_PER_SEC / 4) { - n = ((u32) jiffies) - f->sent_jiffs; - n *= USEC_PER_SEC / HZ; - } - return n; } @@ -589,7 +570,6 @@ reassign_frame(struct frame *f) nf->waited = 0; nf->waited_total = f->waited_total; nf->sent = f->sent; - nf->sent_jiffs = f->sent_jiffs; f->skb = skb; return nf; @@ -633,8 +613,7 @@ probe(struct aoetgt *t) skb = skb_clone(f->skb, GFP_ATOMIC); if (skb) { - do_gettimeofday(&f->sent); - f->sent_jiffs = (u32) jiffies; + f->sent = ktime_get(); __skb_queue_head_init(&queue); __skb_queue_tail(&queue, skb); aoenet_xmit(&queue); @@ -1474,8 +1453,7 @@ aoecmd_ata_id(struct aoedev *d) skb = skb_clone(skb, GFP_ATOMIC); if (skb) { - do_gettimeofday(&f->sent); - f->sent_jiffs = (u32) jiffies; + f->sent = ktime_get(); } return skb; -- 2.2.0.rc0.207.ga3a616c

9 years, 11 months

[PATCH v3] Staging: media: Replace timeval with ktime_t

by Ksenija Stanojevic

'struct timeval last_tv' is used to get the time of last signal change and 'struct timeval last_intr_tv' is used to get the time of last UART interrupt. 32-bit systems using 'struct timeval' will break in the year 2038, so we have to replace that code with more appropriate types. Here struct timeval is replaced with ktime_t. Signed-off-by: Ksenija Stanojevic <ksenija.stanojevic(a)gmail.com> --- Changes in v3: - as John suggested delta function is changed to inline function, checkpatch signals a warning to change min to min_t. Is it a false positive? - change variable names. Changes in v2: - change subject line drivers/staging/media/lirc/lirc_sir.c | 51 +++++++++++++---------------------- 1 file changed, 18 insertions(+), 33 deletions(-) diff --git a/drivers/staging/media/lirc/lirc_sir.c b/drivers/staging/media/lirc/lirc_sir.c index 29087f6..c98c486 100644 --- a/drivers/staging/media/lirc/lirc_sir.c +++ b/drivers/staging/media/lirc/lirc_sir.c @@ -44,7 +44,7 @@ #include <linux/ioport.h> #include <linux/kernel.h> #include <linux/serial_reg.h> -#include <linux/time.h> +#include <linux/ktime.h> #include <linux/string.h> #include <linux/types.h> #include <linux/wait.h> @@ -127,9 +127,9 @@ static int threshold = 3; static DEFINE_SPINLOCK(timer_lock); static struct timer_list timerlist; /* time of last signal change detected */ -static struct timeval last_tv = {0, 0}; +static ktime_t last; /* time of last UART data ready interrupt */ -static struct timeval last_intr_tv = {0, 0}; +static ktime_t last_intr_time; static int last_value; static DECLARE_WAIT_QUEUE_HEAD(lirc_read_queue); @@ -400,18 +400,11 @@ static void drop_chrdev(void) } /* SECTION: Hardware */ -static long delta(struct timeval *tv1, struct timeval *tv2) +static inline long delta(ktime_t t1, ktime_t t2) { - unsigned long deltv; - - deltv = tv2->tv_sec - tv1->tv_sec; - if (deltv > 15) - deltv = 0xFFFFFF; - else - deltv = deltv*1000000 + - tv2->tv_usec - - tv1->tv_usec; - return deltv; + /* return the delta in 32bit usecs, but cap to UINTMAX in case the + * delta is greater then 32bits */ + return (long) min((unsigned int) ktime_us_delta(t1, t2), UINT_MAX); } static void sir_timeout(unsigned long data) @@ -432,12 +425,12 @@ static void sir_timeout(unsigned long data) /* clear unread bits in UART and restart */ outb(UART_FCR_CLEAR_RCVR, io + UART_FCR); /* determine 'virtual' pulse end: */ - pulse_end = delta(&last_tv, &last_intr_tv); + pulse_end = delta(last, last_intr_time); dev_dbg(driver.dev, "timeout add %d for %lu usec\n", last_value, pulse_end); add_read_queue(last_value, pulse_end); last_value = 0; - last_tv = last_intr_tv; + last = last_intr_time; } spin_unlock_irqrestore(&timer_lock, flags); } @@ -445,7 +438,7 @@ static void sir_timeout(unsigned long data) static irqreturn_t sir_interrupt(int irq, void *dev_id) { unsigned char data; - struct timeval curr_tv; + ktime_t curr_time; static unsigned long deltv; unsigned long deltintrtv; unsigned long flags; @@ -471,9 +464,9 @@ static irqreturn_t sir_interrupt(int irq, void *dev_id) do { del_timer(&timerlist); data = inb(io + UART_RX); - do_gettimeofday(&curr_tv); - deltv = delta(&last_tv, &curr_tv); - deltintrtv = delta(&last_intr_tv, &curr_tv); + curr_time = ktime_get(); + deltv = delta(last, curr_time); + deltintrtv = delta(last_intr_time, curr_time); dev_dbg(driver.dev, "t %lu, d %d\n", deltintrtv, (int)data); /* @@ -488,10 +481,7 @@ static irqreturn_t sir_interrupt(int irq, void *dev_id) deltv - deltintrtv); last_value = 0; - last_tv.tv_sec = - last_intr_tv.tv_sec; - last_tv.tv_usec = - last_intr_tv.tv_usec; + last = last_intr_time; deltv = deltintrtv; } } @@ -504,16 +494,11 @@ static irqreturn_t sir_interrupt(int irq, void *dev_id) add_read_queue(last_value, deltv-TIME_CONST); last_value = data; - last_tv = curr_tv; - if (last_tv.tv_usec >= TIME_CONST) { - last_tv.tv_usec -= TIME_CONST; - } else { - last_tv.tv_sec--; - last_tv.tv_usec += 1000000 - - TIME_CONST; - } + last = curr_time; + last = ktime_sub_us(last, + TIME_CONST); } - last_intr_tv = curr_tv; + last_intr_time = curr_time; if (data) { /* * start timer for end of -- 1.9.1

9 years, 11 months

[PATCH v3 14/22] time:Introduce the do_sys_settimeofday64() function with timespec64 type

by Baolin Wang

This patch introduces the do_sys_settimeofday64() function with timespec64 type, that makes this function ready for 2038 issue when setting the time of day. And moves the do_sys_settimeofday() function to the timekeeping.h file. Signed-off-by: Baolin Wang <baolin.wang(a)linaro.org> --- include/linux/timekeeping.h | 12 ++++++++++-- kernel/time/time.c | 10 ++++++---- 2 files changed, 16 insertions(+), 6 deletions(-) diff --git a/include/linux/timekeeping.h b/include/linux/timekeeping.h index c6d5ae9..89beb62 100644 --- a/include/linux/timekeeping.h +++ b/include/linux/timekeeping.h @@ -11,8 +11,16 @@ extern int timekeeping_suspended; */ extern void do_gettimeofday(struct timeval *tv); extern int do_settimeofday64(const struct timespec64 *ts); -extern int do_sys_settimeofday(const struct timespec *tv, - const struct timezone *tz); +extern int do_sys_settimeofday64(const struct timespec64 *tv, + const struct timezone *tz); +static inline int do_sys_settimeofday(const struct timespec *tv, + const struct timezone *tz) +{ + struct timespec64 ts64; + + ts64 = timespec_to_timespec64(*tv); + return do_sys_settimeofday64(&ts64, tz); +} /* * Kernel time accessors diff --git a/kernel/time/time.c b/kernel/time/time.c index 2c85b77..f43011b 100644 --- a/kernel/time/time.c +++ b/kernel/time/time.c @@ -160,15 +160,17 @@ static inline void warp_clock(void) * various programs will get confused when the clock gets warped. */ -int do_sys_settimeofday(const struct timespec *tv, const struct timezone *tz) +int do_sys_settimeofday64(const struct timespec64 *tv, const struct timezone *tz) { static int firsttime = 1; int error = 0; + struct timespec ts; - if (tv && !timespec_valid(tv)) + if (tv && !timespec64_valid(tv)) return -EINVAL; - error = security_settime(tv, tz); + ts = timespec64_to_timespec(*tv); + error = security_settime(&ts, tz); if (error) return error; @@ -182,7 +184,7 @@ int do_sys_settimeofday(const struct timespec *tv, const struct timezone *tz) } } if (tv) - return do_settimeofday(tv); + return do_settimeofday64(tv); return 0; } -- 1.7.9.5

9 years, 11 months

[PATCH v3 11/22] posix-timers:Convert to the 64bit methods for the clock_gettime syscall function

by Baolin Wang

This patch introduces the clock_get64 methods with timespec64 type for k_clock structure. Convert to the 64bit methods with timespec64 type for the clock_gettime syscall function, and change the clock_gettime syscall implementation according the the CONFIG_64BIT macro. Signed-off-by: Baolin Wang <baolin.wang(a)linaro.org> --- include/linux/posix-timers.h | 1 + kernel/time/posix-timers.c | 32 ++++++++++++++++++++++++++------ 2 files changed, 27 insertions(+), 6 deletions(-) diff --git a/include/linux/posix-timers.h b/include/linux/posix-timers.h index 9b6469c..c08a536 100644 --- a/include/linux/posix-timers.h +++ b/include/linux/posix-timers.h @@ -103,6 +103,7 @@ struct k_clock { 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_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/posix-timers.c b/kernel/time/posix-timers.c index 8aac06d..ccc84d3 100644 --- a/kernel/time/posix-timers.c +++ b/kernel/time/posix-timers.c @@ -545,6 +545,16 @@ static int default_clock_set64(const clockid_t which_clock, return 0; } +static int default_clock_get64(const clockid_t which_clock, + struct timespec64 *tp64) +{ + struct k_clock *kc = clockid_to_kclock(which_clock); + struct timespec tp; + + kc->clock_get(which_clock, &tp); + return 0; +} + void posix_timers_register_clock(const clockid_t clock_id, struct k_clock *new_clock) { @@ -554,8 +564,8 @@ void posix_timers_register_clock(const clockid_t clock_id, return; } - if (!new_clock->clock_get) { - printk(KERN_WARNING "POSIX clock id %d lacks clock_get()\n", + if (!new_clock->clock_get && !new_clock->clock_get64) { + printk(KERN_WARNING "POSIX clock id %d lacks clock_get() and clock_get64()\n", clock_id); return; } @@ -571,6 +581,8 @@ void posix_timers_register_clock(const clockid_t clock_id, new_clock->timer_set64 = default_timer_set64; if (new_clock->clock_set && !new_clock->clock_set64) new_clock->clock_set64 = default_clock_set64; + if (new_clock->clock_get && !new_clock->clock_get64) + new_clock->clock_get64 = default_clock_get64; posix_clocks[clock_id] = *new_clock; } @@ -1115,23 +1127,31 @@ SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock, #endif } -static int __clock_gettime(clockid_t which_clock, struct timespec *ts) +static int __clock_gettime(clockid_t which_clock, struct timespec64 *ts) { struct k_clock *kc = clockid_to_kclock(which_clock); if (!kc) return -EINVAL; - return kc->clock_get(which_clock, ts); + return kc->clock_get64(which_clock, ts); } SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock, struct timespec __user *,tp) { - struct timespec kernel_tp; int error; - +#ifdef CONFIG_64BIT + struct timespec64 kernel_tp; error = __clock_gettime(which_clock, &kernel_tp); +#else + struct timespec64 kernel_tp64; + struct timespec kernel_tp; + + error = __clock_gettime(which_clock, &kernel_tp64); + if (!error) + kernel_tp = timespec64_to_timespec(kernel_tp64); +#endif if (!error && copy_to_user(tp, &kernel_tp, sizeof (kernel_tp))) error = -EFAULT; -- 1.7.9.5

9 years, 11 months

[PATCH v3 09/22] posix-timers:Convert to the 64bit methods for the clock_settime syscall function

by Baolin Wang

This patch introduces the clock_set64 methods with timespec64 type for k_clock structure. Convert to the 64bit methods with timespec64 type for the clock_settime syscall function, and change the clock_settime syscall implementation according the the CONFIG_64BIT macro. Signed-off-by: Baolin Wang <baolin.wang(a)linaro.org> --- include/linux/posix-timers.h | 2 ++ kernel/time/posix-timers.c | 28 +++++++++++++++++++++++++--- 2 files changed, 27 insertions(+), 3 deletions(-) diff --git a/include/linux/posix-timers.h b/include/linux/posix-timers.h index 870ab93..9b6469c 100644 --- a/include/linux/posix-timers.h +++ b/include/linux/posix-timers.h @@ -100,6 +100,8 @@ struct k_clock { int (*clock_getres) (const clockid_t which_clock, struct timespec *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_adj) (const clockid_t which_clock, struct timex *tx); int (*timer_create) (struct k_itimer *timer); diff --git a/kernel/time/posix-timers.c b/kernel/time/posix-timers.c index dcc35fc..0fe8a65 100644 --- a/kernel/time/posix-timers.c +++ b/kernel/time/posix-timers.c @@ -535,6 +535,16 @@ static int default_timer_set64(struct k_itimer *timr, int flags, return 0; } +static int default_clock_set64(const clockid_t which_clock, + const struct timespec64 *tp64) +{ + struct k_clock *kc = clockid_to_kclock(which_clock); + struct timespec tp; + + kc->clock_set(which_clock, &tp); + return 0; +} + void posix_timers_register_clock(const clockid_t clock_id, struct k_clock *new_clock) { @@ -559,6 +569,8 @@ void posix_timers_register_clock(const clockid_t clock_id, new_clock->timer_get64 = default_timer_get64; if (new_clock->timer_set && !new_clock->timer_set64) new_clock->timer_set64 = default_timer_set64; + if (new_clock->clock_set && !new_clock->clock_set64) + new_clock->clock_set64 = default_clock_set64; posix_clocks[clock_id] = *new_clock; } @@ -1072,25 +1084,35 @@ void exit_itimers(struct signal_struct *sig) } } -static int __clock_settime(clockid_t which_clock, struct timespec *ts) +static int __clock_settime(clockid_t which_clock, struct timespec64 *ts) { struct k_clock *kc = clockid_to_kclock(which_clock); - if (!kc || !kc->clock_set) + if (!kc || !kc->clock_set64) return -EINVAL; - return kc->clock_set(which_clock, ts); + return kc->clock_set64(which_clock, ts); } SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock, const struct timespec __user *, tp) { +#ifdef CONFIG_64BIT + struct timespec64 new_tp; +#else struct timespec new_tp; + struct timespec64 new_tp64; +#endif if (copy_from_user(&new_tp, tp, sizeof (*tp))) return -EFAULT; +#ifdef CONFIG_64BIT return __clock_settime(which_clock, &new_tp); +#else + new_tp64 = timespec_to_timespec64(new_tp); + return __clock_settime(which_clock, &new_tp64); +#endif } SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock, -- 1.7.9.5

9 years, 11 months

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

Y2038