ext4: Add nanosecond timestamps

This patch adds nanosecond timestamps for ext4. This involves adding
*time_extra fields to the ext4_inode to extend the timestamps to
64-bits.  Creation time is also added by this patch.

These extended fields will fit into an inode if the filesystem was
formatted with large inodes (-I 256 or larger) and there are currently
no EAs consuming all of the available space. For new inodes we always
reserve enough space for the kernel's known extended fields, but for
inodes created with an old kernel this might not have been the case. So
this patch also adds the EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE feature
flag(ro-compat so that older kernels can't create inodes with a smaller
extra_isize). which indicates if the fields fitting inside
s_min_extra_isize are available or not.  If the expansion of inodes if
unsuccessful then this feature will be disabled.  This feature is only
enabled if requested by the sysadmin.

None of the extended inode fields is critical for correct filesystem
operation.

Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Signed-off-by: Kalpak Shah <kalpak@clusterfs.com>
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Dave Kleikamp <shaggy@linux.vnet.ibm.com>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>

6 files changed, 56 insertions, 24 deletions

diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index c88b439ba5cd..427f83066a0d 100644
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -563,7 +563,8 @@ got:
         inode->i_ino = ino;
         /* 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 = CURRENT_TIME_SEC;
+        inode->i_mtime = inode->i_atime = inode->i_ctime = ei->i_crtime =
+                                                       ext4_current_time(inode);
 
         memset(ei->i_data, 0, sizeof(ei->i_data));
         ei->i_dir_start_lookup = 0;
@@ -595,9 +596,8 @@ got:
         spin_unlock(&sbi->s_next_gen_lock);
 
         ei->i_state = EXT4_STATE_NEW;
-        ei->i_extra_isize =
-                (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) ?
-                sizeof(struct ext4_inode) - EXT4_GOOD_OLD_INODE_SIZE : 0;
+
+        ei->i_extra_isize = EXT4_SB(sb)->s_want_extra_isize;
 
         ret = inode;
         if(DQUOT_ALLOC_INODE(inode)) {
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 49035c5a2c43..b83f91edebd1 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -726,7 +726,7 @@ static int ext4_splice_branch(handle_t *handle, struct inode *inode,
 
         /* We are done with atomic stuff, now do the rest of housekeeping */
 
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = ext4_current_time(inode);
         ext4_mark_inode_dirty(handle, inode);
 
         /* had we spliced it onto indirect block? */
@@ -2375,7 +2375,7 @@ do_indirects:
         ext4_discard_reservation(inode);
 
         mutex_unlock(&ei->truncate_mutex);
-        inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_mtime = inode->i_ctime = ext4_current_time(inode);
         ext4_mark_inode_dirty(handle, inode);
 
         /*
@@ -2629,10 +2629,6 @@ void ext4_read_inode(struct inode * inode)
         }
         inode->i_nlink = le16_to_cpu(raw_inode->i_links_count);
         inode->i_size = le32_to_cpu(raw_inode->i_size);
-        inode->i_atime.tv_sec = (signed)le32_to_cpu(raw_inode->i_atime);
-        inode->i_ctime.tv_sec = (signed)le32_to_cpu(raw_inode->i_ctime);
-        inode->i_mtime.tv_sec = (signed)le32_to_cpu(raw_inode->i_mtime);
-        inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_mtime.tv_nsec = 0;
 
         ei->i_state = 0;
         ei->i_dir_start_lookup = 0;
@@ -2710,6 +2706,11 @@ void ext4_read_inode(struct inode * inode)
         } else
                 ei->i_extra_isize = 0;
 
+        EXT4_INODE_GET_XTIME(i_ctime, inode, raw_inode);
+        EXT4_INODE_GET_XTIME(i_mtime, inode, raw_inode);
+        EXT4_INODE_GET_XTIME(i_atime, inode, raw_inode);
+        EXT4_EINODE_GET_XTIME(i_crtime, ei, raw_inode);
+
         if (S_ISREG(inode->i_mode)) {
                 inode->i_op = &ext4_file_inode_operations;
                 inode->i_fop = &ext4_file_operations;
@@ -2791,9 +2792,12 @@ static int ext4_do_update_inode(handle_t *handle,
         }
         raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
         raw_inode->i_size = cpu_to_le32(ei->i_disksize);
-        raw_inode->i_atime = cpu_to_le32(inode->i_atime.tv_sec);
-        raw_inode->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec);
-        raw_inode->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec);
+
+        EXT4_INODE_SET_XTIME(i_ctime, inode, raw_inode);
+        EXT4_INODE_SET_XTIME(i_mtime, inode, raw_inode);
+        EXT4_INODE_SET_XTIME(i_atime, inode, raw_inode);
+        EXT4_EINODE_SET_XTIME(i_crtime, ei, raw_inode);
+
         raw_inode->i_blocks = cpu_to_le32(inode->i_blocks);
         raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
         raw_inode->i_flags = cpu_to_le32(ei->i_flags);
diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c
index 5b00775d5096..c04c7ccba9e3 100644
--- a/fs/ext4/ioctl.c
+++ b/fs/ext4/ioctl.c
@@ -97,7 +97,7 @@ int ext4_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
                 ei->i_flags = flags;
 
                 ext4_set_inode_flags(inode);
-                inode->i_ctime = CURRENT_TIME_SEC;
+                inode->i_ctime = ext4_current_time(inode);
 
                 err = ext4_mark_iloc_dirty(handle, inode, &iloc);
 flags_err:
@@ -134,7 +134,7 @@ flags_err:
                         return PTR_ERR(handle);
                 err = ext4_reserve_inode_write(handle, inode, &iloc);
                 if (err == 0) {
-                        inode->i_ctime = CURRENT_TIME_SEC;
+                        inode->i_ctime = ext4_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 2de339dd7554..40106b7ea4b8 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -1295,7 +1295,7 @@ static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
          * happen is that the times are slightly out of date
          * and/or different from the directory change time.
          */
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
+        dir->i_mtime = dir->i_ctime = ext4_current_time(dir);
         ext4_update_dx_flag(dir);
         dir->i_version++;
         ext4_mark_inode_dirty(handle, dir);
@@ -2056,7 +2056,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 = CURRENT_TIME_SEC;
+        inode->i_ctime = dir->i_ctime = dir->i_mtime = ext4_current_time(inode);
         ext4_mark_inode_dirty(handle, inode);
         drop_nlink(dir);
         ext4_update_dx_flag(dir);
@@ -2106,13 +2106,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 = CURRENT_TIME_SEC;
+        dir->i_ctime = dir->i_mtime = ext4_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 = dir->i_ctime;
+        inode->i_ctime = ext4_current_time(inode);
         ext4_mark_inode_dirty(handle, inode);
         retval = 0;
 
@@ -2203,7 +2203,7 @@ retry:
         if (IS_DIRSYNC(dir))
                 handle->h_sync = 1;
 
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = ext4_current_time(inode);
         inc_nlink(inode);
         atomic_inc(&inode->i_count);
 
@@ -2305,7 +2305,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 = CURRENT_TIME_SEC;
+        old_inode->i_ctime = ext4_current_time(old_inode);
         ext4_mark_inode_dirty(handle, old_inode);
 
         /*
@@ -2338,9 +2338,9 @@ static int ext4_rename (struct inode * old_dir, struct dentry *old_dentry,
 
         if (new_inode) {
                 drop_nlink(new_inode);
-                new_inode->i_ctime = CURRENT_TIME_SEC;
+                new_inode->i_ctime = ext4_current_time(new_inode);
         }
-        old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME_SEC;
+        old_dir->i_ctime = old_dir->i_mtime = ext4_current_time(old_dir);
         ext4_update_dx_flag(old_dir);
         if (dir_bh) {
                 BUFFER_TRACE(dir_bh, "get_write_access");
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index af0835187e76..b47259f6f39c 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -1651,6 +1651,8 @@ static int ext4_fill_super (struct super_block *sb, void *data, int silent)
                                 sbi->s_inode_size);
                         goto failed_mount;
                 }
+                if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE)
+                        sb->s_time_gran = 1 << (EXT4_EPOCH_BITS - 2);
         }
         sbi->s_frag_size = EXT4_MIN_FRAG_SIZE <<
                                    le32_to_cpu(es->s_log_frag_size);
@@ -1874,6 +1876,32 @@ static int ext4_fill_super (struct super_block *sb, void *data, int silent)
         }
 
         ext4_setup_super (sb, es, sb->s_flags & MS_RDONLY);
+
+        /* determine the minimum size of new large inodes, if present */
+        if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE) {
+                sbi->s_want_extra_isize = sizeof(struct ext4_inode) -
+                                                     EXT4_GOOD_OLD_INODE_SIZE;
+                if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
+                                       EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE)) {
+                        if (sbi->s_want_extra_isize <
+                            le16_to_cpu(es->s_want_extra_isize))
+                                sbi->s_want_extra_isize =
+                                        le16_to_cpu(es->s_want_extra_isize);
+                        if (sbi->s_want_extra_isize <
+                            le16_to_cpu(es->s_min_extra_isize))
+                                sbi->s_want_extra_isize =
+                                        le16_to_cpu(es->s_min_extra_isize);
+                }
+        }
+        /* Check if enough inode space is available */
+        if (EXT4_GOOD_OLD_INODE_SIZE + sbi->s_want_extra_isize >
+                                                        sbi->s_inode_size) {
+                sbi->s_want_extra_isize = sizeof(struct ext4_inode) -
+                                                       EXT4_GOOD_OLD_INODE_SIZE;
+                printk(KERN_INFO "EXT4-fs: required extra inode space not"
+                        "available.\n");
+        }
+
         /*
          * akpm: core read_super() calls in here with the superblock locked.
          * That deadlocks, because orphan cleanup needs to lock the superblock
diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c
index e832e96095b3..fe16a569d06b 100644
--- a/fs/ext4/xattr.c
+++ b/fs/ext4/xattr.c
@@ -1013,7 +1013,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 = CURRENT_TIME_SEC;
+                inode->i_ctime = ext4_current_time(inode);
                 error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
                 /*
                  * The bh is consumed by ext4_mark_iloc_dirty, even with