From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: From: =?UTF-8?q?Matias=20Bj=C3=B8rling?= To: linux-block@vger.kernel.org, linux-kernel@vger.kernel.org, axboe@fb.com, keith.busch@intel.com, linux-nvme@lists.infradead.org Subject: [PATCH 4/6] lightnvm: let drivers control the lifetime of nvm_dev Date: Fri, 10 Jun 2016 14:21:00 +0200 Message-Id: <1465561262-13789-5-git-send-email-m@bjorling.me> In-Reply-To: <1465561262-13789-1-git-send-email-m@bjorling.me> References: <1465561262-13789-1-git-send-email-m@bjorling.me> MIME-Version: 1.0 List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?UTF-8?q?Matias=20Bj=C3=B8rling?= Content-Type: text/plain; charset="utf-8" Sender: "Linux-nvme" Errors-To: linux-nvme-bounces+axboe=kernel.dk@lists.infradead.org List-ID: TGlnaHROVk0gZG9lcyBub3QgY3VycmVudGx5IGV4cG9zZSB0aGUgZGV2aWNlIGRyaXZlciBzeXNm cyBzcGVjaWZpYwplbnRyaWVzIHRvIHVzZXItc3BhY2UsIGFzIHRoZSBkZXZpY2UgZHJpdmVyIHNr aXBzIHRoZSBpbml0aWFsaXphdGlvbiBvZgpnZW5kaXNrLgoKVG8gZW5hYmxlIGEgZGV2aWNlIGRy aXZlciBzeXNmcyBlbnRyaWVzIHRvIGJlIGV4cG9zZWQsIHdlIG5lZWQgYSBzdHJ1Y3QKZGV2aWNl IHRvIGF0dGFjaCBpdCB0by4gVG8gYWxsb3cgYm90aCB0aGUgZGV2aWNlIGRyaXZlciBhbmQgTGln aHROVk0gdG8KYWNjZXNzIHRoZSBzYW1lIHN0cnVjdCBkZXZpY2UsIHdlIG5lZWQgdGhlIGRldmlj ZSBkcml2ZXIgdG8gdHJhY2sgdGhlCmxpZmV0aW1lIG9mIHRoZSBudm1fZGV2IHN0cnVjdHVyZS4K ClRoaXMgcGF0Y2ggcmVmYWN0b3JzIHRoZSB0d28gdXNlcnMgb2YgTGlnaHROVk0gKE5WTWUgYW5k IG51bGxfYmxrKSwKZW5hYmxlcyB0aGVtIHRvIGFsbG9jYXRlIGFuZCBmcmVlIG52bV9kZXYsIGFu ZCBhdCBsYXN0IHJlbW92ZXMgZ2VuZGlzawp1c2FnZSB3aGVuIGEgTGlnaHROVk0gZGV2aWNlIGlz IHVzZWQuCgpTaWduZWQtb2ZmLWJ5OiBNYXRpYXMgQmrDuHJsaW5nIDxtQGJqb3JsaW5nLm1lPgot LS0KIGRyaXZlcnMvYmxvY2svbnVsbF9ibGsuYyAgICAgfCAyMiArKysrKysrKysrKysrKysrKysr Ky0tCiBkcml2ZXJzL2xpZ2h0bnZtL2NvcmUuYyAgICAgIHwgMzQgKysrKysrKy0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy9udm1lL2hvc3QvY29yZS5jICAgICB8IDM0ICsrKysr KysrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0KIGRyaXZlcnMvbnZtZS9ob3N0L2xpZ2h0bnZt LmMgfCAyMSArKysrKysrKysrKysrKysrKy0tLS0KIGRyaXZlcnMvbnZtZS9ob3N0L252bWUuaCAg ICAgfCAgOCArKysrKy0tLQogaW5jbHVkZS9saW51eC9saWdodG52bS5oICAgICB8IDE1ICsrKysr KysrKy0tLS0tLQogNiBmaWxlcyBjaGFuZ2VkLCA3MiBpbnNlcnRpb25zKCspLCA2MiBkZWxldGlv bnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL251bGxfYmxrLmMgYi9kcml2ZXJzL2Js b2NrL251bGxfYmxrLmMKaW5kZXggMzExN2RmMS4uNWEwZGE4YiAxMDA2NDQKLS0tIGEvZHJpdmVy cy9ibG9jay9udWxsX2Jsay5jCisrKyBiL2RyaXZlcnMvYmxvY2svbnVsbF9ibGsuYwpAQCAtMzQs NiArMzQsNyBAQCBzdHJ1Y3QgbnVsbGIgewogCXVuc2lnbmVkIGludCBpbmRleDsKIAlzdHJ1Y3Qg cmVxdWVzdF9xdWV1ZSAqcTsKIAlzdHJ1Y3QgZ2VuZGlzayAqZGlzazsKKwlzdHJ1Y3QgbnZtX2Rl diAqbmRldjsKIAlzdHJ1Y3QgYmxrX21xX3RhZ19zZXQgdGFnX3NldDsKIAlzdHJ1Y3QgaHJ0aW1l ciB0aW1lcjsKIAl1bnNpZ25lZCBpbnQgcXVldWVfZGVwdGg7CkBAIC01NTAsMTIgKzU1MSwyOSBA QCBzdGF0aWMgc3RydWN0IG52bV9kZXZfb3BzIG51bGxfbG52bV9kZXZfb3BzID0gewogCiBzdGF0 aWMgaW50IG51bGxfbnZtX3JlZ2lzdGVyKHN0cnVjdCBudWxsYiAqbnVsbGIpCiB7Ci0JcmV0dXJu IG52bV9yZWdpc3RlcihudWxsYi0+cSwgbnVsbGItPmRpc2tfbmFtZSwgJm51bGxfbG52bV9kZXZf b3BzKTsKKwlzdHJ1Y3QgbnZtX2RldiAqZGV2OworCWludCBydjsKKworCWRldiA9IG52bV9hbGxv Y19kZXYoMCk7CisJaWYgKCFkZXYpCisJCXJldHVybiAtRU5PTUVNOworCisJZGV2LT5xID0gbnVs bGItPnE7CisJbWVtY3B5KGRldi0+bmFtZSwgbnVsbGItPmRpc2tfbmFtZSwgRElTS19OQU1FX0xF Tik7CisJZGV2LT5vcHMgPSAmbnVsbF9sbnZtX2Rldl9vcHM7CisKKwlydiA9IG52bV9yZWdpc3Rl cihkZXYpOworCWlmIChydikgeworCQlrZnJlZShkZXYpOworCQlyZXR1cm4gcnY7CisJfQorCW51 bGxiLT5uZGV2ID0gZGV2OworCXJldHVybiAwOwogfQogCiBzdGF0aWMgdm9pZCBudWxsX252bV91 bnJlZ2lzdGVyKHN0cnVjdCBudWxsYiAqbnVsbGIpCiB7Ci0JbnZtX3VucmVnaXN0ZXIobnVsbGIt PmRpc2tfbmFtZSk7CisJbnZtX3VucmVnaXN0ZXIobnVsbGItPm5kZXYpOwogfQogI2Vsc2UKIHN0 YXRpYyBpbnQgbnVsbF9udm1fcmVnaXN0ZXIoc3RydWN0IG51bGxiICpudWxsYikKZGlmZiAtLWdp dCBhL2RyaXZlcnMvbGlnaHRudm0vY29yZS5jIGIvZHJpdmVycy9saWdodG52bS9jb3JlLmMKaW5k ZXggNDU3NGMwYi4uYWQyNzc2OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9saWdodG52bS9jb3JlLmMK KysrIGIvZHJpdmVycy9saWdodG52bS9jb3JlLmMKQEAgLTY1NSwyMyArNjU1LDE1IEBAIHN0YXRp YyB2b2lkIG52bV9leGl0KHN0cnVjdCBudm1fZGV2ICpkZXYpCiAJcHJfaW5mbygibnZtOiBzdWNj ZXNzZnVsbHkgdW5sb2FkZWRcbiIpOwogfQogCi1pbnQgbnZtX3JlZ2lzdGVyKHN0cnVjdCByZXF1 ZXN0X3F1ZXVlICpxLCBjaGFyICpkaXNrX25hbWUsCi0JCQkJCQkJc3RydWN0IG52bV9kZXZfb3Bz ICpvcHMpCitzdHJ1Y3QgbnZtX2RldiAqbnZtX2FsbG9jX2RldihpbnQgbm9kZSkKK3sKKwlyZXR1 cm4ga3phbGxvY19ub2RlKHNpemVvZihzdHJ1Y3QgbnZtX2RldiksIEdGUF9LRVJORUwsIG5vZGUp OworfQorCitpbnQgbnZtX3JlZ2lzdGVyKHN0cnVjdCBudm1fZGV2ICpkZXYpCiB7Ci0Jc3RydWN0 IG52bV9kZXYgKmRldjsKIAlpbnQgcmV0OwogCi0JaWYgKCFvcHMtPmlkZW50aXR5KQotCQlyZXR1 cm4gLUVJTlZBTDsKLQotCWRldiA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBudm1fZGV2KSwgR0ZQ X0tFUk5FTCk7Ci0JaWYgKCFkZXYpCi0JCXJldHVybiAtRU5PTUVNOwotCi0JZGV2LT5xID0gcTsK LQlkZXYtPm9wcyA9IG9wczsKLQlzdHJuY3B5KGRldi0+bmFtZSwgZGlza19uYW1lLCBESVNLX05B TUVfTEVOKTsKLQogCXJldCA9IG52bV9pbml0KGRldik7CiAJaWYgKHJldCkKIAkJZ290byBlcnJf aW5pdDsKQEAgLTcwOSwyOSArNzAxLDE3IEBAIGludCBudm1fcmVnaXN0ZXIoc3RydWN0IHJlcXVl c3RfcXVldWUgKnEsIGNoYXIgKmRpc2tfbmFtZSwKIAlyZXR1cm4gMDsKIGVycl9pbml0OgogCWtm cmVlKGRldi0+bHVuX21hcCk7Ci0Ja2ZyZWUoZGV2KTsKIAlyZXR1cm4gcmV0OwogfQogRVhQT1JU X1NZTUJPTChudm1fcmVnaXN0ZXIpOwogCi12b2lkIG52bV91bnJlZ2lzdGVyKGNoYXIgKmRpc2tf bmFtZSkKK3ZvaWQgbnZtX3VucmVnaXN0ZXIoc3RydWN0IG52bV9kZXYgKmRldikKIHsKLQlzdHJ1 Y3QgbnZtX2RldiAqZGV2OwotCiAJZG93bl93cml0ZSgmbnZtX2xvY2spOwotCWRldiA9IG52bV9m aW5kX252bV9kZXYoZGlza19uYW1lKTsKLQlpZiAoIWRldikgewotCQlwcl9lcnIoIm52bTogY291 bGQgbm90IGZpbmQgZGV2aWNlICVzIHRvIHVucmVnaXN0ZXJcbiIsCi0JCQkJCQkJCWRpc2tfbmFt ZSk7Ci0JCXVwX3dyaXRlKCZudm1fbG9jayk7Ci0JCXJldHVybjsKLQl9Ci0KIAlsaXN0X2RlbCgm ZGV2LT5kZXZpY2VzKTsKIAl1cF93cml0ZSgmbnZtX2xvY2spOwogCiAJbnZtX2V4aXQoZGV2KTsK LQlrZnJlZShkZXYpOwogfQogRVhQT1JUX1NZTUJPTChudm1fdW5yZWdpc3Rlcik7CiAKZGlmZiAt LWdpdCBhL2RyaXZlcnMvbnZtZS9ob3N0L2NvcmUuYyBiL2RyaXZlcnMvbnZtZS9ob3N0L2NvcmUu YwppbmRleCBmNjE1YjZiLi5mZTEzNWQ5IDEwMDY0NAotLS0gYS9kcml2ZXJzL252bWUvaG9zdC9j b3JlLmMKKysrIGIvZHJpdmVycy9udm1lL2hvc3QvY29yZS5jCkBAIC0xMzcsMTIgKzEzNywxNCBA QCBzdGF0aWMgdm9pZCBudm1lX2ZyZWVfbnMoc3RydWN0IGtyZWYgKmtyZWYpCiB7CiAJc3RydWN0 IG52bWVfbnMgKm5zID0gY29udGFpbmVyX29mKGtyZWYsIHN0cnVjdCBudm1lX25zLCBrcmVmKTsK IAotCWlmIChucy0+dHlwZSA9PSBOVk1FX05TX0xJR0hUTlZNKQotCQludm1lX252bV91bnJlZ2lz dGVyKG5zLT5xdWV1ZSwgbnMtPmRpc2stPmRpc2tfbmFtZSk7CisJaWYgKG5zLT5uZGV2KQorCQlu dm1lX252bV91bnJlZ2lzdGVyKG5zKTsKIAotCXNwaW5fbG9jaygmZGV2X2xpc3RfbG9jayk7Ci0J bnMtPmRpc2stPnByaXZhdGVfZGF0YSA9IE5VTEw7Ci0Jc3Bpbl91bmxvY2soJmRldl9saXN0X2xv Y2spOworCWlmIChucy0+ZGlzaykgeworCQlzcGluX2xvY2soJmRldl9saXN0X2xvY2spOworCQlu cy0+ZGlzay0+cHJpdmF0ZV9kYXRhID0gTlVMTDsKKwkJc3Bpbl91bmxvY2soJmRldl9saXN0X2xv Y2spOworCX0KIAogCXB1dF9kaXNrKG5zLT5kaXNrKTsKIAlpZGFfc2ltcGxlX3JlbW92ZSgmbnMt PmN0cmwtPm5zX2lkYSwgbnMtPmluc3RhbmNlKTsKQEAgLTc4OCw4ICs3OTAsNyBAQCBzdGF0aWMg dm9pZCBudm1lX2NvbmZpZ19kaXNjYXJkKHN0cnVjdCBudm1lX25zICpucykKIHN0YXRpYyBpbnQg bnZtZV9yZXZhbGlkYXRlX25zKHN0cnVjdCBudm1lX25zICpucywgc3RydWN0IG52bWVfaWRfbnMg KippZCkKIHsKIAlpZiAobnZtZV9pZGVudGlmeV9ucyhucy0+Y3RybCwgbnMtPm5zX2lkLCBpZCkp IHsKLQkJZGV2X3dhcm4oZGlza190b19kZXYobnMtPmRpc2spLCAiJXM6IElkZW50aWZ5IGZhaWx1 cmVcbiIsCi0JCQkJX19mdW5jX18pOworCQlkZXZfd2Fybihucy0+Y3RybC0+ZGV2LCAiJXM6IElk ZW50aWZ5IGZhaWx1cmVcbiIsIF9fZnVuY19fKTsKIAkJcmV0dXJuIC1FTk9ERVY7CiAJfQogCkBA IC0xNDczLDE4ICsxNDc0LDExIEBAIHN0YXRpYyB2b2lkIG52bWVfYWxsb2NfbnMoc3RydWN0IG52 bWVfY3RybCAqY3RybCwgdW5zaWduZWQgbnNpZCkKIAlzcHJpbnRmKGRpc2tfbmFtZSwgIm52bWUl ZG4lZCIsIGN0cmwtPmluc3RhbmNlLCBucy0+aW5zdGFuY2UpOwogCiAJaWYgKG52bWVfbnZtX25z X3N1cHBvcnRlZChucywgaWQpKSB7Ci0JCWlmIChudm1lX252bV9yZWdpc3Rlcihucy0+cXVldWUs IGRpc2tfbmFtZSkpIHsKLQkJCWRldl93YXJuKGN0cmwtPmRldiwKLQkJCQkiJXM6IExpZ2h0TlZN IGluaXQgZmFpbHVyZVxuIiwgX19mdW5jX18pOworCQlpZiAobnZtZV9udm1fcmVnaXN0ZXIobnMs IGRpc2tfbmFtZSwgbm9kZSkpIHsKKwkJCWRldl93YXJuKGN0cmwtPmRldiwgIiVzOiBMaWdodE5W TSBpbml0IGZhaWx1cmVcbiIsCisJCQkJCQkJCV9fZnVuY19fKTsKIAkJCWdvdG8gb3V0X2ZyZWVf aWQ7CiAJCX0KLQotCQlkaXNrID0gYWxsb2NfZGlza19ub2RlKDAsIG5vZGUpOwotCQlpZiAoIWRp c2spCi0JCQlnb3RvIG91dF9mcmVlX2lkOwotCQltZW1jcHkoZGlzay0+ZGlza19uYW1lLCBkaXNr X25hbWUsIERJU0tfTkFNRV9MRU4pOwotCQlucy0+ZGlzayA9IGRpc2s7Ci0JCW5zLT50eXBlID0g TlZNRV9OU19MSUdIVE5WTTsKIAl9IGVsc2UgewogCQlkaXNrID0gYWxsb2NfZGlza19ub2RlKDAs IG5vZGUpOwogCQlpZiAoIWRpc2spCkBAIC0xNTMyLDcgKzE1MjYsNyBAQCBzdGF0aWMgdm9pZCBu dm1lX25zX3JlbW92ZShzdHJ1Y3QgbnZtZV9ucyAqbnMpCiAJaWYgKHRlc3RfYW5kX3NldF9iaXQo TlZNRV9OU19SRU1PVklORywgJm5zLT5mbGFncykpCiAJCXJldHVybjsKIAotCWlmIChucy0+ZGlz ay0+ZmxhZ3MgJiBHRU5IRF9GTF9VUCkgeworCWlmIChucy0+ZGlzayAmJiBucy0+ZGlzay0+Zmxh Z3MgJiBHRU5IRF9GTF9VUCkgewogCQlpZiAoYmxrX2dldF9pbnRlZ3JpdHkobnMtPmRpc2spKQog CQkJYmxrX2ludGVncml0eV91bnJlZ2lzdGVyKG5zLT5kaXNrKTsKIAkJc3lzZnNfcmVtb3ZlX2dy b3VwKCZkaXNrX3RvX2Rldihucy0+ZGlzayktPmtvYmosCkBAIC0xNTUyLDcgKzE1NDYsNyBAQCBz dGF0aWMgdm9pZCBudm1lX3ZhbGlkYXRlX25zKHN0cnVjdCBudm1lX2N0cmwgKmN0cmwsIHVuc2ln bmVkIG5zaWQpCiAKIAlucyA9IG52bWVfZmluZF9ucyhjdHJsLCBuc2lkKTsKIAlpZiAobnMpIHsK LQkJaWYgKHJldmFsaWRhdGVfZGlzayhucy0+ZGlzaykpCisJCWlmIChucy0+ZGlzayAmJiByZXZh bGlkYXRlX2Rpc2sobnMtPmRpc2spKQogCQkJbnZtZV9uc19yZW1vdmUobnMpOwogCX0gZWxzZQog CQludm1lX2FsbG9jX25zKGN0cmwsIG5zaWQpOwpAQCAtMTg1Niw3ICsxODUwLDcgQEAgdm9pZCBu dm1lX2tpbGxfcXVldWVzKHN0cnVjdCBudm1lX2N0cmwgKmN0cmwpCiAJCSAqIFJldmFsaWRhdGlu ZyBhIGRlYWQgbmFtZXNwYWNlIHNldHMgY2FwYWNpdHkgdG8gMC4gVGhpcyB3aWxsCiAJCSAqIGVu ZCBidWZmZXJlZCB3cml0ZXJzIGRpcnR5aW5nIHBhZ2VzIHRoYXQgY2FuJ3QgYmUgc3luY2VkLgog CQkgKi8KLQkJaWYgKCF0ZXN0X2FuZF9zZXRfYml0KE5WTUVfTlNfREVBRCwgJm5zLT5mbGFncykp CisJCWlmIChucy0+ZGlzayAmJiAhdGVzdF9hbmRfc2V0X2JpdChOVk1FX05TX0RFQUQsICZucy0+ ZmxhZ3MpKQogCQkJcmV2YWxpZGF0ZV9kaXNrKG5zLT5kaXNrKTsKIAogCQlibGtfc2V0X3F1ZXVl X2R5aW5nKG5zLT5xdWV1ZSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL252bWUvaG9zdC9saWdodG52 bS5jIGIvZHJpdmVycy9udm1lL2hvc3QvbGlnaHRudm0uYwppbmRleCA5N2ZlNjEwLi4wOTVlNThl IDEwMDY0NAotLS0gYS9kcml2ZXJzL252bWUvaG9zdC9saWdodG52bS5jCisrKyBiL2RyaXZlcnMv bnZtZS9ob3N0L2xpZ2h0bnZtLmMKQEAgLTU5MiwxNCArNTkyLDI3IEBAIHN0YXRpYyBzdHJ1Y3Qg bnZtX2Rldl9vcHMgbnZtZV9udm1fZGV2X29wcyA9IHsKIAkubWF4X3BoeXNfc2VjdAkJPSA2NCwK IH07CiAKLWludCBudm1lX252bV9yZWdpc3RlcihzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSwgY2hh ciAqZGlza19uYW1lKQoraW50IG52bWVfbnZtX3JlZ2lzdGVyKHN0cnVjdCBudm1lX25zICpucywg Y2hhciAqZGlza19uYW1lLCBpbnQgbm9kZSkKIHsKLQlyZXR1cm4gbnZtX3JlZ2lzdGVyKHEsIGRp c2tfbmFtZSwgJm52bWVfbnZtX2Rldl9vcHMpOworCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0g bnMtPnF1ZXVlOworCXN0cnVjdCBudm1fZGV2ICpkZXY7CisKKwlkZXYgPSBudm1fYWxsb2NfZGV2 KG5vZGUpOworCWlmICghZGV2KQorCQlyZXR1cm4gLUVOT01FTTsKKworCWRldi0+cSA9IHE7CisJ bWVtY3B5KGRldi0+bmFtZSwgZGlza19uYW1lLCBESVNLX05BTUVfTEVOKTsKKwlkZXYtPm9wcyA9 ICZudm1lX252bV9kZXZfb3BzOworCW5zLT5uZGV2ID0gZGV2OworCisJcmV0dXJuIG52bV9yZWdp c3RlcihkZXYpOwogfQogCi12b2lkIG52bWVfbnZtX3VucmVnaXN0ZXIoc3RydWN0IHJlcXVlc3Rf cXVldWUgKnEsIGNoYXIgKmRpc2tfbmFtZSkKK3ZvaWQgbnZtZV9udm1fdW5yZWdpc3RlcihzdHJ1 Y3QgbnZtZV9ucyAqbnMpCiB7Ci0JbnZtX3VucmVnaXN0ZXIoZGlza19uYW1lKTsKKwludm1fdW5y ZWdpc3Rlcihucy0+bmRldik7CisJa2ZyZWUobnMtPm5kZXYpOwogfQogCiAvKiBtb3ZlIHRvIHNo YXJlZCBwbGFjZSB3aGVuIHVzZWQgaW4gbXVsdGlwbGUgcGxhY2VzLiAqLwpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9udm1lL2hvc3QvbnZtZS5oIGIvZHJpdmVycy9udm1lL2hvc3QvbnZtZS5oCmluZGV4 IDI4MjQyMWYuLjdiNDliNDUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbnZtZS9ob3N0L252bWUuaAor KysgYi9kcml2ZXJzL252bWUvaG9zdC9udm1lLmgKQEAgLTE4LDYgKzE4LDcgQEAKICNpbmNsdWRl IDxsaW51eC9wY2kuaD4KICNpbmNsdWRlIDxsaW51eC9rcmVmLmg+CiAjaW5jbHVkZSA8bGludXgv YmxrLW1xLmg+CisjaW5jbHVkZSA8bGludXgvbGlnaHRudm0uaD4KIAogZW51bSB7CiAJLyoKQEAg LTEyMiw2ICsxMjMsNyBAQCBzdHJ1Y3QgbnZtZV9ucyB7CiAJc3RydWN0IG52bWVfY3RybCAqY3Ry bDsKIAlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcXVldWU7CiAJc3RydWN0IGdlbmRpc2sgKmRpc2s7 CisJc3RydWN0IG52bV9kZXYgKm5kZXY7CiAJc3RydWN0IGtyZWYga3JlZjsKIAlpbnQgaW5zdGFu Y2U7CiAKQEAgLTEzMyw3ICsxMzUsNiBAQCBzdHJ1Y3QgbnZtZV9ucyB7CiAJdTE2IG1zOwogCWJv b2wgZXh0OwogCXU4IHBpX3R5cGU7Ci0JaW50IHR5cGU7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsK IAogI2RlZmluZSBOVk1FX05TX1JFTU9WSU5HIDAKQEAgLTI2OSwxMiArMjcwLDEzIEBAIGludCBu dm1lX252bV9uc19zdXBwb3J0ZWQoc3RydWN0IG52bWVfbnMgKm5zLCBzdHJ1Y3QgbnZtZV9pZF9u cyAqaWQpOwogaW50IG52bWVfbnZtX3JlZ2lzdGVyKHN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxLCBj aGFyICpkaXNrX25hbWUpOwogdm9pZCBudm1lX252bV91bnJlZ2lzdGVyKHN0cnVjdCByZXF1ZXN0 X3F1ZXVlICpxLCBjaGFyICpkaXNrX25hbWUpOwogI2Vsc2UKLXN0YXRpYyBpbmxpbmUgaW50IG52 bWVfbnZtX3JlZ2lzdGVyKHN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxLCBjaGFyICpkaXNrX25hbWUp CitzdGF0aWMgaW5saW5lIGludCBudm1lX252bV9yZWdpc3RlcihzdHJ1Y3QgbnZtZV9ucyAqbnMs IGNoYXIgKmRpc2tfbmFtZSwKKwkJCQkJCQkJaW50IG5vZGUpCiB7CiAJcmV0dXJuIDA7CiB9CiAK LXN0YXRpYyBpbmxpbmUgdm9pZCBudm1lX252bV91bnJlZ2lzdGVyKHN0cnVjdCByZXF1ZXN0X3F1 ZXVlICpxLCBjaGFyICpkaXNrX25hbWUpIHt9Oworc3RhdGljIGlubGluZSB2b2lkIG52bWVfbnZt X3VucmVnaXN0ZXIoc3RydWN0IG52bWVfbnMgKm5zKSB7fTsKIAogc3RhdGljIGlubGluZSBpbnQg bnZtZV9udm1fbnNfc3VwcG9ydGVkKHN0cnVjdCBudm1lX25zICpucywgc3RydWN0IG52bWVfaWRf bnMgKmlkKQogewpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9saWdodG52bS5oIGIvaW5jbHVk ZS9saW51eC9saWdodG52bS5oCmluZGV4IGJhNzhiODMuLjVhZmMyNjMgMTAwNjQ0Ci0tLSBhL2lu Y2x1ZGUvbGludXgvbGlnaHRudm0uaAorKysgYi9pbmNsdWRlL2xpbnV4L2xpZ2h0bnZtLmgKQEAg LTUyNCw5ICs1MjQsOSBAQCBleHRlcm4gc3RydWN0IG52bV9ibG9jayAqbnZtX2dldF9ibGsoc3Ry dWN0IG52bV9kZXYgKiwgc3RydWN0IG52bV9sdW4gKiwKIAkJCQkJCQkJdW5zaWduZWQgbG9uZyk7 CiBleHRlcm4gdm9pZCBudm1fcHV0X2JsayhzdHJ1Y3QgbnZtX2RldiAqLCBzdHJ1Y3QgbnZtX2Js b2NrICopOwogCi1leHRlcm4gaW50IG52bV9yZWdpc3RlcihzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAq LCBjaGFyICosCi0JCQkJCQlzdHJ1Y3QgbnZtX2Rldl9vcHMgKik7Ci1leHRlcm4gdm9pZCBudm1f dW5yZWdpc3RlcihjaGFyICopOworZXh0ZXJuIHN0cnVjdCBudm1fZGV2ICpudm1fYWxsb2NfZGV2 KGludCk7CitleHRlcm4gaW50IG52bV9yZWdpc3RlcihzdHJ1Y3QgbnZtX2RldiAqKTsKK2V4dGVy biB2b2lkIG52bV91bnJlZ2lzdGVyKHN0cnVjdCBudm1fZGV2ICopOwogCiB2b2lkIG52bV9tYXJr X2JsayhzdHJ1Y3QgbnZtX2RldiAqZGV2LCBzdHJ1Y3QgcHBhX2FkZHIgcHBhLCBpbnQgdHlwZSk7 CiAKQEAgLTU3NSwxMSArNTc1LDE0IEBAIGV4dGVybiBpbnQgbnZtX2Rldl9mYWN0b3J5KHN0cnVj dCBudm1fZGV2ICosIGludCBmbGFncyk7CiAjZWxzZSAvKiBDT05GSUdfTlZNICovCiBzdHJ1Y3Qg bnZtX2Rldl9vcHM7CiAKLXN0YXRpYyBpbmxpbmUgaW50IG52bV9yZWdpc3RlcihzdHJ1Y3QgcmVx dWVzdF9xdWV1ZSAqcSwgY2hhciAqZGlza19uYW1lLAotCQkJCQkJCXN0cnVjdCBudm1fZGV2X29w cyAqb3BzKQorc3RhdGljIGlubGluZSBzdHJ1Y3QgbnZtX2RldiAqbnZtX2FsbG9jX2RldihpbnQg bm9kZSkKK3sKKwlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTsKK30KK3N0YXRpYyBpbmxpbmUgaW50 IG52bV9yZWdpc3RlcihzdHJ1Y3QgbnZtX2RldiAqZGV2KQogewogCXJldHVybiAtRUlOVkFMOwog fQotc3RhdGljIGlubGluZSB2b2lkIG52bV91bnJlZ2lzdGVyKGNoYXIgKmRpc2tfbmFtZSkge30K K3N0YXRpYyBpbmxpbmUgdm9pZCBudm1fdW5yZWdpc3RlcihzdHJ1Y3QgbnZtX2RldiAqZGV2KSB7 fQogI2VuZGlmIC8qIENPTkZJR19OVk0gKi8KICNlbmRpZiAvKiBMSUdIVE5WTS5IICovCi0tIAoy LjEuNAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkxp bnV4LW52bWUgbWFpbGluZyBsaXN0CkxpbnV4LW52bWVAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRw Oi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LW52bWUK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932869AbcFJMVt (ORCPT ); Fri, 10 Jun 2016 08:21:49 -0400 Received: from mail-wm0-f67.google.com ([74.125.82.67]:34854 "EHLO mail-wm0-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932702AbcFJMVd (ORCPT ); Fri, 10 Jun 2016 08:21:33 -0400 From: =?UTF-8?q?Matias=20Bj=C3=B8rling?= To: linux-block@vger.kernel.org, linux-kernel@vger.kernel.org, axboe@fb.com, keith.busch@intel.com, linux-nvme@lists.infradead.org Cc: =?UTF-8?q?Matias=20Bj=C3=B8rling?= Subject: [PATCH 4/6] lightnvm: let drivers control the lifetime of nvm_dev Date: Fri, 10 Jun 2016 14:21:00 +0200 Message-Id: <1465561262-13789-5-git-send-email-m@bjorling.me> X-Mailer: git-send-email 2.1.4 In-Reply-To: <1465561262-13789-1-git-send-email-m@bjorling.me> References: <1465561262-13789-1-git-send-email-m@bjorling.me> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org LightNVM does not currently expose the device driver sysfs specific entries to user-space, as the device driver skips the initialization of gendisk. To enable a device driver sysfs entries to be exposed, we need a struct device to attach it to. To allow both the device driver and LightNVM to access the same struct device, we need the device driver to track the lifetime of the nvm_dev structure. This patch refactors the two users of LightNVM (NVMe and null_blk), enables them to allocate and free nvm_dev, and at last removes gendisk usage when a LightNVM device is used. Signed-off-by: Matias Bjørling --- drivers/block/null_blk.c | 22 ++++++++++++++++++++-- drivers/lightnvm/core.c | 34 +++++++--------------------------- drivers/nvme/host/core.c | 34 ++++++++++++++-------------------- drivers/nvme/host/lightnvm.c | 21 +++++++++++++++++---- drivers/nvme/host/nvme.h | 8 +++++--- include/linux/lightnvm.h | 15 +++++++++------ 6 files changed, 72 insertions(+), 62 deletions(-) diff --git a/drivers/block/null_blk.c b/drivers/block/null_blk.c index 3117df1..5a0da8b 100644 --- a/drivers/block/null_blk.c +++ b/drivers/block/null_blk.c @@ -34,6 +34,7 @@ struct nullb { unsigned int index; struct request_queue *q; struct gendisk *disk; + struct nvm_dev *ndev; struct blk_mq_tag_set tag_set; struct hrtimer timer; unsigned int queue_depth; @@ -550,12 +551,29 @@ static struct nvm_dev_ops null_lnvm_dev_ops = { static int null_nvm_register(struct nullb *nullb) { - return nvm_register(nullb->q, nullb->disk_name, &null_lnvm_dev_ops); + struct nvm_dev *dev; + int rv; + + dev = nvm_alloc_dev(0); + if (!dev) + return -ENOMEM; + + dev->q = nullb->q; + memcpy(dev->name, nullb->disk_name, DISK_NAME_LEN); + dev->ops = &null_lnvm_dev_ops; + + rv = nvm_register(dev); + if (rv) { + kfree(dev); + return rv; + } + nullb->ndev = dev; + return 0; } static void null_nvm_unregister(struct nullb *nullb) { - nvm_unregister(nullb->disk_name); + nvm_unregister(nullb->ndev); } #else static int null_nvm_register(struct nullb *nullb) diff --git a/drivers/lightnvm/core.c b/drivers/lightnvm/core.c index 4574c0b..ad27768 100644 --- a/drivers/lightnvm/core.c +++ b/drivers/lightnvm/core.c @@ -655,23 +655,15 @@ static void nvm_exit(struct nvm_dev *dev) pr_info("nvm: successfully unloaded\n"); } -int nvm_register(struct request_queue *q, char *disk_name, - struct nvm_dev_ops *ops) +struct nvm_dev *nvm_alloc_dev(int node) +{ + return kzalloc_node(sizeof(struct nvm_dev), GFP_KERNEL, node); +} + +int nvm_register(struct nvm_dev *dev) { - struct nvm_dev *dev; int ret; - if (!ops->identity) - return -EINVAL; - - dev = kzalloc(sizeof(struct nvm_dev), GFP_KERNEL); - if (!dev) - return -ENOMEM; - - dev->q = q; - dev->ops = ops; - strncpy(dev->name, disk_name, DISK_NAME_LEN); - ret = nvm_init(dev); if (ret) goto err_init; @@ -709,29 +701,17 @@ int nvm_register(struct request_queue *q, char *disk_name, return 0; err_init: kfree(dev->lun_map); - kfree(dev); return ret; } EXPORT_SYMBOL(nvm_register); -void nvm_unregister(char *disk_name) +void nvm_unregister(struct nvm_dev *dev) { - struct nvm_dev *dev; - down_write(&nvm_lock); - dev = nvm_find_nvm_dev(disk_name); - if (!dev) { - pr_err("nvm: could not find device %s to unregister\n", - disk_name); - up_write(&nvm_lock); - return; - } - list_del(&dev->devices); up_write(&nvm_lock); nvm_exit(dev); - kfree(dev); } EXPORT_SYMBOL(nvm_unregister); diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c index f615b6b..fe135d9 100644 --- a/drivers/nvme/host/core.c +++ b/drivers/nvme/host/core.c @@ -137,12 +137,14 @@ static void nvme_free_ns(struct kref *kref) { struct nvme_ns *ns = container_of(kref, struct nvme_ns, kref); - if (ns->type == NVME_NS_LIGHTNVM) - nvme_nvm_unregister(ns->queue, ns->disk->disk_name); + if (ns->ndev) + nvme_nvm_unregister(ns); - spin_lock(&dev_list_lock); - ns->disk->private_data = NULL; - spin_unlock(&dev_list_lock); + if (ns->disk) { + spin_lock(&dev_list_lock); + ns->disk->private_data = NULL; + spin_unlock(&dev_list_lock); + } put_disk(ns->disk); ida_simple_remove(&ns->ctrl->ns_ida, ns->instance); @@ -788,8 +790,7 @@ static void nvme_config_discard(struct nvme_ns *ns) static int nvme_revalidate_ns(struct nvme_ns *ns, struct nvme_id_ns **id) { if (nvme_identify_ns(ns->ctrl, ns->ns_id, id)) { - dev_warn(disk_to_dev(ns->disk), "%s: Identify failure\n", - __func__); + dev_warn(ns->ctrl->dev, "%s: Identify failure\n", __func__); return -ENODEV; } @@ -1473,18 +1474,11 @@ static void nvme_alloc_ns(struct nvme_ctrl *ctrl, unsigned nsid) sprintf(disk_name, "nvme%dn%d", ctrl->instance, ns->instance); if (nvme_nvm_ns_supported(ns, id)) { - if (nvme_nvm_register(ns->queue, disk_name)) { - dev_warn(ctrl->dev, - "%s: LightNVM init failure\n", __func__); + if (nvme_nvm_register(ns, disk_name, node)) { + dev_warn(ctrl->dev, "%s: LightNVM init failure\n", + __func__); goto out_free_id; } - - disk = alloc_disk_node(0, node); - if (!disk) - goto out_free_id; - memcpy(disk->disk_name, disk_name, DISK_NAME_LEN); - ns->disk = disk; - ns->type = NVME_NS_LIGHTNVM; } else { disk = alloc_disk_node(0, node); if (!disk) @@ -1532,7 +1526,7 @@ static void nvme_ns_remove(struct nvme_ns *ns) if (test_and_set_bit(NVME_NS_REMOVING, &ns->flags)) return; - if (ns->disk->flags & GENHD_FL_UP) { + if (ns->disk && ns->disk->flags & GENHD_FL_UP) { if (blk_get_integrity(ns->disk)) blk_integrity_unregister(ns->disk); sysfs_remove_group(&disk_to_dev(ns->disk)->kobj, @@ -1552,7 +1546,7 @@ static void nvme_validate_ns(struct nvme_ctrl *ctrl, unsigned nsid) ns = nvme_find_ns(ctrl, nsid); if (ns) { - if (revalidate_disk(ns->disk)) + if (ns->disk && revalidate_disk(ns->disk)) nvme_ns_remove(ns); } else nvme_alloc_ns(ctrl, nsid); @@ -1856,7 +1850,7 @@ void nvme_kill_queues(struct nvme_ctrl *ctrl) * Revalidating a dead namespace sets capacity to 0. This will * end buffered writers dirtying pages that can't be synced. */ - if (!test_and_set_bit(NVME_NS_DEAD, &ns->flags)) + if (ns->disk && !test_and_set_bit(NVME_NS_DEAD, &ns->flags)) revalidate_disk(ns->disk); blk_set_queue_dying(ns->queue); diff --git a/drivers/nvme/host/lightnvm.c b/drivers/nvme/host/lightnvm.c index 97fe610..095e58e 100644 --- a/drivers/nvme/host/lightnvm.c +++ b/drivers/nvme/host/lightnvm.c @@ -592,14 +592,27 @@ static struct nvm_dev_ops nvme_nvm_dev_ops = { .max_phys_sect = 64, }; -int nvme_nvm_register(struct request_queue *q, char *disk_name) +int nvme_nvm_register(struct nvme_ns *ns, char *disk_name, int node) { - return nvm_register(q, disk_name, &nvme_nvm_dev_ops); + struct request_queue *q = ns->queue; + struct nvm_dev *dev; + + dev = nvm_alloc_dev(node); + if (!dev) + return -ENOMEM; + + dev->q = q; + memcpy(dev->name, disk_name, DISK_NAME_LEN); + dev->ops = &nvme_nvm_dev_ops; + ns->ndev = dev; + + return nvm_register(dev); } -void nvme_nvm_unregister(struct request_queue *q, char *disk_name) +void nvme_nvm_unregister(struct nvme_ns *ns) { - nvm_unregister(disk_name); + nvm_unregister(ns->ndev); + kfree(ns->ndev); } /* move to shared place when used in multiple places. */ diff --git a/drivers/nvme/host/nvme.h b/drivers/nvme/host/nvme.h index 282421f..7b49b45 100644 --- a/drivers/nvme/host/nvme.h +++ b/drivers/nvme/host/nvme.h @@ -18,6 +18,7 @@ #include #include #include +#include enum { /* @@ -122,6 +123,7 @@ struct nvme_ns { struct nvme_ctrl *ctrl; struct request_queue *queue; struct gendisk *disk; + struct nvm_dev *ndev; struct kref kref; int instance; @@ -133,7 +135,6 @@ struct nvme_ns { u16 ms; bool ext; u8 pi_type; - int type; unsigned long flags; #define NVME_NS_REMOVING 0 @@ -269,12 +270,13 @@ int nvme_nvm_ns_supported(struct nvme_ns *ns, struct nvme_id_ns *id); int nvme_nvm_register(struct request_queue *q, char *disk_name); void nvme_nvm_unregister(struct request_queue *q, char *disk_name); #else -static inline int nvme_nvm_register(struct request_queue *q, char *disk_name) +static inline int nvme_nvm_register(struct nvme_ns *ns, char *disk_name, + int node) { return 0; } -static inline void nvme_nvm_unregister(struct request_queue *q, char *disk_name) {}; +static inline void nvme_nvm_unregister(struct nvme_ns *ns) {}; static inline int nvme_nvm_ns_supported(struct nvme_ns *ns, struct nvme_id_ns *id) { diff --git a/include/linux/lightnvm.h b/include/linux/lightnvm.h index ba78b83..5afc263 100644 --- a/include/linux/lightnvm.h +++ b/include/linux/lightnvm.h @@ -524,9 +524,9 @@ extern struct nvm_block *nvm_get_blk(struct nvm_dev *, struct nvm_lun *, unsigned long); extern void nvm_put_blk(struct nvm_dev *, struct nvm_block *); -extern int nvm_register(struct request_queue *, char *, - struct nvm_dev_ops *); -extern void nvm_unregister(char *); +extern struct nvm_dev *nvm_alloc_dev(int); +extern int nvm_register(struct nvm_dev *); +extern void nvm_unregister(struct nvm_dev *); void nvm_mark_blk(struct nvm_dev *dev, struct ppa_addr ppa, int type); @@ -575,11 +575,14 @@ extern int nvm_dev_factory(struct nvm_dev *, int flags); #else /* CONFIG_NVM */ struct nvm_dev_ops; -static inline int nvm_register(struct request_queue *q, char *disk_name, - struct nvm_dev_ops *ops) +static inline struct nvm_dev *nvm_alloc_dev(int node) +{ + return ERR_PTR(-EINVAL); +} +static inline int nvm_register(struct nvm_dev *dev) { return -EINVAL; } -static inline void nvm_unregister(char *disk_name) {} +static inline void nvm_unregister(struct nvm_dev *dev) {} #endif /* CONFIG_NVM */ #endif /* LIGHTNVM.H */ -- 2.1.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: m@bjorling.me (=?UTF-8?q?Matias=20Bj=C3=B8rling?=) Date: Fri, 10 Jun 2016 14:21:00 +0200 Subject: [PATCH 4/6] lightnvm: let drivers control the lifetime of nvm_dev In-Reply-To: <1465561262-13789-1-git-send-email-m@bjorling.me> References: <1465561262-13789-1-git-send-email-m@bjorling.me> Message-ID: <1465561262-13789-5-git-send-email-m@bjorling.me> LightNVM does not currently expose the device driver sysfs specific entries to user-space, as the device driver skips the initialization of gendisk. To enable a device driver sysfs entries to be exposed, we need a struct device to attach it to. To allow both the device driver and LightNVM to access the same struct device, we need the device driver to track the lifetime of the nvm_dev structure. This patch refactors the two users of LightNVM (NVMe and null_blk), enables them to allocate and free nvm_dev, and at last removes gendisk usage when a LightNVM device is used. Signed-off-by: Matias Bj?rling --- drivers/block/null_blk.c | 22 ++++++++++++++++++++-- drivers/lightnvm/core.c | 34 +++++++--------------------------- drivers/nvme/host/core.c | 34 ++++++++++++++-------------------- drivers/nvme/host/lightnvm.c | 21 +++++++++++++++++---- drivers/nvme/host/nvme.h | 8 +++++--- include/linux/lightnvm.h | 15 +++++++++------ 6 files changed, 72 insertions(+), 62 deletions(-) diff --git a/drivers/block/null_blk.c b/drivers/block/null_blk.c index 3117df1..5a0da8b 100644 --- a/drivers/block/null_blk.c +++ b/drivers/block/null_blk.c @@ -34,6 +34,7 @@ struct nullb { unsigned int index; struct request_queue *q; struct gendisk *disk; + struct nvm_dev *ndev; struct blk_mq_tag_set tag_set; struct hrtimer timer; unsigned int queue_depth; @@ -550,12 +551,29 @@ static struct nvm_dev_ops null_lnvm_dev_ops = { static int null_nvm_register(struct nullb *nullb) { - return nvm_register(nullb->q, nullb->disk_name, &null_lnvm_dev_ops); + struct nvm_dev *dev; + int rv; + + dev = nvm_alloc_dev(0); + if (!dev) + return -ENOMEM; + + dev->q = nullb->q; + memcpy(dev->name, nullb->disk_name, DISK_NAME_LEN); + dev->ops = &null_lnvm_dev_ops; + + rv = nvm_register(dev); + if (rv) { + kfree(dev); + return rv; + } + nullb->ndev = dev; + return 0; } static void null_nvm_unregister(struct nullb *nullb) { - nvm_unregister(nullb->disk_name); + nvm_unregister(nullb->ndev); } #else static int null_nvm_register(struct nullb *nullb) diff --git a/drivers/lightnvm/core.c b/drivers/lightnvm/core.c index 4574c0b..ad27768 100644 --- a/drivers/lightnvm/core.c +++ b/drivers/lightnvm/core.c @@ -655,23 +655,15 @@ static void nvm_exit(struct nvm_dev *dev) pr_info("nvm: successfully unloaded\n"); } -int nvm_register(struct request_queue *q, char *disk_name, - struct nvm_dev_ops *ops) +struct nvm_dev *nvm_alloc_dev(int node) +{ + return kzalloc_node(sizeof(struct nvm_dev), GFP_KERNEL, node); +} + +int nvm_register(struct nvm_dev *dev) { - struct nvm_dev *dev; int ret; - if (!ops->identity) - return -EINVAL; - - dev = kzalloc(sizeof(struct nvm_dev), GFP_KERNEL); - if (!dev) - return -ENOMEM; - - dev->q = q; - dev->ops = ops; - strncpy(dev->name, disk_name, DISK_NAME_LEN); - ret = nvm_init(dev); if (ret) goto err_init; @@ -709,29 +701,17 @@ int nvm_register(struct request_queue *q, char *disk_name, return 0; err_init: kfree(dev->lun_map); - kfree(dev); return ret; } EXPORT_SYMBOL(nvm_register); -void nvm_unregister(char *disk_name) +void nvm_unregister(struct nvm_dev *dev) { - struct nvm_dev *dev; - down_write(&nvm_lock); - dev = nvm_find_nvm_dev(disk_name); - if (!dev) { - pr_err("nvm: could not find device %s to unregister\n", - disk_name); - up_write(&nvm_lock); - return; - } - list_del(&dev->devices); up_write(&nvm_lock); nvm_exit(dev); - kfree(dev); } EXPORT_SYMBOL(nvm_unregister); diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c index f615b6b..fe135d9 100644 --- a/drivers/nvme/host/core.c +++ b/drivers/nvme/host/core.c @@ -137,12 +137,14 @@ static void nvme_free_ns(struct kref *kref) { struct nvme_ns *ns = container_of(kref, struct nvme_ns, kref); - if (ns->type == NVME_NS_LIGHTNVM) - nvme_nvm_unregister(ns->queue, ns->disk->disk_name); + if (ns->ndev) + nvme_nvm_unregister(ns); - spin_lock(&dev_list_lock); - ns->disk->private_data = NULL; - spin_unlock(&dev_list_lock); + if (ns->disk) { + spin_lock(&dev_list_lock); + ns->disk->private_data = NULL; + spin_unlock(&dev_list_lock); + } put_disk(ns->disk); ida_simple_remove(&ns->ctrl->ns_ida, ns->instance); @@ -788,8 +790,7 @@ static void nvme_config_discard(struct nvme_ns *ns) static int nvme_revalidate_ns(struct nvme_ns *ns, struct nvme_id_ns **id) { if (nvme_identify_ns(ns->ctrl, ns->ns_id, id)) { - dev_warn(disk_to_dev(ns->disk), "%s: Identify failure\n", - __func__); + dev_warn(ns->ctrl->dev, "%s: Identify failure\n", __func__); return -ENODEV; } @@ -1473,18 +1474,11 @@ static void nvme_alloc_ns(struct nvme_ctrl *ctrl, unsigned nsid) sprintf(disk_name, "nvme%dn%d", ctrl->instance, ns->instance); if (nvme_nvm_ns_supported(ns, id)) { - if (nvme_nvm_register(ns->queue, disk_name)) { - dev_warn(ctrl->dev, - "%s: LightNVM init failure\n", __func__); + if (nvme_nvm_register(ns, disk_name, node)) { + dev_warn(ctrl->dev, "%s: LightNVM init failure\n", + __func__); goto out_free_id; } - - disk = alloc_disk_node(0, node); - if (!disk) - goto out_free_id; - memcpy(disk->disk_name, disk_name, DISK_NAME_LEN); - ns->disk = disk; - ns->type = NVME_NS_LIGHTNVM; } else { disk = alloc_disk_node(0, node); if (!disk) @@ -1532,7 +1526,7 @@ static void nvme_ns_remove(struct nvme_ns *ns) if (test_and_set_bit(NVME_NS_REMOVING, &ns->flags)) return; - if (ns->disk->flags & GENHD_FL_UP) { + if (ns->disk && ns->disk->flags & GENHD_FL_UP) { if (blk_get_integrity(ns->disk)) blk_integrity_unregister(ns->disk); sysfs_remove_group(&disk_to_dev(ns->disk)->kobj, @@ -1552,7 +1546,7 @@ static void nvme_validate_ns(struct nvme_ctrl *ctrl, unsigned nsid) ns = nvme_find_ns(ctrl, nsid); if (ns) { - if (revalidate_disk(ns->disk)) + if (ns->disk && revalidate_disk(ns->disk)) nvme_ns_remove(ns); } else nvme_alloc_ns(ctrl, nsid); @@ -1856,7 +1850,7 @@ void nvme_kill_queues(struct nvme_ctrl *ctrl) * Revalidating a dead namespace sets capacity to 0. This will * end buffered writers dirtying pages that can't be synced. */ - if (!test_and_set_bit(NVME_NS_DEAD, &ns->flags)) + if (ns->disk && !test_and_set_bit(NVME_NS_DEAD, &ns->flags)) revalidate_disk(ns->disk); blk_set_queue_dying(ns->queue); diff --git a/drivers/nvme/host/lightnvm.c b/drivers/nvme/host/lightnvm.c index 97fe610..095e58e 100644 --- a/drivers/nvme/host/lightnvm.c +++ b/drivers/nvme/host/lightnvm.c @@ -592,14 +592,27 @@ static struct nvm_dev_ops nvme_nvm_dev_ops = { .max_phys_sect = 64, }; -int nvme_nvm_register(struct request_queue *q, char *disk_name) +int nvme_nvm_register(struct nvme_ns *ns, char *disk_name, int node) { - return nvm_register(q, disk_name, &nvme_nvm_dev_ops); + struct request_queue *q = ns->queue; + struct nvm_dev *dev; + + dev = nvm_alloc_dev(node); + if (!dev) + return -ENOMEM; + + dev->q = q; + memcpy(dev->name, disk_name, DISK_NAME_LEN); + dev->ops = &nvme_nvm_dev_ops; + ns->ndev = dev; + + return nvm_register(dev); } -void nvme_nvm_unregister(struct request_queue *q, char *disk_name) +void nvme_nvm_unregister(struct nvme_ns *ns) { - nvm_unregister(disk_name); + nvm_unregister(ns->ndev); + kfree(ns->ndev); } /* move to shared place when used in multiple places. */ diff --git a/drivers/nvme/host/nvme.h b/drivers/nvme/host/nvme.h index 282421f..7b49b45 100644 --- a/drivers/nvme/host/nvme.h +++ b/drivers/nvme/host/nvme.h @@ -18,6 +18,7 @@ #include #include #include +#include enum { /* @@ -122,6 +123,7 @@ struct nvme_ns { struct nvme_ctrl *ctrl; struct request_queue *queue; struct gendisk *disk; + struct nvm_dev *ndev; struct kref kref; int instance; @@ -133,7 +135,6 @@ struct nvme_ns { u16 ms; bool ext; u8 pi_type; - int type; unsigned long flags; #define NVME_NS_REMOVING 0 @@ -269,12 +270,13 @@ int nvme_nvm_ns_supported(struct nvme_ns *ns, struct nvme_id_ns *id); int nvme_nvm_register(struct request_queue *q, char *disk_name); void nvme_nvm_unregister(struct request_queue *q, char *disk_name); #else -static inline int nvme_nvm_register(struct request_queue *q, char *disk_name) +static inline int nvme_nvm_register(struct nvme_ns *ns, char *disk_name, + int node) { return 0; } -static inline void nvme_nvm_unregister(struct request_queue *q, char *disk_name) {}; +static inline void nvme_nvm_unregister(struct nvme_ns *ns) {}; static inline int nvme_nvm_ns_supported(struct nvme_ns *ns, struct nvme_id_ns *id) { diff --git a/include/linux/lightnvm.h b/include/linux/lightnvm.h index ba78b83..5afc263 100644 --- a/include/linux/lightnvm.h +++ b/include/linux/lightnvm.h @@ -524,9 +524,9 @@ extern struct nvm_block *nvm_get_blk(struct nvm_dev *, struct nvm_lun *, unsigned long); extern void nvm_put_blk(struct nvm_dev *, struct nvm_block *); -extern int nvm_register(struct request_queue *, char *, - struct nvm_dev_ops *); -extern void nvm_unregister(char *); +extern struct nvm_dev *nvm_alloc_dev(int); +extern int nvm_register(struct nvm_dev *); +extern void nvm_unregister(struct nvm_dev *); void nvm_mark_blk(struct nvm_dev *dev, struct ppa_addr ppa, int type); @@ -575,11 +575,14 @@ extern int nvm_dev_factory(struct nvm_dev *, int flags); #else /* CONFIG_NVM */ struct nvm_dev_ops; -static inline int nvm_register(struct request_queue *q, char *disk_name, - struct nvm_dev_ops *ops) +static inline struct nvm_dev *nvm_alloc_dev(int node) +{ + return ERR_PTR(-EINVAL); +} +static inline int nvm_register(struct nvm_dev *dev) { return -EINVAL; } -static inline void nvm_unregister(char *disk_name) {} +static inline void nvm_unregister(struct nvm_dev *dev) {} #endif /* CONFIG_NVM */ #endif /* LIGHTNVM.H */ -- 2.1.4