From mboxrd@z Thu Jan 1 00:00:00 1970 From: Christoph Hellwig Subject: [PATCH 10/27] block: add a flags argument to (__)blkdev_issue_zeroout Date: Wed, 5 Apr 2017 19:21:08 +0200 Message-ID: <20170405172125.22600-11-hch@lst.de> References: <20170405172125.22600-1-hch@lst.de> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20170405172125.22600-1-hch@lst.de> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: dm-devel-bounces@redhat.com Errors-To: dm-devel-bounces@redhat.com To: axboe@kernel.dk, martin.petersen@oracle.com, agk@redhat.com, snitzer@redhat.com, shli@kernel.org, philipp.reisner@linbit.com, lars.ellenberg@linbit.com Cc: linux-block@vger.kernel.org, linux-raid@vger.kernel.org, dm-devel@redhat.com, linux-scsi@vger.kernel.org, drbd-dev@lists.linbit.com List-Id: linux-raid.ids VHVybiB0aGUgZXhpc3RpbmcgZGlzY2FyZCBmbGFnIGludG8gYSBuZXcgQkxLREVWX1pFUk9fVU5N QVAgZmxhZyB3aXRoCnNpbWlsYXIgc2VtYW50aWNzLCBidXQgd2l0aG91dCByZWZlcnJpbmcgdG8g ZGnRlWNhcmQuCgpTaWduZWQtb2ZmLWJ5OiBDaHJpc3RvcGggSGVsbHdpZyA8aGNoQGxzdC5kZT4K UmV2aWV3ZWQtYnk6IE1hcnRpbiBLLiBQZXRlcnNlbiA8bWFydGluLnBldGVyc2VuQG9yYWNsZS5j b20+ClJldmlld2VkLWJ5OiBIYW5uZXMgUmVpbmVja2UgPGhhcmVAc3VzZS5jb20+Ci0tLQogYmxv Y2svYmxrLWxpYi5jICAgICAgICAgICAgICAgICAgICB8IDMxICsrKysrKysrKysrKysrLS0tLS0t LS0tLS0tLS0tLS0KIGJsb2NrL2lvY3RsLmMgICAgICAgICAgICAgICAgICAgICAgfCAgMiArLQog ZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfcmVjZWl2ZXIuYyB8ICA5ICsrKysrKy0tLQogZHJpdmVy cy9udm1lL3RhcmdldC9pby1jbWQuYyAgICAgICB8ICAyICstCiBmcy9ibG9ja19kZXYuYyAgICAg ICAgICAgICAgICAgICAgIHwgIDIgKy0KIGZzL2RheC5jICAgICAgICAgICAgICAgICAgICAgICAg ICAgfCAgMiArLQogZnMveGZzL3hmc19ibWFwX3V0aWwuYyAgICAgICAgICAgICB8ICAyICstCiBp bmNsdWRlL2xpbnV4L2Jsa2Rldi5oICAgICAgICAgICAgIHwgMTYgKysrKysrKysrKy0tLS0tLQog OCBmaWxlcyBjaGFuZ2VkLCAzNSBpbnNlcnRpb25zKCspLCAzMSBkZWxldGlvbnMoLSkKCmRpZmYg LS1naXQgYS9ibG9jay9ibGstbGliLmMgYi9ibG9jay9ibGstbGliLmMKaW5kZXggMmE4ZDYzODU0 NGE3Li5mOWYyNGVjNjljMjcgMTAwNjQ0Ci0tLSBhL2Jsb2NrL2Jsay1saWIuYworKysgYi9ibG9j ay9ibGstbGliLmMKQEAgLTI4MiwxNCArMjgyLDE4IEBAIHN0YXRpYyBpbnQgX19ibGtkZXZfaXNz dWVfd3JpdGVfemVyb2VzKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYsCiAgKiBAbnJfc2VjdHM6 CW51bWJlciBvZiBzZWN0b3JzIHRvIHdyaXRlCiAgKiBAZ2ZwX21hc2s6CW1lbW9yeSBhbGxvY2F0 aW9uIGZsYWdzIChmb3IgYmlvX2FsbG9jKQogICogQGJpb3A6CXBvaW50ZXIgdG8gYW5jaG9yIGJp bwotICogQGRpc2NhcmQ6CWRpc2NhcmQgZmxhZworICogQGZsYWdzOgljb250cm9scyBkZXRhaWxl ZCBiZWhhdmlvcgogICoKICAqIERlc2NyaXB0aW9uOgotICogIEdlbmVyYXRlIGFuZCBpc3N1ZSBu dW1iZXIgb2YgYmlvcyB3aXRoIHplcm9maWxlZCBwYWdlcy4KKyAqICBaZXJvLWZpbGwgYSBibG9j ayByYW5nZSwgZWl0aGVyIHVzaW5nIGhhcmR3YXJlIG9mZmxvYWQgb3IgYnkgZXhwbGljaXRseQor ICogIHdyaXRpbmcgemVyb2VzIHRvIHRoZSBkZXZpY2UuCisgKgorICogIElmIGEgZGV2aWNlIGlz IHVzaW5nIGxvZ2ljYWwgYmxvY2sgcHJvdmlzaW9uaW5nLCB0aGUgdW5kZXJseWluZyBzcGFjZSB3 aWxsCisgKiAgbm90IGJlIHJlbGVhc2VkIGlmICVmbGFncyBjb250YWlucyBCTEtERVZfWkVST19O T1VOTUFQLgogICovCiBpbnQgX19ibGtkZXZfaXNzdWVfemVyb291dChzdHJ1Y3QgYmxvY2tfZGV2 aWNlICpiZGV2LCBzZWN0b3JfdCBzZWN0b3IsCiAJCXNlY3Rvcl90IG5yX3NlY3RzLCBnZnBfdCBn ZnBfbWFzaywgc3RydWN0IGJpbyAqKmJpb3AsCi0JCWJvb2wgZGlzY2FyZCkKKwkJdW5zaWduZWQg ZmxhZ3MpCiB7CiAJaW50IHJldDsKIAlpbnQgYmlfc2l6ZSA9IDA7CkBAIC0zMzcsMjggKzM0MSwy MSBAQCBFWFBPUlRfU1lNQk9MKF9fYmxrZGV2X2lzc3VlX3plcm9vdXQpOwogICogQHNlY3RvcjoJ c3RhcnQgc2VjdG9yCiAgKiBAbnJfc2VjdHM6CW51bWJlciBvZiBzZWN0b3JzIHRvIHdyaXRlCiAg KiBAZ2ZwX21hc2s6CW1lbW9yeSBhbGxvY2F0aW9uIGZsYWdzIChmb3IgYmlvX2FsbG9jKQotICog QGRpc2NhcmQ6CXdoZXRoZXIgdG8gZGlzY2FyZCB0aGUgYmxvY2sgcmFuZ2UKKyAqIEBmbGFnczoJ Y29udHJvbHMgZGV0YWlsZWQgYmVoYXZpb3IKICAqCiAgKiBEZXNjcmlwdGlvbjoKLSAqICBaZXJv LWZpbGwgYSBibG9jayByYW5nZS4gIElmIHRoZSBkaXNjYXJkIGZsYWcgaXMgc2V0IGFuZCB0aGUg YmxvY2sKLSAqICBkZXZpY2UgZ3VhcmFudGVlcyB0aGF0IHN1YnNlcXVlbnQgUkVBRCBvcGVyYXRp b25zIHRvIHRoZSBibG9jayByYW5nZQotICogIGluIHF1ZXN0aW9uIHdpbGwgcmV0dXJuIHplcm9l cywgdGhlIGJsb2NrcyB3aWxsIGJlIGRpc2NhcmRlZC4gU2hvdWxkCi0gKiAgdGhlIGRpc2NhcmQg cmVxdWVzdCBmYWlsLCBpZiB0aGUgZGlzY2FyZCBmbGFnIGlzIG5vdCBzZXQsIG9yIGlmCi0gKiAg ZGlzY2FyZF96ZXJvZXNfZGF0YSBpcyBub3Qgc3VwcG9ydGVkLCB0aGlzIGZ1bmN0aW9uIHdpbGwg cmVzb3J0IHRvCi0gKiAgemVyb2luZyB0aGUgYmxvY2tzIG1hbnVhbGx5LCB0aHVzIHByb3Zpc2lv bmluZyAoYWxsb2NhdGluZywKLSAqICBhbmNob3JpbmcpIHRoZW0uIElmIHRoZSBibG9jayBkZXZp Y2Ugc3VwcG9ydHMgV1JJVEUgWkVST0VTIG9yIFdSSVRFIFNBTUUKLSAqICBjb21tYW5kKHMpLCBi bGtkZXZfaXNzdWVfemVyb291dCgpIHdpbGwgdXNlIGl0IHRvIG9wdGltaXplIHRoZSBwcm9jZXNz IG9mCi0gKiAgY2xlYXJpbmcgdGhlIGJsb2NrIHJhbmdlLiBPdGhlcndpc2UgdGhlIHplcm9pbmcg d2lsbCBiZSBwZXJmb3JtZWQKLSAqICB1c2luZyByZWd1bGFyIFdSSVRFIGNhbGxzLgorICogIFpl cm8tZmlsbCBhIGJsb2NrIHJhbmdlLCBlaXRoZXIgdXNpbmcgaGFyZHdhcmUgb2ZmbG9hZCBvciBi eSBleHBsaWNpdGx5CisgKiAgd3JpdGluZyB6ZXJvZXMgdG8gdGhlIGRldmljZS4gIFNlZSBfX2Js a2Rldl9pc3N1ZV96ZXJvb3V0KCkgZm9yIHRoZQorICogIHZhbGlkIHZhbHVlcyBmb3IgJWZsYWdz LgogICovCiBpbnQgYmxrZGV2X2lzc3VlX3plcm9vdXQoc3RydWN0IGJsb2NrX2RldmljZSAqYmRl diwgc2VjdG9yX3Qgc2VjdG9yLAotCQkJIHNlY3Rvcl90IG5yX3NlY3RzLCBnZnBfdCBnZnBfbWFz aywgYm9vbCBkaXNjYXJkKQorCQlzZWN0b3JfdCBucl9zZWN0cywgZ2ZwX3QgZ2ZwX21hc2ssIHVu c2lnbmVkIGZsYWdzKQogewogCWludCByZXQ7CiAJc3RydWN0IGJpbyAqYmlvID0gTlVMTDsKIAlz dHJ1Y3QgYmxrX3BsdWcgcGx1ZzsKIAotCWlmIChkaXNjYXJkKSB7CisJaWYgKCEoZmxhZ3MgJiBC TEtERVZfWkVST19OT1VOTUFQKSkgewogCQlpZiAoIWJsa2Rldl9pc3N1ZV9kaXNjYXJkKGJkZXYs IHNlY3RvciwgbnJfc2VjdHMsIGdmcF9tYXNrLAogCQkJCUJMS0RFVl9ESVNDQVJEX1pFUk8pKQog CQkJcmV0dXJuIDA7CkBAIC0zNjYsNyArMzYzLDcgQEAgaW50IGJsa2Rldl9pc3N1ZV96ZXJvb3V0 KHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYsIHNlY3Rvcl90IHNlY3RvciwKIAogCWJsa19zdGFy dF9wbHVnKCZwbHVnKTsKIAlyZXQgPSBfX2Jsa2Rldl9pc3N1ZV96ZXJvb3V0KGJkZXYsIHNlY3Rv ciwgbnJfc2VjdHMsIGdmcF9tYXNrLAotCQkJJmJpbywgZGlzY2FyZCk7CisJCQkmYmlvLCBmbGFn cyk7CiAJaWYgKHJldCA9PSAwICYmIGJpbykgewogCQlyZXQgPSBzdWJtaXRfYmlvX3dhaXQoYmlv KTsKIAkJYmlvX3B1dChiaW8pOwpkaWZmIC0tZ2l0IGEvYmxvY2svaW9jdGwuYyBiL2Jsb2NrL2lv Y3RsLmMKaW5kZXggN2I4ODgyMGI5M2Q5Li44ZWEwMGE0MWJlMDEgMTAwNjQ0Ci0tLSBhL2Jsb2Nr L2lvY3RsLmMKKysrIGIvYmxvY2svaW9jdGwuYwpAQCAtMjU1LDcgKzI1NSw3IEBAIHN0YXRpYyBp bnQgYmxrX2lvY3RsX3plcm9vdXQoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwgZm1vZGVfdCBt b2RlLAogCXRydW5jYXRlX2lub2RlX3BhZ2VzX3JhbmdlKG1hcHBpbmcsIHN0YXJ0LCBlbmQpOwog CiAJcmV0dXJuIGJsa2Rldl9pc3N1ZV96ZXJvb3V0KGJkZXYsIHN0YXJ0ID4+IDksIGxlbiA+PiA5 LCBHRlBfS0VSTkVMLAotCQkJCSAgICBmYWxzZSk7CisJCQlCTEtERVZfWkVST19OT1VOTUFQKTsK IH0KIAogc3RhdGljIGludCBwdXRfdXNob3J0KHVuc2lnbmVkIGxvbmcgYXJnLCB1bnNpZ25lZCBz aG9ydCB2YWwpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9yZWNlaXZlci5j IGIvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfcmVjZWl2ZXIuYwppbmRleCBhYTZiZjk2OTJlZmYu LmRjOWE2ZGNkNDMxYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfcmVjZWl2 ZXIuYworKysgYi9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9yZWNlaXZlci5jCkBAIC0xNDk5LDE5 ICsxNDk5LDIyIEBAIGludCBkcmJkX2lzc3VlX2Rpc2NhcmRfb3JfemVyb19vdXQoc3RydWN0IGRy YmRfZGV2aWNlICpkZXZpY2UsIHNlY3Rvcl90IHN0YXJ0LCB1CiAJCXRtcCA9IHN0YXJ0ICsgZ3Jh bnVsYXJpdHkgLSBzZWN0b3JfZGl2KHRtcCwgZ3JhbnVsYXJpdHkpOwogCiAJCW5yID0gdG1wIC0g c3RhcnQ7Ci0JCWVyciB8PSBibGtkZXZfaXNzdWVfemVyb291dChiZGV2LCBzdGFydCwgbnIsIEdG UF9OT0lPLCAwKTsKKwkJZXJyIHw9IGJsa2Rldl9pc3N1ZV96ZXJvb3V0KGJkZXYsIHN0YXJ0LCBu ciwgR0ZQX05PSU8sCisJCQkJQkxLREVWX1pFUk9fTk9VTk1BUCk7CiAJCW5yX3NlY3RvcnMgLT0g bnI7CiAJCXN0YXJ0ID0gdG1wOwogCX0KIAl3aGlsZSAobnJfc2VjdG9ycyA+PSBncmFudWxhcml0 eSkgewogCQluciA9IG1pbl90KHNlY3Rvcl90LCBucl9zZWN0b3JzLCBtYXhfZGlzY2FyZF9zZWN0 b3JzKTsKLQkJZXJyIHw9IGJsa2Rldl9pc3N1ZV9kaXNjYXJkKGJkZXYsIHN0YXJ0LCBuciwgR0ZQ X05PSU8sIDApOworCQllcnIgfD0gYmxrZGV2X2lzc3VlX2Rpc2NhcmQoYmRldiwgc3RhcnQsIG5y LCBHRlBfTk9JTywKKwkJCQlCTEtERVZfWkVST19OT1VOTUFQKTsKIAkJbnJfc2VjdG9ycyAtPSBu cjsKIAkJc3RhcnQgKz0gbnI7CiAJfQogIHplcm9fb3V0OgogCWlmIChucl9zZWN0b3JzKSB7Ci0J CWVyciB8PSBibGtkZXZfaXNzdWVfemVyb291dChiZGV2LCBzdGFydCwgbnJfc2VjdG9ycywgR0ZQ X05PSU8sIDApOworCQllcnIgfD0gYmxrZGV2X2lzc3VlX3plcm9vdXQoYmRldiwgc3RhcnQsIG5y X3NlY3RvcnMsIEdGUF9OT0lPLAorCQkJCUJMS0RFVl9aRVJPX05PVU5NQVApOwogCX0KIAlyZXR1 cm4gZXJyICE9IDA7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL252bWUvdGFyZ2V0L2lvLWNtZC5j IGIvZHJpdmVycy9udm1lL3RhcmdldC9pby1jbWQuYwppbmRleCAyNzYyM2YyYmZlNmIuLmRlMjY2 Y2M5OTM5NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9udm1lL3RhcmdldC9pby1jbWQuYworKysgYi9k cml2ZXJzL252bWUvdGFyZ2V0L2lvLWNtZC5jCkBAIC0xODQsNyArMTg0LDcgQEAgc3RhdGljIHZv aWQgbnZtZXRfZXhlY3V0ZV93cml0ZV96ZXJvZXMoc3RydWN0IG52bWV0X3JlcSAqcmVxKQogCQko cmVxLT5ucy0+Ymxrc2l6ZV9zaGlmdCAtIDkpKSArIDE7CiAKIAlpZiAoX19ibGtkZXZfaXNzdWVf emVyb291dChyZXEtPm5zLT5iZGV2LCBzZWN0b3IsIG5yX3NlY3RvciwKLQkJCQlHRlBfS0VSTkVM LCAmYmlvLCB0cnVlKSkKKwkJCQlHRlBfS0VSTkVMLCAmYmlvLCAwKSkKIAkJc3RhdHVzID0gTlZN RV9TQ19JTlRFUk5BTCB8IE5WTUVfU0NfRE5SOwogCiAJaWYgKGJpbykgewpkaWZmIC0tZ2l0IGEv ZnMvYmxvY2tfZGV2LmMgYi9mcy9ibG9ja19kZXYuYwppbmRleCBmMmQ1OWYxNDNlZjQuLjJmNzA0 YzNhODE2ZiAxMDA2NDQKLS0tIGEvZnMvYmxvY2tfZGV2LmMKKysrIGIvZnMvYmxvY2tfZGV2LmMK QEAgLTIxMDUsNyArMjEwNSw3IEBAIHN0YXRpYyBsb25nIGJsa2Rldl9mYWxsb2NhdGUoc3RydWN0 IGZpbGUgKmZpbGUsIGludCBtb2RlLCBsb2ZmX3Qgc3RhcnQsCiAJY2FzZSBGQUxMT0NfRkxfWkVS T19SQU5HRToKIAljYXNlIEZBTExPQ19GTF9aRVJPX1JBTkdFIHwgRkFMTE9DX0ZMX0tFRVBfU0la RToKIAkJZXJyb3IgPSBibGtkZXZfaXNzdWVfemVyb291dChiZGV2LCBzdGFydCA+PiA5LCBsZW4g Pj4gOSwKLQkJCQkJICAgIEdGUF9LRVJORUwsIGZhbHNlKTsKKwkJCQkJICAgIEdGUF9LRVJORUws IEJMS0RFVl9aRVJPX05PVU5NQVApOwogCQlicmVhazsKIAljYXNlIEZBTExPQ19GTF9QVU5DSF9I T0xFIHwgRkFMTE9DX0ZMX0tFRVBfU0laRToKIAkJLyogT25seSBwdW5jaCBpZiB0aGUgZGV2aWNl IGNhbiBkbyB6ZXJvaW5nIGRpc2NhcmQuICovCmRpZmYgLS1naXQgYS9mcy9kYXguYyBiL2ZzL2Rh eC5jCmluZGV4IGRlNjIyZDQyODJhNi4uMmJmYmNkNzI2MDQ3IDEwMDY0NAotLS0gYS9mcy9kYXgu YworKysgYi9mcy9kYXguYwpAQCAtOTgyLDcgKzk4Miw3IEBAIGludCBfX2RheF96ZXJvX3BhZ2Vf cmFuZ2Uoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwgc2VjdG9yX3Qgc2VjdG9yLAogCQlzZWN0 b3JfdCBzdGFydF9zZWN0b3IgPSBkYXguc2VjdG9yICsgKG9mZnNldCA+PiA5KTsKIAogCQlyZXR1 cm4gYmxrZGV2X2lzc3VlX3plcm9vdXQoYmRldiwgc3RhcnRfc2VjdG9yLAotCQkJCWxlbmd0aCA+ PiA5LCBHRlBfTk9GUywgdHJ1ZSk7CisJCQkJbGVuZ3RoID4+IDksIEdGUF9OT0ZTLCAwKTsKIAl9 IGVsc2UgewogCQlpZiAoZGF4X21hcF9hdG9taWMoYmRldiwgJmRheCkgPCAwKQogCQkJcmV0dXJu IFBUUl9FUlIoZGF4LmFkZHIpOwpkaWZmIC0tZ2l0IGEvZnMveGZzL3hmc19ibWFwX3V0aWwuYyBi L2ZzL3hmcy94ZnNfYm1hcF91dGlsLmMKaW5kZXggOGI3NWRjZWE1OTY2Li4xNDJiYmJlMDYxMTQg MTAwNjQ0Ci0tLSBhL2ZzL3hmcy94ZnNfYm1hcF91dGlsLmMKKysrIGIvZnMveGZzL3hmc19ibWFw X3V0aWwuYwpAQCAtODEsNyArODEsNyBAQCB4ZnNfemVyb19leHRlbnQoCiAJcmV0dXJuIGJsa2Rl dl9pc3N1ZV96ZXJvb3V0KHhmc19maW5kX2JkZXZfZm9yX2lub2RlKFZGU19JKGlwKSksCiAJCWJs b2NrIDw8IChtcC0+bV9zdXBlci0+c19ibG9ja3NpemVfYml0cyAtIDkpLAogCQljb3VudF9mc2Ig PDwgKG1wLT5tX3N1cGVyLT5zX2Jsb2Nrc2l6ZV9iaXRzIC0gOSksCi0JCUdGUF9OT0ZTLCB0cnVl KTsKKwkJR0ZQX05PRlMsIDApOwogfQogCiBpbnQKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgv YmxrZGV2LmggYi9pbmNsdWRlL2xpbnV4L2Jsa2Rldi5oCmluZGV4IGEyZGM2YjM5MGQ0OC4uZTc1 MTNjZTNkYmRlIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2Jsa2Rldi5oCisrKyBiL2luY2x1 ZGUvbGludXgvYmxrZGV2LmgKQEAgLTEzMzcsMjMgKzEzMzcsMjcgQEAgc3RhdGljIGlubGluZSBz dHJ1Y3QgcmVxdWVzdCAqYmxrX21hcF9xdWV1ZV9maW5kX3RhZyhzdHJ1Y3QgYmxrX3F1ZXVlX3Rh ZyAqYnF0LAogCXJldHVybiBicXQtPnRhZ19pbmRleFt0YWddOwogfQogCitleHRlcm4gaW50IGJs a2Rldl9pc3N1ZV9mbHVzaChzdHJ1Y3QgYmxvY2tfZGV2aWNlICosIGdmcF90LCBzZWN0b3JfdCAq KTsKK2V4dGVybiBpbnQgYmxrZGV2X2lzc3VlX3dyaXRlX3NhbWUoc3RydWN0IGJsb2NrX2Rldmlj ZSAqYmRldiwgc2VjdG9yX3Qgc2VjdG9yLAorCQlzZWN0b3JfdCBucl9zZWN0cywgZ2ZwX3QgZ2Zw X21hc2ssIHN0cnVjdCBwYWdlICpwYWdlKTsKIAogI2RlZmluZSBCTEtERVZfRElTQ0FSRF9TRUNV UkUJKDEgPDwgMCkJLyogaXNzdWUgYSBzZWN1cmUgZXJhc2UgKi8KICNkZWZpbmUgQkxLREVWX0RJ U0NBUkRfWkVSTwkoMSA8PCAxKQkvKiBtdXN0IHJlbGlhYmx5IHplcm8gZGF0YSAqLwogCi1leHRl cm4gaW50IGJsa2Rldl9pc3N1ZV9mbHVzaChzdHJ1Y3QgYmxvY2tfZGV2aWNlICosIGdmcF90LCBz ZWN0b3JfdCAqKTsKIGV4dGVybiBpbnQgYmxrZGV2X2lzc3VlX2Rpc2NhcmQoc3RydWN0IGJsb2Nr X2RldmljZSAqYmRldiwgc2VjdG9yX3Qgc2VjdG9yLAogCQlzZWN0b3JfdCBucl9zZWN0cywgZ2Zw X3QgZ2ZwX21hc2ssIHVuc2lnbmVkIGxvbmcgZmxhZ3MpOwogZXh0ZXJuIGludCBfX2Jsa2Rldl9p c3N1ZV9kaXNjYXJkKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYsIHNlY3Rvcl90IHNlY3RvciwK IAkJc2VjdG9yX3QgbnJfc2VjdHMsIGdmcF90IGdmcF9tYXNrLCBpbnQgZmxhZ3MsCiAJCXN0cnVj dCBiaW8gKipiaW9wKTsKLWV4dGVybiBpbnQgYmxrZGV2X2lzc3VlX3dyaXRlX3NhbWUoc3RydWN0 IGJsb2NrX2RldmljZSAqYmRldiwgc2VjdG9yX3Qgc2VjdG9yLAotCQlzZWN0b3JfdCBucl9zZWN0 cywgZ2ZwX3QgZ2ZwX21hc2ssIHN0cnVjdCBwYWdlICpwYWdlKTsKKworI2RlZmluZSBCTEtERVZf WkVST19OT1VOTUFQCSgxIDw8IDApICAvKiBkbyBub3QgZnJlZSBibG9ja3MgKi8KKwogZXh0ZXJu IGludCBfX2Jsa2Rldl9pc3N1ZV96ZXJvb3V0KHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYsIHNl Y3Rvcl90IHNlY3RvciwKIAkJc2VjdG9yX3QgbnJfc2VjdHMsIGdmcF90IGdmcF9tYXNrLCBzdHJ1 Y3QgYmlvICoqYmlvcCwKLQkJYm9vbCBkaXNjYXJkKTsKKwkJdW5zaWduZWQgZmxhZ3MpOwogZXh0 ZXJuIGludCBibGtkZXZfaXNzdWVfemVyb291dChzdHJ1Y3QgYmxvY2tfZGV2aWNlICpiZGV2LCBz ZWN0b3JfdCBzZWN0b3IsCi0JCXNlY3Rvcl90IG5yX3NlY3RzLCBnZnBfdCBnZnBfbWFzaywgYm9v bCBkaXNjYXJkKTsKKwkJc2VjdG9yX3QgbnJfc2VjdHMsIGdmcF90IGdmcF9tYXNrLCB1bnNpZ25l ZCBmbGFncyk7CisKIHN0YXRpYyBpbmxpbmUgaW50IHNiX2lzc3VlX2Rpc2NhcmQoc3RydWN0IHN1 cGVyX2Jsb2NrICpzYiwgc2VjdG9yX3QgYmxvY2ssCiAJCXNlY3Rvcl90IG5yX2Jsb2NrcywgZ2Zw X3QgZ2ZwX21hc2ssIHVuc2lnbmVkIGxvbmcgZmxhZ3MpCiB7CkBAIC0xMzY3LDcgKzEzNzEsNyBA QCBzdGF0aWMgaW5saW5lIGludCBzYl9pc3N1ZV96ZXJvb3V0KHN0cnVjdCBzdXBlcl9ibG9jayAq c2IsIHNlY3Rvcl90IGJsb2NrLAogCXJldHVybiBibGtkZXZfaXNzdWVfemVyb291dChzYi0+c19i ZGV2LAogCQkJCSAgICBibG9jayA8PCAoc2ItPnNfYmxvY2tzaXplX2JpdHMgLSA5KSwKIAkJCQkg ICAgbnJfYmxvY2tzIDw8IChzYi0+c19ibG9ja3NpemVfYml0cyAtIDkpLAotCQkJCSAgICBnZnBf bWFzaywgdHJ1ZSk7CisJCQkJICAgIGdmcF9tYXNrLCAwKTsKIH0KIAogZXh0ZXJuIGludCBibGtf dmVyaWZ5X2NvbW1hbmQodW5zaWduZWQgY2hhciAqY21kLCBmbW9kZV90IGhhc193cml0ZV9wZXJt KTsKLS0gCjIuMTEuMAoKLS0KZG0tZGV2ZWwgbWFpbGluZyBsaXN0CmRtLWRldmVsQHJlZGhhdC5j b20KaHR0cHM6Ly93d3cucmVkaGF0LmNvbS9tYWlsbWFuL2xpc3RpbmZvL2RtLWRldmVs From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: From: Christoph Hellwig To: axboe@kernel.dk, martin.petersen@oracle.com, agk@redhat.com, snitzer@redhat.com, shli@kernel.org, philipp.reisner@linbit.com, lars.ellenberg@linbit.com Cc: linux-block@vger.kernel.org, linux-scsi@vger.kernel.org, drbd-dev@lists.linbit.com, dm-devel@redhat.com, linux-raid@vger.kernel.org Subject: [PATCH 10/27] block: add a flags argument to (__)blkdev_issue_zeroout Date: Wed, 5 Apr 2017 19:21:08 +0200 Message-Id: <20170405172125.22600-11-hch@lst.de> In-Reply-To: <20170405172125.22600-1-hch@lst.de> References: <20170405172125.22600-1-hch@lst.de> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 List-ID: Turn the existing discard flag into a new BLKDEV_ZERO_UNMAP flag with similar semantics, but without referring to diѕcard. Signed-off-by: Christoph Hellwig Reviewed-by: Martin K. Petersen Reviewed-by: Hannes Reinecke --- block/blk-lib.c | 31 ++++++++++++++----------------- block/ioctl.c | 2 +- drivers/block/drbd/drbd_receiver.c | 9 ++++++--- drivers/nvme/target/io-cmd.c | 2 +- fs/block_dev.c | 2 +- fs/dax.c | 2 +- fs/xfs/xfs_bmap_util.c | 2 +- include/linux/blkdev.h | 16 ++++++++++------ 8 files changed, 35 insertions(+), 31 deletions(-) diff --git a/block/blk-lib.c b/block/blk-lib.c index 2a8d638544a7..f9f24ec69c27 100644 --- a/block/blk-lib.c +++ b/block/blk-lib.c @@ -282,14 +282,18 @@ static int __blkdev_issue_write_zeroes(struct block_device *bdev, * @nr_sects: number of sectors to write * @gfp_mask: memory allocation flags (for bio_alloc) * @biop: pointer to anchor bio - * @discard: discard flag + * @flags: controls detailed behavior * * Description: - * Generate and issue number of bios with zerofiled pages. + * Zero-fill a block range, either using hardware offload or by explicitly + * writing zeroes to the device. + * + * If a device is using logical block provisioning, the underlying space will + * not be released if %flags contains BLKDEV_ZERO_NOUNMAP. */ int __blkdev_issue_zeroout(struct block_device *bdev, sector_t sector, sector_t nr_sects, gfp_t gfp_mask, struct bio **biop, - bool discard) + unsigned flags) { int ret; int bi_size = 0; @@ -337,28 +341,21 @@ EXPORT_SYMBOL(__blkdev_issue_zeroout); * @sector: start sector * @nr_sects: number of sectors to write * @gfp_mask: memory allocation flags (for bio_alloc) - * @discard: whether to discard the block range + * @flags: controls detailed behavior * * Description: - * Zero-fill a block range. If the discard flag is set and the block - * device guarantees that subsequent READ operations to the block range - * in question will return zeroes, the blocks will be discarded. Should - * the discard request fail, if the discard flag is not set, or if - * discard_zeroes_data is not supported, this function will resort to - * zeroing the blocks manually, thus provisioning (allocating, - * anchoring) them. If the block device supports WRITE ZEROES or WRITE SAME - * command(s), blkdev_issue_zeroout() will use it to optimize the process of - * clearing the block range. Otherwise the zeroing will be performed - * using regular WRITE calls. + * Zero-fill a block range, either using hardware offload or by explicitly + * writing zeroes to the device. See __blkdev_issue_zeroout() for the + * valid values for %flags. */ int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector, - sector_t nr_sects, gfp_t gfp_mask, bool discard) + sector_t nr_sects, gfp_t gfp_mask, unsigned flags) { int ret; struct bio *bio = NULL; struct blk_plug plug; - if (discard) { + if (!(flags & BLKDEV_ZERO_NOUNMAP)) { if (!blkdev_issue_discard(bdev, sector, nr_sects, gfp_mask, BLKDEV_DISCARD_ZERO)) return 0; @@ -366,7 +363,7 @@ int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector, blk_start_plug(&plug); ret = __blkdev_issue_zeroout(bdev, sector, nr_sects, gfp_mask, - &bio, discard); + &bio, flags); if (ret == 0 && bio) { ret = submit_bio_wait(bio); bio_put(bio); diff --git a/block/ioctl.c b/block/ioctl.c index 7b88820b93d9..8ea00a41be01 100644 --- a/block/ioctl.c +++ b/block/ioctl.c @@ -255,7 +255,7 @@ static int blk_ioctl_zeroout(struct block_device *bdev, fmode_t mode, truncate_inode_pages_range(mapping, start, end); return blkdev_issue_zeroout(bdev, start >> 9, len >> 9, GFP_KERNEL, - false); + BLKDEV_ZERO_NOUNMAP); } static int put_ushort(unsigned long arg, unsigned short val) diff --git a/drivers/block/drbd/drbd_receiver.c b/drivers/block/drbd/drbd_receiver.c index aa6bf9692eff..dc9a6dcd431c 100644 --- a/drivers/block/drbd/drbd_receiver.c +++ b/drivers/block/drbd/drbd_receiver.c @@ -1499,19 +1499,22 @@ int drbd_issue_discard_or_zero_out(struct drbd_device *device, sector_t start, u tmp = start + granularity - sector_div(tmp, granularity); nr = tmp - start; - err |= blkdev_issue_zeroout(bdev, start, nr, GFP_NOIO, 0); + err |= blkdev_issue_zeroout(bdev, start, nr, GFP_NOIO, + BLKDEV_ZERO_NOUNMAP); nr_sectors -= nr; start = tmp; } while (nr_sectors >= granularity) { nr = min_t(sector_t, nr_sectors, max_discard_sectors); - err |= blkdev_issue_discard(bdev, start, nr, GFP_NOIO, 0); + err |= blkdev_issue_discard(bdev, start, nr, GFP_NOIO, + BLKDEV_ZERO_NOUNMAP); nr_sectors -= nr; start += nr; } zero_out: if (nr_sectors) { - err |= blkdev_issue_zeroout(bdev, start, nr_sectors, GFP_NOIO, 0); + err |= blkdev_issue_zeroout(bdev, start, nr_sectors, GFP_NOIO, + BLKDEV_ZERO_NOUNMAP); } return err != 0; } diff --git a/drivers/nvme/target/io-cmd.c b/drivers/nvme/target/io-cmd.c index 27623f2bfe6b..de266cc99397 100644 --- a/drivers/nvme/target/io-cmd.c +++ b/drivers/nvme/target/io-cmd.c @@ -184,7 +184,7 @@ static void nvmet_execute_write_zeroes(struct nvmet_req *req) (req->ns->blksize_shift - 9)) + 1; if (__blkdev_issue_zeroout(req->ns->bdev, sector, nr_sector, - GFP_KERNEL, &bio, true)) + GFP_KERNEL, &bio, 0)) status = NVME_SC_INTERNAL | NVME_SC_DNR; if (bio) { diff --git a/fs/block_dev.c b/fs/block_dev.c index f2d59f143ef4..2f704c3a816f 100644 --- a/fs/block_dev.c +++ b/fs/block_dev.c @@ -2105,7 +2105,7 @@ static long blkdev_fallocate(struct file *file, int mode, loff_t start, case FALLOC_FL_ZERO_RANGE: case FALLOC_FL_ZERO_RANGE | FALLOC_FL_KEEP_SIZE: error = blkdev_issue_zeroout(bdev, start >> 9, len >> 9, - GFP_KERNEL, false); + GFP_KERNEL, BLKDEV_ZERO_NOUNMAP); break; case FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE: /* Only punch if the device can do zeroing discard. */ diff --git a/fs/dax.c b/fs/dax.c index de622d4282a6..2bfbcd726047 100644 --- a/fs/dax.c +++ b/fs/dax.c @@ -982,7 +982,7 @@ int __dax_zero_page_range(struct block_device *bdev, sector_t sector, sector_t start_sector = dax.sector + (offset >> 9); return blkdev_issue_zeroout(bdev, start_sector, - length >> 9, GFP_NOFS, true); + length >> 9, GFP_NOFS, 0); } else { if (dax_map_atomic(bdev, &dax) < 0) return PTR_ERR(dax.addr); diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c index 8b75dcea5966..142bbbe06114 100644 --- a/fs/xfs/xfs_bmap_util.c +++ b/fs/xfs/xfs_bmap_util.c @@ -81,7 +81,7 @@ xfs_zero_extent( return blkdev_issue_zeroout(xfs_find_bdev_for_inode(VFS_I(ip)), block << (mp->m_super->s_blocksize_bits - 9), count_fsb << (mp->m_super->s_blocksize_bits - 9), - GFP_NOFS, true); + GFP_NOFS, 0); } int diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h index a2dc6b390d48..e7513ce3dbde 100644 --- a/include/linux/blkdev.h +++ b/include/linux/blkdev.h @@ -1337,23 +1337,27 @@ static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt, return bqt->tag_index[tag]; } +extern int blkdev_issue_flush(struct block_device *, gfp_t, sector_t *); +extern int blkdev_issue_write_same(struct block_device *bdev, sector_t sector, + sector_t nr_sects, gfp_t gfp_mask, struct page *page); #define BLKDEV_DISCARD_SECURE (1 << 0) /* issue a secure erase */ #define BLKDEV_DISCARD_ZERO (1 << 1) /* must reliably zero data */ -extern int blkdev_issue_flush(struct block_device *, gfp_t, sector_t *); extern int blkdev_issue_discard(struct block_device *bdev, sector_t sector, sector_t nr_sects, gfp_t gfp_mask, unsigned long flags); extern int __blkdev_issue_discard(struct block_device *bdev, sector_t sector, sector_t nr_sects, gfp_t gfp_mask, int flags, struct bio **biop); -extern int blkdev_issue_write_same(struct block_device *bdev, sector_t sector, - sector_t nr_sects, gfp_t gfp_mask, struct page *page); + +#define BLKDEV_ZERO_NOUNMAP (1 << 0) /* do not free blocks */ + extern int __blkdev_issue_zeroout(struct block_device *bdev, sector_t sector, sector_t nr_sects, gfp_t gfp_mask, struct bio **biop, - bool discard); + unsigned flags); extern int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector, - sector_t nr_sects, gfp_t gfp_mask, bool discard); + sector_t nr_sects, gfp_t gfp_mask, unsigned flags); + static inline int sb_issue_discard(struct super_block *sb, sector_t block, sector_t nr_blocks, gfp_t gfp_mask, unsigned long flags) { @@ -1367,7 +1371,7 @@ static inline int sb_issue_zeroout(struct super_block *sb, sector_t block, return blkdev_issue_zeroout(sb->s_bdev, block << (sb->s_blocksize_bits - 9), nr_blocks << (sb->s_blocksize_bits - 9), - gfp_mask, true); + gfp_mask, 0); } extern int blk_verify_command(unsigned char *cmd, fmode_t has_write_perm); -- 2.11.0