Commit 9bbeab41 authored by Arnd Bergmann's avatar Arnd Bergmann Committed by Ilya Dryomov
Browse files

ceph: use timespec64 for inode timestamp 



Since the vfs structures are all using timespec64, we can now
change the internal representation, using ceph_encode_timespec64 and
ceph_decode_timespec64.

In case of ceph_aux_inode however, we need to avoid doing a memcmp()
on uninitialized padding data, so the members of the i_mtime field get
copied individually into 64-bit integers.

Signed-off-by: default avatarArnd Bergmann <arnd@arndb.de>
Reviewed-by: default avatar"Yan, Zheng" <zyan@redhat.com>
Signed-off-by: default avatarIlya Dryomov <idryomov@gmail.com>
parent 63ecae7e

fs/ceph/cache.c

+7 −4
Original line number Diff line number Diff line
@@ -26,7 +26,8 @@ 


struct ceph_aux_inode {

	u64 	version;

	struct timespec	mtime;

	u64	mtime_sec;

	u64	mtime_nsec;

};



struct fscache_netfs ceph_cache_netfs = {
@@ -130,7 +131,8 @@ static enum fscache_checkaux ceph_fscache_inode_check_aux( 


	memset(&aux, 0, sizeof(aux));

	aux.version = ci->i_version;

	aux.mtime = timespec64_to_timespec(inode->i_mtime);

	aux.mtime_sec = inode->i_mtime.tv_sec;

	aux.mtime_nsec = inode->i_mtime.tv_nsec;



	if (memcmp(data, &aux, sizeof(aux)) != 0)

		return FSCACHE_CHECKAUX_OBSOLETE;
@@ -163,7 +165,8 @@ void ceph_fscache_register_inode_cookie(struct inode *inode) 
	if (!ci->fscache) {

		memset(&aux, 0, sizeof(aux));

		aux.version = ci->i_version;

		aux.mtime = timespec64_to_timespec(inode->i_mtime);

		aux.mtime_sec = inode->i_mtime.tv_sec;

		aux.mtime_nsec = inode->i_mtime.tv_nsec;

		ci->fscache = fscache_acquire_cookie(fsc->fscache,

						     &ceph_fscache_inode_object_def,

						     &ci->i_vino, sizeof(ci->i_vino),

fs/ceph/caps.c

+13 −13
Original line number Diff line number Diff line
@@ -1125,7 +1125,7 @@ struct cap_msg_args { 
	u64			flush_tid, oldest_flush_tid, size, max_size;

	u64			xattr_version;

	struct ceph_buffer	*xattr_buf;

	struct timespec		atime, mtime, ctime;

	struct timespec64	atime, mtime, ctime;

	int			op, caps, wanted, dirty;

	u32			seq, issue_seq, mseq, time_warp_seq;

	u32			flags;
@@ -1146,7 +1146,7 @@ static int send_cap_msg(struct cap_msg_args *arg) 
	struct ceph_msg *msg;

	void *p;

	size_t extra_len;

	struct timespec zerotime = {0};

	struct timespec64 zerotime = {0};

	struct ceph_osd_client *osdc = &arg->session->s_mdsc->fsc->client->osdc;



	dout("send_cap_msg %s %llx %llx caps %s wanted %s dirty %s"
@@ -1186,9 +1186,9 @@ static int send_cap_msg(struct cap_msg_args *arg) 


	fc->size = cpu_to_le64(arg->size);

	fc->max_size = cpu_to_le64(arg->max_size);

	ceph_encode_timespec(&fc->mtime, &arg->mtime);

	ceph_encode_timespec(&fc->atime, &arg->atime);

	ceph_encode_timespec(&fc->ctime, &arg->ctime);

	ceph_encode_timespec64(&fc->mtime, &arg->mtime);

	ceph_encode_timespec64(&fc->atime, &arg->atime);

	ceph_encode_timespec64(&fc->ctime, &arg->ctime);

	fc->time_warp_seq = cpu_to_le32(arg->time_warp_seq);



	fc->uid = cpu_to_le32(from_kuid(&init_user_ns, arg->uid));
@@ -1237,7 +1237,7 @@ static int send_cap_msg(struct cap_msg_args *arg) 
	 * We just zero these out for now, as the MDS ignores them unless

	 * the requisite feature flags are set (which we don't do yet).

	 */

	ceph_encode_timespec(p, &zerotime);

	ceph_encode_timespec64(p, &zerotime);

	p += sizeof(struct ceph_timespec);

	ceph_encode_64(&p, 0);
@@ -1360,9 +1360,9 @@ static int __send_cap(struct ceph_mds_client *mdsc, struct ceph_cap *cap, 
		arg.xattr_buf = NULL;

	}



	arg.mtime = timespec64_to_timespec(inode->i_mtime);

	arg.atime = timespec64_to_timespec(inode->i_atime);

	arg.ctime = timespec64_to_timespec(inode->i_ctime);

	arg.mtime = inode->i_mtime;

	arg.atime = inode->i_atime;

	arg.ctime = inode->i_ctime;



	arg.op = op;

	arg.caps = cap->implemented;
@@ -3148,11 +3148,11 @@ static void handle_cap_grant(struct inode *inode, 
	}



	if (newcaps & CEPH_CAP_ANY_RD) {

		struct timespec mtime, atime, ctime;

		struct timespec64 mtime, atime, ctime;

		/* ctime/mtime/atime? */

		ceph_decode_timespec(&mtime, &grant->mtime);

		ceph_decode_timespec(&atime, &grant->atime);

		ceph_decode_timespec(&ctime, &grant->ctime);

		ceph_decode_timespec64(&mtime, &grant->mtime);

		ceph_decode_timespec64(&atime, &grant->atime);

		ceph_decode_timespec64(&ctime, &grant->ctime);

		ceph_fill_file_time(inode, extra_info->issued,

				    le32_to_cpu(grant->time_warp_seq),

				    &ctime, &mtime, &atime);

fs/ceph/dir.c

+3 −3
Original line number Diff line number Diff line
@@ -1397,7 +1397,7 @@ static ssize_t ceph_read_dir(struct file *file, char __user *buf, size_t size, 
				" rfiles:   %20lld\n"

				" rsubdirs: %20lld\n"

				"rbytes:    %20lld\n"

				"rctime:    %10ld.%09ld\n",

				"rctime:    %10lld.%09ld\n",

				ci->i_files + ci->i_subdirs,

				ci->i_files,

				ci->i_subdirs,
@@ -1405,8 +1405,8 @@ static ssize_t ceph_read_dir(struct file *file, char __user *buf, size_t size, 
				ci->i_rfiles,

				ci->i_rsubdirs,

				ci->i_rbytes,

				(long)ci->i_rctime.tv_sec,

				(long)ci->i_rctime.tv_nsec);

				ci->i_rctime.tv_sec,

				ci->i_rctime.tv_nsec);

	}



	if (*ppos >= dfi->dir_info_len)

fs/ceph/inode.c

+36 −40
Original line number Diff line number Diff line
@@ -658,13 +658,10 @@ int ceph_fill_file_size(struct inode *inode, int issued, 
}



void ceph_fill_file_time(struct inode *inode, int issued,

			 u64 time_warp_seq, struct timespec *ctime,

			 struct timespec *mtime, struct timespec *atime)

			 u64 time_warp_seq, struct timespec64 *ctime,

			 struct timespec64 *mtime, struct timespec64 *atime)

{

	struct ceph_inode_info *ci = ceph_inode(inode);

	struct timespec64 ctime64 = timespec_to_timespec64(*ctime);

	struct timespec64 mtime64 = timespec_to_timespec64(*mtime);

	struct timespec64 atime64 = timespec_to_timespec64(*atime);

	int warn = 0;



	if (issued & (CEPH_CAP_FILE_EXCL|
@@ -673,39 +670,39 @@ void ceph_fill_file_time(struct inode *inode, int issued, 
		      CEPH_CAP_AUTH_EXCL|

		      CEPH_CAP_XATTR_EXCL)) {

		if (ci->i_version == 0 ||

		    timespec64_compare(&ctime64, &inode->i_ctime) > 0) {

		    timespec64_compare(ctime, &inode->i_ctime) > 0) {

			dout("ctime %lld.%09ld -> %lld.%09ld inc w/ cap\n",

			     (long long)inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec,

			     (long long)ctime->tv_sec, ctime->tv_nsec);

			inode->i_ctime = ctime64;

			     inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec,

			     ctime->tv_sec, ctime->tv_nsec);

			inode->i_ctime = *ctime;

		}

		if (ci->i_version == 0 ||

		    ceph_seq_cmp(time_warp_seq, ci->i_time_warp_seq) > 0) {

			/* the MDS did a utimes() */

			dout("mtime %lld.%09ld -> %lld.%09ld "

			     "tw %d -> %d\n",

			     (long long)inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec,

			     (long long)mtime->tv_sec, mtime->tv_nsec,

			     inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec,

			     mtime->tv_sec, mtime->tv_nsec,

			     ci->i_time_warp_seq, (int)time_warp_seq);



			inode->i_mtime = mtime64;

			inode->i_atime = atime64;

			inode->i_mtime = *mtime;

			inode->i_atime = *atime;

			ci->i_time_warp_seq = time_warp_seq;

		} else if (time_warp_seq == ci->i_time_warp_seq) {

			/* nobody did utimes(); take the max */

			if (timespec64_compare(&mtime64, &inode->i_mtime) > 0) {

			if (timespec64_compare(mtime, &inode->i_mtime) > 0) {

				dout("mtime %lld.%09ld -> %lld.%09ld inc\n",

				     (long long)inode->i_mtime.tv_sec,

				     inode->i_mtime.tv_sec,

				     inode->i_mtime.tv_nsec,

				     (long long)mtime->tv_sec, mtime->tv_nsec);

				inode->i_mtime = mtime64;

				     mtime->tv_sec, mtime->tv_nsec);

				inode->i_mtime = *mtime;

			}

			if (timespec64_compare(&atime64, &inode->i_atime) > 0) {

			if (timespec64_compare(atime, &inode->i_atime) > 0) {

				dout("atime %lld.%09ld -> %lld.%09ld inc\n",

				     (long long)inode->i_atime.tv_sec,

				     inode->i_atime.tv_sec,

				     inode->i_atime.tv_nsec,

				     (long long)atime->tv_sec, atime->tv_nsec);

				inode->i_atime = atime64;

				     atime->tv_sec, atime->tv_nsec);

				inode->i_atime = *atime;

			}

		} else if (issued & CEPH_CAP_FILE_EXCL) {

			/* we did a utimes(); ignore mds values */
@@ -715,9 +712,9 @@ void ceph_fill_file_time(struct inode *inode, int issued, 
	} else {

		/* we have no write|excl caps; whatever the MDS says is true */

		if (ceph_seq_cmp(time_warp_seq, ci->i_time_warp_seq) >= 0) {

			inode->i_ctime = ctime64;

			inode->i_mtime = mtime64;

			inode->i_atime = atime64;

			inode->i_ctime = *ctime;

			inode->i_mtime = *mtime;

			inode->i_atime = *atime;

			ci->i_time_warp_seq = time_warp_seq;

		} else {

			warn = 1;
@@ -743,7 +740,7 @@ static int fill_inode(struct inode *inode, struct page *locked_page, 
	struct ceph_mds_reply_inode *info = iinfo->in;

	struct ceph_inode_info *ci = ceph_inode(inode);

	int issued, new_issued, info_caps;

	struct timespec mtime, atime, ctime;

	struct timespec64 mtime, atime, ctime;

	struct ceph_buffer *xattr_blob = NULL;

	struct ceph_string *pool_ns = NULL;

	struct ceph_cap *new_cap = NULL;
@@ -823,9 +820,9 @@ static int fill_inode(struct inode *inode, struct page *locked_page, 


	if (new_version || (new_issued & CEPH_CAP_ANY_RD)) {

		/* be careful with mtime, atime, size */

		ceph_decode_timespec(&atime, &info->atime);

		ceph_decode_timespec(&mtime, &info->mtime);

		ceph_decode_timespec(&ctime, &info->ctime);

		ceph_decode_timespec64(&atime, &info->atime);

		ceph_decode_timespec64(&mtime, &info->mtime);

		ceph_decode_timespec64(&ctime, &info->ctime);

		ceph_fill_file_time(inode, issued,

				le32_to_cpu(info->time_warp_seq),

				&ctime, &mtime, &atime);
@@ -872,7 +869,7 @@ static int fill_inode(struct inode *inode, struct page *locked_page, 
			ci->i_rbytes = le64_to_cpu(info->rbytes);

			ci->i_rfiles = le64_to_cpu(info->rfiles);

			ci->i_rsubdirs = le64_to_cpu(info->rsubdirs);

			ceph_decode_timespec(&ci->i_rctime, &info->rctime);

			ceph_decode_timespec64(&ci->i_rctime, &info->rctime);

		}

	}
@@ -1954,7 +1951,6 @@ int __ceph_setattr(struct inode *inode, struct iattr *attr) 
	int err = 0;

	int inode_dirty_flags = 0;

	bool lock_snap_rwsem = false;

	struct timespec ts;



	prealloc_cf = ceph_alloc_cap_flush();

	if (!prealloc_cf)
@@ -2030,8 +2026,8 @@ int __ceph_setattr(struct inode *inode, struct iattr *attr) 


	if (ia_valid & ATTR_ATIME) {

		dout("setattr %p atime %lld.%ld -> %lld.%ld\n", inode,

		     (long long)inode->i_atime.tv_sec, inode->i_atime.tv_nsec,

		     (long long)attr->ia_atime.tv_sec, attr->ia_atime.tv_nsec);

		     inode->i_atime.tv_sec, inode->i_atime.tv_nsec,

		     attr->ia_atime.tv_sec, attr->ia_atime.tv_nsec);

		if (issued & CEPH_CAP_FILE_EXCL) {

			ci->i_time_warp_seq++;

			inode->i_atime = attr->ia_atime;
@@ -2043,8 +2039,8 @@ int __ceph_setattr(struct inode *inode, struct iattr *attr) 
			dirtied |= CEPH_CAP_FILE_WR;

		} else if ((issued & CEPH_CAP_FILE_SHARED) == 0 ||

			   !timespec64_equal(&inode->i_atime, &attr->ia_atime)) {

			ts = timespec64_to_timespec(attr->ia_atime);

			ceph_encode_timespec(&req->r_args.setattr.atime, &ts);

			ceph_encode_timespec64(&req->r_args.setattr.atime,

					       &attr->ia_atime);

			mask |= CEPH_SETATTR_ATIME;

			release |= CEPH_CAP_FILE_SHARED |

				   CEPH_CAP_FILE_RD | CEPH_CAP_FILE_WR;
@@ -2052,8 +2048,8 @@ int __ceph_setattr(struct inode *inode, struct iattr *attr) 
	}

	if (ia_valid & ATTR_MTIME) {

		dout("setattr %p mtime %lld.%ld -> %lld.%ld\n", inode,

		     (long long)inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec,

		     (long long)attr->ia_mtime.tv_sec, attr->ia_mtime.tv_nsec);

		     inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec,

		     attr->ia_mtime.tv_sec, attr->ia_mtime.tv_nsec);

		if (issued & CEPH_CAP_FILE_EXCL) {

			ci->i_time_warp_seq++;

			inode->i_mtime = attr->ia_mtime;
@@ -2065,8 +2061,8 @@ int __ceph_setattr(struct inode *inode, struct iattr *attr) 
			dirtied |= CEPH_CAP_FILE_WR;

		} else if ((issued & CEPH_CAP_FILE_SHARED) == 0 ||

			   !timespec64_equal(&inode->i_mtime, &attr->ia_mtime)) {

			ts = timespec64_to_timespec(attr->ia_mtime);

			ceph_encode_timespec(&req->r_args.setattr.mtime, &ts);

			ceph_encode_timespec64(&req->r_args.setattr.mtime,

					       &attr->ia_mtime);

			mask |= CEPH_SETATTR_MTIME;

			release |= CEPH_CAP_FILE_SHARED |

				   CEPH_CAP_FILE_RD | CEPH_CAP_FILE_WR;
@@ -2097,8 +2093,8 @@ int __ceph_setattr(struct inode *inode, struct iattr *attr) 
		bool only = (ia_valid & (ATTR_SIZE|ATTR_MTIME|ATTR_ATIME|

					 ATTR_MODE|ATTR_UID|ATTR_GID)) == 0;

		dout("setattr %p ctime %lld.%ld -> %lld.%ld (%s)\n", inode,

		     (long long)inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec,

		     (long long)attr->ia_ctime.tv_sec, attr->ia_ctime.tv_nsec,

		     inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec,

		     attr->ia_ctime.tv_sec, attr->ia_ctime.tv_nsec,

		     only ? "ctime only" : "ignored");

		if (only) {

			/*

fs/ceph/mds_client.c

+2 −5
Original line number Diff line number Diff line
@@ -2961,15 +2961,12 @@ static int encode_caps_cb(struct inode *inode, struct ceph_cap *cap, 
		rec.v2.flock_len = (__force __le32)

			((ci->i_ceph_flags & CEPH_I_ERROR_FILELOCK) ? 0 : 1);

	} else {

		struct timespec ts;

		rec.v1.cap_id = cpu_to_le64(cap->cap_id);

		rec.v1.wanted = cpu_to_le32(__ceph_caps_wanted(ci));

		rec.v1.issued = cpu_to_le32(cap->issued);

		rec.v1.size = cpu_to_le64(inode->i_size);

		ts = timespec64_to_timespec(inode->i_mtime);

		ceph_encode_timespec(&rec.v1.mtime, &ts);

		ts = timespec64_to_timespec(inode->i_atime);

		ceph_encode_timespec(&rec.v1.atime, &ts);

		ceph_encode_timespec64(&rec.v1.mtime, &inode->i_mtime);

		ceph_encode_timespec64(&rec.v1.atime, &inode->i_atime);

		rec.v1.snaprealm = cpu_to_le64(ci->i_snap_realm->ino);

		rec.v1.pathbase = cpu_to_le64(pathbase);

	}

CRA Git | Maintained and supported by SUSTech CRA and CCSE