Fix atime handling and relatime

The problem for atime:

We have 3 places for atime: inode->i_atime, znode->z_atime and SA. And its
handling is a mess. A huge part of mess regarding atime comes from
zfs_tstamp_update_setup, zfs_inode_update, and zfs_getattr, which behave
inconsistently with those three values.

zfs_tstamp_update_setup clears z_atime_dirty unconditionally as long as you
don't pass ATTR_ATIME. Which means every write(2) operation which only updates
ctime and mtime will cause atime changes to not be written to disk.

Also zfs_inode_update from write(2) will replace inode->i_atime with what's
inside SA(stale). But doesn't touch z_atime. So after read(2) and write(2).
You'll have i_atime(stale), z_atime(new), SA(stale) and z_atime_dirty=0.

Now, if you do stat(2), zfs_getattr will actually replace i_atime with what's
inside, z_atime. So you will have now you'll have i_atime(new), z_atime(new),
SA(stale) and z_atime_dirty=0. These will all gone after umount. And you'll
leave with a stale atime.

The problem for relatime:

We do have a relatime config inside ZFS dataset, but how it should interact
with the mount flag MS_RELATIME is not well defined. It seems it wanted
relatime mount option to override the dataset config by showing it as
temporary in `zfs get`. But at the same time, `zfs set relatime=on|off` would
also seems to want to override the mount option. Not to mention that
MS_RELATIME flag is actually never passed into ZFS, so it never really worked.

How Linux handles atime:

The Linux kernel actually handles atime completely in VFS, except for writing
it to disk. So if we remove the atime handling in ZFS, things would just work,
no matter it's strictatime, relatime, noatime, or even O_NOATIME. And whenever
VFS updates the i_atime, it will notify the underlying filesystem via
sb->dirty_inode().

And also there's one thing to note about atime flags like MS_RELATIME and
other flags like MS_NODEV, etc. They are mount point flags rather than
filesystem(sb) flags. Since native linux filesystem can be mounted at multiple
places at the same time, they can all have different atime settings. So these
flags are never passed down to filesystem drivers.

What this patch tries to do:

We remove znode->z_atime, since we won't gain anything from it. We remove most
of the atime handling and leave it to VFS. The only thing we do with atime is
to write it when dirty_inode() or setattr() is called. We also add
file_accessed() in zpl_read() since it's not provided in vfs_read().

After this patch, only the MS_RELATIME flag will have effect. The setting in
dataset won't do anything. We will make zfstuil to mount ZFS with MS_RELATIME
set according to the setting in dataset in future patch.

Signed-off-by: Chunwei Chen <david.chen@osnexus.com>
Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov>
Issue #4482

diff --git a/include/sys/trace_acl.h b/include/sys/trace_acl.h
index b94cb79c656a82232268ae3c92192574c861c37f..87ffecb4e28f3198ced0d05fcb156e492dcabc08 100644 (file)
--- a/include/sys/trace_acl.h
+++ b/include/sys/trace_acl.h
@@ -56,7 +56,6 @@ DECLARE_EVENT_CLASS(zfs_ace_class,
            __field(uint64_t,           z_mapcnt)
            __field(uint64_t,           z_gen)
            __field(uint64_t,           z_size)
-           __array(uint64_t,           z_atime, 2)
            __field(uint64_t,           z_links)
            __field(uint64_t,           z_pflags)
            __field(uint64_t,           z_uid)
@@ -95,8 +94,6 @@ DECLARE_EVENT_CLASS(zfs_ace_class,
            __entry->z_mapcnt           = zn->z_mapcnt;
            __entry->z_gen              = zn->z_gen;
            __entry->z_size             = zn->z_size;
-           __entry->z_atime[0]         = zn->z_atime[0];
-           __entry->z_atime[1]         = zn->z_atime[1];
            __entry->z_links            = zn->z_links;
            __entry->z_pflags           = zn->z_pflags;
            __entry->z_uid              = zn->z_uid;
@@ -126,7 +123,7 @@ DECLARE_EVENT_CLASS(zfs_ace_class,
        ),
        TP_printk("zn { id %llu unlinked %u atime_dirty %u "
            "zn_prefetch %u moved %u blksz %u seq %u "
-           "mapcnt %llu gen %llu size %llu atime 0x%llx:0x%llx "
+           "mapcnt %llu gen %llu size %llu "
            "links %llu pflags %llu uid %llu gid %llu "
            "sync_cnt %u mode 0x%x is_sa %d is_zvol %d "
            "is_mapped %d is_ctldir %d is_stale %d inode { "
@@ -136,7 +133,7 @@ DECLARE_EVENT_CLASS(zfs_ace_class,
            __entry->z_id, __entry->z_unlinked, __entry->z_atime_dirty,
            __entry->z_zn_prefetch, __entry->z_moved, __entry->z_blksz,
            __entry->z_seq, __entry->z_mapcnt, __entry->z_gen,
-           __entry->z_size, __entry->z_atime[0], __entry->z_atime[1],
+           __entry->z_size,
            __entry->z_links, __entry->z_pflags, __entry->z_uid,
            __entry->z_gid, __entry->z_sync_cnt, __entry->z_mode,
            __entry->z_is_sa, __entry->z_is_zvol, __entry->z_is_mapped,

diff --git a/include/sys/zfs_znode.h b/include/sys/zfs_znode.h
index c03bef5c7d6453e32f95e4f9560f82a728254e8c..65fa1039926f65f68a300d73b11dc67869dce453 100644 (file)
--- a/include/sys/zfs_znode.h
+++ b/include/sys/zfs_znode.h
@@ -198,7 +198,6 @@ typedef struct znode {
        uint64_t        z_mapcnt;       /* number of pages mapped to file */
        uint64_t        z_gen;          /* generation (cached) */
        uint64_t        z_size;         /* file size (cached) */
-       uint64_t        z_atime[2];     /* atime (cached) */
        uint64_t        z_links;        /* file links (cached) */
        uint64_t        z_pflags;       /* pflags (cached) */
        uint64_t        z_uid;          /* uid fuid (cached) */
@@ -306,16 +305,12 @@ extern unsigned int zfs_object_mutex_size;
 #define        STATE_CHANGED           (ATTR_CTIME)
 #define        CONTENT_MODIFIED        (ATTR_MTIME | ATTR_CTIME)
 
-#define        ZFS_ACCESSTIME_STAMP(zsb, zp) \
-       if ((zsb)->z_atime && !(zfs_is_readonly(zsb))) \
-               zfs_tstamp_update_setup(zp, ACCESSED, NULL, NULL, B_FALSE);
-
 extern int     zfs_init_fs(zfs_sb_t *, znode_t **);
 extern void    zfs_set_dataprop(objset_t *);
 extern void    zfs_create_fs(objset_t *os, cred_t *cr, nvlist_t *,
     dmu_tx_t *tx);
 extern void    zfs_tstamp_update_setup(znode_t *, uint_t, uint64_t [2],
-    uint64_t [2], boolean_t);
+    uint64_t [2]);
 extern void    zfs_grow_blocksize(znode_t *, uint64_t, dmu_tx_t *);
 extern int     zfs_freesp(znode_t *, uint64_t, uint64_t, int, boolean_t);
 extern void    zfs_znode_init(void);

diff --git a/module/zfs/zfs_acl.c b/module/zfs/zfs_acl.c
index a208dea15e5aca0ea52e79afb3577c7a8a2dd41a..47cfd464b164acb20d10ac313be659d550bace0e 100644 (file)
--- a/module/zfs/zfs_acl.c
+++ b/module/zfs/zfs_acl.c
@@ -1457,7 +1457,7 @@ zfs_aclset_common(znode_t *zp, zfs_acl_t *aclp, cred_t *cr, dmu_tx_t *tx)
        if (ace_trivial_common(aclp, 0, zfs_ace_walk) == 0)
                zp->z_pflags |= ZFS_ACL_TRIVIAL;
 
-       zfs_tstamp_update_setup(zp, STATE_CHANGED, NULL, ctime, B_TRUE);
+       zfs_tstamp_update_setup(zp, STATE_CHANGED, NULL, ctime);
        return (sa_bulk_update(zp->z_sa_hdl, bulk, count, tx));
 }
 

diff --git a/module/zfs/zfs_ctldir.c b/module/zfs/zfs_ctldir.c
index fc46a7307f441ce78fa6976c10a8028703d72975..937feac23148fb1430d6833b5629f771bed0d3e5 100644 (file)
--- a/module/zfs/zfs_ctldir.c
+++ b/module/zfs/zfs_ctldir.c
@@ -478,8 +478,6 @@ zfsctl_inode_alloc(zfs_sb_t *zsb, uint64_t id,
        zp->z_mapcnt = 0;
        zp->z_gen = 0;
        zp->z_size = 0;
-       zp->z_atime[0] = 0;
-       zp->z_atime[1] = 0;
        zp->z_links = 0;
        zp->z_pflags = 0;
        zp->z_uid = 0;

diff --git a/module/zfs/zfs_dir.c b/module/zfs/zfs_dir.c
index 951acb0d6e5bbfebe8835db6e593cb6a63a59570..bdcb87b942f27cdf6d552dd0d374d1424e14f225 100644 (file)
--- a/module/zfs/zfs_dir.c
+++ b/module/zfs/zfs_dir.c
@@ -760,7 +760,7 @@ zfs_link_create(zfs_dirlock_t *dl, znode_t *zp, dmu_tx_t *tx, int flag)
                SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zsb), NULL,
                    ctime, sizeof (ctime));
                zfs_tstamp_update_setup(zp, STATE_CHANGED, mtime,
-                   ctime, B_TRUE);
+                   ctime);
        }
        error = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
        ASSERT(error == 0);
@@ -781,7 +781,7 @@ zfs_link_create(zfs_dirlock_t *dl, znode_t *zp, dmu_tx_t *tx, int flag)
            ctime, sizeof (ctime));
        SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zsb), NULL,
            &dzp->z_pflags, sizeof (dzp->z_pflags));
-       zfs_tstamp_update_setup(dzp, CONTENT_MODIFIED, mtime, ctime, B_TRUE);
+       zfs_tstamp_update_setup(dzp, CONTENT_MODIFIED, mtime, ctime);
        error = sa_bulk_update(dzp->z_sa_hdl, bulk, count, tx);
        ASSERT(error == 0);
        mutex_exit(&dzp->z_lock);
@@ -876,8 +876,8 @@ zfs_link_destroy(zfs_dirlock_t *dl, znode_t *zp, dmu_tx_t *tx, int flag,
                            NULL, &ctime, sizeof (ctime));
                        SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zsb),
                            NULL, &zp->z_pflags, sizeof (zp->z_pflags));
-                       zfs_tstamp_update_setup(zp, STATE_CHANGED, mtime, ctime,
-                           B_TRUE);
+                       zfs_tstamp_update_setup(zp, STATE_CHANGED, mtime,
+                           ctime);
                }
                SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zsb),
                    NULL, &zp->z_links, sizeof (zp->z_links));
@@ -904,7 +904,7 @@ zfs_link_destroy(zfs_dirlock_t *dl, znode_t *zp, dmu_tx_t *tx, int flag,
            NULL, mtime, sizeof (mtime));
        SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zsb),
            NULL, &dzp->z_pflags, sizeof (dzp->z_pflags));
-       zfs_tstamp_update_setup(dzp, CONTENT_MODIFIED, mtime, ctime, B_TRUE);
+       zfs_tstamp_update_setup(dzp, CONTENT_MODIFIED, mtime, ctime);
        error = sa_bulk_update(dzp->z_sa_hdl, bulk, count, tx);
        ASSERT(error == 0);
        mutex_exit(&dzp->z_lock);

diff --git a/module/zfs/zfs_sa.c b/module/zfs/zfs_sa.c
index fa1a679e177a9031b55057d968383a6466af5f14..98e6185cfd1ad78cbf40977b6365d766672255fc 100644 (file)
--- a/module/zfs/zfs_sa.c
+++ b/module/zfs/zfs_sa.c
@@ -277,7 +277,7 @@ zfs_sa_upgrade(sa_handle_t *hdl, dmu_tx_t *tx)
        sa_bulk_attr_t *bulk, *sa_attrs;
        zfs_acl_locator_cb_t locate = { 0 };
        uint64_t uid, gid, mode, rdev, xattr, parent;
-       uint64_t crtime[2], mtime[2], ctime[2];
+       uint64_t crtime[2], mtime[2], ctime[2], atime[2];
        zfs_acl_phys_t znode_acl;
        char scanstamp[AV_SCANSTAMP_SZ];
        boolean_t drop_lock = B_FALSE;
@@ -309,6 +309,7 @@ zfs_sa_upgrade(sa_handle_t *hdl, dmu_tx_t *tx)
 
        /* First do a bulk query of the attributes that aren't cached */
        bulk = kmem_alloc(sizeof (sa_bulk_attr_t) * 20, KM_SLEEP);
+       SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ATIME(zsb), NULL, &atime, 16);
        SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zsb), NULL, &mtime, 16);
        SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zsb), NULL, &ctime, 16);
        SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CRTIME(zsb), NULL, &crtime, 16);
@@ -344,7 +345,7 @@ zfs_sa_upgrade(sa_handle_t *hdl, dmu_tx_t *tx)
        SA_ADD_BULK_ATTR(sa_attrs, count, SA_ZPL_FLAGS(zsb), NULL,
            &zp->z_pflags, 8);
        SA_ADD_BULK_ATTR(sa_attrs, count, SA_ZPL_ATIME(zsb), NULL,
-           zp->z_atime, 16);
+           &atime, 16);
        SA_ADD_BULK_ATTR(sa_attrs, count, SA_ZPL_MTIME(zsb), NULL,
            &mtime, 16);
        SA_ADD_BULK_ATTR(sa_attrs, count, SA_ZPL_CTIME(zsb), NULL,

diff --git a/module/zfs/zfs_vnops.c b/module/zfs/zfs_vnops.c
index 4fa4fe074cb280cb0a5d936697625bed3b2cfb70..b4ffd8d2ad28a5cd20d60e937b2d889c0582403e 100644 (file)
--- a/module/zfs/zfs_vnops.c
+++ b/module/zfs/zfs_vnops.c
@@ -551,7 +551,6 @@ zfs_read(struct inode *ip, uio_t *uio, int ioflag, cred_t *cr)
 out:
        zfs_range_unlock(rl);
 
-       ZFS_ACCESSTIME_STAMP(zsb, zp);
        ZFS_EXIT(zsb);
        return (error);
 }
@@ -875,8 +874,7 @@ zfs_write(struct inode *ip, uio_t *uio, int ioflag, cred_t *cr)
                }
                mutex_exit(&zp->z_acl_lock);
 
-               zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime,
-                   B_TRUE);
+               zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime);
 
                /*
                 * Update the file size (zp_size) if it has changed;
@@ -2211,9 +2209,6 @@ update:
        zap_cursor_fini(&zc);
        if (error == ENOENT)
                error = 0;
-
-       ZFS_ACCESSTIME_STAMP(zsb, zp);
-
 out:
        ZFS_EXIT(zsb);
 
@@ -2266,11 +2261,11 @@ zfs_getattr(struct inode *ip, vattr_t *vap, int flags, cred_t *cr)
        zfs_sb_t *zsb = ITOZSB(ip);
        int     error = 0;
        uint64_t links;
-       uint64_t mtime[2], ctime[2];
+       uint64_t atime[2], mtime[2], ctime[2];
        xvattr_t *xvap = (xvattr_t *)vap;       /* vap may be an xvattr_t * */
        xoptattr_t *xoap = NULL;
        boolean_t skipaclchk = (flags & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE;
-       sa_bulk_attr_t bulk[2];
+       sa_bulk_attr_t bulk[3];
        int count = 0;
 
        ZFS_ENTER(zsb);
@@ -2278,6 +2273,7 @@ zfs_getattr(struct inode *ip, vattr_t *vap, int flags, cred_t *cr)
 
        zfs_fuid_map_ids(zp, cr, &vap->va_uid, &vap->va_gid);
 
+       SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ATIME(zsb), NULL, &atime, 16);
        SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zsb), NULL, &mtime, 16);
        SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zsb), NULL, &ctime, 16);
 
@@ -2426,7 +2422,7 @@ zfs_getattr(struct inode *ip, vattr_t *vap, int flags, cred_t *cr)
                }
        }
 
-       ZFS_TIME_DECODE(&vap->va_atime, zp->z_atime);
+       ZFS_TIME_DECODE(&vap->va_atime, atime);
        ZFS_TIME_DECODE(&vap->va_mtime, mtime);
        ZFS_TIME_DECODE(&vap->va_ctime, ctime);
 
@@ -2473,7 +2469,6 @@ zfs_getattr_fast(struct inode *ip, struct kstat *sp)
        mutex_enter(&zp->z_lock);
 
        generic_fillattr(ip, sp);
-       ZFS_TIME_DECODE(&sp->atime, zp->z_atime);
 
        sa_object_size(zp->z_sa_hdl, &blksize, &nblocks);
        sp->blksize = blksize;
@@ -2537,7 +2532,7 @@ zfs_setattr(struct inode *ip, vattr_t *vap, int flags, cred_t *cr)
        uint64_t        new_mode;
        uint64_t        new_uid, new_gid;
        uint64_t        xattr_obj;
-       uint64_t        mtime[2], ctime[2];
+       uint64_t        mtime[2], ctime[2], atime[2];
        znode_t         *attrzp;
        int             need_policy = FALSE;
        int             err, err2;
@@ -3011,9 +3006,9 @@ top:
 
 
        if (mask & ATTR_ATIME) {
-               ZFS_TIME_ENCODE(&vap->va_atime, zp->z_atime);
+               ZFS_TIME_ENCODE(&vap->va_atime, atime);
                SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ATIME(zsb), NULL,
-                   &zp->z_atime, sizeof (zp->z_atime));
+                   &atime, sizeof (atime));
        }
 
        if (mask & ATTR_MTIME) {
@@ -3028,19 +3023,17 @@ top:
                    NULL, mtime, sizeof (mtime));
                SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zsb), NULL,
                    &ctime, sizeof (ctime));
-               zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime,
-                   B_TRUE);
+               zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime);
        } else if (mask != 0) {
                SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zsb), NULL,
                    &ctime, sizeof (ctime));
-               zfs_tstamp_update_setup(zp, STATE_CHANGED, mtime, ctime,
-                   B_TRUE);
+               zfs_tstamp_update_setup(zp, STATE_CHANGED, mtime, ctime);
                if (attrzp) {
                        SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
                            SA_ZPL_CTIME(zsb), NULL,
                            &ctime, sizeof (ctime));
                        zfs_tstamp_update_setup(attrzp, STATE_CHANGED,
-                           mtime, ctime, B_TRUE);
+                           mtime, ctime);
                }
        }
        /*
@@ -3766,7 +3759,6 @@ zfs_readlink(struct inode *ip, uio_t *uio, cred_t *cr)
                error = zfs_sa_readlink(zp, uio);
        mutex_exit(&zp->z_lock);
 
-       ZFS_ACCESSTIME_STAMP(zsb, zp);
        ZFS_EXIT(zsb);
        return (error);
 }
@@ -4169,7 +4161,6 @@ zfs_dirty_inode(struct inode *ip, int flags)
        mode = ip->i_mode;
 
        zp->z_mode = mode;
-       zp->z_atime_dirty = 0;
 
        error = sa_bulk_update(zp->z_sa_hdl, bulk, cnt, tx);
        mutex_exit(&zp->z_lock);
@@ -4187,6 +4178,7 @@ zfs_inactive(struct inode *ip)
 {
        znode_t *zp = ITOZ(ip);
        zfs_sb_t *zsb = ITOZSB(ip);
+       uint64_t atime[2];
        int error;
        int need_unlock = 0;
 
@@ -4210,9 +4202,10 @@ zfs_inactive(struct inode *ip)
                if (error) {
                        dmu_tx_abort(tx);
                } else {
+                       ZFS_TIME_ENCODE(&ip->i_atime, atime);
                        mutex_enter(&zp->z_lock);
                        (void) sa_update(zp->z_sa_hdl, SA_ZPL_ATIME(zsb),
-                           (void *)&zp->z_atime, sizeof (zp->z_atime), tx);
+                           (void *)&atime, sizeof (atime), tx);
                        zp->z_atime_dirty = 0;
                        mutex_exit(&zp->z_lock);
                        dmu_tx_commit(tx);
@@ -4322,9 +4315,6 @@ zfs_getpage(struct inode *ip, struct page *pl[], int nr_pages)
 
        err = zfs_fillpage(ip, pl, nr_pages);
 
-       if (!err)
-               ZFS_ACCESSTIME_STAMP(zsb, zp);
-
        ZFS_EXIT(zsb);
        return (err);
 }

diff --git a/module/zfs/zfs_znode.c b/module/zfs/zfs_znode.c
index f324822470f2ea1f273b83f841add297ff39a56f..f3662e27254231a6c7f1f20fb256a4add5f5ba35 100644 (file)
--- a/module/zfs/zfs_znode.c
+++ b/module/zfs/zfs_znode.c
@@ -508,7 +508,7 @@ zfs_znode_alloc(zfs_sb_t *zsb, dmu_buf_t *db, int blksz,
        struct inode *ip;
        uint64_t mode;
        uint64_t parent;
-       sa_bulk_attr_t bulk[9];
+       sa_bulk_attr_t bulk[8];
        int count = 0;
 
        ASSERT(zsb != NULL);
@@ -546,8 +546,6 @@ zfs_znode_alloc(zfs_sb_t *zsb, dmu_buf_t *db, int blksz,
            &zp->z_pflags, 8);
        SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_PARENT(zsb), NULL,
            &parent, 8);
-       SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ATIME(zsb), NULL,
-           &zp->z_atime, 16);
        SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_UID(zsb), NULL, &zp->z_uid, 8);
        SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GID(zsb), NULL, &zp->z_gid, 8);
 
@@ -1144,7 +1142,7 @@ zfs_rezget(znode_t *zp)
        dmu_buf_t *db;
        uint64_t obj_num = zp->z_id;
        uint64_t mode;
-       sa_bulk_attr_t bulk[8];
+       sa_bulk_attr_t bulk[7];
        int err;
        int count = 0;
        uint64_t gen;
@@ -1199,8 +1197,6 @@ zfs_rezget(znode_t *zp)
            &zp->z_links, sizeof (zp->z_links));
        SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zsb), NULL,
            &zp->z_pflags, sizeof (zp->z_pflags));
-       SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ATIME(zsb), NULL,
-           &zp->z_atime, sizeof (zp->z_atime));
        SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_UID(zsb), NULL,
            &zp->z_uid, sizeof (zp->z_uid));
        SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GID(zsb), NULL,
@@ -1295,78 +1291,28 @@ zfs_compare_timespec(struct timespec *t1, struct timespec *t2)
        return (t1->tv_nsec - t2->tv_nsec);
 }
 
-/*
- *  Determine whether the znode's atime must be updated.  The logic mostly
- *  duplicates the Linux kernel's relatime_need_update() functionality.
- *  This function is only called if the underlying filesystem actually has
- *  atime updates enabled.
- */
-static inline boolean_t
-zfs_atime_need_update(znode_t *zp, timestruc_t *now)
-{
-       if (!ZTOZSB(zp)->z_relatime)
-               return (B_TRUE);
-
-       /*
-        * In relatime mode, only update the atime if the previous atime
-        * is earlier than either the ctime or mtime or if at least a day
-        * has passed since the last update of atime.
-        */
-       if (zfs_compare_timespec(&ZTOI(zp)->i_mtime, &ZTOI(zp)->i_atime) >= 0)
-               return (B_TRUE);
-
-       if (zfs_compare_timespec(&ZTOI(zp)->i_ctime, &ZTOI(zp)->i_atime) >= 0)
-               return (B_TRUE);
-
-       if ((long)now->tv_sec - ZTOI(zp)->i_atime.tv_sec >= 24*60*60)
-               return (B_TRUE);
-
-       return (B_FALSE);
-}
-
 /*
  * Prepare to update znode time stamps.
  *
  *     IN:     zp      - znode requiring timestamp update
- *             flag    - ATTR_MTIME, ATTR_CTIME, ATTR_ATIME flags
- *             have_tx - true of caller is creating a new txg
+ *             flag    - ATTR_MTIME, ATTR_CTIME flags
  *
- *     OUT:    zp      - new atime (via underlying inode's i_atime)
+ *     OUT:    zp      - z_seq
  *             mtime   - new mtime
  *             ctime   - new ctime
  *
- * NOTE: The arguments are somewhat redundant.  The following condition
- * is always true:
- *
- *             have_tx == !(flag & ATTR_ATIME)
+ *     Note: We don't update atime here, because we rely on Linux VFS to do
+ *     atime updating.
  */
 void
 zfs_tstamp_update_setup(znode_t *zp, uint_t flag, uint64_t mtime[2],
-    uint64_t ctime[2], boolean_t have_tx)
+    uint64_t ctime[2])
 {
        timestruc_t     now;
 
-       ASSERT(have_tx == !(flag & ATTR_ATIME));
        gethrestime(&now);
 
-       /*
-        * NOTE: The following test intentionally does not update z_atime_dirty
-        * in the case where an ATIME update has been requested but for which
-        * the update is omitted due to relatime logic.  The rationale being
-        * that if the flag was set somewhere else, we should leave it alone
-        * here.
-        */
-       if (flag & ATTR_ATIME) {
-               if (zfs_atime_need_update(zp, &now)) {
-                       ZFS_TIME_ENCODE(&now, zp->z_atime);
-                       ZTOI(zp)->i_atime.tv_sec = zp->z_atime[0];
-                       ZTOI(zp)->i_atime.tv_nsec = zp->z_atime[1];
-                       zp->z_atime_dirty = 1;
-               }
-       } else {
-               zp->z_atime_dirty = 0;
-               zp->z_seq++;
-       }
+       zp->z_seq++;
 
        if (flag & ATTR_MTIME) {
                ZFS_TIME_ENCODE(&now, mtime);
@@ -1739,7 +1685,7 @@ log:
        SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zsb), NULL, ctime, 16);
        SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zsb),
            NULL, &zp->z_pflags, 8);
-       zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime, B_TRUE);
+       zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime);
        error = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
        ASSERT(error == 0);
 

diff --git a/module/zfs/zpl_file.c b/module/zfs/zpl_file.c
index 5c430c7ca801d1647b8103c1191b273f22582303..36153cb903c2bc22e83611d773634054949447f6 100644 (file)
--- a/module/zfs/zpl_file.c
+++ b/module/zfs/zpl_file.c
@@ -261,6 +261,7 @@ zpl_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)
            UIO_USERSPACE, filp->f_flags, cr);
        crfree(cr);
 
+       file_accessed(filp);
        return (read);
 }
 
@@ -277,6 +278,7 @@ zpl_iter_read_common(struct kiocb *kiocb, const struct iovec *iovp,
            nr_segs, &kiocb->ki_pos, seg, filp->f_flags, cr, skip);
        crfree(cr);
 
+       file_accessed(filp);
        return (read);
 }