Y2038

y2038@lists.linaro.org

1 participants
1149 discussions

[RFC 0/6] vfs: Add timestamp range check support

by Deepa Dinamani

The original thread is at https://lkml.org/lkml/2016/11/2/294 The branch is available at https://github.com/deepa-hub/vfs.git refs/heads/vfs_timestamp_policy Changes since v1: * return EROFS on mount errors * fix mtime copy/paste error in utimes Deepa Dinamani (6): vfs: Add file timestamp range support vfs: Add checks for filesystem timestamp limits afs: Add time limits in the super block ext4: Initialize timestamps limits vfs: Add timestamp_truncate() api utimes: Clamp the timestamps before update fs/afs/super.c | 2 ++ fs/ext4/ext4.h | 4 ++++ fs/ext4/super.c | 7 ++++++- fs/inode.c | 37 ++++++++++++++++++++++++++++++++++++- fs/internal.h | 2 ++ fs/libfs.c | 4 ++++ fs/namespace.c | 12 ++++++++++++ fs/super.c | 9 +++++++++ fs/utimes.c | 17 +++++++++++++---- include/linux/fs.h | 4 ++++ include/linux/time64.h | 6 ++++++ include/uapi/linux/fs.h | 6 +++++- kernel/sysctl.c | 7 +++++++ 13 files changed, 110 insertions(+), 7 deletions(-) -- 2.7.4

9 years, 3 months

[RESEND PATCH] fs: ext4: Use current_time() for inode timestamps

by Deepa Dinamani

CURRENT_TIME_SEC and CURRENT_TIME are not y2038 safe. current_time() will be transitioned to be y2038 safe along with vfs. current_time() returns timestamps according to the granularities set in the super_block. The granularity check in ext4_current_time() to call current_time() or CURRENT_TIME_SEC is not required. Use current_time() directly to obtain timestamps unconditionally, and remove ext4_current_time(). Quota files are assumed to be on the same filesystem. Hence, use current_time() for these files as well. Signed-off-by: Deepa Dinamani <deepa.kernel(a)gmail.com> Reviewed-by: Arnd Bergmann <arnd(a)arndb.de> --- fs/ext4/acl.c | 2 +- fs/ext4/ext4.h | 6 ------ fs/ext4/extents.c | 10 +++++----- fs/ext4/ialloc.c | 2 +- fs/ext4/inline.c | 4 ++-- fs/ext4/inode.c | 6 +++--- fs/ext4/ioctl.c | 8 ++++---- fs/ext4/namei.c | 24 +++++++++++++----------- fs/ext4/super.c | 2 +- fs/ext4/xattr.c | 2 +- 10 files changed, 31 insertions(+), 35 deletions(-) diff --git a/fs/ext4/acl.c b/fs/ext4/acl.c index dfa5199..fd38993 100644 --- a/fs/ext4/acl.c +++ b/fs/ext4/acl.c @@ -196,7 +196,7 @@ __ext4_set_acl(handle_t *handle, struct inode *inode, int type, error = posix_acl_update_mode(inode, &inode->i_mode, &acl); if (error) return error; - inode->i_ctime = ext4_current_time(inode); + inode->i_ctime = current_time(inode); ext4_mark_inode_dirty(handle, inode); } break; diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h index 282a51b..6789379 100644 --- a/fs/ext4/ext4.h +++ b/fs/ext4/ext4.h @@ -1532,12 +1532,6 @@ static inline struct ext4_inode_info *EXT4_I(struct inode *inode) return container_of(inode, struct ext4_inode_info, vfs_inode); } -static inline struct timespec ext4_current_time(struct inode *inode) -{ - return (inode->i_sb->s_time_gran < NSEC_PER_SEC) ? - current_fs_time(inode->i_sb) : CURRENT_TIME_SEC; -} - static inline int ext4_valid_inum(struct super_block *sb, unsigned long ino) { return ino == EXT4_ROOT_INO || diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c index c930a01..786be87 100644 --- a/fs/ext4/extents.c +++ b/fs/ext4/extents.c @@ -4725,7 +4725,7 @@ static int ext4_alloc_file_blocks(struct file *file, ext4_lblk_t offset, map.m_lblk += ret; map.m_len = len = len - ret; epos = (loff_t)map.m_lblk << inode->i_blkbits; - inode->i_ctime = ext4_current_time(inode); + inode->i_ctime = current_time(inode); if (new_size) { if (epos > new_size) epos = new_size; @@ -4853,7 +4853,7 @@ static long ext4_zero_range(struct file *file, loff_t offset, } /* Now release the pages and zero block aligned part of pages */ truncate_pagecache_range(inode, start, end - 1); - inode->i_mtime = inode->i_ctime = ext4_current_time(inode); + inode->i_mtime = inode->i_ctime = current_time(inode); ret = ext4_alloc_file_blocks(file, lblk, max_blocks, new_size, flags, mode); @@ -4878,7 +4878,7 @@ static long ext4_zero_range(struct file *file, loff_t offset, goto out_dio; } - inode->i_mtime = inode->i_ctime = ext4_current_time(inode); + inode->i_mtime = inode->i_ctime = current_time(inode); if (new_size) { ext4_update_inode_size(inode, new_size); } else { @@ -5568,7 +5568,7 @@ int ext4_collapse_range(struct inode *inode, loff_t offset, loff_t len) up_write(&EXT4_I(inode)->i_data_sem); if (IS_SYNC(inode)) ext4_handle_sync(handle); - inode->i_mtime = inode->i_ctime = ext4_current_time(inode); + inode->i_mtime = inode->i_ctime = current_time(inode); ext4_mark_inode_dirty(handle, inode); out_stop: @@ -5678,7 +5678,7 @@ int ext4_insert_range(struct inode *inode, loff_t offset, loff_t len) /* Expand file to avoid data loss if there is error while shifting */ inode->i_size += len; EXT4_I(inode)->i_disksize += len; - inode->i_mtime = inode->i_ctime = ext4_current_time(inode); + inode->i_mtime = inode->i_ctime = current_time(inode); ret = ext4_mark_inode_dirty(handle, inode); if (ret) goto out_stop; diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c index 170421e..088afe0 100644 --- a/fs/ext4/ialloc.c +++ b/fs/ext4/ialloc.c @@ -1039,7 +1039,7 @@ struct inode *__ext4_new_inode(handle_t *handle, struct inode *dir, /* This is the optimal IO size (for stat), not the fs block size */ inode->i_blocks = 0; inode->i_mtime = inode->i_atime = inode->i_ctime = ei->i_crtime = - ext4_current_time(inode); + current_time(inode); memset(ei->i_data, 0, sizeof(ei->i_data)); ei->i_dir_start_lookup = 0; diff --git a/fs/ext4/inline.c b/fs/ext4/inline.c index f74d5ee..cfa87bd 100644 --- a/fs/ext4/inline.c +++ b/fs/ext4/inline.c @@ -1028,7 +1028,7 @@ static int ext4_add_dirent_to_inline(handle_t *handle, * happen is that the times are slightly out of date * and/or different from the directory change time. */ - dir->i_mtime = dir->i_ctime = ext4_current_time(dir); + dir->i_mtime = dir->i_ctime = current_time(dir); ext4_update_dx_flag(dir); dir->i_version++; ext4_mark_inode_dirty(handle, dir); @@ -1971,7 +1971,7 @@ void ext4_inline_data_truncate(struct inode *inode, int *has_inline) if (inode->i_nlink) ext4_orphan_del(handle, inode); - inode->i_mtime = inode->i_ctime = ext4_current_time(inode); + inode->i_mtime = inode->i_ctime = current_time(inode); ext4_mark_inode_dirty(handle, inode); if (IS_SYNC(inode)) ext4_handle_sync(handle); diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c index 3d58b2b..926ed1f 100644 --- a/fs/ext4/inode.c +++ b/fs/ext4/inode.c @@ -4029,7 +4029,7 @@ int ext4_punch_hole(struct inode *inode, loff_t offset, loff_t length) if (IS_SYNC(inode)) ext4_handle_sync(handle); - inode->i_mtime = inode->i_ctime = ext4_current_time(inode); + inode->i_mtime = inode->i_ctime = current_time(inode); ext4_mark_inode_dirty(handle, inode); out_stop: ext4_journal_stop(handle); @@ -4183,7 +4183,7 @@ void ext4_truncate(struct inode *inode) if (inode->i_nlink) ext4_orphan_del(handle, inode); - inode->i_mtime = inode->i_ctime = ext4_current_time(inode); + inode->i_mtime = inode->i_ctime = current_time(inode); ext4_mark_inode_dirty(handle, inode); ext4_journal_stop(handle); @@ -5157,7 +5157,7 @@ int ext4_setattr(struct dentry *dentry, struct iattr *attr) * update c/mtime in shrink case below */ if (!shrink) { - inode->i_mtime = ext4_current_time(inode); + inode->i_mtime = current_time(inode); inode->i_ctime = inode->i_mtime; } down_write(&EXT4_I(inode)->i_data_sem); diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c index bf5ae8e..3bba9e9 100644 --- a/fs/ext4/ioctl.c +++ b/fs/ext4/ioctl.c @@ -153,7 +153,7 @@ static long swap_inode_boot_loader(struct super_block *sb, swap_inode_data(inode, inode_bl); - inode->i_ctime = inode_bl->i_ctime = ext4_current_time(inode); + inode->i_ctime = inode_bl->i_ctime = current_time(inode); spin_lock(&sbi->s_next_gen_lock); inode->i_generation = sbi->s_next_generation++; @@ -272,7 +272,7 @@ static int ext4_ioctl_setflags(struct inode *inode, } ext4_set_inode_flags(inode); - inode->i_ctime = ext4_current_time(inode); + inode->i_ctime = current_time(inode); err = ext4_mark_iloc_dirty(handle, inode, &iloc); flags_err: @@ -368,7 +368,7 @@ static int ext4_ioctl_setproject(struct file *filp, __u32 projid) } EXT4_I(inode)->i_projid = kprojid; - inode->i_ctime = ext4_current_time(inode); + inode->i_ctime = current_time(inode); out_dirty: rc = ext4_mark_iloc_dirty(handle, inode, &iloc); if (!err) @@ -500,7 +500,7 @@ long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) } err = ext4_reserve_inode_write(handle, inode, &iloc); if (err == 0) { - inode->i_ctime = ext4_current_time(inode); + inode->i_ctime = current_time(inode); inode->i_generation = generation; err = ext4_mark_iloc_dirty(handle, inode, &iloc); } diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c index 104f8bf..eadba91 100644 --- a/fs/ext4/namei.c +++ b/fs/ext4/namei.c @@ -1941,7 +1941,7 @@ static int add_dirent_to_buf(handle_t *handle, struct ext4_filename *fname, * happen is that the times are slightly out of date * and/or different from the directory change time. */ - dir->i_mtime = dir->i_ctime = ext4_current_time(dir); + dir->i_mtime = dir->i_ctime = current_time(dir); ext4_update_dx_flag(dir); dir->i_version++; ext4_mark_inode_dirty(handle, dir); @@ -2987,7 +2987,7 @@ static int ext4_rmdir(struct inode *dir, struct dentry *dentry) * recovery. */ inode->i_size = 0; ext4_orphan_add(handle, inode); - inode->i_ctime = dir->i_ctime = dir->i_mtime = ext4_current_time(inode); + inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode); ext4_mark_inode_dirty(handle, inode); ext4_dec_count(handle, dir); ext4_update_dx_flag(dir); @@ -3050,13 +3050,13 @@ static int ext4_unlink(struct inode *dir, struct dentry *dentry) retval = ext4_delete_entry(handle, dir, de, bh); if (retval) goto end_unlink; - dir->i_ctime = dir->i_mtime = ext4_current_time(dir); + dir->i_ctime = dir->i_mtime = current_time(dir); ext4_update_dx_flag(dir); ext4_mark_inode_dirty(handle, dir); drop_nlink(inode); if (!inode->i_nlink) ext4_orphan_add(handle, inode); - inode->i_ctime = ext4_current_time(inode); + inode->i_ctime = current_time(inode); ext4_mark_inode_dirty(handle, inode); end_unlink: @@ -3254,7 +3254,7 @@ static int ext4_link(struct dentry *old_dentry, if (IS_DIRSYNC(dir)) ext4_handle_sync(handle); - inode->i_ctime = ext4_current_time(inode); + inode->i_ctime = current_time(inode); ext4_inc_count(handle, inode); ihold(inode); @@ -3381,7 +3381,7 @@ static int ext4_setent(handle_t *handle, struct ext4_renament *ent, ent->de->file_type = file_type; ent->dir->i_version++; ent->dir->i_ctime = ent->dir->i_mtime = - ext4_current_time(ent->dir); + current_time(ent->dir); ext4_mark_inode_dirty(handle, ent->dir); BUFFER_TRACE(ent->bh, "call ext4_handle_dirty_metadata"); if (!ent->inlined) { @@ -3651,7 +3651,7 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry, * Like most other Unix systems, set the ctime for inodes on a * rename. */ - old.inode->i_ctime = ext4_current_time(old.inode); + old.inode->i_ctime = current_time(old.inode); ext4_mark_inode_dirty(handle, old.inode); if (!whiteout) { @@ -3663,9 +3663,9 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry, if (new.inode) { ext4_dec_count(handle, new.inode); - new.inode->i_ctime = ext4_current_time(new.inode); + new.inode->i_ctime = current_time(new.inode); } - old.dir->i_ctime = old.dir->i_mtime = ext4_current_time(old.dir); + old.dir->i_ctime = old.dir->i_mtime = current_time(old.dir); ext4_update_dx_flag(old.dir); if (old.dir_bh) { retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino); @@ -3723,6 +3723,7 @@ static int ext4_cross_rename(struct inode *old_dir, struct dentry *old_dentry, }; u8 new_file_type; int retval; + struct timespec ctime; if ((ext4_encrypted_inode(old_dir) || ext4_encrypted_inode(new_dir)) && @@ -3823,8 +3824,9 @@ static int ext4_cross_rename(struct inode *old_dir, struct dentry *old_dentry, * Like most other Unix systems, set the ctime for inodes on a * rename. */ - old.inode->i_ctime = ext4_current_time(old.inode); - new.inode->i_ctime = ext4_current_time(new.inode); + ctime = current_time(old.inode); + old.inode->i_ctime = ctime; + new.inode->i_ctime = ctime; ext4_mark_inode_dirty(handle, old.inode); ext4_mark_inode_dirty(handle, new.inode); diff --git a/fs/ext4/super.c b/fs/ext4/super.c index 45589c8..f86d0cb 100644 --- a/fs/ext4/super.c +++ b/fs/ext4/super.c @@ -5351,7 +5351,7 @@ static int ext4_quota_off(struct super_block *sb, int type) handle = ext4_journal_start(inode, EXT4_HT_QUOTA, 1); if (IS_ERR(handle)) goto out; - inode->i_mtime = inode->i_ctime = CURRENT_TIME; + inode->i_mtime = inode->i_ctime = current_time(inode); ext4_mark_inode_dirty(handle, inode); ext4_journal_stop(handle); diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c index d77be9e..9c1bb5c 100644 --- a/fs/ext4/xattr.c +++ b/fs/ext4/xattr.c @@ -1249,7 +1249,7 @@ ext4_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index, } if (!error) { ext4_xattr_update_super_block(handle, inode->i_sb); - inode->i_ctime = ext4_current_time(inode); + inode->i_ctime = current_time(inode); if (!value) ext4_clear_inode_state(inode, EXT4_STATE_NO_EXPAND); error = ext4_mark_iloc_dirty(handle, inode, &is.iloc); -- 2.7.4

9 years, 3 months

[RESEND PATCH] fs: jfs: Replace CURRENT_TIME_SEC by current_time()

by Deepa Dinamani

jfs uses nanosecond granularity for filesystem timestamps. Only this assignment is not using nanosecond granularity. Use current_time() to get the right granularity. Signed-off-by: Deepa Dinamani <deepa.kernel(a)gmail.com> Acked-by: Dave Kleikamp <dave.kleikamp(a)oracle.com> Reviewed-by: Arnd Bergmann <arnd(a)arndb.de> --- fs/jfs/ioctl.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/fs/jfs/ioctl.c b/fs/jfs/ioctl.c index 8653cac..b6fd1ff 100644 --- a/fs/jfs/ioctl.c +++ b/fs/jfs/ioctl.c @@ -121,7 +121,7 @@ long jfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) jfs_set_inode_flags(inode); inode_unlock(inode); - inode->i_ctime = CURRENT_TIME_SEC; + inode->i_ctime = current_time(inode); mark_inode_dirty(inode); setflags_out: mnt_drop_write_file(filp); -- 2.7.4

9 years, 3 months

[RESEND PATCH] fs: ufs: Use ktime_get_real_ts64() for birthtime

by Deepa Dinamani

CURRENT_TIME is not y2038 safe. Replace it with ktime_get_real_ts64(). Inode time formats are already 64 bit long and accommodates time64_t. Signed-off-by: Deepa Dinamani <deepa.kernel(a)gmail.com> --- fs/ufs/ialloc.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/fs/ufs/ialloc.c b/fs/ufs/ialloc.c index 9774555..d1dd8cc 100644 --- a/fs/ufs/ialloc.c +++ b/fs/ufs/ialloc.c @@ -176,6 +176,7 @@ struct inode *ufs_new_inode(struct inode *dir, umode_t mode) struct ufs_cg_private_info * ucpi; struct ufs_cylinder_group * ucg; struct inode * inode; + struct timespec64 ts; unsigned cg, bit, i, j, start; struct ufs_inode_info *ufsi; int err = -ENOSPC; @@ -323,8 +324,9 @@ struct inode *ufs_new_inode(struct inode *dir, umode_t mode) lock_buffer(bh); ufs2_inode = (struct ufs2_inode *)bh->b_data; ufs2_inode += ufs_inotofsbo(inode->i_ino); - ufs2_inode->ui_birthtime = cpu_to_fs64(sb, CURRENT_TIME.tv_sec); - ufs2_inode->ui_birthnsec = cpu_to_fs32(sb, CURRENT_TIME.tv_nsec); + ktime_get_real_ts64(&ts); + ufs2_inode->ui_birthtime = cpu_to_fs64(sb, ts.tv_sec); + ufs2_inode->ui_birthnsec = cpu_to_fs32(sb, ts.tv_nsec); mark_buffer_dirty(bh); unlock_buffer(bh); if (sb->s_flags & MS_SYNCHRONOUS) -- 2.7.4

9 years, 3 months

Re: [Y2038] [RFC 0/6] vfs: Add timestamp range check support

by Deepa Dinamani

I will post xfs tests that validate mount and range checking. I will keep the policy same as what the RFC suggests for now. Clamping can be verified once vfs is transitioned to using time64_t. Thanks, Deepa

9 years, 4 months

[RFC 0/6] vfs: Add timestamp range check support

by Deepa Dinamani

The series is aimed at adding timestamp checking and policy related to it to vfs. The series was developed with discussions and guidance from Arnd Bergmann. The original idea for the series was the discussion: https://lkml.org/lkml/2014/5/30/551 Patches 5 and 6 can be merged only after vfs is transitioned to use 64 bit timestamps as noted in the respective commit texts. The series only includes adding range limits to filesystems: ext4 and afs as examples to keep the series simple. Every filesystem will be updated to add these limits. There is an ext4 current_time() api replacement patch that the series depends on: https://lkml.org/lkml/2016/6/9/38 . This needs reposting to the mailing list. The branch for the tree along with dependency can be found at https://github.com/deepa-hub/vfs.git refs/heads/vfs_timestamp_policy Deepa Dinamani (6): vfs: Add file timestamp range support vfs: Add checks for filesystem timestamp limits afs: Add time limits in the super block ext4: Initialize timestamps limits vfs: Add timestamp_truncate() api utimes: Clamp the timestamps before update fs/afs/super.c | 2 ++ fs/ext4/ext4.h | 4 ++++ fs/ext4/super.c | 7 ++++++- fs/inode.c | 37 ++++++++++++++++++++++++++++++++++++- fs/internal.h | 2 ++ fs/libfs.c | 4 ++++ fs/namespace.c | 12 ++++++++++++ fs/super.c | 8 ++++++++ fs/utimes.c | 17 +++++++++++++---- include/linux/fs.h | 4 ++++ include/linux/time64.h | 6 ++++++ include/uapi/linux/fs.h | 6 +++++- kernel/sysctl.c | 7 +++++++ 13 files changed, 109 insertions(+), 7 deletions(-) -- 2.7.4 Cc: linux-afs(a)lists.infradead.org Cc: "Theodore Ts'o" <tytso(a)mit.edu> Cc: Andreas Dilger <adilger.kernel(a)dilger.ca> Cc: linux-ext4(a)vger.kernel.org

9 years, 4 months

[PATCH v2 0/4] Make input drivers y2038 safe

by Deepa Dinamani

Reposting the series as I did not hear comments from the maintainers. The series is aimed at making input events y2038 safe. It extends the lifetime of the realtime timestamps in the events to year 2106. The plan is to deprecate realtime timestamps anyway as they are not appropriate for these timestamps as noted in the patch a80b83b7b8 by John Stultz. The series is a result of many discussions with Arnd Bergmann. The design updates the format of the input events read/ written to the device nodes. This structure and the uapi/input.h header file are copied across many userspace libraries. These libraries not only use this struct input_event locally, but also expose interfaces that contain input_event. To maintain backward compatibility with all these interfaces, kernel updates the format of the input events at the dev node to struct raw_input_event. Kernel also maintains the old struct input_event and provides apis to convert between the old and new input event types. The userspace library changes to libevdev, libuinput and mtdev will be posted to the respective mailing groups for review. Once there is a consensus on the design, all the changes dependent on the kernel change will be merged at the same time. Changes from v1: * Updated changes according to review comments. * Posted userspace library changes that go along with the series. Deepa Dinamani (4): uinput: Add ioctl for using monotonic/ boot times input: evdev: Replace timeval with timespec64 input: Deprecate real timestamps beyond year 2106 input: serio: Replace timeval by timespec64 drivers/input/evdev.c | 57 ++++++++++++++++++++---------------- drivers/input/input-compat.c | 29 ++++++++++--------- drivers/input/input-compat.h | 19 +++++++----- drivers/input/misc/uinput.c | 62 +++++++++++++++++++++++++++++++++++++--- drivers/input/serio/hil_mlc.c | 37 ++++++++++++------------ drivers/input/serio/hp_sdc.c | 17 +++++------ drivers/input/serio/hp_sdc_mlc.c | 10 +++---- include/linux/hil_mlc.h | 6 ++-- include/linux/hp_sdc.h | 6 ++-- include/linux/uinput.h | 3 +- include/uapi/linux/input.h | 47 ++++++++++++++++++++++++++++++ include/uapi/linux/uinput.h | 3 ++ 12 files changed, 208 insertions(+), 88 deletions(-) -- 2.7.4

9 years, 4 months

[PATCH] Update libinput to support evdev driver v1.2

by Deepa Dinamani

Update input event structures read from the kernel to match the 1.2 version of the driver. There are no changes to the exposed interfaces of libinput. Note that the patch goes along with the changes to libevdev and mtdev to support the updated kernel driver. The associated kernel driver change is proposed at https://lkml.org/lkml/2016/10/17/1146 . Signed-off-by: Deepa Dinamani <deepa.kernel(a)gmail.com> --- include/linux/input.h | 49 +++++++++++++++++++++++++++++++++++++++++++++++-- src/evdev.c | 4 ++-- 2 files changed, 49 insertions(+), 4 deletions(-) diff --git a/include/linux/input.h b/include/linux/input.h index 4bf3d6d..202798a 100644 --- a/include/linux/input.h +++ b/include/linux/input.h @@ -13,10 +13,29 @@ #include <sys/types.h> #include <linux/types.h> -/* - * The event structure itself +/* The time structure for y2038 safe raw_input_event. + * The fields use unsigned types to extend times until + * year 2106 rather than 2038. */ +struct input_timeval { + __kernel_ulong_t tv_sec; + __kernel_ulong_t tv_usec; +}; + +struct raw_input_event { + struct input_timeval time; + __u16 type; + __u16 code; + __s32 value; +}; + +#ifndef __KERNEL__ +/* Userspace structure. + * Definition maintained here for userspace that is not yet updated to use + * struct raw_input_event. + * Not to be used anywhere within the kernel. + */ struct input_event { struct timeval time; __u16 type; @@ -24,11 +43,37 @@ struct input_event { __s32 value; }; + +static inline void +raw_input_to_input_event(const struct raw_input_event *raw, struct input_event *ev) +{ + ev->time.tv_sec = raw->time.tv_sec; + ev->time.tv_usec = raw->time.tv_usec; + ev->type = raw->type; + ev->code = raw->code; + ev->value = raw->value; +} + +static inline void +input_to_raw_event(const struct input_event *ev, struct raw_input_event *raw) +{ + raw->time.tv_sec = ev->time.tv_sec; + raw->time.tv_usec = ev->time.tv_usec; + raw->type = ev->type; + raw->code = ev->code; + raw->value = ev->value; +} + +#endif + + /* * Protocol version. */ #define EV_VERSION 0x010001 +#define EV_VERSION_1_2 0x010002 + /* * IOCTLs (0x00 - 0x7f) diff --git a/src/evdev.c b/src/evdev.c index f7f7230..5d47119 100644 --- a/src/evdev.c +++ b/src/evdev.c @@ -256,7 +256,7 @@ evdev_device_led_update(struct evdev_device *device, enum libinput_led leds) { LIBINPUT_LED_CAPS_LOCK, LED_CAPSL }, { LIBINPUT_LED_SCROLL_LOCK, LED_SCROLLL }, }; - struct input_event ev[ARRAY_LENGTH(map) + 1]; + struct raw_input_event ev[ARRAY_LENGTH(map) + 1]; unsigned int i; if (!(device->seat_caps & EVDEV_DEVICE_KEYBOARD)) @@ -2665,7 +2665,7 @@ evdev_set_device_group(struct evdev_device *device, static inline void evdev_drain_fd(int fd) { - struct input_event ev[24]; + struct raw_input_event ev[24]; size_t sz = sizeof ev; while (read(fd, &ev, sz) == (int)sz) { -- 2.7.4

9 years, 4 months

[PATCH] Update mtdev to support evdev driver v1.2

by Deepa Dinamani

Update input event structures read from the kernel to match the 1.2 version of the driver. There are no changes to the exposed interfaces of the mtdev. The associated kernel driver change is proposed at https://lkml.org/lkml/2016/10/17/1146 . Signed-off-by: Deepa Dinamani <deepa.kernel(a)gmail.com> --- src/evbuf.h | 10 ++++++---- src/iobuf.c | 8 ++++---- src/iobuf.h | 4 +++- 3 files changed, 13 insertions(+), 9 deletions(-) diff --git a/src/evbuf.h b/src/evbuf.h index 17ea4e7..9ec2da6 100644 --- a/src/evbuf.h +++ b/src/evbuf.h @@ -34,7 +34,7 @@ struct mtdev_evbuf { int head; int tail; - struct input_event buffer[DIM_EVENTS]; + struct raw_input_event buffer[DIM_EVENTS]; }; static inline int evbuf_empty(const struct mtdev_evbuf *evbuf) @@ -43,16 +43,18 @@ static inline int evbuf_empty(const struct mtdev_evbuf *evbuf) } static inline void evbuf_put(struct mtdev_evbuf *evbuf, - const struct input_event *ev) + struct input_event *ev) { - evbuf->buffer[evbuf->head++] = *ev; + input_to_raw_event(ev, &evbuf->buffer[evbuf->head]); + evbuf->head++; evbuf->head &= DIM_EVENTS - 1; } static inline void evbuf_get(struct mtdev_evbuf *evbuf, struct input_event *ev) { - *ev = evbuf->buffer[evbuf->tail++]; + raw_input_to_input_event(&evbuf->buffer[evbuf->tail], ev); + evbuf->tail++; evbuf->tail &= DIM_EVENTS - 1; } diff --git a/src/iobuf.c b/src/iobuf.c index 61ec9c1..6f7c923 100644 --- a/src/iobuf.c +++ b/src/iobuf.c @@ -42,7 +42,7 @@ int mtdev_fetch_event(struct mtdev *dev, int fd, struct input_event *ev) { struct mtdev_iobuf *buf = &dev->state->iobuf; int n = buf->head - buf->tail; - if (n < EVENT_SIZE) { + if (n < RAW_EVENT_SIZE) { if (buf->tail && n > 0) memmove(buf->data, buf->data + buf->tail, n); buf->head = n; @@ -53,10 +53,10 @@ int mtdev_fetch_event(struct mtdev *dev, int fd, struct input_event *ev) return n; buf->head += n; } - if (buf->head - buf->tail < EVENT_SIZE) + if (buf->head - buf->tail < RAW_EVENT_SIZE) return 0; - memcpy(ev, buf->data + buf->tail, EVENT_SIZE); - buf->tail += EVENT_SIZE; + raw_input_to_input_event(buf->data + buf->tail, ev); + buf->tail += RAW_EVENT_SIZE; return 1; } diff --git a/src/iobuf.h b/src/iobuf.h index 09c26c4..7450b01 100644 --- a/src/iobuf.h +++ b/src/iobuf.h @@ -32,7 +32,9 @@ #include "common.h" #define EVENT_SIZE sizeof(struct input_event) -#define DIM_BUFFER (DIM_EVENTS * EVENT_SIZE) +#define RAW_EVENT_SIZE sizeof(struct input_event) + +#define DIM_BUFFER (DIM_EVENTS * RAW_EVENT_SIZE) struct mtdev_iobuf { int head, tail; -- 2.7.4

9 years, 4 months

[PATCH] Update libevdev to support evdev driver v1.2

by Deepa Dinamani

Update input event structures read from the kernel to match the 1.2 version of the driver. Update the UAPI version of the header file input.h to use __inline__ instead of inline to maintain compatibility with the pedantic gcc flag used to test the headers. There are no changes to the exposed interfaces of libevdev. The associated kernel driver change is at https://lkml.org/lkml/2016/10/17/1146 . Signed-off-by: Deepa Dinamani <deepa.kernel(a)gmail.com> --- include/linux/input.h | 47 ++++++++++++++++++++++++++++++++++++++++++ include/linux/uinput.h | 3 +++ libevdev/libevdev-int.h | 31 +++++++++++++++++++--------- libevdev/libevdev.c | 30 ++++++++++++++++++--------- test/test-libevdev-has-event.c | 2 +- 5 files changed, 92 insertions(+), 21 deletions(-) diff --git a/include/linux/input.h b/include/linux/input.h index fbc968f..e253679 100644 --- a/include/linux/input.h +++ b/include/linux/input.h @@ -20,6 +20,29 @@ * The event structure itself */ +/* The time structure for y2038 safe raw_input_event. + * The fields use unsigned types to extend times until + * year 2106 rather than 2038. + */ +struct input_timeval { + __kernel_ulong_t tv_sec; + __kernel_ulong_t tv_usec; +}; + +struct raw_input_event { + struct input_timeval time; + __u16 type; + __u16 code; + __s32 value; +}; + +#ifndef __KERNEL__ + +/* Userspace structure. + * Definition maintained here for userspace that is not yet updated to use + * struct raw_input_event. + * Not to be used anywhere within the kernel. + */ struct input_event { struct timeval time; __u16 type; @@ -27,11 +50,35 @@ struct input_event { __s32 value; }; +static __inline__ void +raw_input_to_input_event(const struct raw_input_event *raw, struct input_event *ev) +{ + ev->time.tv_sec = raw->time.tv_sec; + ev->time.tv_usec = raw->time.tv_usec; + ev->type = raw->type; + ev->code = raw->code; + ev->value = raw->value; +} + +static __inline__ void +input_to_raw_event(const struct input_event *ev, struct raw_input_event *raw) +{ + raw->time.tv_sec = ev->time.tv_sec; + raw->time.tv_usec = ev->time.tv_usec; + raw->type = ev->type; + raw->code = ev->code; + raw->value = ev->value; +} + +#endif + /* * Protocol version. */ #define EV_VERSION 0x010001 +#define EV_VERSION_1_2 0x010002 + /* * IOCTLs (0x00 - 0x7f) diff --git a/include/linux/uinput.h b/include/linux/uinput.h index 434f02d..c7b7054 100644 --- a/include/linux/uinput.h +++ b/include/linux/uinput.h @@ -133,6 +133,9 @@ struct uinput_abs_setup { */ #define UI_ABS_SETUP _IOW(UINPUT_IOCTL_BASE, 4, struct uinput_abs_setup) +/* Set clockid to be used for timestamps */ +#define UI_SET_CLOCKID _IOW(UINPUT_IOCTL_BASE, 5, int) + #define UI_SET_EVBIT _IOW(UINPUT_IOCTL_BASE, 100, int) #define UI_SET_KEYBIT _IOW(UINPUT_IOCTL_BASE, 101, int) #define UI_SET_RELBIT _IOW(UINPUT_IOCTL_BASE, 102, int) diff --git a/libevdev/libevdev-int.h b/libevdev/libevdev-int.h index e1c7ec5..8539987 100644 --- a/libevdev/libevdev-int.h +++ b/libevdev/libevdev-int.h @@ -105,7 +105,7 @@ struct libevdev { enum SyncState sync_state; enum libevdev_grab_mode grabbed; - struct input_event *queue; + struct raw_input_event *queue; size_t queue_size; /**< size of queue in elements */ size_t queue_next; /**< next event index */ size_t queue_nsync; /**< number of sync events */ @@ -147,7 +147,7 @@ _libevdev_log_priority(const struct libevdev *dev); * @return a pointer to the next element in the queue, or NULL if the queue * is full. */ -static inline struct input_event* +static inline struct raw_input_event* queue_push(struct libevdev *dev) { if (dev->queue_next >= dev->queue_size) @@ -167,8 +167,8 @@ queue_pop(struct libevdev *dev, struct input_event *ev) if (dev->queue_next == 0) return 1; - *ev = dev->queue[--dev->queue_next]; - + raw_input_to_input_event(&dev->queue[dev->queue_next-1], ev); + --dev->queue_next; return 0; } @@ -177,7 +177,8 @@ queue_peek(struct libevdev *dev, size_t idx, struct input_event *ev) { if (dev->queue_next == 0 || idx > dev->queue_next) return 1; - *ev = dev->queue[idx]; + raw_input_to_input_event(&dev->queue[idx], ev); + return 0; } @@ -192,7 +193,9 @@ queue_peek(struct libevdev *dev, size_t idx, struct input_event *ev) static inline int queue_shift_multiple(struct libevdev *dev, size_t n, struct input_event *ev) { - size_t remaining; + struct raw_input_event *raw_event; + struct input_event *event; + size_t i, remaining; if (dev->queue_next == 0) return 0; @@ -201,8 +204,16 @@ queue_shift_multiple(struct libevdev *dev, size_t n, struct input_event *ev) n = min(n, remaining); remaining -= n; - if (ev) - memcpy(ev, dev->queue, n * sizeof(*ev)); + raw_event = dev->queue; + event = ev; + + if (ev) { + for (i = 0; i < n; i++) { + raw_input_to_input_event(raw_event, event); + raw_event++; + event++; + } + } memmove(dev->queue, &dev->queue[n], remaining * sizeof(*dev->queue)); @@ -228,7 +239,7 @@ queue_alloc(struct libevdev *dev, size_t size) if (size == 0) return -ENOMEM; - dev->queue = calloc(size, sizeof(struct input_event)); + dev->queue = calloc(size, sizeof(struct raw_input_event)); if (!dev->queue) return -ENOMEM; @@ -266,7 +277,7 @@ queue_num_free_elements(struct libevdev *dev) return dev->queue_size - dev->queue_next; } -static inline struct input_event * +static inline struct raw_input_event * queue_next_element(struct libevdev *dev) { if (dev->queue_next == dev->queue_size) diff --git a/libevdev/libevdev.c b/libevdev/libevdev.c index 43a095c..adf351a 100644 --- a/libevdev/libevdev.c +++ b/libevdev/libevdev.c @@ -29,6 +29,7 @@ #include <unistd.h> #include <stdarg.h> #include <stdbool.h> +#include <time.h> #include "libevdev.h" #include "libevdev-int.h" @@ -383,6 +384,10 @@ libevdev_set_fd(struct libevdev* dev, int fd) rc = ioctl(fd, EVIOCGVERSION, &dev->driver_version); if (rc < 0) goto out; + if (dev->driver_version < EV_VERSION_1_2) { + log_error(dev, "Library requires at least kernel driver version 2"); + goto out; + } /* Built on a kernel with props, running against a kernel without property support. This should not be a fatal case, we'll be missing properties but other @@ -522,9 +527,10 @@ libevdev_get_fd(const struct libevdev* dev) } static inline void -init_event(struct libevdev *dev, struct input_event *ev, int type, int code, int value) +init_event(struct libevdev *dev, struct raw_input_event *ev, int type, int code, int value) { - ev->time = dev->last_event_time; + ev->time.tv_sec = dev->last_event_time.tv_sec; + ev->time.tv_usec = dev->last_event_time.tv_usec; ev->type = type; ev->code = code; ev->value = value; @@ -546,7 +552,7 @@ sync_key_state(struct libevdev *dev) old = bit_is_set(dev->key_values, i); new = bit_is_set(keystate, i); if (old ^ new) { - struct input_event *ev = queue_push(dev); + struct raw_input_event *ev = queue_push(dev); init_event(dev, ev, EV_KEY, i, new ? 1 : 0); } } @@ -574,7 +580,7 @@ sync_sw_state(struct libevdev *dev) old = bit_is_set(dev->sw_values, i); new = bit_is_set(swstate, i); if (old ^ new) { - struct input_event *ev = queue_push(dev); + struct raw_input_event *ev = queue_push(dev); init_event(dev, ev, EV_SW, i, new ? 1 : 0); } } @@ -602,7 +608,7 @@ sync_led_state(struct libevdev *dev) old = bit_is_set(dev->led_values, i); new = bit_is_set(ledstate, i); if (old ^ new) { - struct input_event *ev = queue_push(dev); + struct raw_input_event *ev = queue_push(dev); init_event(dev, ev, EV_LED, i, new ? 1 : 0); } } @@ -633,7 +639,7 @@ sync_abs_state(struct libevdev *dev) goto out; if (dev->abs_info[i].value != abs_info.value) { - struct input_event *ev = queue_push(dev); + struct raw_input_event *ev = queue_push(dev); init_event(dev, ev, EV_ABS, i, abs_info.value); dev->abs_info[i].value = abs_info.value; @@ -648,7 +654,7 @@ out: static int sync_mt_state(struct libevdev *dev, int create_events) { - struct input_event *ev; + struct raw_input_event *ev; struct input_absinfo abs_info; int rc; int axis, slot; @@ -775,7 +781,7 @@ read_more_events(struct libevdev *dev) { int free_elem; int len; - struct input_event *next; + struct raw_input_event *next; free_elem = queue_num_free_elements(dev); if (free_elem <= 0) @@ -834,7 +840,7 @@ static int sync_state(struct libevdev *dev) { int rc = 0; - struct input_event *ev; + struct raw_input_event *ev; /* see section "Discarding events before synchronizing" in * libevdev/libevdev.h */ @@ -966,7 +972,8 @@ update_state(struct libevdev *dev, const struct input_event *e) break; } - dev->last_event_time = e->time; + dev->last_event_time.tv_sec = e->time.tv_sec; + dev->last_event_time.tv_usec = e->time.tv_usec; return rc; } @@ -1720,5 +1727,8 @@ libevdev_set_clock_id(struct libevdev *dev, int clockid) } else if (dev->fd < 0) return -EBADF; + if (clockid == CLOCK_REALTIME) + log_info(dev, "REALTIME clock support does not work beyond year 2106.\n"); + return ioctl(dev->fd, EVIOCSCLOCKID, &clockid) ? -errno : 0; } diff --git a/test/test-libevdev-has-event.c b/test/test-libevdev-has-event.c index 7703206..fee11fa 100644 --- a/test/test-libevdev-has-event.c +++ b/test/test-libevdev-has-event.c @@ -475,7 +475,7 @@ START_TEST(test_device_name) ck_assert_int_eq(libevdev_get_id_vendor(dev), ids.vendor); ck_assert_int_eq(libevdev_get_id_product(dev), ids.product); ck_assert_int_eq(libevdev_get_id_version(dev), ids.version); - ck_assert_int_eq(libevdev_get_driver_version(dev), EV_VERSION); + ck_assert_int_eq(libevdev_get_driver_version(dev), EV_VERSION_1_2); uinput_device_free(uidev); libevdev_free(dev); -- 2.7.4

9 years, 4 months

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

Y2038