Y2038

y2038@lists.linaro.org

1140 discussions

[PATCH RESEND] net: ipv4: Fix truncated timestamp returned by inet_current_timestamp()

by Deepa Dinamani

The millisecond timestamps returned by the function is converted to network byte order by making a call to htons(). htons() only returns __be16 while __be32 is required here. This was identified by the sparse warning from the buildbot: net/ipv4/af_inet.c:1405:16: sparse: incorrect type in return expression (different base types) net/ipv4/af_inet.c:1405:16: expected restricted __be32 net/ipv4/af_inet.c:1405:16: got restricted __be16 [usertype] <noident> Change the function to use htonl() to return the correct __be32 type instead so that the millisecond value doesn't get truncated. Signed-off-by: Deepa Dinamani <deepa.kernel(a)gmail.com> Cc: "David S. Miller" <davem(a)davemloft.net> Cc: Alexey Kuznetsov <kuznet(a)ms2.inr.ac.ru> Cc: Hideaki YOSHIFUJI <yoshfuji(a)linux-ipv6.org> Cc: James Morris <jmorris(a)namei.org> Cc: Patrick McHardy <kaber(a)trash.net> Cc: Arnd Bergmann <arnd(a)arndb.de> Fixes: 822c868532ca ("net: ipv4: Convert IP network timestamps to be y2038 safe") Reported-by: Fengguang Wu <fengguang.wu(a)intel.com> [0-day test robot] --- Fixed the y2038 list email address. net/ipv4/af_inet.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c index 0cc923f..5fab7e3 100644 --- a/net/ipv4/af_inet.c +++ b/net/ipv4/af_inet.c @@ -1402,7 +1402,7 @@ __be32 inet_current_timestamp(void) msecs += (u32)ts.tv_nsec / NSEC_PER_MSEC; /* Convert to network byte order. */ - return htons(msecs); + return htonl(msecs); } EXPORT_SYMBOL(inet_current_timestamp); -- 1.9.1

9 years, 8 months

[PATCH v7] isdn: Use ktime_t instead of 'struct timeval'

by Tina Ruchandani

'struct timeval' uses 32-bit representation for seconds which will overflow in year 2038 and beyond. mISDN/clock.c needs to compute and store elapsed time in intervals of 125 microseconds. This patch replaces the usage of 'struct timeval' with 64-bit ktime_t which is y2038 safe. The patch also replaces do_gettimeofday() (wall-clock time) with ktime_get() (monotonic time) since we only care about elapsed time here. Signed-off-by: Tina Ruchandani <ruchandani.tina(a)gmail.com> Suggested-by: Arnd Bergmnann <arnd(a)arndb.de> Suggested-by: David Miller <davem(a)davemloft.net> --- Changes in v7: - Upodate variable names to remove mentions of 'tv' for timeval Changes in v6: - Fix compilation errors caused by bad code editing Changes in v5: - Apply cleanly to net-next Changes in v4: - Fix compile error (NS_PER_SEC -> NSEC_PER_SEC) Changes in v3: - Use division scheme suggested by Arnd Bergmann to avoid a (64-bit variable) / (32-bit variable) expression. Changes in v2: - Avoid possible truncation bug caused by assigning ktime_us_delta output to a 16-bit number. - Use ktime_us_delta, more concise than a combination of ktime_sub and ktime_to_us. --- drivers/isdn/mISDN/clock.c | 69 +++++++++++++++++++--------------------------- include/linux/mISDNif.h | 2 +- 2 files changed, 30 insertions(+), 41 deletions(-) diff --git a/drivers/isdn/mISDN/clock.c b/drivers/isdn/mISDN/clock.c index 693fb7c..f8f659f 100644 --- a/drivers/isdn/mISDN/clock.c +++ b/drivers/isdn/mISDN/clock.c @@ -37,6 +37,7 @@ #include <linux/types.h> #include <linux/stddef.h> #include <linux/spinlock.h> +#include <linux/ktime.h> #include <linux/mISDNif.h> #include <linux/export.h> #include "core.h" @@ -45,15 +46,15 @@ static u_int *debug; static LIST_HEAD(iclock_list); static DEFINE_RWLOCK(iclock_lock); static u16 iclock_count; /* counter of last clock */ -static struct timeval iclock_tv; /* time stamp of last clock */ -static int iclock_tv_valid; /* already received one timestamp */ +static ktime_t iclock_timestamp; /* time stamp of last clock */ +static int iclock_timestamp_valid; /* already received one timestamp */ static struct mISDNclock *iclock_current; void mISDN_init_clock(u_int *dp) { debug = dp; - do_gettimeofday(&iclock_tv); + iclock_timestamp = ktime_get(); } static void @@ -86,7 +87,7 @@ select_iclock(void) } if (bestclock != iclock_current) { /* no clock received yet */ - iclock_tv_valid = 0; + iclock_timestamp_valid = 0; } iclock_current = bestclock; } @@ -139,12 +140,11 @@ mISDN_unregister_clock(struct mISDNclock *iclock) EXPORT_SYMBOL(mISDN_unregister_clock); void -mISDN_clock_update(struct mISDNclock *iclock, int samples, struct timeval *tv) +mISDN_clock_update(struct mISDNclock *iclock, int samples, ktime_t *timestamp) { u_long flags; - struct timeval tv_now; - time_t elapsed_sec; - int elapsed_8000th; + ktime_t timestamp_now; + u16 delta; write_lock_irqsave(&iclock_lock, flags); if (iclock_current != iclock) { @@ -156,33 +156,27 @@ mISDN_clock_update(struct mISDNclock *iclock, int samples, struct timeval *tv) write_unlock_irqrestore(&iclock_lock, flags); return; } - if (iclock_tv_valid) { + if (iclock_timestamp_valid) { /* increment sample counter by given samples */ iclock_count += samples; - if (tv) { /* tv must be set, if function call is delayed */ - iclock_tv.tv_sec = tv->tv_sec; - iclock_tv.tv_usec = tv->tv_usec; - } else - do_gettimeofday(&iclock_tv); + if (timestamp) { /* timestamp must be set, if function call is delayed */ + iclock_timestamp = *timestamp; + } else { + iclock_timestamp = ktime_get(); + } } else { /* calc elapsed time by system clock */ - if (tv) { /* tv must be set, if function call is delayed */ - tv_now.tv_sec = tv->tv_sec; - tv_now.tv_usec = tv->tv_usec; - } else - do_gettimeofday(&tv_now); - elapsed_sec = tv_now.tv_sec - iclock_tv.tv_sec; - elapsed_8000th = (tv_now.tv_usec / 125) - - (iclock_tv.tv_usec / 125); - if (elapsed_8000th < 0) { - elapsed_sec -= 1; - elapsed_8000th += 8000; + if (timestamp) { /* timestamp must be set, if function call is delayed */ + timestamp_now = *timestamp; + } else { + timestamp_now = ktime_get(); } + delta = ktime_divns(ktime_sub(timestamp_now, iclock_timestamp), + (NSEC_PER_SEC / 8000)); /* add elapsed time to counter and set new timestamp */ - iclock_count += elapsed_sec * 8000 + elapsed_8000th; - iclock_tv.tv_sec = tv_now.tv_sec; - iclock_tv.tv_usec = tv_now.tv_usec; - iclock_tv_valid = 1; + iclock_count += delta; + iclock_timestamp = timestamp_now; + iclock_timestamp_valid = 1; if (*debug & DEBUG_CLOCK) printk("Received first clock from source '%s'.\n", iclock_current ? iclock_current->name : "nothing"); @@ -195,22 +189,17 @@ unsigned short mISDN_clock_get(void) { u_long flags; - struct timeval tv_now; - time_t elapsed_sec; - int elapsed_8000th; + ktime_t timestamp_now; + u16 delta; u16 count; read_lock_irqsave(&iclock_lock, flags); /* calc elapsed time by system clock */ - do_gettimeofday(&tv_now); - elapsed_sec = tv_now.tv_sec - iclock_tv.tv_sec; - elapsed_8000th = (tv_now.tv_usec / 125) - (iclock_tv.tv_usec / 125); - if (elapsed_8000th < 0) { - elapsed_sec -= 1; - elapsed_8000th += 8000; - } + timestamp_now = ktime_get(); + delta = ktime_divns(ktime_sub(timestamp_now, iclock_timestamp), + (NSEC_PER_SEC / 8000)); /* add elapsed time to counter */ - count = iclock_count + elapsed_sec * 8000 + elapsed_8000th; + count = iclock_count + delta; read_unlock_irqrestore(&iclock_lock, flags); return count; } diff --git a/include/linux/mISDNif.h b/include/linux/mISDNif.h index 246a352..ac02c54 100644 --- a/include/linux/mISDNif.h +++ b/include/linux/mISDNif.h @@ -596,7 +596,7 @@ static inline struct mISDNdevice *dev_to_mISDN(struct device *dev) } extern void set_channel_address(struct mISDNchannel *, u_int, u_int); -extern void mISDN_clock_update(struct mISDNclock *, int, struct timeval *); +extern void mISDN_clock_update(struct mISDNclock *, int, ktime_t *); extern unsigned short mISDN_clock_get(void); extern const char *mISDNDevName4ch(struct mISDNchannel *); -- 1.9.1

9 years, 8 months

[PATCH v2] vfs: Add support to check max and min inode times

by Deepa Dinamani

This is a preparation patch to add range checking for inode timestamps. Extend struct super_block to include information about the max and min inode times each filesystem can hold. These are dependent on the on-disk format of filesystems. These range checks will be used to clamp timestamps to filesystem allowed ranges. Individual filesystems do not have the same on disk format as the in memory inodes. Range checking and clamping times assigned to inodes will help keep in memory and on-disk timestamps to be in sync. Every time a new superblock is created, make sure that the superblock max and min timestamp fields are assigned invalid values. Another series will initialize these fields to appropriate values for every filesystem. The values are currently ignored. The exact policy and behavior will be decided in a separate patch. max and min times are initialized to MIN_VFS_TIME and MAX_VFS_TIME respectively so that even if one of the fields is uninitialized, it can be detected by using the condition max_time < min_time. The original idea for the feature comes from the discussion: https://lkml.org/lkml/2014/5/30/669 Signed-off-by: Deepa Dinamani <deepa.kernel(a)gmail.com> --- The intention is to include this as part of 4.6 so that the follow on patches can go into 4.7. The series and the plan have been discussed with Arnd Bergmann. Changes from v1: * Delete INVALID macros, use VFS_TIME macros directly. * Add comment in alloc_super() to explain range checking. * Reword the commit text to reflect the above. fs/super.c | 7 +++++++ include/linux/fs.h | 12 +++++++++++- 2 files changed, 18 insertions(+), 1 deletion(-) diff --git a/fs/super.c b/fs/super.c index 1182af8..37ec188 100644 --- a/fs/super.c +++ b/fs/super.c @@ -239,6 +239,13 @@ static struct super_block *alloc_super(struct file_system_type *type, int flags) s->s_maxbytes = MAX_NON_LFS; s->s_op = &default_op; s->s_time_gran = 1000000000; + /* + * Assign a default empty range [MAX_VFS_TIME, MIN_VFS_TIME]. + * This will help VFS detect filesystems that do not populate + * these fields in the superblock. + */ + s->s_time_min = MAX_VFS_TIME; + s->s_time_max = MIN_VFS_TIME; s->cleancache_poolid = CLEANCACHE_NO_POOL; s->s_shrink.seeks = DEFAULT_SEEKS; diff --git a/include/linux/fs.h b/include/linux/fs.h index 1af4727..cee8f99 100644 --- a/include/linux/fs.h +++ b/include/linux/fs.h @@ -927,6 +927,9 @@ static inline struct file *get_file(struct file *f) #define MAX_LFS_FILESIZE ((loff_t)0x7fffffffffffffffLL) #endif +#define MIN_VFS_TIME S64_MIN +#define MAX_VFS_TIME S64_MAX + #define FL_POSIX 1 #define FL_FLOCK 2 #define FL_DELEG 4 /* NFSv4 delegation */ @@ -1343,7 +1346,14 @@ struct super_block { /* Granularity of c/m/atime in ns. Cannot be worse than a second */ - u32 s_time_gran; + u32 s_time_gran; + + /* + * Max and min values for timestamps + * according to the range supported by filesystems. + */ + time64_t s_time_min; + time64_t s_time_max; /* * The next field is for VFS *only*. No filesystems have any business -- 1.9.1

9 years, 8 months

[PATCH] vfs: Add support to check max and min inode times

by Deepa Dinamani

This is a preparation patch to add range checking for inode timestamps. These range checks will be used to clamp timestamps to filesystem allowed ranges. Individual filesystems do not have the same on disk format as the in memory inodes. Range checking and clamping times assigned to inodes will help keep in memory and on-disk timestamps to be in sync. Extend struct super_block to include information about the max and min inode times each filesystem can hold. These are dependent on the on-disk format of filesystems. Every time a new superblock is created, make sure that the superblock max and min timestamp fields are assigned invalid values. Another series will initialize these fields to appropriate values for every filesystem. The values are currently ignored. The exact policy and behavior will be decided in a separate patch. MAX_INVALID_VFS_TIME and MIN_INVALID_VFS_TIME are initialized to S64_MIN and S64_MAX respectively so that even if one of the fields is uninitialized, it can be detected by using the condition max_time < min_time. The original idea for the feature comes from the discussion: https://lkml.org/lkml/2014/5/30/669 Signed-off-by: Deepa Dinamani <deepa.kernel(a)gmail.com> --- The intention is to include this as part of 4.6 so that the follow on patches can go into 4.7. The series and the plan have been discussed with Arnd Bergmann. fs/super.c | 2 ++ include/linux/fs.h | 13 ++++++++++++- 2 files changed, 14 insertions(+), 1 deletion(-) diff --git a/fs/super.c b/fs/super.c index 1182af8..d70a8f6 100644 --- a/fs/super.c +++ b/fs/super.c @@ -239,6 +239,8 @@ static struct super_block *alloc_super(struct file_system_type *type, int flags) s->s_maxbytes = MAX_NON_LFS; s->s_op = &default_op; s->s_time_gran = 1000000000; + s->s_time_max = MAX_INVALID_VFS_TIME; + s->s_time_min = MIN_INVALID_VFS_TIME; s->cleancache_poolid = CLEANCACHE_NO_POOL; s->s_shrink.seeks = DEFAULT_SEEKS; diff --git a/include/linux/fs.h b/include/linux/fs.h index 1af4727..15b41e6 100644 --- a/include/linux/fs.h +++ b/include/linux/fs.h @@ -927,6 +927,12 @@ static inline struct file *get_file(struct file *f) #define MAX_LFS_FILESIZE ((loff_t)0x7fffffffffffffffLL) #endif +#define MAX_VFS_TIME S64_MAX +#define MIN_VFS_TIME S64_MIN + +#define MAX_INVALID_VFS_TIME S64_MIN +#define MIN_INVALID_VFS_TIME S64_MAX + #define FL_POSIX 1 #define FL_FLOCK 2 #define FL_DELEG 4 /* NFSv4 delegation */ @@ -1343,7 +1349,12 @@ struct super_block { /* Granularity of c/m/atime in ns. Cannot be worse than a second */ - u32 s_time_gran; + u32 s_time_gran; + /* Max and min values for timestamps + * according to the range supported by filesystems. + */ + time64_t s_time_max; + time64_t s_time_min; /* * The next field is for VFS *only*. No filesystems have any business -- 1.9.1

9 years, 9 months

[PATCH 0/2] Add infrastructure to support vfs 64 bit times

by Deepa Dinamani

The series contains infrastucture patches required to convert vfs times to use 64 bit time. The intention is to include these as part of 4.6 so that the follow on patches can go into 4.7. Patch 1 is as per the agreed upon RFC approach 2b: https://lkml.org/lkml/2016/2/12/105 And, patch 2 is as per previously agreed upon discussion in: https://lkml.org/lkml/2016/1/7/20 The patches that will use these will be posted for the subsequent kernel release. The series and the plan have been discussed with Arnd Bergmann. Deepa Dinamani (2): fs: Add current_fs_time_sec() function vfs: Add vfs_time accessors include/linux/fs.h | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) -- 1.9.1

9 years, 9 months

[PATCH v2 0/3] Convert network timestamps to be y2038 safe

by Deepa Dinamani

Introduction: The series is aimed at transitioning network timestamps to being y2038 safe. All patches can be reviewed and merged independently. Socket timestamps and ioctl calls will be handled separately. Thanks to Arnd Bergmann for discussing solution options with me. Solution: Data type struct timespec is not y2038 safe. Replace timespec with struct timespec64 which is y2038 safe. Changes v1 -> v2: Move and rename inet_current_time() as discussed Squash patches 1 and 2 Reword commit text for patch 2/3 Carry over review tags Deepa Dinamani (3): net: ipv4: Convert IP network timestamps to be y2038 safe net: ipv4: tcp_probe: Replace timespec with timespec64 net: sctp: Convert log timestamps to be y2038 safe include/net/ip.h | 2 ++ net/ipv4/af_inet.c | 26 ++++++++++++++++++++++++++ net/ipv4/icmp.c | 5 +---- net/ipv4/ip_options.c | 14 ++++++-------- net/ipv4/tcp_probe.c | 8 ++++---- net/sctp/probe.c | 10 +++++----- 6 files changed, 44 insertions(+), 21 deletions(-) -- 1.9.1 Cc: Vlad Yasevich <vyasevich(a)gmail.com> Cc: Neil Horman <nhorman(a)tuxdriver.com> Cc: "David S. Miller" <davem(a)davemloft.net> Cc: Alexey Kuznetsov <kuznet(a)ms2.inr.ac.ru> Cc: James Morris <jmorris(a)namei.org> Cc: Hideaki YOSHIFUJI <yoshfuji(a)linux-ipv6.org> Cc: Patrick McHardy <kaber(a)trash.net> Cc: linux-sctp(a)vger.kernel.org

9 years, 9 months

[PATCH] include: ceph: Fix encode and decode type conversions

by Deepa Dinamani

long/ kernel_time_t is 32 bit on a 32 bit system and 64 bit on a 64 bit system. ceph_encode_timespec() encodes only the lower 32 bits on a 64 bit system and encodes all of 32 bits on a 32bit system. ceph_decode_timespec() decodes 32 bit tv_sec and tv_nsec into kernel_time_t/ long. The encode and decode functions do not match when the values are negative: Consider the following scenario on a 32 bit system: When a negative number is cast to u32 as encode does, the value is positive and is greater than INT_MAX. Decode reads back this value. And, this value cannot be represented by long on 32 bit systems. So by section 6.3.1.3 of the C99 standard, the result is implementation defined. Consider the following scenario on a 64 bit system: When a negative number is cast to u32 as encode does, the value is positive. This value is later assigned by decode function by a cast to long. Since this value can be represented in long data type, this becomes a positive value greater than INT_MAX. But, the value encoded was negative, so the encode and decode functions do not match. Change the decode function as follows to overcome the above bug: The decode should first cast the value to a s64 this will be positive value greater than INT_MAX(in case of a negative encoded value)and then cast this value again as s32, which drops the higher order 32 bits. On 32 bit systems, this is the right value in kernel_time_t/ long. On 64 bit systems, assignment to kernel_time_t/ long will sign extend this value to reflect the signed bit encoded. Assume ceph timestamp ranges permitted are 1902..2038. Suggested-by: Arnd Bergmann <arnd(a)arndb.de> Signed-off-by: Deepa Dinamani <deepa.kernel(a)gmail.com> --- include/linux/ceph/decode.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/linux/ceph/decode.h b/include/linux/ceph/decode.h index a6ef9cc..e777e99 100644 --- a/include/linux/ceph/decode.h +++ b/include/linux/ceph/decode.h @@ -137,8 +137,8 @@ bad: static inline void ceph_decode_timespec(struct timespec *ts, const struct ceph_timespec *tv) { - ts->tv_sec = (__kernel_time_t)le32_to_cpu(tv->tv_sec); - ts->tv_nsec = (long)le32_to_cpu(tv->tv_nsec); + ts->tv_sec = (s32)(s64)le32_to_cpu(tv->tv_sec); + ts->tv_nsec = (s32)(s64)le32_to_cpu(tv->tv_nsec); } static inline void ceph_encode_timespec(struct ceph_timespec *tv, const struct timespec *ts) -- 1.9.1

9 years, 9 months

[PATCH 0/4] Convert network timestamps to be y2038 safe

by Deepa Dinamani

Introduction: The series is aimed at transitioning network timestamps to being y2038 safe. All patches can be reviewed and merged independently, except for the [PATCH 2/4], which is dependent on the [PATCH 1/4]. Socket timestamps and ioctl calls will be handled separately. Thanks to Arnd Bergmann for discussing solution options with me. Solution: Data type struct timespec is not y2038 safe. Replace timespec with struct timespec64 which is y2038 safe. Deepa Dinamani (4): kernel: time: Add current_nw_timestamp() for network timestamps net: ipv4: Use y2038 safe functions and data structures net: ipv4: tcp_probe: Replace timespec with timespec64 net: sctp: Convert log timestamps to be y2038 safe include/linux/ip.h | 2 ++ include/linux/time64.h | 3 +++ kernel/time/time.c | 26 ++++++++++++++++++++++++++ net/ipv4/icmp.c | 5 +---- net/ipv4/ip_options.c | 13 +++++-------- net/ipv4/tcp_probe.c | 8 ++++---- net/sctp/probe.c | 10 +++++----- 7 files changed, 46 insertions(+), 21 deletions(-) -- 1.9.1 Cc: Vlad Yasevich <vyasevich(a)gmail.com> Cc: Neil Horman <nhorman(a)tuxdriver.com> Cc: "David S. Miller" <davem(a)davemloft.net> Cc: Alexey Kuznetsov <kuznet(a)ms2.inr.ac.ru> Cc: James Morris <jmorris(a)namei.org> Cc: Hideaki YOSHIFUJI <yoshfuji(a)linux-ipv6.org> Cc: Patrick McHardy <kaber(a)trash.net> Cc: John Stultz <john.stultz(a)linaro.org> Cc: Thomas Gleixner <tglx(a)linutronix.de> Cc: linux-sctp(a)vger.kernel.org

9 years, 9 months

[PATCH 0/8] Remove CURRENT_TIME and CURRENT_TIME_SEC - PART 2

by Deepa Dinamani

Introduction This patch series is aimed at getting rid of CURRENT_TIME and CURRENT_TIME_SEC macros. The idea for the series evolved from my discussions with Arnd Bergmann. This was originally part of the RFC series[2]: https://lkml.org/lkml/2016/1/7/20 (under discussion). Dave Chinner suggested moving bug fixes out of the feature series to keep the original series simple. There are 354 occurrences of the the above macros in the kernel. The series will be divided into 4 or 5 parts to keep the parts manageable and so that each part could be reviewed and merged independently. This is part 2 of the series. Motivation The macros: CURRENT_TIME and CURRENT_TIME_SEC are primarily used for filesystem timestamps. But, they are not accurate as they do not perform clamping according to filesystem timestamps ranges, nor do they truncate the nanoseconds value to the granularity as required by the filesystem. The series is also viewed as an ancillary to another upcoming series[2] that attempts to transition file system timestamps to use 64 bit time to make these y2038 safe. There will also be another series[3] to add range checks and clamping to filesystem time functions that are meant to substitute the above macros. Solution CURRENT_TIME macro has an equivalent function: struct timespec current_fs_time(struct super_block *sb) These will be the changes to the above function: 1. Function will return the type y2038 safe timespec64 in [2]. 2. Function will use y2038 safe 64 bit functions in [2]. 3. Function will be extended to perform range checks in [3]. A new function will be added to substitute for CURRENT_TIME_SEC macro in the current series: struct timespec current_fs_time_sec(struct super_block *sb) These will be the changes to the above function: 1. Function will return the type y2038 safe timespec64 in [2]. 2. Function will use y2038 safe 64 bit functions in [2]. 3. Function will be extended to perform range checks in [3]. Any use of these macros outside of filesystem timestamps will be replaced by function calls to appropriate time functions. Deepa Dinamani (8): fs: debugfs: Replace CURRENT_TIME by current_fs_time() fs: logfs: Replace CURRENT_TIME by current_fs_time() fs: devpts: Replace CURRENT_TIME by current_fs_time() fs: configfs: Replace CURRENT_TIME by current_fs_time() fs: proc: Replace CURRENT_TIME by current_fs_time() fs: ramfs: Replace CURRENT_TIME by current_fs_time() fs: kernfs: Replace CURRENT_TIME by current_fs_time() net: sunrpc: Replace CURRENT_TIME by current_fs_time() fs/configfs/inode.c | 8 +++++--- fs/debugfs/inode.c | 3 ++- fs/devpts/inode.c | 9 ++++++--- fs/kernfs/dir.c | 8 +++++--- fs/kernfs/inode.c | 15 ++++++++++----- fs/logfs/dir.c | 11 +++++++---- fs/logfs/file.c | 2 +- fs/logfs/inode.c | 3 +-- fs/logfs/readwrite.c | 7 ++++--- fs/proc/base.c | 3 ++- fs/proc/inode.c | 6 ++++-- fs/proc/proc_sysctl.c | 3 ++- fs/proc/self.c | 3 ++- fs/proc/thread_self.c | 3 ++- fs/ramfs/inode.c | 13 ++++++++----- net/sunrpc/rpc_pipe.c | 4 +++- 16 files changed, 64 insertions(+), 37 deletions(-) -- 1.9.1

9 years, 9 months

[PATCH] scsi: gdth: replace struct timeval with ktime_get_real_seconds()

by Alison Schofield

struct timeval will overflow on 32-bit systems in y2038. Replace the use of struct timeval and do_gettimeofday() with 64 bit ktime_get_real_seconds. gdth uses the seconds portion of timeval in two places: 1) in an unsigned-32 timestamp field in the ioctl GDTIOCTL_EVENT 2) in an int defined local var to calculate elapsed time for a debug msg Use ktime_get_real_seconds() cast to u32 to extend these fields to y2106. Signed-off-by: Alison Schofield <amsfield22(a)gmail.com> --- drivers/scsi/gdth.c | 8 +++----- drivers/scsi/gdth_proc.c | 5 ++--- 2 files changed, 5 insertions(+), 8 deletions(-) diff --git a/drivers/scsi/gdth.c b/drivers/scsi/gdth.c index 71e1380..3da4f43 100644 --- a/drivers/scsi/gdth.c +++ b/drivers/scsi/gdth.c @@ -118,6 +118,7 @@ #include <linux/proc_fs.h> #include <linux/time.h> #include <linux/timer.h> +#include <linux/ktime.h> #include <linux/dma-mapping.h> #include <linux/list.h> #include <linux/mutex.h> @@ -2838,7 +2839,6 @@ static gdth_evt_str *gdth_store_event(gdth_ha_str *ha, u16 source, u16 idx, gdth_evt_data *evt) { gdth_evt_str *e; - struct timeval tv; /* no GDTH_LOCK_HA() ! */ TRACE2(("gdth_store_event() source %d idx %d\n", source, idx)); @@ -2854,8 +2854,7 @@ static gdth_evt_str *gdth_store_event(gdth_ha_str *ha, u16 source, !strcmp((char *)&ebuffer[elastidx].event_data.event_string, (char *)&evt->event_string)))) { e = &ebuffer[elastidx]; - do_gettimeofday(&tv); - e->last_stamp = tv.tv_sec; + e->last_stamp = (u32)ktime_get_real_seconds(); ++e->same_count; } else { if (ebuffer[elastidx].event_source != 0) { /* entry not free ? */ @@ -2871,8 +2870,7 @@ static gdth_evt_str *gdth_store_event(gdth_ha_str *ha, u16 source, e = &ebuffer[elastidx]; e->event_source = source; e->event_idx = idx; - do_gettimeofday(&tv); - e->first_stamp = e->last_stamp = tv.tv_sec; + e->first_stamp = e->last_stamp = (u32)ktime_get_real_seconds(); e->same_count = 1; e->event_data = *evt; e->application = 0; diff --git a/drivers/scsi/gdth_proc.c b/drivers/scsi/gdth_proc.c index e66e997..992d325 100644 --- a/drivers/scsi/gdth_proc.c +++ b/drivers/scsi/gdth_proc.c @@ -4,6 +4,7 @@ #include <linux/completion.h> #include <linux/slab.h> +#include <linux/ktime.h> int gdth_set_info(struct Scsi_Host *host, char *buffer, int length) { @@ -148,7 +149,6 @@ int gdth_show_info(struct seq_file *m, struct Scsi_Host *host) gdth_cmd_str *gdtcmd; gdth_evt_str *estr; char hrec[161]; - struct timeval tv; char *buf; gdth_dskstat_str *pds; @@ -540,8 +540,7 @@ int gdth_show_info(struct seq_file *m, struct Scsi_Host *host) if (estr->event_data.eu.driver.ionode == ha->hanum && estr->event_source == ES_ASYNC) { gdth_log_event(&estr->event_data, hrec); - do_gettimeofday(&tv); - sec = (int)(tv.tv_sec - estr->first_stamp); + sec = (int)((u32)ktime_get_real_seconds() - estr->first_stamp); if (sec < 0) sec = 0; seq_printf(m," date- %02d:%02d:%02d\t%s\n", sec/3600, sec%3600/60, sec%60, hrec); -- 2.1.4

9 years, 9 months

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

Y2038