From mboxrd@z Thu Jan 1 00:00:00 1970 From: Al Viro Subject: Re: [PATCH] utimes: Clamp the timestamps in notify_change() Date: Sun, 24 Nov 2019 21:34:15 +0000 Message-ID: <20191124213415.GD4203@ZenIV.linux.org.uk> References: <20191124193145.22945-1-amir73il@gmail.com> <20191124194934.GB4203@ZenIV.linux.org.uk> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: y2038-bounces@lists.linaro.org Sender: "Y2038" To: Deepa Dinamani Cc: Linux NFS Mailing List , Arnd Bergmann , Miklos Szeredi , y2038 Mailman List , Amir Goldstein , Jeff Layton , overlayfs , "J . Bruce Fields" , Linux FS-devel Mailing List List-Id: linux-unionfs@vger.kernel.org T24gU3VuLCBOb3YgMjQsIDIwMTkgYXQgMDE6MTM6NTBQTSAtMDgwMCwgRGVlcGEgRGluYW1hbmkg d3JvdGU6Cgo+IFdlIGFsc28gd2FudCB0byByZXBsYWNlIGFsbCB1c2VzIG9mIHRpbWVzcGVjNjRf dHJ1bmMoKSB3aXRoCj4gdGltZXN0YW1wX3RydW5jYXRlKCkgZm9yIGFsbCBmcyBjYXNlcy4KPiAK PiBJbiB0aGF0IGNhc2Ugd2UgaGF2ZSBhIGZldyBtb3JlOgo+IAo+IGZzL2NlcGgvbWRzX2NsaWVu dC5jOiAgIHJlcS0+cl9zdGFtcCA9IHRpbWVzcGVjNjRfdHJ1bmModHMsCj4gbWRzYy0+ZnNjLT5z Yi0+c190aW1lX2dyYW4pOwoKVW1tLi4uIFRoYXQgY29tZXMgZnJvbSBrdGltZV9nZXRfY29hcnNl X3JlYWxfdHM2NCgmdHMpOwoKPiBmcy9jaWZzL2lub2RlLmM6ICAgICAgICBmYXR0ci0+Y2ZfbXRp bWUgPQo+IHRpbWVzcGVjNjRfdHJ1bmMoZmF0dHItPmNmX210aW1lLCBzYi0+c190aW1lX2dyYW4p OwprdGltZV9nZXRfcmVhbF90czY0KCZmYXR0ci0+Y2ZfbXRpbWUpIGhlcmUKCj4gZnMvY2lmcy9p bm9kZS5jOiAgICAgICAgICAgICAgICBmYXR0ci0+Y2ZfYXRpbWUgPQo+IHRpbWVzcGVjNjRfdHJ1 bmMoZmF0dHItPmNmX2F0aW1lLCBzYi0+c190aW1lX2dyYW4pOwpkaXR0bwoKPiBmcy9mYXQvbWlz Yy5jOiAgICAgICAgICAgICAgICAgIGlub2RlLT5pX2N0aW1lID0KPiB0aW1lc3BlYzY0X3RydW5j KCpub3csIDEwMDAwMDAwKTsKCkkgd29uZGVyLi4uIHNvbWUgYXJlIGZyb20gc2V0YXR0ciwgc29t ZSAod2l0aCBOVUxMIHBhc3NlZCB0byBmYXRfdHJ1bmNhdGVfdGltZSgpKQpmcm9tIGN1cnJlbnRf dGltZSgpLi4uICBXb3VsZG4ndCBpdCBtYWtlIG1vcmUgc2Vuc2UgdG8gbW92ZSB0aGUgdHJ1bmNh dGlvbiBpbnRvCnRoZSBmZXcgY2FsbGVycyB0aGF0IHJlYWxseSBuZWVkIGl0IChpZiBhbnkpPyAg UXVpdGUgYSBmZXcgb2YgdGhvc2UgYXJlICphbHNvKgpnZXR0aW5nIHRoZSB2YWx1ZSBmcm9tIGN1 cnJlbnRfdGltZSgpLCBhZnRlciBhbGwuICBmYXRfZmlsbF9pbm9kZSgpIGxvb2tzIGxpa2UKdGhl IG9ubHkgY2FzZSB0aGF0IGRvZXNuJ3QgZmFsbCBpbnRvIHRoZXNlIGNsYXNzZXM7IGRvZXMgaXQg bmVlZCB0cnVuY2F0aW9uPwoKQlRXLCBjb3VsZCB3ZSAqcGxlYXNlKiBkbyBzb21ldGhpbmcgYWJv dXQgZnMvaW5vZGUuYzp1cGRhdGVfdGltZSgpPyAgSSBtZWFuLApzdXJlLCBsb2NhbCB2YXJpYWJs ZSBzaGFkb3dzIGZpbGUtc2NvcGUgZnVuY3Rpb24sIHNvIGl0J3MgbGVnaXRpbWF0ZSBDLCBidXQK dGhpcyBpcyBub3QgSU9DQ0MgYW5kIGhhdmluZyBhIGZ1bmN0aW9uIGNhbGxlZCAndXBkYXRlX3Rp bWUnIGVuZCB3aXRoCiAgICAgICAgcmV0dXJuIHVwZGF0ZV90aW1lKGlub2RlLCB0aW1lLCBmbGFn cyk7CmlzIGFjdGl2ZWx5IGhvc3RpbGUgdG93YXJkcyBjYXN1YWwgcmVhZGVycy4uLgoKPiBmcy9m YXQvbWlzYy5jOiAgICAgICAgICAgICAgICAgIGlub2RlLT5pX2N0aW1lID0KPiBmYXRfdGltZXNw ZWM2NF90cnVuY18yc2Vjcygqbm93KTsKPiBmcy9mYXQvbWlzYy5jOiAgICAgICAgICBpbm9kZS0+ aV9tdGltZSA9IGZhdF90aW1lc3BlYzY0X3RydW5jXzJzZWNzKCpub3cpOwo+IGZzL3ViaWZzL3Ni LmM6ICB0cyA9IHRpbWVzcGVjNjRfdHJ1bmModHMsIERFRkFVTFRfVElNRV9HUkFOKTsKPiAKPiBU aGVzZSBkbyBub3QgZm9sbG93IGZyb20gbm90aWZ5X2NoYW5nZSgpLCBzbyB0aGVzZSBtaWdodCBz dGlsbCBuZWVkCj4gdGltZXN0YW1wX3RydW5jYXRlKCkgZXhwb3J0ZWQuCj4gSSB3aWxsIHBvc3Qg YSBjbGVhbnVwIHNlcmllcyBmb3IgdGltZXNwZWM2NF90cnVuYygpIGFsc28sIHRoZW4gd2UgY2Fu IGRlY2lkZS4KCldoYXQgSSd2ZSBnb3QgcmlnaHQgbm93IGlzCgpjb21taXQgNmQxMzQxMmUyYjI3 OTcwODEwMDM3ZjdiMWI0MThmZWJjZDcwMTNhYQpBdXRob3I6IEFtaXIgR29sZHN0ZWluIDxhbWly NzNpbEBnbWFpbC5jb20+CkRhdGU6ICAgU3VuIE5vdiAyNCAyMTozMTo0NSAyMDE5ICswMjAwCgog ICAgdXRpbWVzOiBDbGFtcCB0aGUgdGltZXN0YW1wcyBpbiBub3RpZnlfY2hhbmdlKCkKICAgIAog ICAgUHVzaCBjbGFtcGluZyB0aW1lc3RhbXBzIGludG8gbm90aWZ5X2NoYW5nZSgpLCBzbyBpbi1r ZXJuZWwKICAgIGNhbGxlcnMgbGlrZSBuZnNkIGFuZCBvdmVybGF5ZnMgd2lsbCBnZXQgc2ltaWxh ciB0aW1lc3RhbXAKICAgIHNldCBiZWhhdmlvciBhcyB1dGltZXMuCiAgICAKICAgIEFWOiBnZXQg cmlkIG9mIGNsYW1waW5nIGluIC0+c2V0YXR0cigpIGluc3RhbmNlczsgd2UgZG9uJ3QgbmVlZAog ICAgdG8gYm90aGVyIHdpdGggdGhhdCB0aGVyZSwgd2l0aCBub3RpZnlfY2hhbmdlKCkgZG9pbmcg bm9ybWFsaXphdGlvbgogICAgaW4gYWxsIGNhc2VzIG5vdyAoaXQgYWxyZWFkeSBkaWQgZm9yIGlt cGxpY2l0IGNhc2UsIHNpbmNlIGN1cnJlbnRfdGltZSgpCiAgICBjbGFtcHMpLgogICAgCiAgICBT dWdnZXN0ZWQtYnk6IE1pa2xvcyBTemVyZWRpIDxtc3plcmVkaUByZWRoYXQuY29tPgogICAgRml4 ZXM6IDQyZTcyOWI5ZGRiYiAoInV0aW1lczogQ2xhbXAgdGhlIHRpbWVzdGFtcHMgYmVmb3JlIHVw ZGF0ZSIpCiAgICBDYzogc3RhYmxlQHZnZXIua2VybmVsLm9yZyAjIHY1LjQKICAgIENjOiBEZWVw YSBEaW5hbWFuaSA8ZGVlcGEua2VybmVsQGdtYWlsLmNvbT4KICAgIENjOiBKZWZmIExheXRvbiA8 amxheXRvbkBrZXJuZWwub3JnPgogICAgU2lnbmVkLW9mZi1ieTogQW1pciBHb2xkc3RlaW4gPGFt aXI3M2lsQGdtYWlsLmNvbT4KICAgIFNpZ25lZC1vZmYtYnk6IEFsIFZpcm8gPHZpcm9AemVuaXYu bGludXgub3JnLnVrPgoKZGlmZiAtLWdpdCBhL2ZzL2F0dHIuYyBiL2ZzL2F0dHIuYwppbmRleCBk ZjI4MDM1YWEyM2UuLmI0YmJkYmQ0YzhjYSAxMDA2NDQKLS0tIGEvZnMvYXR0ci5jCisrKyBiL2Zz L2F0dHIuYwpAQCAtMTgzLDE4ICsxODMsMTIgQEAgdm9pZCBzZXRhdHRyX2NvcHkoc3RydWN0IGlu b2RlICppbm9kZSwgY29uc3Qgc3RydWN0IGlhdHRyICphdHRyKQogCQlpbm9kZS0+aV91aWQgPSBh dHRyLT5pYV91aWQ7CiAJaWYgKGlhX3ZhbGlkICYgQVRUUl9HSUQpCiAJCWlub2RlLT5pX2dpZCA9 IGF0dHItPmlhX2dpZDsKLQlpZiAoaWFfdmFsaWQgJiBBVFRSX0FUSU1FKSB7Ci0JCWlub2RlLT5p X2F0aW1lID0gdGltZXN0YW1wX3RydW5jYXRlKGF0dHItPmlhX2F0aW1lLAotCQkJCQkJICBpbm9k ZSk7Ci0JfQotCWlmIChpYV92YWxpZCAmIEFUVFJfTVRJTUUpIHsKLQkJaW5vZGUtPmlfbXRpbWUg PSB0aW1lc3RhbXBfdHJ1bmNhdGUoYXR0ci0+aWFfbXRpbWUsCi0JCQkJCQkgIGlub2RlKTsKLQl9 Ci0JaWYgKGlhX3ZhbGlkICYgQVRUUl9DVElNRSkgewotCQlpbm9kZS0+aV9jdGltZSA9IHRpbWVz dGFtcF90cnVuY2F0ZShhdHRyLT5pYV9jdGltZSwKLQkJCQkJCSAgaW5vZGUpOwotCX0KKwlpZiAo aWFfdmFsaWQgJiBBVFRSX0FUSU1FKQorCQlpbm9kZS0+aV9hdGltZSA9IGF0dHItPmlhX2F0aW1l OworCWlmIChpYV92YWxpZCAmIEFUVFJfTVRJTUUpCisJCWlub2RlLT5pX210aW1lID0gYXR0ci0+ aWFfbXRpbWU7CisJaWYgKGlhX3ZhbGlkICYgQVRUUl9DVElNRSkKKwkJaW5vZGUtPmlfY3RpbWUg PSBhdHRyLT5pYV9jdGltZTsKIAlpZiAoaWFfdmFsaWQgJiBBVFRSX01PREUpIHsKIAkJdW1vZGVf dCBtb2RlID0gYXR0ci0+aWFfbW9kZTsKIApAQCAtMjY4LDggKzI2MiwxMyBAQCBpbnQgbm90aWZ5 X2NoYW5nZShzdHJ1Y3QgZGVudHJ5ICogZGVudHJ5LCBzdHJ1Y3QgaWF0dHIgKiBhdHRyLCBzdHJ1 Y3QgaW5vZGUgKipkZQogCWF0dHItPmlhX2N0aW1lID0gbm93OwogCWlmICghKGlhX3ZhbGlkICYg QVRUUl9BVElNRV9TRVQpKQogCQlhdHRyLT5pYV9hdGltZSA9IG5vdzsKKwllbHNlCisJCWF0dHIt PmlhX2F0aW1lID0gdGltZXN0YW1wX3RydW5jYXRlKGF0dHItPmlhX2F0aW1lLCBpbm9kZSk7CiAJ aWYgKCEoaWFfdmFsaWQgJiBBVFRSX01USU1FX1NFVCkpCiAJCWF0dHItPmlhX210aW1lID0gbm93 OworCWVsc2UKKwkJYXR0ci0+aWFfbXRpbWUgPSB0aW1lc3RhbXBfdHJ1bmNhdGUoYXR0ci0+aWFf bXRpbWUsIGlub2RlKTsKKwogCWlmIChpYV92YWxpZCAmIEFUVFJfS0lMTF9QUklWKSB7CiAJCWVy cm9yID0gc2VjdXJpdHlfaW5vZGVfbmVlZF9raWxscHJpdihkZW50cnkpOwogCQlpZiAoZXJyb3Ig PCAwKQpkaWZmIC0tZ2l0IGEvZnMvY29uZmlnZnMvaW5vZGUuYyBiL2ZzL2NvbmZpZ2ZzL2lub2Rl LmMKaW5kZXggNjgwYWJhOWMwMGQ1Li5mZDBiNWRkNjhmOWUgMTAwNjQ0Ci0tLSBhL2ZzL2NvbmZp Z2ZzL2lub2RlLmMKKysrIGIvZnMvY29uZmlnZnMvaW5vZGUuYwpAQCAtNzYsMTQgKzc2LDExIEBA IGludCBjb25maWdmc19zZXRhdHRyKHN0cnVjdCBkZW50cnkgKiBkZW50cnksIHN0cnVjdCBpYXR0 ciAqIGlhdHRyKQogCWlmIChpYV92YWxpZCAmIEFUVFJfR0lEKQogCQlzZF9pYXR0ci0+aWFfZ2lk ID0gaWF0dHItPmlhX2dpZDsKIAlpZiAoaWFfdmFsaWQgJiBBVFRSX0FUSU1FKQotCQlzZF9pYXR0 ci0+aWFfYXRpbWUgPSB0aW1lc3RhbXBfdHJ1bmNhdGUoaWF0dHItPmlhX2F0aW1lLAotCQkJCQkJ ICAgICAgaW5vZGUpOworCQlzZF9pYXR0ci0+aWFfYXRpbWUgPSBpYXR0ci0+aWFfYXRpbWU7CiAJ aWYgKGlhX3ZhbGlkICYgQVRUUl9NVElNRSkKLQkJc2RfaWF0dHItPmlhX210aW1lID0gdGltZXN0 YW1wX3RydW5jYXRlKGlhdHRyLT5pYV9tdGltZSwKLQkJCQkJCSAgICAgIGlub2RlKTsKKwkJc2Rf aWF0dHItPmlhX210aW1lID0gaWF0dHItPmlhX210aW1lOwogCWlmIChpYV92YWxpZCAmIEFUVFJf Q1RJTUUpCi0JCXNkX2lhdHRyLT5pYV9jdGltZSA9IHRpbWVzdGFtcF90cnVuY2F0ZShpYXR0ci0+ aWFfY3RpbWUsCi0JCQkJCQkgICAgICBpbm9kZSk7CisJCXNkX2lhdHRyLT5pYV9jdGltZSA9IGlh dHRyLT5pYV9jdGltZTsKIAlpZiAoaWFfdmFsaWQgJiBBVFRSX01PREUpIHsKIAkJdW1vZGVfdCBt b2RlID0gaWF0dHItPmlhX21vZGU7CiAKZGlmZiAtLWdpdCBhL2ZzL2YyZnMvZmlsZS5jIGIvZnMv ZjJmcy9maWxlLmMKaW5kZXggMjliYzBhNTQyNzU5Li5hMjg2NTY0YmEyZTEgMTAwNjQ0Ci0tLSBh L2ZzL2YyZnMvZmlsZS5jCisrKyBiL2ZzL2YyZnMvZmlsZS5jCkBAIC03NTEsMTggKzc1MSwxMiBA QCBzdGF0aWMgdm9pZCBfX3NldGF0dHJfY29weShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBjb25zdCBz dHJ1Y3QgaWF0dHIgKmF0dHIpCiAJCWlub2RlLT5pX3VpZCA9IGF0dHItPmlhX3VpZDsKIAlpZiAo aWFfdmFsaWQgJiBBVFRSX0dJRCkKIAkJaW5vZGUtPmlfZ2lkID0gYXR0ci0+aWFfZ2lkOwotCWlm IChpYV92YWxpZCAmIEFUVFJfQVRJTUUpIHsKLQkJaW5vZGUtPmlfYXRpbWUgPSB0aW1lc3RhbXBf dHJ1bmNhdGUoYXR0ci0+aWFfYXRpbWUsCi0JCQkJCQkgIGlub2RlKTsKLQl9Ci0JaWYgKGlhX3Zh bGlkICYgQVRUUl9NVElNRSkgewotCQlpbm9kZS0+aV9tdGltZSA9IHRpbWVzdGFtcF90cnVuY2F0 ZShhdHRyLT5pYV9tdGltZSwKLQkJCQkJCSAgaW5vZGUpOwotCX0KLQlpZiAoaWFfdmFsaWQgJiBB VFRSX0NUSU1FKSB7Ci0JCWlub2RlLT5pX2N0aW1lID0gdGltZXN0YW1wX3RydW5jYXRlKGF0dHIt PmlhX2N0aW1lLAotCQkJCQkJICBpbm9kZSk7Ci0JfQorCWlmIChpYV92YWxpZCAmIEFUVFJfQVRJ TUUpCisJCWlub2RlLT5pX2F0aW1lID0gYXR0ci0+aWFfYXRpbWU7CisJaWYgKGlhX3ZhbGlkICYg QVRUUl9NVElNRSkKKwkJaW5vZGUtPmlfbXRpbWUgPSBhdHRyLT5pYV9tdGltZTsKKwlpZiAoaWFf dmFsaWQgJiBBVFRSX0NUSU1FKQorCQlpbm9kZS0+aV9jdGltZSA9IGF0dHItPmlhX2N0aW1lOwog CWlmIChpYV92YWxpZCAmIEFUVFJfTU9ERSkgewogCQl1bW9kZV90IG1vZGUgPSBhdHRyLT5pYV9t b2RlOwogCmRpZmYgLS1naXQgYS9mcy9udGZzL2lub2RlLmMgYi9mcy9udGZzL2lub2RlLmMKaW5k ZXggNmM3Mzg4NDMwYWQzLi5kNDM1OWExZGYzZDUgMTAwNjQ0Ci0tLSBhL2ZzL250ZnMvaW5vZGUu YworKysgYi9mcy9udGZzL2lub2RlLmMKQEAgLTI4OTksMTggKzI4OTksMTIgQEAgaW50IG50ZnNf c2V0YXR0cihzdHJ1Y3QgZGVudHJ5ICpkZW50cnksIHN0cnVjdCBpYXR0ciAqYXR0cikKIAkJCWlh X3ZhbGlkIHw9IEFUVFJfTVRJTUUgfCBBVFRSX0NUSU1FOwogCQl9CiAJfQotCWlmIChpYV92YWxp ZCAmIEFUVFJfQVRJTUUpIHsKLQkJdmktPmlfYXRpbWUgPSB0aW1lc3RhbXBfdHJ1bmNhdGUoYXR0 ci0+aWFfYXRpbWUsCi0JCQkJCSAgICAgICB2aSk7Ci0JfQotCWlmIChpYV92YWxpZCAmIEFUVFJf TVRJTUUpIHsKLQkJdmktPmlfbXRpbWUgPSB0aW1lc3RhbXBfdHJ1bmNhdGUoYXR0ci0+aWFfbXRp bWUsCi0JCQkJCSAgICAgICB2aSk7Ci0JfQotCWlmIChpYV92YWxpZCAmIEFUVFJfQ1RJTUUpIHsK LQkJdmktPmlfY3RpbWUgPSB0aW1lc3RhbXBfdHJ1bmNhdGUoYXR0ci0+aWFfY3RpbWUsCi0JCQkJ CSAgICAgICB2aSk7Ci0JfQorCWlmIChpYV92YWxpZCAmIEFUVFJfQVRJTUUpCisJCXZpLT5pX2F0 aW1lID0gYXR0ci0+aWFfYXRpbWU7CisJaWYgKGlhX3ZhbGlkICYgQVRUUl9NVElNRSkKKwkJdmkt PmlfbXRpbWUgPSBhdHRyLT5pYV9tdGltZTsKKwlpZiAoaWFfdmFsaWQgJiBBVFRSX0NUSU1FKQor CQl2aS0+aV9jdGltZSA9IGF0dHItPmlhX2N0aW1lOwogCW1hcmtfaW5vZGVfZGlydHkodmkpOwog b3V0OgogCXJldHVybiBlcnI7CmRpZmYgLS1naXQgYS9mcy91Ymlmcy9maWxlLmMgYi9mcy91Ymlm cy9maWxlLmMKaW5kZXggY2Q1MjU4NWM4ZjRmLi45MTM2MjA3OWY4MmEgMTAwNjQ0Ci0tLSBhL2Zz L3ViaWZzL2ZpbGUuYworKysgYi9mcy91Ymlmcy9maWxlLmMKQEAgLTEwNzgsMTggKzEwNzgsMTIg QEAgc3RhdGljIHZvaWQgZG9fYXR0cl9jaGFuZ2VzKHN0cnVjdCBpbm9kZSAqaW5vZGUsIGNvbnN0 IHN0cnVjdCBpYXR0ciAqYXR0cikKIAkJaW5vZGUtPmlfdWlkID0gYXR0ci0+aWFfdWlkOwogCWlm IChhdHRyLT5pYV92YWxpZCAmIEFUVFJfR0lEKQogCQlpbm9kZS0+aV9naWQgPSBhdHRyLT5pYV9n aWQ7Ci0JaWYgKGF0dHItPmlhX3ZhbGlkICYgQVRUUl9BVElNRSkgewotCQlpbm9kZS0+aV9hdGlt ZSA9IHRpbWVzdGFtcF90cnVuY2F0ZShhdHRyLT5pYV9hdGltZSwKLQkJCQkJCSAgaW5vZGUpOwot CX0KLQlpZiAoYXR0ci0+aWFfdmFsaWQgJiBBVFRSX01USU1FKSB7Ci0JCWlub2RlLT5pX210aW1l ID0gdGltZXN0YW1wX3RydW5jYXRlKGF0dHItPmlhX210aW1lLAotCQkJCQkJICBpbm9kZSk7Ci0J fQotCWlmIChhdHRyLT5pYV92YWxpZCAmIEFUVFJfQ1RJTUUpIHsKLQkJaW5vZGUtPmlfY3RpbWUg PSB0aW1lc3RhbXBfdHJ1bmNhdGUoYXR0ci0+aWFfY3RpbWUsCi0JCQkJCQkgIGlub2RlKTsKLQl9 CisJaWYgKGF0dHItPmlhX3ZhbGlkICYgQVRUUl9BVElNRSkKKwkJaW5vZGUtPmlfYXRpbWUgPSBh dHRyLT5pYV9hdGltZTsKKwlpZiAoYXR0ci0+aWFfdmFsaWQgJiBBVFRSX01USU1FKQorCQlpbm9k ZS0+aV9tdGltZSA9IGF0dHItPmlhX210aW1lOworCWlmIChhdHRyLT5pYV92YWxpZCAmIEFUVFJf Q1RJTUUpCisJCWlub2RlLT5pX2N0aW1lID0gYXR0ci0+aWFfY3RpbWU7CiAJaWYgKGF0dHItPmlh X3ZhbGlkICYgQVRUUl9NT0RFKSB7CiAJCXVtb2RlX3QgbW9kZSA9IGF0dHItPmlhX21vZGU7CiAK ZGlmZiAtLWdpdCBhL2ZzL3V0aW1lcy5jIGIvZnMvdXRpbWVzLmMKaW5kZXggMWJhM2Y3ODgzODcw Li4wOTA3MzkzMjI0NjMgMTAwNjQ0Ci0tLSBhL2ZzL3V0aW1lcy5jCisrKyBiL2ZzL3V0aW1lcy5j CkBAIC0zNiwxNCArMzYsMTQgQEAgc3RhdGljIGludCB1dGltZXNfY29tbW9uKGNvbnN0IHN0cnVj dCBwYXRoICpwYXRoLCBzdHJ1Y3QgdGltZXNwZWM2NCAqdGltZXMpCiAJCWlmICh0aW1lc1swXS50 dl9uc2VjID09IFVUSU1FX09NSVQpCiAJCQluZXdhdHRycy5pYV92YWxpZCAmPSB+QVRUUl9BVElN RTsKIAkJZWxzZSBpZiAodGltZXNbMF0udHZfbnNlYyAhPSBVVElNRV9OT1cpIHsKLQkJCW5ld2F0 dHJzLmlhX2F0aW1lID0gdGltZXN0YW1wX3RydW5jYXRlKHRpbWVzWzBdLCBpbm9kZSk7CisJCQlu ZXdhdHRycy5pYV9hdGltZSA9IHRpbWVzWzBdOwogCQkJbmV3YXR0cnMuaWFfdmFsaWQgfD0gQVRU Ul9BVElNRV9TRVQ7CiAJCX0KIAogCQlpZiAodGltZXNbMV0udHZfbnNlYyA9PSBVVElNRV9PTUlU KQogCQkJbmV3YXR0cnMuaWFfdmFsaWQgJj0gfkFUVFJfTVRJTUU7CiAJCWVsc2UgaWYgKHRpbWVz WzFdLnR2X25zZWMgIT0gVVRJTUVfTk9XKSB7Ci0JCQluZXdhdHRycy5pYV9tdGltZSA9IHRpbWVz dGFtcF90cnVuY2F0ZSh0aW1lc1sxXSwgaW5vZGUpOworCQkJbmV3YXR0cnMuaWFfbXRpbWUgPSB0 aW1lc1sxXTsKIAkJCW5ld2F0dHJzLmlhX3ZhbGlkIHw9IEFUVFJfTVRJTUVfU0VUOwogCQl9CiAJ CS8qCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClkyMDM4 IG1haWxpbmcgbGlzdApZMjAzOEBsaXN0cy5saW5hcm8ub3JnCmh0dHBzOi8vbGlzdHMubGluYXJv Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL3kyMDM4Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.2 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7C9C7C43215 for ; Sun, 24 Nov 2019 21:34:22 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 5E1D02075E for ; Sun, 24 Nov 2019 21:34:22 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726907AbfKXVeV (ORCPT ); Sun, 24 Nov 2019 16:34:21 -0500 Received: from zeniv.linux.org.uk ([195.92.253.2]:52718 "EHLO ZenIV.linux.org.uk" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726840AbfKXVeV (ORCPT ); Sun, 24 Nov 2019 16:34:21 -0500 Received: from viro by ZenIV.linux.org.uk with local (Exim 4.92.3 #3 (Red Hat Linux)) id 1iYzWJ-0007zX-VF; Sun, 24 Nov 2019 21:34:16 +0000 Date: Sun, 24 Nov 2019 21:34:15 +0000 From: Al Viro To: Deepa Dinamani Cc: Amir Goldstein , Arnd Bergmann , Jeff Layton , "J . Bruce Fields" , Miklos Szeredi , Linux FS-devel Mailing List , overlayfs , Linux NFS Mailing List , y2038 Mailman List Subject: Re: [PATCH] utimes: Clamp the timestamps in notify_change() Message-ID: <20191124213415.GD4203@ZenIV.linux.org.uk> References: <20191124193145.22945-1-amir73il@gmail.com> <20191124194934.GB4203@ZenIV.linux.org.uk> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: User-Agent: Mutt/1.12.1 (2019-06-15) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org On Sun, Nov 24, 2019 at 01:13:50PM -0800, Deepa Dinamani wrote: > We also want to replace all uses of timespec64_trunc() with > timestamp_truncate() for all fs cases. > > In that case we have a few more: > > fs/ceph/mds_client.c: req->r_stamp = timespec64_trunc(ts, > mdsc->fsc->sb->s_time_gran); Umm... That comes from ktime_get_coarse_real_ts64(&ts); > fs/cifs/inode.c: fattr->cf_mtime = > timespec64_trunc(fattr->cf_mtime, sb->s_time_gran); ktime_get_real_ts64(&fattr->cf_mtime) here > fs/cifs/inode.c: fattr->cf_atime = > timespec64_trunc(fattr->cf_atime, sb->s_time_gran); ditto > fs/fat/misc.c: inode->i_ctime = > timespec64_trunc(*now, 10000000); I wonder... some are from setattr, some (with NULL passed to fat_truncate_time()) from current_time()... Wouldn't it make more sense to move the truncation into the few callers that really need it (if any)? Quite a few of those are *also* getting the value from current_time(), after all. fat_fill_inode() looks like the only case that doesn't fall into these classes; does it need truncation? BTW, could we *please* do something about fs/inode.c:update_time()? I mean, sure, local variable shadows file-scope function, so it's legitimate C, but this is not IOCCC and having a function called 'update_time' end with return update_time(inode, time, flags); is actively hostile towards casual readers... > fs/fat/misc.c: inode->i_ctime = > fat_timespec64_trunc_2secs(*now); > fs/fat/misc.c: inode->i_mtime = fat_timespec64_trunc_2secs(*now); > fs/ubifs/sb.c: ts = timespec64_trunc(ts, DEFAULT_TIME_GRAN); > > These do not follow from notify_change(), so these might still need > timestamp_truncate() exported. > I will post a cleanup series for timespec64_trunc() also, then we can decide. What I've got right now is commit 6d13412e2b27970810037f7b1b418febcd7013aa Author: Amir Goldstein Date: Sun Nov 24 21:31:45 2019 +0200 utimes: Clamp the timestamps in notify_change() Push clamping timestamps into notify_change(), so in-kernel callers like nfsd and overlayfs will get similar timestamp set behavior as utimes. AV: get rid of clamping in ->setattr() instances; we don't need to bother with that there, with notify_change() doing normalization in all cases now (it already did for implicit case, since current_time() clamps). Suggested-by: Miklos Szeredi Fixes: 42e729b9ddbb ("utimes: Clamp the timestamps before update") Cc: stable@vger.kernel.org # v5.4 Cc: Deepa Dinamani Cc: Jeff Layton Signed-off-by: Amir Goldstein Signed-off-by: Al Viro diff --git a/fs/attr.c b/fs/attr.c index df28035aa23e..b4bbdbd4c8ca 100644 --- a/fs/attr.c +++ b/fs/attr.c @@ -183,18 +183,12 @@ void setattr_copy(struct inode *inode, const struct iattr *attr) inode->i_uid = attr->ia_uid; if (ia_valid & ATTR_GID) inode->i_gid = attr->ia_gid; - if (ia_valid & ATTR_ATIME) { - inode->i_atime = timestamp_truncate(attr->ia_atime, - inode); - } - if (ia_valid & ATTR_MTIME) { - inode->i_mtime = timestamp_truncate(attr->ia_mtime, - inode); - } - if (ia_valid & ATTR_CTIME) { - inode->i_ctime = timestamp_truncate(attr->ia_ctime, - inode); - } + if (ia_valid & ATTR_ATIME) + inode->i_atime = attr->ia_atime; + if (ia_valid & ATTR_MTIME) + inode->i_mtime = attr->ia_mtime; + if (ia_valid & ATTR_CTIME) + inode->i_ctime = attr->ia_ctime; if (ia_valid & ATTR_MODE) { umode_t mode = attr->ia_mode; @@ -268,8 +262,13 @@ int notify_change(struct dentry * dentry, struct iattr * attr, struct inode **de attr->ia_ctime = now; if (!(ia_valid & ATTR_ATIME_SET)) attr->ia_atime = now; + else + attr->ia_atime = timestamp_truncate(attr->ia_atime, inode); if (!(ia_valid & ATTR_MTIME_SET)) attr->ia_mtime = now; + else + attr->ia_mtime = timestamp_truncate(attr->ia_mtime, inode); + if (ia_valid & ATTR_KILL_PRIV) { error = security_inode_need_killpriv(dentry); if (error < 0) diff --git a/fs/configfs/inode.c b/fs/configfs/inode.c index 680aba9c00d5..fd0b5dd68f9e 100644 --- a/fs/configfs/inode.c +++ b/fs/configfs/inode.c @@ -76,14 +76,11 @@ int configfs_setattr(struct dentry * dentry, struct iattr * iattr) if (ia_valid & ATTR_GID) sd_iattr->ia_gid = iattr->ia_gid; if (ia_valid & ATTR_ATIME) - sd_iattr->ia_atime = timestamp_truncate(iattr->ia_atime, - inode); + sd_iattr->ia_atime = iattr->ia_atime; if (ia_valid & ATTR_MTIME) - sd_iattr->ia_mtime = timestamp_truncate(iattr->ia_mtime, - inode); + sd_iattr->ia_mtime = iattr->ia_mtime; if (ia_valid & ATTR_CTIME) - sd_iattr->ia_ctime = timestamp_truncate(iattr->ia_ctime, - inode); + sd_iattr->ia_ctime = iattr->ia_ctime; if (ia_valid & ATTR_MODE) { umode_t mode = iattr->ia_mode; diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c index 29bc0a542759..a286564ba2e1 100644 --- a/fs/f2fs/file.c +++ b/fs/f2fs/file.c @@ -751,18 +751,12 @@ static void __setattr_copy(struct inode *inode, const struct iattr *attr) inode->i_uid = attr->ia_uid; if (ia_valid & ATTR_GID) inode->i_gid = attr->ia_gid; - if (ia_valid & ATTR_ATIME) { - inode->i_atime = timestamp_truncate(attr->ia_atime, - inode); - } - if (ia_valid & ATTR_MTIME) { - inode->i_mtime = timestamp_truncate(attr->ia_mtime, - inode); - } - if (ia_valid & ATTR_CTIME) { - inode->i_ctime = timestamp_truncate(attr->ia_ctime, - inode); - } + if (ia_valid & ATTR_ATIME) + inode->i_atime = attr->ia_atime; + if (ia_valid & ATTR_MTIME) + inode->i_mtime = attr->ia_mtime; + if (ia_valid & ATTR_CTIME) + inode->i_ctime = attr->ia_ctime; if (ia_valid & ATTR_MODE) { umode_t mode = attr->ia_mode; diff --git a/fs/ntfs/inode.c b/fs/ntfs/inode.c index 6c7388430ad3..d4359a1df3d5 100644 --- a/fs/ntfs/inode.c +++ b/fs/ntfs/inode.c @@ -2899,18 +2899,12 @@ int ntfs_setattr(struct dentry *dentry, struct iattr *attr) ia_valid |= ATTR_MTIME | ATTR_CTIME; } } - if (ia_valid & ATTR_ATIME) { - vi->i_atime = timestamp_truncate(attr->ia_atime, - vi); - } - if (ia_valid & ATTR_MTIME) { - vi->i_mtime = timestamp_truncate(attr->ia_mtime, - vi); - } - if (ia_valid & ATTR_CTIME) { - vi->i_ctime = timestamp_truncate(attr->ia_ctime, - vi); - } + if (ia_valid & ATTR_ATIME) + vi->i_atime = attr->ia_atime; + if (ia_valid & ATTR_MTIME) + vi->i_mtime = attr->ia_mtime; + if (ia_valid & ATTR_CTIME) + vi->i_ctime = attr->ia_ctime; mark_inode_dirty(vi); out: return err; diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c index cd52585c8f4f..91362079f82a 100644 --- a/fs/ubifs/file.c +++ b/fs/ubifs/file.c @@ -1078,18 +1078,12 @@ static void do_attr_changes(struct inode *inode, const struct iattr *attr) inode->i_uid = attr->ia_uid; if (attr->ia_valid & ATTR_GID) inode->i_gid = attr->ia_gid; - if (attr->ia_valid & ATTR_ATIME) { - inode->i_atime = timestamp_truncate(attr->ia_atime, - inode); - } - if (attr->ia_valid & ATTR_MTIME) { - inode->i_mtime = timestamp_truncate(attr->ia_mtime, - inode); - } - if (attr->ia_valid & ATTR_CTIME) { - inode->i_ctime = timestamp_truncate(attr->ia_ctime, - inode); - } + if (attr->ia_valid & ATTR_ATIME) + inode->i_atime = attr->ia_atime; + if (attr->ia_valid & ATTR_MTIME) + inode->i_mtime = attr->ia_mtime; + if (attr->ia_valid & ATTR_CTIME) + inode->i_ctime = attr->ia_ctime; if (attr->ia_valid & ATTR_MODE) { umode_t mode = attr->ia_mode; diff --git a/fs/utimes.c b/fs/utimes.c index 1ba3f7883870..090739322463 100644 --- a/fs/utimes.c +++ b/fs/utimes.c @@ -36,14 +36,14 @@ static int utimes_common(const struct path *path, struct timespec64 *times) if (times[0].tv_nsec == UTIME_OMIT) newattrs.ia_valid &= ~ATTR_ATIME; else if (times[0].tv_nsec != UTIME_NOW) { - newattrs.ia_atime = timestamp_truncate(times[0], inode); + newattrs.ia_atime = times[0]; newattrs.ia_valid |= ATTR_ATIME_SET; } if (times[1].tv_nsec == UTIME_OMIT) newattrs.ia_valid &= ~ATTR_MTIME; else if (times[1].tv_nsec != UTIME_NOW) { - newattrs.ia_mtime = timestamp_truncate(times[1], inode); + newattrs.ia_mtime = times[1]; newattrs.ia_valid |= ATTR_MTIME_SET; } /*