Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 46e62a07 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'for_v4.19-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs 

Pull UDF and ext2 update from Jan Kara.

* tag 'for_v4.19-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs:
  ext2: use ktime_get_real_seconds for timestamps
  udf: convert inode stamps to timespec64
parents 5c60a738 fe2c3254

fs/ext2/inode.c

+1 −1
Original line number Diff line number Diff line
@@ -86,7 +86,7 @@ void ext2_evict_inode(struct inode * inode) 
	if (want_delete) {

		sb_start_intwrite(inode->i_sb);

		/* set dtime */

		EXT2_I(inode)->i_dtime	= get_seconds();

		EXT2_I(inode)->i_dtime	= ktime_get_real_seconds();

		mark_inode_dirty(inode);

		__ext2_write_inode(inode, inode_needs_sync(inode));

		/* truncate to 0 */

fs/ext2/super.c

+4 −3
Original line number Diff line number Diff line
@@ -682,7 +682,8 @@ static int ext2_setup_super (struct super_block * sb, 
			"running e2fsck is recommended");

	else if (le32_to_cpu(es->s_checkinterval) &&

		(le32_to_cpu(es->s_lastcheck) +

			le32_to_cpu(es->s_checkinterval) <= get_seconds()))

			le32_to_cpu(es->s_checkinterval) <=

			ktime_get_real_seconds()))

		ext2_msg(sb, KERN_WARNING,

			"warning: checktime reached, "

			"running e2fsck is recommended");
@@ -1248,7 +1249,7 @@ void ext2_sync_super(struct super_block *sb, struct ext2_super_block *es, 
	spin_lock(&EXT2_SB(sb)->s_lock);

	es->s_free_blocks_count = cpu_to_le32(ext2_count_free_blocks(sb));

	es->s_free_inodes_count = cpu_to_le32(ext2_count_free_inodes(sb));

	es->s_wtime = cpu_to_le32(get_seconds());

	es->s_wtime = cpu_to_le32(ktime_get_real_seconds());

	/* unlock before we do IO */

	spin_unlock(&EXT2_SB(sb)->s_lock);

	mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
@@ -1360,7 +1361,7 @@ static int ext2_remount (struct super_block * sb, int * flags, char * data) 
		 * the rdonly flag and then mark the partition as valid again.

		 */

		es->s_state = cpu_to_le16(sbi->s_mount_state);

		es->s_mtime = cpu_to_le32(get_seconds());

		es->s_mtime = cpu_to_le32(ktime_get_real_seconds());

		spin_unlock(&sbi->s_lock);



		err = dquot_suspend(sb, -1);

fs/udf/ialloc.c

+1 −1
Original line number Diff line number Diff line
@@ -125,7 +125,7 @@ struct inode *udf_new_inode(struct inode *dir, umode_t mode) 
	else

		iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;

	inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);

	iinfo->i_crtime = timespec64_to_timespec(inode->i_mtime);

	iinfo->i_crtime = inode->i_mtime;

	if (unlikely(insert_inode_locked(inode) < 0)) {

		make_bad_inode(inode);

		iput(inode);

fs/udf/inode.c

+16 −29
Original line number Diff line number Diff line
@@ -1270,7 +1270,6 @@ static int udf_read_inode(struct inode *inode, bool hidden_inode) 
	struct udf_inode_info *iinfo = UDF_I(inode);

	struct udf_sb_info *sbi = UDF_SB(inode->i_sb);

	struct kernel_lb_addr *iloc = &iinfo->i_location;

	struct timespec ts;

	unsigned int link_count;

	unsigned int indirections = 0;

	int bs = inode->i_sb->s_blocksize;
@@ -1443,12 +1442,9 @@ static int udf_read_inode(struct inode *inode, bool hidden_inode) 
		inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) <<

			(inode->i_sb->s_blocksize_bits - 9);



		udf_disk_stamp_to_time(&ts, fe->accessTime);

		inode->i_atime = timespec_to_timespec64(ts);

		udf_disk_stamp_to_time(&ts, fe->modificationTime);

		inode->i_mtime = timespec_to_timespec64(ts);

		udf_disk_stamp_to_time(&ts, fe->attrTime);

		inode->i_ctime = timespec_to_timespec64(ts);

		udf_disk_stamp_to_time(&inode->i_atime, fe->accessTime);

		udf_disk_stamp_to_time(&inode->i_mtime, fe->modificationTime);

		udf_disk_stamp_to_time(&inode->i_ctime, fe->attrTime);



		iinfo->i_unique = le64_to_cpu(fe->uniqueID);

		iinfo->i_lenEAttr = le32_to_cpu(fe->lengthExtendedAttr);
@@ -1458,13 +1454,10 @@ static int udf_read_inode(struct inode *inode, bool hidden_inode) 
		inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) <<

		    (inode->i_sb->s_blocksize_bits - 9);



		udf_disk_stamp_to_time(&ts, efe->accessTime);

		inode->i_atime = timespec_to_timespec64(ts);

		udf_disk_stamp_to_time(&ts, efe->modificationTime);

		inode->i_mtime = timespec_to_timespec64(ts);

		udf_disk_stamp_to_time(&inode->i_atime, efe->accessTime);

		udf_disk_stamp_to_time(&inode->i_mtime, efe->modificationTime);

		udf_disk_stamp_to_time(&iinfo->i_crtime, efe->createTime);

		udf_disk_stamp_to_time(&ts, efe->attrTime);

		inode->i_ctime = timespec_to_timespec64(ts);

		udf_disk_stamp_to_time(&inode->i_ctime, efe->attrTime);



		iinfo->i_unique = le64_to_cpu(efe->uniqueID);

		iinfo->i_lenEAttr = le32_to_cpu(efe->lengthExtendedAttr);
@@ -1601,7 +1594,7 @@ static int udf_sync_inode(struct inode *inode) 
	return udf_update_inode(inode, 1);

}



static void udf_adjust_time(struct udf_inode_info *iinfo, struct timespec time)

static void udf_adjust_time(struct udf_inode_info *iinfo, struct timespec64 time)

{

	if (iinfo->i_crtime.tv_sec > time.tv_sec ||

	    (iinfo->i_crtime.tv_sec == time.tv_sec &&
@@ -1714,12 +1707,9 @@ static int udf_update_inode(struct inode *inode, int do_sync) 
		       inode->i_sb->s_blocksize - sizeof(struct fileEntry));

		fe->logicalBlocksRecorded = cpu_to_le64(lb_recorded);



		udf_time_to_disk_stamp(&fe->accessTime,

				       timespec64_to_timespec(inode->i_atime));

		udf_time_to_disk_stamp(&fe->modificationTime,

				       timespec64_to_timespec(inode->i_mtime));

		udf_time_to_disk_stamp(&fe->attrTime,

				       timespec64_to_timespec(inode->i_ctime));

		udf_time_to_disk_stamp(&fe->accessTime, inode->i_atime);

		udf_time_to_disk_stamp(&fe->modificationTime, inode->i_mtime);

		udf_time_to_disk_stamp(&fe->attrTime, inode->i_ctime);

		memset(&(fe->impIdent), 0, sizeof(struct regid));

		strcpy(fe->impIdent.ident, UDF_ID_DEVELOPER);

		fe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
@@ -1738,17 +1728,14 @@ static int udf_update_inode(struct inode *inode, int do_sync) 
		efe->objectSize = cpu_to_le64(inode->i_size);

		efe->logicalBlocksRecorded = cpu_to_le64(lb_recorded);



		udf_adjust_time(iinfo, timespec64_to_timespec(inode->i_atime));

		udf_adjust_time(iinfo, timespec64_to_timespec(inode->i_mtime));

		udf_adjust_time(iinfo, timespec64_to_timespec(inode->i_ctime));

		udf_adjust_time(iinfo, inode->i_atime);

		udf_adjust_time(iinfo, inode->i_mtime);

		udf_adjust_time(iinfo, inode->i_ctime);



		udf_time_to_disk_stamp(&efe->accessTime,

				       timespec64_to_timespec(inode->i_atime));

		udf_time_to_disk_stamp(&efe->modificationTime,

				       timespec64_to_timespec(inode->i_mtime));

		udf_time_to_disk_stamp(&efe->accessTime, inode->i_atime);

		udf_time_to_disk_stamp(&efe->modificationTime, inode->i_mtime);

		udf_time_to_disk_stamp(&efe->createTime, iinfo->i_crtime);

		udf_time_to_disk_stamp(&efe->attrTime,

				       timespec64_to_timespec(inode->i_ctime));

		udf_time_to_disk_stamp(&efe->attrTime, inode->i_ctime);



		memset(&(efe->impIdent), 0, sizeof(efe->impIdent));

		strcpy(efe->impIdent.ident, UDF_ID_DEVELOPER);

fs/udf/super.c

+4 −4
Original line number Diff line number Diff line
@@ -1980,7 +1980,7 @@ static void udf_open_lvid(struct super_block *sb) 
	struct buffer_head *bh = sbi->s_lvid_bh;

	struct logicalVolIntegrityDesc *lvid;

	struct logicalVolIntegrityDescImpUse *lvidiu;

	struct timespec ts;

	struct timespec64 ts;



	if (!bh)

		return;
@@ -1992,7 +1992,7 @@ static void udf_open_lvid(struct super_block *sb) 
	mutex_lock(&sbi->s_alloc_mutex);

	lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;

	lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;

	ktime_get_real_ts(&ts);

	ktime_get_real_ts64(&ts);

	udf_time_to_disk_stamp(&lvid->recordingDateAndTime, ts);

	if (le32_to_cpu(lvid->integrityType) == LVID_INTEGRITY_TYPE_CLOSE)

		lvid->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_OPEN);
@@ -2017,7 +2017,7 @@ static void udf_close_lvid(struct super_block *sb) 
	struct buffer_head *bh = sbi->s_lvid_bh;

	struct logicalVolIntegrityDesc *lvid;

	struct logicalVolIntegrityDescImpUse *lvidiu;

	struct timespec ts;

	struct timespec64 ts;



	if (!bh)

		return;
@@ -2029,7 +2029,7 @@ static void udf_close_lvid(struct super_block *sb) 
	mutex_lock(&sbi->s_alloc_mutex);

	lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;

	lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;

	ktime_get_real_ts(&ts);

	ktime_get_real_ts64(&ts);

	udf_time_to_disk_stamp(&lvid->recordingDateAndTime, ts);

	if (UDF_MAX_WRITE_VERSION > le16_to_cpu(lvidiu->maxUDFWriteRev))

		lvidiu->maxUDFWriteRev = cpu_to_le16(UDF_MAX_WRITE_VERSION);