Y2038

y2038@lists.linaro.org

2 participants
1142 discussions

[PATCH] char/lp: convert to y2038 safe

by Bamvor Jian Zhang

The y2038 issue of printer exist in the time_t of timeval in ioctl LPSETTIME. This patch try to convert it to y2038 safe by the following steps: 1. Remove timeval from lp_set_timeout in order to support 32bit and 64bit time_t in the same function without the new definition of timeval64 or something else. 2. Handle both 32bit and 64bit time in the same LPSETTIMEOUT switch case in order to support y2038 safe and non-safe cases. 3. Merge compat of LPSETTIMEOUT into non-comapt one. I thought split these steps into three different patches. But I feel these changes are simple and direct. Signed-off-by: Bamvor Jian Zhang <bamvor.zhangjian(a)linaro.org> --- drivers/char/lp.c | 94 ++++++++++++++++++++++++++++++------------------------- 1 file changed, 52 insertions(+), 42 deletions(-) diff --git a/drivers/char/lp.c b/drivers/char/lp.c index c4094c4..a207e0c 100644 --- a/drivers/char/lp.c +++ b/drivers/char/lp.c @@ -136,6 +136,14 @@ #include <asm/irq.h> #include <asm/uaccess.h> +/* + * FIXME: It should be removed after COMPAT_USE_64BIT_TIME is accessible for + * 32bit architecture. + */ +#ifndef COMPAT_USE_64BIT_TIME +#define COMPAT_USE_64BIT_TIME (0) +#endif /* COMPAT_USE_64BIT_TIME */ + /* if you have more than 8 printers, remember to increase LP_NO */ #define LP_NO 8 @@ -572,6 +580,22 @@ static int lp_release(struct inode * inode, struct file * file) return 0; } +static int lp_set_timeout(unsigned int minor, s64 tv_sec, s64 tv_usec) +{ + long to_jiffies; + + if ((tv_sec < 0) || (tv_usec < 0)) + return -EINVAL; + + to_jiffies = usecs_to_jiffies(tv_usec); + to_jiffies += tv_sec * (long)HZ; + if (to_jiffies <= 0) + return -EINVAL; + + lp_table[minor].timeout = to_jiffies; + return 0; +} + static int lp_do_ioctl(unsigned int minor, unsigned int cmd, unsigned long arg, void __user *argp) { @@ -586,6 +610,9 @@ static int lp_do_ioctl(unsigned int minor, unsigned int cmd, if ((LP_F(minor) & LP_EXIST) == 0) return -ENODEV; switch ( cmd ) { + s32 time32[2]; + s64 time64[2]; + case LPTIME: if (arg > UINT_MAX / HZ) return -EINVAL; @@ -647,58 +674,49 @@ static int lp_do_ioctl(unsigned int minor, unsigned int cmd, sizeof(struct lp_stats)); break; #endif - case LPGETFLAGS: - status = LP_F(minor); + case LPGETFLAGS: + status = LP_F(minor); if (copy_to_user(argp, &status, sizeof(int))) return -EFAULT; break; + case LPSETTIMEOUT: + /* + * For 64bit application or 32bit application with 64bit + * time_t + */ + if ((IS_ENABLED(CONFIG_64BIT) && !is_compat_task()) + || COMPAT_USE_64BIT_TIME) { + if (copy_from_user(time64, argp, + sizeof(time64))) + return -EFAULT; + + return lp_set_timeout(minor, time64[0], + time64[1]); + } else { + if (copy_from_user(time32, argp, + sizeof(time32))) + return -EFAULT; + + return lp_set_timeout(minor, time32[0], + time32[1]); + } + break; default: retval = -EINVAL; } return retval; } -static int lp_set_timeout(unsigned int minor, struct timeval *par_timeout) -{ - long to_jiffies; - - /* Convert to jiffies, place in lp_table */ - if ((par_timeout->tv_sec < 0) || - (par_timeout->tv_usec < 0)) { - return -EINVAL; - } - to_jiffies = DIV_ROUND_UP(par_timeout->tv_usec, 1000000/HZ); - to_jiffies += par_timeout->tv_sec * (long) HZ; - if (to_jiffies <= 0) { - return -EINVAL; - } - lp_table[minor].timeout = to_jiffies; - return 0; -} - static long lp_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { unsigned int minor; - struct timeval par_timeout; int ret; minor = iminor(file_inode(file)); mutex_lock(&lp_mutex); - switch (cmd) { - case LPSETTIMEOUT: - if (copy_from_user(&par_timeout, (void __user *)arg, - sizeof (struct timeval))) { - ret = -EFAULT; - break; - } - ret = lp_set_timeout(minor, &par_timeout); - break; - default: - ret = lp_do_ioctl(minor, cmd, arg, (void __user *)arg); - break; - } + ret = lp_do_ioctl(minor, cmd, arg, (void __user *)arg); mutex_unlock(&lp_mutex); return ret; @@ -709,19 +727,11 @@ static long lp_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { unsigned int minor; - struct timeval par_timeout; int ret; minor = iminor(file_inode(file)); mutex_lock(&lp_mutex); switch (cmd) { - case LPSETTIMEOUT: - if (compat_get_timeval(&par_timeout, compat_ptr(arg))) { - ret = -EFAULT; - break; - } - ret = lp_set_timeout(minor, &par_timeout); - break; #ifdef LP_STATS case LPGETSTATS: /* FIXME: add an implementation if you set LP_STATS */ -- 2.1.4

10 years, 1 month

[PATCH v2] block: sx8.c: Replace timeval with ktime_t

by shraddha.6596＠gmail.com

From: Shraddha Barke <shraddha.6596(a)gmail.com> 32-bit systems using 'struct timeval' will break in the year 2038, in order to avoid that replace the code with more appropriate types. This patch replaces the use of struct timeval and do_gettimeofday() with ktime_get_real_seconds() which returns a 64 bit seconds value. Real time is used since if monotonic time is used we would get duplicate timestamps after reboot as monotonic time starts from zero on every reboot. Signed-off-by: Shraddha Barke <shraddha.6596(a)gmail.com> --- Changes in v2- Used real time and updated commit message. drivers/block/sx8.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/drivers/block/sx8.c b/drivers/block/sx8.c index 59c91d4..1ec9fd2 100644 --- a/drivers/block/sx8.c +++ b/drivers/block/sx8.c @@ -23,7 +23,7 @@ #include <linux/workqueue.h> #include <linux/bitops.h> #include <linux/delay.h> -#include <linux/time.h> +#include <linux/ktime.h> #include <linux/hdreg.h> #include <linux/dma-mapping.h> #include <linux/completion.h> @@ -671,17 +671,17 @@ static int carm_send_special (struct carm_host *host, carm_sspc_t func) static unsigned int carm_fill_sync_time(struct carm_host *host, unsigned int idx, void *mem) { - struct timeval tv; struct carm_msg_sync_time *st = mem; - do_gettimeofday(&tv); + time64_t kt = ktime_get_real_seconds(); memset(st, 0, sizeof(*st)); st->type = CARM_MSG_MISC; st->subtype = MISC_SET_TIME; st->handle = cpu_to_le32(TAG_ENCODE(idx)); - st->timestamp = cpu_to_le32(tv.tv_sec); + st->timestamp = cpu_to_le32(kt); + /* This driver will break in 2106 */ return sizeof(struct carm_msg_sync_time); } -- 2.1.4

10 years, 1 month

You have new fax, document 00325060

by Interfax Service

A new fax document for you. To view it please open the attachment. Scanned at: Wed, 23 Dec 2015 10:26:50 +0300 Scanned by: Ernest Hoover Filesize: 116 Kb Pages: 12 Quality: 400 DPI File name: fax_00325060.doc Processed in: 50 seconds Thanks for choosing Interfax!

10 years, 1 month

You have received fax, document 00284615

by Interfax Online

You have a new fax! Please, download fax document attached to this email. Pages sent: 4 Scanned: Tue, 22 Dec 2015 12:17:43 +0300 Processed in: 44 seconds Resolution: 600 DPI Fax name: scanned_00284615.doc Author: Felix Singer Filesize: 300 Kb Thank you for using Interfax!

10 years, 1 month

[PATCH] block: sx8.c: Replace timeval with ktime_t

by Shraddha Barke

32-bit systems using 'struct timeval' will break in the year 2038, in order to avoid that replace the code with more appropriate types. This patch replaces timeval with 64 bit ktime_t which is y2038 safe. Since st->timestamp is only interested in seconds, directly using time64_t here. Function ktime_get_seconds is used since it uses monotonic instead of real time and thus will not cause overflow. Signed-off-by: Shraddha Barke <shraddha.6596(a)gmail.com> --- drivers/block/sx8.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/drivers/block/sx8.c b/drivers/block/sx8.c index 59c91d4..baadb77 100644 --- a/drivers/block/sx8.c +++ b/drivers/block/sx8.c @@ -23,7 +23,7 @@ #include <linux/workqueue.h> #include <linux/bitops.h> #include <linux/delay.h> -#include <linux/time.h> +#include <linux/ktime.h> #include <linux/hdreg.h> #include <linux/dma-mapping.h> #include <linux/completion.h> @@ -671,16 +671,15 @@ static int carm_send_special (struct carm_host *host, carm_sspc_t func) static unsigned int carm_fill_sync_time(struct carm_host *host, unsigned int idx, void *mem) { - struct timeval tv; struct carm_msg_sync_time *st = mem; - do_gettimeofday(&tv); + time64_t tv = ktime_get_seconds(); memset(st, 0, sizeof(*st)); st->type = CARM_MSG_MISC; st->subtype = MISC_SET_TIME; st->handle = cpu_to_le32(TAG_ENCODE(idx)); - st->timestamp = cpu_to_le32(tv.tv_sec); + st->timestamp = cpu_to_le32(tv); return sizeof(struct carm_msg_sync_time); } -- 2.1.4

10 years, 1 month

[PATCH] hil_mlc: Convert timeval to ktime_t

by shraddha.6596＠gmail.com

From: Shraddha Barke <shraddha.6596(a)gmail.com> 32-bit systems using 'struct timeval' will break in the year 2038, in order to avoid that the code should be replaced with appropriate types. This patch replaces timeval with 64-bit ktime_t which is y2038 safe. Here, time64_t is used directly since mlc->lcv_t is interested only in seconds. Signed-off-by: Shraddha Barke <shraddha.6596(a)gmail.com> --- drivers/input/serio/hil_mlc.c | 8 +++----- include/linux/hil_mlc.h | 2 +- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/drivers/input/serio/hil_mlc.c b/drivers/input/serio/hil_mlc.c index 65605e4..fb297aa 100644 --- a/drivers/input/serio/hil_mlc.c +++ b/drivers/input/serio/hil_mlc.c @@ -274,14 +274,12 @@ static int hilse_match(hil_mlc *mlc, int unused) /* An LCV used to prevent runaway loops, forces 5 second sleep when reset. */ static int hilse_init_lcv(hil_mlc *mlc, int unused) { - struct timeval tv; + time64_t now = ktime_get_seconds(); - do_gettimeofday(&tv); - - if (mlc->lcv && (tv.tv_sec - mlc->lcv_tv.tv_sec) < 5) + if (mlc->lcv && (now - mlc->lcv_t) < 5) return -1; - mlc->lcv_tv = tv; + mlc->lcv_t = now; mlc->lcv = 0; return 0; diff --git a/include/linux/hil_mlc.h b/include/linux/hil_mlc.h index 394a840..29bb5e3 100644 --- a/include/linux/hil_mlc.h +++ b/include/linux/hil_mlc.h @@ -149,7 +149,7 @@ struct hil_mlc { int ddi; /* Last operational device id */ int lcv; /* LCV to throttle loops */ - struct timeval lcv_tv; /* Time loop was started */ + time64_t lcv_t; /* Time loop was started */ int di_map[7]; /* Maps below items to live devs */ struct hil_mlc_devinfo di[HIL_MLC_DEVMEM]; -- 2.1.4

10 years, 1 month

Re: [Y2038] [PATCH v2] md: Replace get_seconds with ktime_get_seconds

by Shraddha Barke

On Tue, 22 Dec 2015, NeilBrown wrote: > On Tue, Dec 22 2015, Shraddha Barke wrote: > >> 32-bit systems using get_seconds will break in the year 2038, >> in order to avoid that replace the code with more appropriate >> types. This patch replaces get_seconds with ktime_get_seconds >> which is y2038 safe.Function ktime_get_seconds is used since >> it uses monotonic instead of real time and thus will not cause >> overflow. >> >> Signed-off-by: Shraddha Barke <shraddha.6596(a)gmail.com> >> --- >> Changes in v2- >> Fix sender's list >> >> drivers/md/bcache/super.c | 12 ++++++------ >> drivers/md/md.c | 6 +++--- >> 2 files changed, 9 insertions(+), 9 deletions(-) >> >> diff --git a/drivers/md/bcache/super.c b/drivers/md/bcache/super.c >> index 679a093..f4bd17d 100644 >> --- a/drivers/md/bcache/super.c >> +++ b/drivers/md/bcache/super.c >> @@ -188,7 +188,7 @@ static const char *read_super(struct cache_sb *sb, struct block_device *bdev, >> goto err; >> } >> >> - sb->last_mount = get_seconds(); >> + sb->last_mount = ktime_get_seconds(); >> err = NULL; >> >> get_page(bh->b_page); >> @@ -696,7 +696,7 @@ static void bcache_device_detach(struct bcache_device *d) >> >> SET_UUID_FLASH_ONLY(u, 0); >> memcpy(u->uuid, invalid_uuid, 16); >> - u->invalidated = cpu_to_le32(get_seconds()); >> + u->invalidated = cpu_to_le32(ktime_get_seconds()); >> bch_uuid_write(d->c); >> } >> >> @@ -927,7 +927,7 @@ void bch_cached_dev_detach(struct cached_dev *dc) >> >> int bch_cached_dev_attach(struct cached_dev *dc, struct cache_set *c) >> { >> - uint32_t rtime = cpu_to_le32(get_seconds()); >> + uint32_t rtime = cpu_to_le32(ktime_get_seconds()); >> struct uuid_entry *u; >> char buf[BDEVNAME_SIZE]; >> >> @@ -959,7 +959,7 @@ int bch_cached_dev_attach(struct cached_dev *dc, struct cache_set *c) >> (BDEV_STATE(&dc->sb) == BDEV_STATE_STALE || >> BDEV_STATE(&dc->sb) == BDEV_STATE_NONE)) { >> memcpy(u->uuid, invalid_uuid, 16); >> - u->invalidated = cpu_to_le32(get_seconds()); >> + u->invalidated = cpu_to_le32(ktime_get_seconds()); >> u = NULL; >> } >> >> @@ -1261,7 +1261,7 @@ int bch_flash_dev_create(struct cache_set *c, uint64_t size) >> >> get_random_bytes(u->uuid, 16); >> memset(u->label, 0, 32); >> - u->first_reg = u->last_reg = cpu_to_le32(get_seconds()); >> + u->first_reg = u->last_reg = cpu_to_le32(ktime_get_seconds()); >> >> SET_UUID_FLASH_ONLY(u, 1); >> u->sectors = size >> 9; >> @@ -1670,7 +1670,7 @@ static void run_cache_set(struct cache_set *c) >> goto err; >> >> closure_sync(&cl); >> - c->sb.last_mount = get_seconds(); >> + c->sb.last_mount = ktime_get_seconds(); >> bcache_write_super(c); >> >> list_for_each_entry_safe(dc, t, &uncached_devices, list) >> diff --git a/drivers/md/md.c b/drivers/md/md.c >> index 807095f..8dd74bb 100644 >> --- a/drivers/md/md.c >> +++ b/drivers/md/md.c >> @@ -2333,7 +2333,7 @@ repeat: >> >> spin_lock(&mddev->lock); >> >> - mddev->utime = get_seconds(); >> + mddev->utime = ktime_get_seconds(); >> >> if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags)) >> force_change = 1; >> @@ -6347,13 +6347,13 @@ static int set_array_info(struct mddev *mddev, mdu_array_info_t *info) >> /* ensure mddev_put doesn't delete this now that there >> * is some minimal configuration. >> */ >> - mddev->ctime = get_seconds(); >> + mddev->ctime = ktime_get_seconds(); >> return 0; >> } >> mddev->major_version = MD_MAJOR_VERSION; >> mddev->minor_version = MD_MINOR_VERSION; >> mddev->patch_version = MD_PATCHLEVEL_VERSION; >> - mddev->ctime = get_seconds(); >> + mddev->ctime = ktime_get_seconds(); >> >> mddev->level = info->level; >> mddev->clevel[0] = 0; >> -- >> 2.1.4 > > Maybe I'm being a bit fussy, but these is two completely separate > patches, one for md/raid and one for bcache (which happens to live in > drivers/md). > I'll take the md.c one, someone else should process the bcache one. Sure. I'll split it up and resend. Shraddha > > NeilBrown >

10 years, 1 month

[PATCH v2] md: Replace get_seconds with ktime_get_seconds

by Shraddha Barke

32-bit systems using get_seconds will break in the year 2038, in order to avoid that replace the code with more appropriate types. This patch replaces get_seconds with ktime_get_seconds which is y2038 safe.Function ktime_get_seconds is used since it uses monotonic instead of real time and thus will not cause overflow. Signed-off-by: Shraddha Barke <shraddha.6596(a)gmail.com> --- Changes in v2- Fix sender's list drivers/md/bcache/super.c | 12 ++++++------ drivers/md/md.c | 6 +++--- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/drivers/md/bcache/super.c b/drivers/md/bcache/super.c index 679a093..f4bd17d 100644 --- a/drivers/md/bcache/super.c +++ b/drivers/md/bcache/super.c @@ -188,7 +188,7 @@ static const char *read_super(struct cache_sb *sb, struct block_device *bdev, goto err; } - sb->last_mount = get_seconds(); + sb->last_mount = ktime_get_seconds(); err = NULL; get_page(bh->b_page); @@ -696,7 +696,7 @@ static void bcache_device_detach(struct bcache_device *d) SET_UUID_FLASH_ONLY(u, 0); memcpy(u->uuid, invalid_uuid, 16); - u->invalidated = cpu_to_le32(get_seconds()); + u->invalidated = cpu_to_le32(ktime_get_seconds()); bch_uuid_write(d->c); } @@ -927,7 +927,7 @@ void bch_cached_dev_detach(struct cached_dev *dc) int bch_cached_dev_attach(struct cached_dev *dc, struct cache_set *c) { - uint32_t rtime = cpu_to_le32(get_seconds()); + uint32_t rtime = cpu_to_le32(ktime_get_seconds()); struct uuid_entry *u; char buf[BDEVNAME_SIZE]; @@ -959,7 +959,7 @@ int bch_cached_dev_attach(struct cached_dev *dc, struct cache_set *c) (BDEV_STATE(&dc->sb) == BDEV_STATE_STALE || BDEV_STATE(&dc->sb) == BDEV_STATE_NONE)) { memcpy(u->uuid, invalid_uuid, 16); - u->invalidated = cpu_to_le32(get_seconds()); + u->invalidated = cpu_to_le32(ktime_get_seconds()); u = NULL; } @@ -1261,7 +1261,7 @@ int bch_flash_dev_create(struct cache_set *c, uint64_t size) get_random_bytes(u->uuid, 16); memset(u->label, 0, 32); - u->first_reg = u->last_reg = cpu_to_le32(get_seconds()); + u->first_reg = u->last_reg = cpu_to_le32(ktime_get_seconds()); SET_UUID_FLASH_ONLY(u, 1); u->sectors = size >> 9; @@ -1670,7 +1670,7 @@ static void run_cache_set(struct cache_set *c) goto err; closure_sync(&cl); - c->sb.last_mount = get_seconds(); + c->sb.last_mount = ktime_get_seconds(); bcache_write_super(c); list_for_each_entry_safe(dc, t, &uncached_devices, list) diff --git a/drivers/md/md.c b/drivers/md/md.c index 807095f..8dd74bb 100644 --- a/drivers/md/md.c +++ b/drivers/md/md.c @@ -2333,7 +2333,7 @@ repeat: spin_lock(&mddev->lock); - mddev->utime = get_seconds(); + mddev->utime = ktime_get_seconds(); if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags)) force_change = 1; @@ -6347,13 +6347,13 @@ static int set_array_info(struct mddev *mddev, mdu_array_info_t *info) /* ensure mddev_put doesn't delete this now that there * is some minimal configuration. */ - mddev->ctime = get_seconds(); + mddev->ctime = ktime_get_seconds(); return 0; } mddev->major_version = MD_MAJOR_VERSION; mddev->minor_version = MD_MINOR_VERSION; mddev->patch_version = MD_PATCHLEVEL_VERSION; - mddev->ctime = get_seconds(); + mddev->ctime = ktime_get_seconds(); mddev->level = info->level; mddev->clevel[0] = 0; -- 2.1.4

10 years, 1 month

[PATCH] md: Replace get_seconds with ktime_get_seconds

by Kent Overstreet

From: Shraddha Barke <shraddha.6596(a)gmail.com> 32-bit systems using get_seconds function will break in y2038. This patch replaces get_seconds with ktime_get_seconds which is y2038 safe.Function ktime_get_seconds is used since it uses monotonic instead of real time and thus will not cause overflow. Signed-off-by: Shraddha Barke <shraddha.6596(a)gmail.com> --- drivers/md/bcache/super.c | 12 ++++++------ drivers/md/md.c | 6 +++--- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/drivers/md/bcache/super.c b/drivers/md/bcache/super.c index 679a093..f4bd17d 100644 --- a/drivers/md/bcache/super.c +++ b/drivers/md/bcache/super.c @@ -188,7 +188,7 @@ static const char *read_super(struct cache_sb *sb, struct block_device *bdev, goto err; } - sb->last_mount = get_seconds(); + sb->last_mount = ktime_get_seconds(); err = NULL; get_page(bh->b_page); @@ -696,7 +696,7 @@ static void bcache_device_detach(struct bcache_device *d) SET_UUID_FLASH_ONLY(u, 0); memcpy(u->uuid, invalid_uuid, 16); - u->invalidated = cpu_to_le32(get_seconds()); + u->invalidated = cpu_to_le32(ktime_get_seconds()); bch_uuid_write(d->c); } @@ -927,7 +927,7 @@ void bch_cached_dev_detach(struct cached_dev *dc) int bch_cached_dev_attach(struct cached_dev *dc, struct cache_set *c) { - uint32_t rtime = cpu_to_le32(get_seconds()); + uint32_t rtime = cpu_to_le32(ktime_get_seconds()); struct uuid_entry *u; char buf[BDEVNAME_SIZE]; @@ -959,7 +959,7 @@ int bch_cached_dev_attach(struct cached_dev *dc, struct cache_set *c) (BDEV_STATE(&dc->sb) == BDEV_STATE_STALE || BDEV_STATE(&dc->sb) == BDEV_STATE_NONE)) { memcpy(u->uuid, invalid_uuid, 16); - u->invalidated = cpu_to_le32(get_seconds()); + u->invalidated = cpu_to_le32(ktime_get_seconds()); u = NULL; } @@ -1261,7 +1261,7 @@ int bch_flash_dev_create(struct cache_set *c, uint64_t size) get_random_bytes(u->uuid, 16); memset(u->label, 0, 32); - u->first_reg = u->last_reg = cpu_to_le32(get_seconds()); + u->first_reg = u->last_reg = cpu_to_le32(ktime_get_seconds()); SET_UUID_FLASH_ONLY(u, 1); u->sectors = size >> 9; @@ -1670,7 +1670,7 @@ static void run_cache_set(struct cache_set *c) goto err; closure_sync(&cl); - c->sb.last_mount = get_seconds(); + c->sb.last_mount = ktime_get_seconds(); bcache_write_super(c); list_for_each_entry_safe(dc, t, &uncached_devices, list) diff --git a/drivers/md/md.c b/drivers/md/md.c index 807095f..8dd74bb 100644 --- a/drivers/md/md.c +++ b/drivers/md/md.c @@ -2333,7 +2333,7 @@ repeat: spin_lock(&mddev->lock); - mddev->utime = get_seconds(); + mddev->utime = ktime_get_seconds(); if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags)) force_change = 1; @@ -6347,13 +6347,13 @@ static int set_array_info(struct mddev *mddev, mdu_array_info_t *info) /* ensure mddev_put doesn't delete this now that there * is some minimal configuration. */ - mddev->ctime = get_seconds(); + mddev->ctime = ktime_get_seconds(); return 0; } mddev->major_version = MD_MAJOR_VERSION; mddev->minor_version = MD_MINOR_VERSION; mddev->patch_version = MD_PATCHLEVEL_VERSION; - mddev->ctime = get_seconds(); + mddev->ctime = ktime_get_seconds(); mddev->level = info->level; mddev->clevel[0] = 0; -- 2.1.4

10 years, 1 month

[PATCH v2 0/4] fs: Add 64 bit time support

by Deepa Dinamani

The first two patches contain the basic framework for the 64 bit time migration for filesystems. The next two patches shows how the framework has been adapted to vfs layer and cifs filesystem. There might be some minor changes or additions required as I start adapting to other filesystems. The change to timestamp conversion functions(to and from unix format to others) and range checks will be part of a separate series. Changes since v1: * move SYSTEM_TIME macros to fs.h * add 64 bit version of CURRENT_TIME macros. Deepa Dinamani (4): vfs: Add 64 bit time support kernel: time: Add macros and functions to support 64 bit time vfs: Add support for vfs code to use 64 bit time. fs: cifs: Add support for cifs to use 64 bit time fs/attr.c | 14 ++++----- fs/bad_inode.c | 9 ++++-- fs/binfmt_misc.c | 7 +++-- fs/cifs/cache.c | 16 ++++++---- fs/cifs/cifsencrypt.c | 2 +- fs/cifs/cifsglob.h | 6 ++-- fs/cifs/cifsproto.h | 7 +++-- fs/cifs/cifssmb.c | 9 ++++-- fs/cifs/file.c | 9 ++++-- fs/cifs/inode.c | 68 +++++++++++++++++++++++++--------------- fs/cifs/netmisc.c | 10 +++--- fs/inode.c | 44 ++++++++++++++++---------- fs/libfs.c | 58 +++++++++++++++++++++++++--------- fs/locks.c | 5 ++- fs/nsfs.c | 6 +++- fs/pipe.c | 6 +++- fs/posix_acl.c | 2 +- fs/stat.c | 6 ++-- fs/utimes.c | 4 +-- include/linux/fs.h | 85 +++++++++++++++++++++++++++++++++++++++++++------- include/linux/stat.h | 6 ++-- include/linux/time64.h | 39 +++++++++++++++++++++++ kernel/time/time.c | 65 +++++++++++++++++++++++++++++++++++++- 23 files changed, 366 insertions(+), 117 deletions(-) -- 1.9.1

10 years, 1 month

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

Y2038