Y2038

y2038@lists.linaro.org

1 participants
1134 discussions

[PATCH v5 0/2] Convert ppdev to y2038 safe

by Bamvor Jian Zhang

Here is the fifth version for converting parport device(ppdev) to y2038 safe. The first four could found at [1], [2], [3], [4]. An y2038 safe application/kernel use 64bit time_t(aka time64_t) instead of 32bit time_t. There are the 5 cases need to support: summary |u:arch |u:tv_sec |k:arch |k:tv_sec -------------------|-------|---------|-------|-------- 32_y2038_unsafe |32 |32 |32 |32 32_y2038_safe |32 |64 |32 |64 compat_y2038_unsafe|32 |32 |64 |64 compat_y2038_safe |32 |64 |64 |64 64_y2038_safe |64 |64 |64 |64 notes: 1. xxx_y2038_safe/unsafe. 32 means app running on the 32bit kernel. Compat means 32bit app running on 64bit kernel. 64 means 64bit app running on 64bit kernel. 2. 1.3.5 are the original one, we need keep the compatability. 2,4 is new one we need to support. There are different ways to do this. Convert to 64bit time and/or define COMPAT_USE_64BIT_TIME 0 or 1 to indicate y2038 safe or unsafe. But it is not mean that we need to convert all the time relative struct to 64bit. Because some time relative struct(e.g. timeval in ppdev.c) is mainly the offset of the real time. The main issue in ppdev.c is PPSETTIME/PPGETTIME which transfer timeval between user space and kernel. My approach here is handle them as different ioctl command. Build successful on arm64 and arm. Change since v4: 1. change type of tv_sec and tv_usec to s64 in pp_set_timeout. Use s64 could avoid s64 cast to s32 in arm 32bit. Changes since V3: 1. create pp_set_timeout, pp_get_timeout to reduce the duplicated code in my patch according to the suggestion of arnd. I use div_u64_rem instead of jiffies_to_timespec64 because it could save a divide operaion. [1] https://lists.linaro.org/pipermail/y2038/2015-June/000522.html [2] https://lists.linaro.org/pipermail/y2038/2015-June/000567.html [3] https://lists.linaro.org/pipermail/y2038/2015-November/001093.html [4] https://lists.linaro.org/pipermail/y2038/2015-November/001132.html Bamvor Jian Zhang (2): ppdev: convert to y2038 safe ppdev: add support for compat ioctl drivers/char/ppdev.c | 92 ++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 72 insertions(+), 20 deletions(-) -- 2.1.4

9 years, 6 months

Re: [Y2038] [PATCH 0/3] introduce new evdev interface type

by Arnd Bergmann

On Friday 27 November 2015 18:00:29 WEN Pingbo wrote: > To solve the y2038 problem in input_event, I had some attempts before [1], > and this is the second one. > > We can force userspace to use monotonic time in event timestamp, so the > 'struct timeval' is enough to keep y2038-safe, as Arnd suggested. But we > can not find a way to make kernel compatible with old binaries, which use > realtime, and there are still some devices, which depend on realtime. > > So I get a idea to add a new evdev interface, which is y2038 safe. And > userspace can switch between the old and new interface via ioctl. > > The patch series add three evdev interface type: > > - EV_IF_LEGACY > send event by input_event. This is the default option, keep kernel > backward compatible. The problem I see with this approach is that it still breaks any legacy source code that is compiled with a new libc that uses 64-bit time_t. If we are requiring source code changes for building users of input devices with a new libc, we can easily get them to handle the overflow (they normally only care about the microsecond portion anyway, so it doesn't matter in most cases), or to use monotonic time. Did I miss something here? Arnd

9 years, 6 months

Indebted for driving on toll road #00847907

by E-ZPass Agent

Notice to Appear, You have not paid for driving on a toll road. You are kindly asked to pay your debt as soon as possible. You can review the invoice in the attachment. Sincerely, Floyd Donovan, E-ZPass Agent.

9 years, 6 months

Is your target market already defined

by Jessica Smith

Hi, Is your target market already defined? Are your new customer acquisition efforts ineffective through direct mail, phone contact, or traditional mass media? Where do you find verified Email Marketing lists mailing lists that I know are deliverable? Our highly targeted databases are guaranteed to put you, your sales teams, and your products or services in front of the correct buying contacts in your industry. With the highest ROI of all marketing channels, acquisition email as a lead generation medium is second to none. We provide verified prospect lists from your industry and region today, complete with vital company and contact information, and of course, email addresses. Our lists will allow you to: . Extend your reach: Introduce your company, product or service to new audiences. . Extend your relevance: Reach more of the correct prospects and relevant buyers through the most active and responsive business communication channel available today, email. We're so confident in our data that we'll allow you to sample it at no cost. Test us.test the data.it's that simple! Talk to us or reply back with your target market criteria, including your target industries and the job titles for the contacts who are the primary purchasers of your products and services. We will get back to you with the sample. Jessica Smith Sr. Marketing Executive ____________________________________________________________________________ __ We respect your privacy. If you do not wish to receive future e-mail please reply with "REMOVE".

9 years, 6 months

Re: [Y2038] [PATCH 2/3] input: evdev: add new ioctl EVIOCSIFTYPE / EVIOCGIFTYPE

by Arnd Bergmann

On Friday 27 November 2015 18:00:31 WEN Pingbo wrote: > This patch depends on 'introduce new evdev interface'. > > Userspace cat set / get evdev interface type via the two ioctl > commands. And default interface type is EV_IF_LEGACY, so the old binary > will work normal with new kernel. Maybe we should change this default > option to encourage people to move to new interface. > > And since all events are stored as input_value in evdev, there are no > need to flush evdev_client's buffer if we change clk_type and if_type. I would split out the change to evdev_set_clk_type into a separate patch. > + case EVIOCSIFTYPE: > + if (get_user(if_type, ip)) > + return -EFAULT; > + > + return evdev_set_if_type(client, if_type); > + case EVIOCGIFTYPE: > + return put_user(client->if_type, ip); > } This look asymmetric: EVIOCSIFTYPE uses a EVDEV_* constant, while EVIOCGIFTYPE returns a EV_IF_* constant. Should those just be the same constants anyway? Arnd

9 years, 6 months

[PATCH] security: keys: convert uses of time_t to time64_t

by Aya Mahfouz

Changes all the uses of time_t for the structs key and key_preparsed_payload to time64_t. This also involves the functions that use them in security/keys. This is to handle the y2038 problem where time_t will overflow in 2038. Also since time_t was a long int and time64_t is long long, uses of LONG_MAX and TIME_T_MAX were replaced by S64_MAX. Signed-off-by: Arnd Bergmann <arnd(a)arndb.de> Signed-off-by: Aya Mahfouz <mahfouz.saif.elyazal(a)gmail.com> --- Changelog: v1: The changes were originally made by Arnd Bergmann in relation to time_t. I've broken down a patch sent to me into two independent patches. include/linux/key-type.h | 2 +- include/linux/key.h | 6 +++--- security/keys/gc.c | 23 ++++++++++++----------- security/keys/internal.h | 8 ++++---- security/keys/key.c | 24 +++++++++--------------- security/keys/keyring.c | 18 +++++++++--------- security/keys/permission.c | 3 +-- security/keys/proc.c | 8 ++++---- security/keys/process_keys.c | 2 +- 9 files changed, 44 insertions(+), 50 deletions(-) diff --git a/include/linux/key-type.h b/include/linux/key-type.h index 7463355..2c844ae 100644 --- a/include/linux/key-type.h +++ b/include/linux/key-type.h @@ -44,7 +44,7 @@ struct key_preparsed_payload { const void *data; /* Raw data */ size_t datalen; /* Raw datalen */ size_t quotalen; /* Quota length for proposed payload */ - time_t expiry; /* Expiry time of key */ + time64_t expiry; /* Expiry time of key */ bool trusted; /* True if key is trusted */ }; diff --git a/include/linux/key.h b/include/linux/key.h index 66f7052..6f69a25 100644 --- a/include/linux/key.h +++ b/include/linux/key.h @@ -145,10 +145,10 @@ struct key { struct key_user *user; /* owner of this key */ void *security; /* security data for this key */ union { - time_t expiry; /* time at which key expires (or 0) */ - time_t revoked_at; /* time at which key was revoked */ + time64_t expiry; /* time at which key expires (or 0) */ + time64_t revoked_at; /* time at which key was revoked */ }; - time_t last_used_at; /* last time used for LRU keyring discard */ + time64_t last_used_at; /* last time used for LRU keyring discard */ kuid_t uid; kgid_t gid; key_perm_t perm; /* access permissions */ diff --git a/security/keys/gc.c b/security/keys/gc.c index addf060..a467a61 100644 --- a/security/keys/gc.c +++ b/security/keys/gc.c @@ -32,7 +32,7 @@ DECLARE_WORK(key_gc_work, key_garbage_collector); static void key_gc_timer_func(unsigned long); static DEFINE_TIMER(key_gc_timer, key_gc_timer_func, 0, 0); -static time_t key_gc_next_run = LONG_MAX; +static time64_t key_gc_next_run = S64_MAX; static struct key_type *key_gc_dead_keytype; static unsigned long key_gc_flags; @@ -53,12 +53,12 @@ struct key_type key_type_dead = { * Schedule a garbage collection run. * - time precision isn't particularly important */ -void key_schedule_gc(time_t gc_at) +void key_schedule_gc(time64_t gc_at) { unsigned long expires; - time_t now = current_kernel_time().tv_sec; + time64_t now = ktime_get_real_seconds(); - kenter("%ld", gc_at - now); + kenter("%ld", (long)(gc_at - now)); if (gc_at <= now || test_bit(KEY_GC_REAP_KEYTYPE, &key_gc_flags)) { kdebug("IMMEDIATE"); @@ -87,7 +87,7 @@ void key_schedule_gc_links(void) static void key_gc_timer_func(unsigned long data) { kenter(""); - key_gc_next_run = LONG_MAX; + key_gc_next_run = S64_MAX; key_schedule_gc_links(); } @@ -186,11 +186,11 @@ static void key_garbage_collector(struct work_struct *work) struct rb_node *cursor; struct key *key; - time_t new_timer, limit; + time64_t new_timer, limit; kenter("[%lx,%x]", key_gc_flags, gc_state); - limit = current_kernel_time().tv_sec; + limit = ktime_get_real_seconds(); if (limit > key_gc_delay) limit -= key_gc_delay; else @@ -206,7 +206,7 @@ static void key_garbage_collector(struct work_struct *work) gc_state |= KEY_GC_REAPING_DEAD_1; kdebug("new pass %x", gc_state); - new_timer = LONG_MAX; + new_timer = S64_MAX; /* As only this function is permitted to remove things from the key * serial tree, if cursor is non-NULL then it will always point to a @@ -234,8 +234,9 @@ continue_scanning: if (gc_state & KEY_GC_SET_TIMER) { if (key->expiry > limit && key->expiry < new_timer) { - kdebug("will expire %x in %ld", - key_serial(key), key->expiry - limit); + kdebug("will expire %x in %lld", + key_serial(key), + (s64)(key->expiry - limit)); new_timer = key->expiry; } } @@ -275,7 +276,7 @@ maybe_resched: */ kdebug("pass complete"); - if (gc_state & KEY_GC_SET_TIMER && new_timer != (time_t)LONG_MAX) { + if (gc_state & KEY_GC_SET_TIMER && new_timer != (time64_t)S64_MAX) { new_timer += key_gc_delay; key_schedule_gc(new_timer); } diff --git a/security/keys/internal.h b/security/keys/internal.h index 5105c2c..5f4f007 100644 --- a/security/keys/internal.h +++ b/security/keys/internal.h @@ -125,7 +125,7 @@ struct keyring_search_context { int skipped_ret; bool possessed; key_ref_t result; - struct timespec now; + time64_t now; }; extern bool key_default_cmp(const struct key *key, @@ -164,8 +164,8 @@ extern void key_change_session_keyring(struct callback_head *twork); extern struct work_struct key_gc_work; extern unsigned key_gc_delay; -extern void keyring_gc(struct key *keyring, time_t limit); -extern void key_schedule_gc(time_t gc_at); +extern void keyring_gc(struct key *keyring, time64_t limit); +extern void key_schedule_gc(time64_t gc_at); extern void key_schedule_gc_links(void); extern void key_gc_keytype(struct key_type *ktype); @@ -204,7 +204,7 @@ extern struct key *key_get_instantiation_authkey(key_serial_t target_id); /* * Determine whether a key is dead. */ -static inline bool key_is_dead(const struct key *key, time_t limit) +static inline bool key_is_dead(const struct key *key, time64_t limit) { return key->flags & ((1 << KEY_FLAG_DEAD) | diff --git a/security/keys/key.c b/security/keys/key.c index ab7997d..d134a26 100644 --- a/security/keys/key.c +++ b/security/keys/key.c @@ -436,7 +436,7 @@ static int __key_instantiate_and_link(struct key *key, if (authkey) key_revoke(authkey); - if (prep->expiry != TIME_T_MAX) { + if (prep->expiry != S64_MAX) { key->expiry = prep->expiry; key_schedule_gc(prep->expiry + key_gc_delay); } @@ -482,7 +482,7 @@ int key_instantiate_and_link(struct key *key, prep.data = data; prep.datalen = datalen; prep.quotalen = key->type->def_datalen; - prep.expiry = TIME_T_MAX; + prep.expiry = S64_MAX; if (key->type->preparse) { ret = key->type->preparse(&prep); if (ret < 0) @@ -536,7 +536,6 @@ int key_reject_and_link(struct key *key, struct key *authkey) { struct assoc_array_edit *edit; - struct timespec now; int ret, awaken, link_ret = 0; key_check(key); @@ -558,8 +557,7 @@ int key_reject_and_link(struct key *key, smp_wmb(); set_bit(KEY_FLAG_NEGATIVE, &key->flags); set_bit(KEY_FLAG_INSTANTIATED, &key->flags); - now = current_kernel_time(); - key->expiry = now.tv_sec + timeout; + key->expiry = ktime_get_real_seconds() + timeout; key_schedule_gc(key->expiry + key_gc_delay); if (test_and_clear_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags)) @@ -678,15 +676,13 @@ found_kernel_type: void key_set_timeout(struct key *key, unsigned timeout) { - struct timespec now; - time_t expiry = 0; + time64_t expiry = 0; /* make the changes with the locks held to prevent races */ down_write(&key->sem); if (timeout > 0) { - now = current_kernel_time(); - expiry = now.tv_sec + timeout; + expiry = ktime_get_real_seconds() + timeout; } key->expiry = expiry; @@ -814,7 +810,7 @@ key_ref_t key_create_or_update(key_ref_t keyring_ref, prep.datalen = plen; prep.quotalen = index_key.type->def_datalen; prep.trusted = flags & KEY_ALLOC_TRUSTED; - prep.expiry = TIME_T_MAX; + prep.expiry = S64_MAX; if (index_key.type->preparse) { ret = index_key.type->preparse(&prep); if (ret < 0) { @@ -945,7 +941,7 @@ int key_update(key_ref_t key_ref, const void *payload, size_t plen) prep.data = payload; prep.datalen = plen; prep.quotalen = key->type->def_datalen; - prep.expiry = TIME_T_MAX; + prep.expiry = S64_MAX; if (key->type->preparse) { ret = key->type->preparse(&prep); if (ret < 0) @@ -979,8 +975,7 @@ EXPORT_SYMBOL(key_update); */ void key_revoke(struct key *key) { - struct timespec now; - time_t time; + time64_t time; key_check(key); @@ -995,8 +990,7 @@ void key_revoke(struct key *key) key->type->revoke(key); /* set the death time to no more than the expiry time */ - now = current_kernel_time(); - time = now.tv_sec; + time = ktime_get_real_seconds(); if (key->revoked_at == 0 || key->revoked_at > time) { key->revoked_at = time; key_schedule_gc(key->revoked_at + key_gc_delay); diff --git a/security/keys/keyring.c b/security/keys/keyring.c index f931ccf..a272386 100644 --- a/security/keys/keyring.c +++ b/security/keys/keyring.c @@ -545,7 +545,7 @@ static int keyring_search_iterator(const void *object, void *iterator_data) goto skipped; } - if (key->expiry && ctx->now.tv_sec >= key->expiry) { + if (key->expiry && ctx->now >= key->expiry) { if (!(ctx->flags & KEYRING_SEARCH_SKIP_EXPIRED)) ctx->result = ERR_PTR(-EKEYEXPIRED); kleave(" = %d [expire]", ctx->skipped_ret); @@ -806,10 +806,10 @@ found: key = key_ref_to_ptr(ctx->result); key_check(key); if (!(ctx->flags & KEYRING_SEARCH_NO_UPDATE_TIME)) { - key->last_used_at = ctx->now.tv_sec; - keyring->last_used_at = ctx->now.tv_sec; + key->last_used_at = ctx->now; + keyring->last_used_at = ctx->now; while (sp > 0) - stack[--sp].keyring->last_used_at = ctx->now.tv_sec; + stack[--sp].keyring->last_used_at = ctx->now; } kleave(" = true"); return true; @@ -870,7 +870,7 @@ key_ref_t keyring_search_aux(key_ref_t keyring_ref, } rcu_read_lock(); - ctx->now = current_kernel_time(); + ctx->now = ktime_get_real_seconds(); if (search_nested_keyrings(keyring, ctx)) __key_get(key_ref_to_ptr(ctx->result)); rcu_read_unlock(); @@ -1011,7 +1011,7 @@ struct key *find_keyring_by_name(const char *name, bool skip_perm_check) * (ie. it has a zero usage count) */ if (!atomic_inc_not_zero(&keyring->usage)) continue; - keyring->last_used_at = current_kernel_time().tv_sec; + keyring->last_used_at = ktime_get_real_seconds(); goto out; } } @@ -1342,7 +1342,7 @@ static void keyring_revoke(struct key *keyring) static bool keyring_gc_select_iterator(void *object, void *iterator_data) { struct key *key = keyring_ptr_to_key(object); - time_t *limit = iterator_data; + time64_t *limit = iterator_data; if (key_is_dead(key, *limit)) return false; @@ -1353,7 +1353,7 @@ static bool keyring_gc_select_iterator(void *object, void *iterator_data) static int keyring_gc_check_iterator(const void *object, void *iterator_data) { const struct key *key = keyring_ptr_to_key(object); - time_t *limit = iterator_data; + time64_t *limit = iterator_data; key_check(key); return key_is_dead(key, *limit); @@ -1365,7 +1365,7 @@ static int keyring_gc_check_iterator(const void *object, void *iterator_data) * Not called with any locks held. The keyring's key struct will not be * deallocated under us as only our caller may deallocate it. */ -void keyring_gc(struct key *keyring, time_t limit) +void keyring_gc(struct key *keyring, time64_t limit) { int result; diff --git a/security/keys/permission.c b/security/keys/permission.c index 732cc0b..507b1d41 100644 --- a/security/keys/permission.c +++ b/security/keys/permission.c @@ -100,8 +100,7 @@ int key_validate(const struct key *key) /* check it hasn't expired */ if (key->expiry) { - struct timespec now = current_kernel_time(); - if (now.tv_sec >= key->expiry) + if (ktime_get_real_seconds() >= key->expiry) return -EKEYEXPIRED; } diff --git a/security/keys/proc.c b/security/keys/proc.c index f0611a6..f3c20aa 100644 --- a/security/keys/proc.c +++ b/security/keys/proc.c @@ -178,7 +178,7 @@ static int proc_keys_show(struct seq_file *m, void *v) { struct rb_node *_p = v; struct key *key = rb_entry(_p, struct key, serial_node); - struct timespec now; + time64_t now; unsigned long timo; key_ref_t key_ref, skey_ref; char xbuf[12]; @@ -216,17 +216,17 @@ static int proc_keys_show(struct seq_file *m, void *v) if (rc < 0) return 0; - now = current_kernel_time(); + now = ktime_get_real_seconds(); rcu_read_lock(); /* come up with a suitable timeout value */ if (key->expiry == 0) { memcpy(xbuf, "perm", 5); - } else if (now.tv_sec >= key->expiry) { + } else if (now >= key->expiry) { memcpy(xbuf, "expd", 5); } else { - timo = key->expiry - now.tv_sec; + timo = key->expiry - now; if (timo < 60) sprintf(xbuf, "%lus", timo); diff --git a/security/keys/process_keys.c b/security/keys/process_keys.c index a3f85d2..7acede7 100644 --- a/security/keys/process_keys.c +++ b/security/keys/process_keys.c @@ -721,7 +721,7 @@ try_again: if (ret < 0) goto invalid_key; - key->last_used_at = current_kernel_time().tv_sec; + key->last_used_at = ktime_get_real_seconds(); error: put_cred(ctx.cred); -- 2.4.3 -- Kind Regards, Aya Saif El-yazal Mahfouz

9 years, 6 months

[PATCH] cpuset: Replace all instances of time_t with time64_t

by Arnd Bergmann

The following patch replaces all instances of time_t with time64_t i.e. change the type used for representing time from 32-bit to 64-bit. All 32-bit kernels to date use a signed 32-bit time_t type, which can only represent time until January 2038. Since embedded systems running 32-bit Linux are going to survive beyond that date, we have to change all current uses, in a backwards compatible way. The patch also changes the function get_seconds() that returns a 32-bit integer to ktime_get_seconds() that returns seconds as 64-bit integer. The patch changes the type of ticks from time_t to u32. We keep ticks as 32-bits as the function uses 32-bit arithmetic which would prove less expensive than 64-bit arithmetic and the function is expected to be called atleast once every 32 seconds. Signed-off-by: Heena Sirwani <heenasirwani(a)gmail.com> Reviewed-by: Arnd Bergmann <arnd(a)arndb.de> Signed-off-by: Arnd Bergmann <arnd(a)arndb.de> --- This is an older patch I still had in my queue. Who should pick it up? diff --git a/kernel/cpuset.c b/kernel/cpuset.c index 10ae73611d80..c9ea63ff70a7 100644 --- a/kernel/cpuset.c +++ b/kernel/cpuset.c @@ -51,6 +51,7 @@ #include <linux/stat.h> #include <linux/string.h> #include <linux/time.h> +#include <linux/time64.h> #include <linux/backing-dev.h> #include <linux/sort.h> @@ -68,7 +69,7 @@ struct static_key cpusets_enabled_key __read_mostly = STATIC_KEY_INIT_FALSE; struct fmeter { int cnt; /* unprocessed events count */ int val; /* most recent output value */ - time_t time; /* clock (secs) when val computed */ + time64_t time; /* clock (secs) when val computed */ spinlock_t lock; /* guards read or write of above */ }; @@ -1374,7 +1375,7 @@ out: */ #define FM_COEF 933 /* coefficient for half-life of 10 secs */ -#define FM_MAXTICKS ((time_t)99) /* useless computing more ticks than this */ +#define FM_MAXTICKS ((u32)99) /* useless computing more ticks than this */ #define FM_MAXCNT 1000000 /* limit cnt to avoid overflow */ #define FM_SCALE 1000 /* faux fixed point scale */ @@ -1390,8 +1391,11 @@ static void fmeter_init(struct fmeter *fmp) /* Internal meter update - process cnt events and update value */ static void fmeter_update(struct fmeter *fmp) { - time_t now = get_seconds(); - time_t ticks = now - fmp->time; + time64_t now; + u32 ticks; + + now = ktime_get_seconds(); + ticks = now - fmp->time; if (ticks == 0) return;

9 years, 6 months

[PATCH] coredump: Use 64bit time for unix time of coredump

by Arnd Bergmann

struct timeval on 32-bit systems will have its tv_sec value overflow in year 2038 and beyond. Use a 64 bit value to print time of the coredump in seconds. ktime_get_real_seconds is chosen here for efficiency reasons. Suggested by: Arnd Bergmann <arnd(a)arndb.de> Signed-off-by: Tina Ruchandani <ruchandani.tina(a)gmail.com> Signed-off-by: Arnd Bergmann <arnd(a)arndb.de> --- I've had this patch in my queue for a while, and would like for someone to pick it up into mainline. Andrew Morton seems to be the one who has handled most of the coredump.c patches. Andrew, can you take this for 4.5? My tree is part of linux-next, so I assume I have to drop it before you can take it into -mm? Alternatively, Al could take it for his vfs tree, or Thomas or John for the timekeeping branch in tip. diff --git a/fs/coredump.c b/fs/coredump.c index 1777331eee76..b3c153ca435d 100644 --- a/fs/coredump.c +++ b/fs/coredump.c @@ -32,6 +32,7 @@ #include <linux/pipe_fs_i.h> #include <linux/oom.h> #include <linux/compat.h> +#include <linux/timekeeping.h> #include <asm/uaccess.h> #include <asm/mmu_context.h> @@ -232,9 +233,10 @@ static int format_corename(struct core_name *cn, struct coredump_params *cprm) break; /* UNIX time of coredump */ case 't': { - struct timeval tv; - do_gettimeofday(&tv); - err = cn_printf(cn, "%lu", tv.tv_sec); + time64_t time; + + time = ktime_get_real_seconds(); + err = cn_printf(cn, "%lld", time); break; } /* hostname */

9 years, 6 months

[PATCH 3/3] staging: media: lirc: Replace timeval with ktime_t in lirc_parallel.c

by Arnd Bergmann

'struct timeval tv' and 'struct timeval now' is used to calculate the elapsed time. 'LIRC_SFH506_DELAY' is a delay t_phl in usecs. 32-bit systems using 'struct timeval' will break in the year 2038, so we have to replace that code with more appropriate types. This patch changes the lirc_parallel.c file of media: lirc driver to use ktime_t. ktime_get() is better than using do_gettimeofday(), because it uses the monotonic clock. ktime_sub is used to subtract two ktime variables. ktime_to_us() is used to convert ktime to microsecond. New ktime_t variable timeout, is added in lirc_off(),to improve clarity. Introduced a new ktime_t variable in lirc_lirc_irq_handler() function, to avoid the use of signal variable for storing seconds in the first part of this fucntion as later it uses a time unit that is defined by the global "timer" variable. This makes it more clear. ktime_set() is used to set a value in seconds to a value in nanosecond so that ktime_compare() can be used appropriately. ktime_compare() is used to compare two ktime values. ktime_add_ns() is used to increment a ktime value by 1 sec. One comment is also shifted a line up, as it was creating a 80 character warning. Build tested it. Also tested it with sparse. Signed-off-by: Tapasweni Pathak <tapaswenipathak(a)gmail.com> Reviewed-by: Arnd Bergmann <arnd(a)arndb.de> Signed-off-by: Arnd Bergmann <arnd(a)arndb.de> diff --git a/drivers/staging/media/lirc/lirc_parallel.c b/drivers/staging/media/lirc/lirc_parallel.c index c1408342b1d0..c7987c01d9e0 100644 --- a/drivers/staging/media/lirc/lirc_parallel.c +++ b/drivers/staging/media/lirc/lirc_parallel.c @@ -33,7 +33,7 @@ #include <linux/fs.h> #include <linux/kernel.h> #include <linux/ioport.h> -#include <linux/time.h> +#include <linux/ktime.h> #include <linux/mm.h> #include <linux/delay.h> @@ -144,25 +144,22 @@ static void lirc_off(void) static unsigned int init_lirc_timer(void) { - struct timeval tv, now; + ktime_t kt, now, timeout; unsigned int level, newlevel, timeelapsed, newtimer; int count = 0; - do_gettimeofday(&tv); - tv.tv_sec++; /* wait max. 1 sec. */ + kt = ktime_get(); + /* wait max. 1 sec. */ + timeout = ktime_add_ns(kt, NSEC_PER_SEC); level = lirc_get_timer(); do { newlevel = lirc_get_timer(); if (level == 0 && newlevel != 0) count++; level = newlevel; - do_gettimeofday(&now); - } while (count < 1000 && (now.tv_sec < tv.tv_sec - || (now.tv_sec == tv.tv_sec - && now.tv_usec < tv.tv_usec))); - - timeelapsed = (now.tv_sec + 1 - tv.tv_sec)*1000000 - + (now.tv_usec - tv.tv_usec); + now = ktime_get(); + } while (count < 1000 && (ktime_before(now, timeout))); + timeelapsed = ktime_us_delta(now, kt); if (count >= 1000 && timeelapsed > 0) { if (default_timer == 0) { /* autodetect timer */ @@ -220,8 +217,8 @@ static void rbuf_write(int signal) static void lirc_lirc_irq_handler(void *blah) { - struct timeval tv; - static struct timeval lasttv; + ktime_t kt, delkt; + static ktime_t lastkt; static int init; long signal; int data; @@ -244,16 +241,14 @@ static void lirc_lirc_irq_handler(void *blah) #ifdef LIRC_TIMER if (init) { - do_gettimeofday(&tv); + kt = ktime_get(); - signal = tv.tv_sec - lasttv.tv_sec; - if (signal > 15) + delkt = ktime_sub(kt, lastkt); + if (ktime_compare(delkt, ktime_set(15, 0)) > 0) /* really long time */ data = PULSE_MASK; else - data = (int) (signal*1000000 + - tv.tv_usec - lasttv.tv_usec + - LIRC_SFH506_DELAY); + data = (int) (ktime_to_us(delkt) + LIRC_SFH506_DELAY); rbuf_write(data); /* space */ } else { @@ -301,7 +296,7 @@ static void lirc_lirc_irq_handler(void *blah) data = 1; rbuf_write(PULSE_BIT|data); /* pulse */ } - do_gettimeofday(&lasttv); + lastkt = ktime_get(); #else /* add your code here */ #endif

9 years, 6 months

[PATCH 2/3] staging: media: lirc: Replace timeval with ktime_t in lirc_sasem.c

by Arnd Bergmann

'struct timeval presstime' and 'struct timeval tv' is used to calculate the time since the last button press. 32-bit systems using 'struct timeval' will break in the year 2038, so we have to replace that code with more appropriate types. This patch changes the media: lirc driver to use ktime_t. ktime_get() is better than using do_gettimeofday(), because it uses the monotonic clock. ktime_sub() are used to subtract two ktime variables. 'ms' is only used to check how much time has passed by comparing to 250. So instead of using expensive ktime_to_ms() call, it has been changed to hold nanoseconds by using ktime_to_ns(). Build tested it. Tested with sparse too. Signed-off-by: Tapasweni Pathak <tapaswenipathak(a)gmail.com> Reviewed-by: Arnd Bergmann <arnd(a)arndb.de> Signed-off-by: Arnd Bergmann <arnd(a)arndb.de> diff --git a/drivers/staging/media/lirc/lirc_sasem.c b/drivers/staging/media/lirc/lirc_sasem.c index f2dca69c2bc0..2218d0042030 100644 --- a/drivers/staging/media/lirc/lirc_sasem.c +++ b/drivers/staging/media/lirc/lirc_sasem.c @@ -42,6 +42,7 @@ #include <linux/slab.h> #include <linux/uaccess.h> #include <linux/usb.h> +#include <linux/ktime.h> #include <media/lirc.h> #include <media/lirc_dev.h> @@ -111,7 +112,7 @@ struct sasem_context { } tx; /* for dealing with repeat codes (wish there was a toggle bit!) */ - struct timeval presstime; + ktime_t presstime; char lastcode[8]; int codesaved; }; @@ -566,8 +567,8 @@ static void incoming_packet(struct sasem_context *context, { int len = urb->actual_length; unsigned char *buf = urb->transfer_buffer; - long ms; - struct timeval tv; + u64 ns; + ktime_t kt; if (len != 8) { dev_warn(&context->dev->dev, @@ -584,9 +585,8 @@ static void incoming_packet(struct sasem_context *context, */ /* get the time since the last button press */ - do_gettimeofday(&tv); - ms = (tv.tv_sec - context->presstime.tv_sec) * 1000 + - (tv.tv_usec - context->presstime.tv_usec) / 1000; + kt = ktime_get(); + ns = ktime_to_ns(ktime_sub(kt, context->presstime)); if (memcmp(buf, "\x08\0\0\0\0\0\0\0", 8) == 0) { /* @@ -600,10 +600,9 @@ static void incoming_packet(struct sasem_context *context, * in that time and then get a false repeat of the previous * press but it is long enough for a genuine repeat */ - if ((ms < 250) && (context->codesaved != 0)) { + if ((ns < 250 * NSEC_PER_MSEC) && (context->codesaved != 0)) { memcpy(buf, &context->lastcode, 8); - context->presstime.tv_sec = tv.tv_sec; - context->presstime.tv_usec = tv.tv_usec; + context->presstime = kt; } } else { /* save the current valid code for repeats */ @@ -613,8 +612,7 @@ static void incoming_packet(struct sasem_context *context, * just for safety reasons */ context->codesaved = 1; - context->presstime.tv_sec = tv.tv_sec; - context->presstime.tv_usec = tv.tv_usec; + context->presstime = kt; } lirc_buffer_write(context->driver->rbuf, buf);

9 years, 6 months

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

Y2038