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=-9.8 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, MIME_BASE64_TEXT,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,UNPARSEABLE_RELAY, URIBL_BLOCKED,USER_AGENT_GIT 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 92B66C3F2DA for ; Wed, 4 Mar 2020 03:12:35 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 6113020CC7 for ; Wed, 4 Mar 2020 03:12:35 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="jYb7MVdA" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2387609AbgCDDMe (ORCPT ); Tue, 3 Mar 2020 22:12:34 -0500 Received: from mailgw01.mediatek.com ([210.61.82.183]:39422 "EHLO mailgw01.mediatek.com" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S2387492AbgCDDMe (ORCPT ); Tue, 3 Mar 2020 22:12:34 -0500 X-UUID: d37ebb97004e437a8a6ffd59d925eac1-20200304 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Transfer-Encoding:Content-Type:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=+OjRhnFwB7N+qUCZlu/luvxZ8XB1cxUBw5E13DY1Vig=; b=jYb7MVdAEqvJbOaA2eJDe6Qfk+Jo76IwnhSePs48yJqcaO2a7NauYtI27KqrMWmzwuhOKfIvS0EvfPVEmKN5/YDZKDnKuhAKlJJNjiofqrlBwNNE6j1c6UMduF5jg/at5By8R/B1kaaPUtvTlJi7KKR8Be/nahC5gaOWtRcASwc=; X-UUID: d37ebb97004e437a8a6ffd59d925eac1-20200304 Received: from mtkcas06.mediatek.inc [(172.21.101.30)] by mailgw01.mediatek.com (envelope-from ) (Cellopoint E-mail Firewall v4.1.10 Build 0809 with TLS) with ESMTP id 682217633; Wed, 04 Mar 2020 11:12:20 +0800 Received: from MTKCAS06.mediatek.inc (172.21.101.30) by mtkmbs02n1.mediatek.inc (172.21.101.77) with Microsoft SMTP Server (TLS) id 15.0.1395.4; Wed, 4 Mar 2020 11:10:17 +0800 Received: from mtkswgap22.mediatek.inc (172.21.77.33) by MTKCAS06.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1395.4 via Frontend Transport; Wed, 4 Mar 2020 11:09:47 +0800 From: To: CC: , , , , , , Light Hsieh Subject: [RESEND PATCH v1 2/3] mmc: check write-protection status during BLKROSET ioctl Date: Wed, 4 Mar 2020 11:12:16 +0800 Message-ID: <1583291537-15053-3-git-send-email-light.hsieh@mediatek.com> X-Mailer: git-send-email 1.8.1.1.dirty In-Reply-To: <1583291537-15053-1-git-send-email-light.hsieh@mediatek.com> References: <1583291537-15053-1-git-send-email-light.hsieh@mediatek.com> MIME-Version: 1.0 Content-Type: text/plain X-MTK: N Content-Transfer-Encoding: base64 Sender: linux-block-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org RnJvbTogTGlnaHQgSHNpZWggPGxpZ2h0LmhzaWVoQG1lZGlhdGVrLmNvbT4NCg0KU2luY2UgTU1D IGxheWVyIGRvZXMgbm90IGltcGxlbWVudCBCTEtST1NFVCBpb2N0bCwgQkxLUk9TRVQgaW9jdGwg dGhhdA0KdHJpZXMgdG8gY2xlYXIgcm8gYXR0cmlidXRlIG9mIGFuIG1tY2JsayBkZXZpY2Ugd2ls bCBnZXQgLUVJTlZBTCBmcm9tDQpfX2Jsa2Rldl9kcml2ZXJfaW9jdGwoKS4gYmxrZGV2X3Jvc2V0 KCkgcmVnYXJkIC1FSU5WQUwgYXMgInVucmVjb2dpemVkDQppb2N0bCIgYW5kIHRoZW4gY2xlYXIg dGhlIHJvIGF0dHJpYnV0ZSB1bi1jb25kaXRpb25hbGx5Lg0KSG93ZXZlciwgd2hlbiBlTU1DIHdy aXRlLXByb3RlY3Rpb24gKHBvd2VyLW9uLCB0ZW1wb3JhcmlseSB3cml0ZSwgb3INCnBlcm1hbmVu dCkgaXMgZW5hYmxlZCBpbiBzb21lIGFyZWEsIHRoaXMgdW4tY29uZGl0aW9uYWwgY2xlYXIgb2Yg cm8NCndpbGwgbGVhZCB0byBpc3N1ZS4gRnJvbSB1c2VyJ3MgdmlldywgZU1NQyBkZXZpY2UgaXMg d3JpdGFibGUgc2luY2Ugcm8NCmlzIG5vdCBzZXQuIEJ1dCB3cml0ZSBvcGVyYXRpb24gc2VudCB0 byBlTU1DIHdpbGwgZ2V0IHdyaXRlLXByb3RlY3Rpb24NCmVycm9yLiBTaW5jZSBtb3N0IHdyaXRl IGFyZSBhc3luY2hyb251cyBidWZmZXJlZCB3cml0ZSwgc3VjaA0Kd3JpdGUtcHJvdGVjdGlvbiBl cnJvciB3b24ndCBiZSBkZWxpdmVyZWQgdG8gdXNlciB3aG8gc2VuZCB0aGUgd3JpdGUNCm9wZXJh dGlvbi4NCg0KVGhpcyBwYXRjaCBpbXBsZW1lbnQgQkxLUk9TRVQgaW4gTU1DIGxheWVyLg0KMS4g Rm9yIFNEIGRldmljZSwgMCBpcyByZXR1cmVkLg0KMi4gRm9yIHNldHRpbmcgcm8gdG8gZU1NQyBh cmVhLCAwIGlzIHJldHVybmVkIHdpdGhvdXQgYW55IG90aGVyIGNoZWNrLg0KMi4gRm9yIGNsZWFy aW5nIHJvIHRvIGVNTUMgYXJlYSwgd3JpdGUtcHJvZXRjdGlvbiBzdGF0dXMgaXMgY2hlY2tlZDoN CjJhLiBGb3IgYm9vdDAgb3IgYm9vdDEgcGFydGl0aW9uLCBib290X3dwX3N0YXR1cyBnZXQgZnJv bSBFWFRDU0QgaXMNCiAgICBjaGVja2VkLg0KICAgIC1FQUNDRVMgaXMgcmV0dXJuZWQgd2hlbiB0 aGUgdGFyZ2V0IGJvb3QgcGFydGl0aW9uIGlzIHdyaXRlLXByb3RlY3RlZDsNCiAgICAwIGlzIHJl dHVybmVkIG90aGVyd2lzZS4NCjJiLiBGb3IgdXNlciBhcmVhIHBhcnRpdGlvbiwgb25lIG9yIG1v cmUgTU1DX1NFTkRfV1JJVEVfUFJPVF9UWVBFIGNvbW1hbmRzDQogICAgYXJlIHNlbnQgdG8gZ2V0 L2NoZWNrIHdyaXRlLXByb3RlY3Rpb24gc3RhdHVzIG9mIHRhcmdldCBhZGRyZXNzIHJhbmdlLg0K ICAgIC1FQUNDRVMgaXMgcmV0dXJuZWQgd2hlbiB0YXJnZXQgYWRkcmVzcyByYW5nZSBpcyBmdWxs eS9wYXJ0aWFsbHkNCiAgICAgICAgICAgIHdyaXRlLXByb3RlY3RlZDsNCiAgICAwIGlzIHJldHVy bmVkIG90aGVyd2lzZS4NCg0KV2l0aCB0aGUgYWJvdmUgaW1wbGVtZW50YXRpb24gYW5kIGNvcnJl Y3QgaW9jdGwgcGFyYW1ldGVycywgcmV0dXJuIHZhbHVlDQpvZiBfX2Jsa2Rldl9kcml2ZXJfaW9j dGwoKSB3aWxsIGJlIDAgb3IgLUVBQ0NFUy4gYmxrZGV2X3Jvc2V0KCkgY2FuIGNvbnRpbnVlDQp0 byBjbGVhciBybyBhdHRyaWJ1dGUgd2hlbiByZXR1cm4gdmFsdWUgaXMgMCwgd2hpY2ggbWVhbnMg d2hvbGUgdGFyZ2V0IGVNTUMNCmFkZHJlc3MgcmFuZ2UgaXMgbm90IHdyaXRlLXByb3RlY3RlZC4N Cg0KU2lnbmVkLW9mZi1ieTogTGlnaHQgSHNpZWggPGxpZ2h0LmhzaWVoQG1lZGlhdGVrLmNvbT4N Ci0tLQ0KIGJsb2NrL2lvY3RsLmMgICAgICAgICAgICB8ICAgMiArLQ0KIGRyaXZlcnMvbW1jL2Nv cmUvYmxvY2suYyB8IDIxNiArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKw0KIGluY2x1ZGUvbGludXgvbW1jL21tYy5oICB8ICAgMSArDQogMyBmaWxlcyBjaGFu Z2VkLCAyMTggaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQ0KDQpkaWZmIC0tZ2l0IGEvYmxv Y2svaW9jdGwuYyBiL2Jsb2NrL2lvY3RsLmMNCmluZGV4IDEyNzE5NGIuLmFmMDQ3YTAgMTAwNjQ0 DQotLS0gYS9ibG9jay9pb2N0bC5jDQorKysgYi9ibG9jay9pb2N0bC5jDQpAQCAtNDg1LDcgKzQ4 NSw3IEBAIHN0YXRpYyBpbnQgYmxrZGV2X3Jvc2V0KHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYs IGZtb2RlX3QgbW9kZSwNCiAJCXJldHVybiAtRUFDQ0VTOw0KIA0KIAlyZXQgPSBfX2Jsa2Rldl9k cml2ZXJfaW9jdGwoYmRldiwgbW9kZSwgY21kLCBhcmcpOw0KLQlpZiAoIWlzX3VucmVjb2duaXpl ZF9pb2N0bChyZXQpKQ0KKwlpZiAocmV0ICYmICFpc191bnJlY29nbml6ZWRfaW9jdGwocmV0KSkN CiAJCXJldHVybiByZXQ7DQogCWlmIChnZXRfdXNlcihuLCAoaW50IF9fdXNlciAqKWFyZykpDQog CQlyZXR1cm4gLUVGQVVMVDsNCmRpZmYgLS1naXQgYS9kcml2ZXJzL21tYy9jb3JlL2Jsb2NrLmMg Yi9kcml2ZXJzL21tYy9jb3JlL2Jsb2NrLmMNCmluZGV4IDY2M2Q4NzkuLmVlODVhYmYgMTAwNjQ0 DQotLS0gYS9kcml2ZXJzL21tYy9jb3JlL2Jsb2NrLmMNCisrKyBiL2RyaXZlcnMvbW1jL2NvcmUv YmxvY2suYw0KQEAgLTc3OCw2ICs3NzgsMjIwIEBAIHN0YXRpYyBpbnQgbW1jX2Jsa19jaGVja19i bGtkZXYoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldikNCiAJcmV0dXJuIDA7DQogfQ0KIA0KKyNk ZWZpbmUgTU1DX0JMS19OT19XUCAgICAgICAgICAgMA0KKyNkZWZpbmUgTU1DX0JMS19QQVJUSUFM TFlfV1AgICAgMQ0KKyNkZWZpbmUgTU1DX0JMS19GVUxMWV9XUCAgICAgICAgMg0KKw0KK3N0YXRp YyBpbnQgbW1jX2Jsa19jaGVja19kaXNrX3JhbmdlX3dwKHN0cnVjdCBnZW5kaXNrICpkaXNrLA0K KwlzZWN0b3JfdCBwYXJ0X3N0YXJ0LCBzZWN0b3JfdCBwYXJ0X25yX3NlY3RzKQ0KK3sNCisJc3Ry dWN0IG1tY19jb21tYW5kIGNtZCA9IHswfTsNCisJc3RydWN0IG1tY19yZXF1ZXN0IG1ycSA9IHtO VUxMfTsNCisJc3RydWN0IG1tY19kYXRhIGRhdGEgPSB7MH07DQorCXN0cnVjdCBtbWNfYmxrX2Rh dGEgKm1kOw0KKwlzdHJ1Y3QgbW1jX2NhcmQgKmNhcmQ7DQorCXN0cnVjdCBzY2F0dGVybGlzdCBz ZzsNCisJdW5zaWduZWQgY2hhciAqYnVmID0gTlVMTCwgc3RhdHVzOw0KKwlzZWN0b3JfdCBzdGFy dCwgZW5kLCBxdW90Ow0KKwlzZWN0b3JfdCB3cF9ncnBfcmVtLCB3cF9ncnBfdG90YWwsIHdwX2dy cF9mb3VuZCwgc3RhdHVzX3F1ZXJ5X2NudDsNCisJdW5zaWduZWQgaW50IHJlbWFpbjsNCisJaW50 IGVyciA9IDAsIGksIGosIGs7DQorCXU4IGJvb3Rfd3Bfc3RhdHVzID0gMDsNCisNCisJbWQgPSBt bWNfYmxrX2dldChkaXNrKTsNCisJaWYgKCFtZCkNCisJCXJldHVybiAtRUlOVkFMOw0KKw0KKwlp ZiAoIW1kLT5xdWV1ZS5jYXJkKSB7DQorCQllcnIgPSAtRUlOVkFMOw0KKwkJZ290byBvdXQyOw0K Kwl9DQorDQorCWNhcmQgPSBtZC0+cXVldWUuY2FyZDsNCisJaWYgKCFtbWNfY2FyZF9tbWMoY2Fy ZCkgfHwNCisJCW1kLT5wYXJ0X3R5cGUgPT0gRVhUX0NTRF9QQVJUX0NPTkZJR19BQ0NfUlBNQikg ew0KKwkJZXJyID0gTU1DX0JMS19OT19XUDsNCisJCWdvdG8gb3V0MjsNCisJfQ0KKw0KKwlpZiAo bWQtPnBhcnRfdHlwZSA9PSAwKQ0KKwkJZ290byBjaGVja191c2VyX2FyZWFfd3Bfc3RhdHVzOw0K Kw0KKwkvKiBCT09UX1dQX1NUQVRVUyBpbiBFWFRfQ1NEOg0KKwkgKiB8LS0tLS1iaXRbNzo0XS0t LS0tfC0tLS0tLS1iaXRbMzoyXS0tLS0tLS0tfC0tLS0tLS1iaXRbMTowXS0tLS0tLS0tfA0KKwkg KiB8LS0tLS1yZXNlcnZlZC0tLS0tfC0tLS1ib290MSB3cCBzdGF0dXMtLS0tfC0tLS1ib290MCB3 cCBzdGF0dXMtLS0tfA0KKwkgKiBib290MCBhcmVhIHdwIHR5cGU6ZGVwZW5kaW5nIG9uIGJpdFsx OjBdDQorCSAqIDAtPm5vdCB3cDsgMS0+cG93ZXIgb24gd3A7IDItPnBlcm1hbmVudCB3cDsgMzpy ZXNlcnZlZCB2YWx1ZQ0KKwkgKiBib290MSBhcmVhIHdwIHR5cGU6ZGVwZW5kaW5nIG9uIGJpdFsz OjJdDQorCSAqIDAtPm5vdCB3cDsgMS0+cG93ZXIgb24gd3A7IDItPnBlcm1hbmVudCB3cDsgMzpy ZXNlcnZlZCB2YWx1ZQ0KKwkgKi8NCisJaWYgKG1kLT5wYXJ0X3R5cGUgPT0gRVhUX0NTRF9QQVJU X0NPTkZJR19BQ0NfQk9PVDApDQorCQlib290X3dwX3N0YXR1cyA9IGNhcmQtPmV4dF9jc2QuYm9v dF93cF9zdGF0dXMgJiAweDM7DQorCWVsc2UgaWYgKG1kLT5wYXJ0X3R5cGUgPT0gKEVYVF9DU0Rf UEFSVF9DT05GSUdfQUNDX0JPT1QwICsgMSkpDQorCQlib290X3dwX3N0YXR1cyA9IChjYXJkLT5l eHRfY3NkLmJvb3Rfd3Bfc3RhdHVzID4+IDIpICYgMHgzOw0KKw0KKwlpZiAoYm9vdF93cF9zdGF0 dXMgPT0gMHgxIHx8IGJvb3Rfd3Bfc3RhdHVzID09IDB4Mikgew0KKwkJcHJfbm90aWNlKCIlcyBp cyBmdWxseSB3cml0ZSBwcm90ZWN0ZWRcbiIsIGRpc2stPmRpc2tfbmFtZSk7DQorCQllcnIgPSBN TUNfQkxLX0ZVTExZX1dQOw0KKwl9IGVsc2UNCisJCWVyciA9IE1NQ19CTEtfTk9fV1A7DQorCWdv dG8gb3V0MjsNCisNCitjaGVja191c2VyX2FyZWFfd3Bfc3RhdHVzOg0KKwlpZiAoIWNhcmQtPndw X2dycF9zaXplKSB7DQorCQlwcl9ub3RpY2UoIldyaXRlIHByb3RlY3QgZ3JvdXAgc2l6ZSBjYW5u b3QgYmUgMCFcbiIpOw0KKwkJZXJyID0gLUVJTlZBTDsNCisJCWdvdG8gb3V0MjsNCisJfQ0KKw0K KwlzdGFydCA9IHBhcnRfc3RhcnQ7DQorCXF1b3QgPSBzdGFydDsNCisJcmVtYWluID0gZG9fZGl2 KHF1b3QsIGNhcmQtPndwX2dycF9zaXplKTsNCisJaWYgKHJlbWFpbikgew0KKwkJcHJfbm90aWNl KCJTdGFydCAweCVsbHggb2YgZGlzayAlcyBub3Qgd3JpdGUgZ3JvdXAgYWxpZ25lZFxuIiwNCisJ CQkodW5zaWduZWQgbG9uZyBsb25nKXBhcnRfc3RhcnQsIGRpc2stPmRpc2tfbmFtZSk7DQorCQlz dGFydCAtPSByZW1haW47DQorCX0NCisNCisJZW5kID0gcGFydF9zdGFydCArIHBhcnRfbnJfc2Vj dHM7DQorCXF1b3QgPSBlbmQ7DQorCXJlbWFpbiA9IGRvX2RpdihxdW90LCBjYXJkLT53cF9ncnBf c2l6ZSk7DQorCWlmIChyZW1haW4pIHsNCisJCXByX25vdGljZSgiRW5kIDB4JWxseCBvZiBkaXNr ICVzIG5vdCB3cml0ZSBncm91cCBhbGlnbmVkXG4iLA0KKwkJCSh1bnNpZ25lZCBsb25nIGxvbmcp cGFydF9zdGFydCwgZGlzay0+ZGlza19uYW1lKTsNCisJCWVuZCArPSBjYXJkLT53cF9ncnBfc2l6 ZSAtIHJlbWFpbjsNCisJfQ0KKwl3cF9ncnBfdG90YWwgPSBlbmQgLSBzdGFydDsNCisJZG9fZGl2 KHdwX2dycF90b3RhbCwgY2FyZC0+d3BfZ3JwX3NpemUpOw0KKwl3cF9ncnBfcmVtID0gd3BfZ3Jw X3RvdGFsOw0KKwl3cF9ncnBfZm91bmQgPSAwOw0KKw0KKwljbWQub3Bjb2RlID0gTU1DX1NFTkRf V1JJVEVfUFJPVF9UWVBFOw0KKwljbWQuZmxhZ3MgPSBNTUNfUlNQX1NQSV9SMSB8IE1NQ19SU1Bf UjEgfCBNTUNfQ01EX0FEVEM7DQorDQorCWJ1ZiA9IGttYWxsb2MoOCwgR0ZQX0tFUk5FTCk7DQor CWlmICghYnVmKSB7DQorCQllcnIgPSAtRU5PTUVNOw0KKwkJZ290byBvdXQyOw0KKwl9DQorCXNn X2luaXRfb25lKCZzZywgYnVmLCA4KTsNCisNCisJZGF0YS5ibGtzeiA9IDg7DQorCWRhdGEuYmxv Y2tzID0gMTsNCisJZGF0YS5mbGFncyA9IE1NQ19EQVRBX1JFQUQ7DQorCWRhdGEuc2cgPSAmc2c7 DQorCWRhdGEuc2dfbGVuID0gMTsNCisJbW1jX3NldF9kYXRhX3RpbWVvdXQoJmRhdGEsIGNhcmQp Ow0KKw0KKwltcnEuY21kID0gJmNtZDsNCisJbXJxLmRhdGEgPSAmZGF0YTsNCisNCisJbW1jX2dl dF9jYXJkKGNhcmQsIE5VTEwpOw0KKw0KKwllcnIgPSBtbWNfYmxrX3BhcnRfc3dpdGNoKGNhcmQs IG1kLT5wYXJ0X3R5cGUpOw0KKwlpZiAoZXJyKSB7DQorCQllcnIgPSAtRUlPOw0KKwkJZ290byBv dXQ7DQorCX0NCisNCisJc3RhdHVzX3F1ZXJ5X2NudCA9ICh3cF9ncnBfdG90YWwgKyAzMSkgLyAz MjsNCisJZm9yIChpID0gMDsgaSA8IHN0YXR1c19xdWVyeV9jbnQ7IGkrKykgew0KKwkJY21kLmFy ZyA9IHN0YXJ0ICsgaSAqIGNhcmQtPndwX2dycF9zaXplICogMzI7DQorCQltbWNfd2FpdF9mb3Jf cmVxKGNhcmQtPmhvc3QsICZtcnEpOw0KKwkJaWYgKGNtZC5lcnJvcikgew0KKwkJCXByX25vdGlj ZSgiJXM6IGNtZCBlcnJvciAlZFxuIiwgX19mdW5jX18sIGNtZC5lcnJvcik7DQorCQkJZXJyID0g LUVJTzsNCisJCQlnb3RvIG91dDsNCisJCX0NCisNCisJCS8qIHdwIHN0YXR1cyBpcyByZXR1cm5l ZCBpbiA4IGJ5dGVzLg0KKwkJICogVGhlIDggYnl0ZXMgYXJlIHJlZ2FyZGVkIGFzIDY0LWJpdHMg Yml0LXN0cmVhbToNCisJCSAqICstLS0tLS0tLSstLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tKy0tLS0tLS0tKw0KKwkJICogfCBieXRlIDcgfCBieXRlIDYgfCAgICAgICAgICAgLi4u ICAgICAgICAgICB8IGJ5dGUgMCB8DQorCQkgKiB8ICBiaXRzICB8ICBiaXRzICB8ICAgICAgICAg ICAgICAgICAgICAgICAgIHwgIGJpdHMgIHwNCisJCSAqIHw3NjU0MzIxMHw3NjU0MzIxMHwgICAg ICAgICAgICAgICAgICAgICAgICAgfDc2NTQzMjEwfA0KKwkJICogKy0tLS0tLS0tKy0tLS0tLS0t Ky0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rLS0tLS0tLS0rDQorCQkgKiAgIFRoZSAyIExTQml0 cyByZXByZXNlbnQgd3JpdGUtcHJvdGVjdCBncm91cCBzdGF0dXMgb2YNCisJCSAqICAgICAgIHRo ZSBsb3dlc3QgYWRkcmVzcyBncm91cCBiZWluZyBxdWVyaWVkLg0KKwkJICogICBUaGUgMiBNU0Jp dHMgcmVwcmVzZW50IHdyaXRlLXByb3RlY3QgZ3JvdXAgc3RhdHVzIG9mDQorCQkgKiAgICAgICB0 aGUgaGlnaGVzdCBhZGRyZXNzIGdyb3VwIGJlaW5nIHF1ZXJpZWQuDQorCQkgKi8NCisJCS8qIENo ZWNrIHdyaXRlLXByb3RlY3QgZ3JvdXAgc3RhdHVzIGZyb20gbG93ZXN0IGFkZHJlc3MNCisJCSAq ICAgZ3JvdXAgdG8gaGlnaGVzdCBhZGRyZXNzIGdyb3VwDQorCQkgKi8NCisJCWZvciAoaiA9IDA7 IGogPCA4OyBqKyspIHsNCisJCQlzdGF0dXMgPSBidWZbNyAtIGpdOw0KKwkJCWZvciAoayA9IDA7 IGsgPCA4OyBrICs9IDIpIHsNCisJCQkJaWYgKHN0YXR1cyAmICgzIDw8IGspKQ0KKwkJCQkJd3Bf Z3JwX2ZvdW5kKys7DQorCQkJCXdwX2dycF9yZW0tLTsNCisJCQkJaWYgKCF3cF9ncnBfcmVtKQ0K KwkJCQkJZ290byBvdXQ7DQorCQkJfQ0KKwkJfQ0KKw0KKwkJbWVtc2V0KGJ1ZiwgMCwgOCk7DQor CX0NCisNCitvdXQ6DQorCW1tY19wdXRfY2FyZChjYXJkLCBOVUxMKTsNCisJaWYgKCF3cF9ncnBf cmVtKSB7DQorCQlpZiAoIXdwX2dycF9mb3VuZCkNCisJCQllcnIgPSBNTUNfQkxLX05PX1dQOw0K KwkJZWxzZSBpZiAod3BfZ3JwX2ZvdW5kID09IHdwX2dycF90b3RhbCkgew0KKwkJCXByX25vdGlj ZSgiMHglbGx4IH4gMHglbGx4IG9mICVzIGlzIGZ1bGx5IHdyaXRlIHByb3RlY3RlZFxuIiwNCisJ CQkJKHVuc2lnbmVkIGxvbmcgbG9uZylwYXJ0X3N0YXJ0LA0KKwkJCQkodW5zaWduZWQgbG9uZyBs b25nKXBhcnRfc3RhcnQgKyBwYXJ0X25yX3NlY3RzLA0KKwkJCQlkaXNrLT5kaXNrX25hbWUpOw0K KwkJCWVyciA9IE1NQ19CTEtfRlVMTFlfV1A7DQorCQl9IGVsc2Ugew0KKwkJCXByX25vdGljZSgi MHglbGx4IH4gMHglbGx4IG9mICVzIGlzICV1JSUgd3JpdGUgcHJvdGVjdGVkXG4iLA0KKwkJCQl3 cF9ncnBfZm91bmQgKiAxMDAgLyB3cF9ncnBfdG90YWwsDQorCQkJCSh1bnNpZ25lZCBsb25nIGxv bmcpcGFydF9zdGFydCwNCisJCQkJKHVuc2lnbmVkIGxvbmcgbG9uZylwYXJ0X3N0YXJ0ICsgcGFy dF9ucl9zZWN0cywNCisJCQkJZGlzay0+ZGlza19uYW1lKTsNCisJCQllcnIgPSBNTUNfQkxLX1BB UlRJQUxMWV9XUDsNCisJCX0NCisJfQ0KKw0KKwlrZnJlZShidWYpOw0KKw0KK291dDI6DQorCW1t Y19ibGtfcHV0KG1kKTsNCisJcmV0dXJuIGVycjsNCit9DQorDQorc3RhdGljIGludCBtbWNfYmxr X2NoZWNrX3dwKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYpDQorew0KKwlpZiAoIWJkZXYtPmJk X2Rpc2sgfHwgIWJkZXYtPmJkX3BhcnQpDQorCQlyZXR1cm4gLUVJTlZBTDsNCisNCisJcmV0dXJu IG1tY19ibGtfY2hlY2tfZGlza19yYW5nZV93cChiZGV2LT5iZF9kaXNrLA0KKwkJYmRldi0+YmRf cGFydC0+c3RhcnRfc2VjdCwNCisJCWJkZXYtPmJkX3BhcnQtPm5yX3NlY3RzKTsNCit9DQorDQor c3RhdGljIGludCBtbWNfYmxrX2lvY3RsX3Jvc2V0KHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYs DQorCXVuc2lnbmVkIGxvbmcgYXJnKQ0KK3sNCisJaW50IHZhbDsNCisNCisJLyogQWx3YXlzIHJl dHVybiAtRUFDQ0VTIHRvIGJsb2NrIGxheWVyIG9uIGFueSBlcnJvcg0KKwkgKiBhbmQgdGhlbiBi bG9jayBsYXllciB3aWxsIGFib3J0IHRoZSByZW1haW5pbmcgb3BlcmF0aW9uDQorCSAqLw0KKwlp ZiAoZ2V0X3VzZXIodmFsLCAoaW50IF9fdXNlciAqKWFyZykpDQorCQlyZXR1cm4gLUVBQ0NFUzsN CisNCisJLyogTm8gbmVlZCB0byBjaGVjayB3cml0ZS1wcm90ZWN0IHN0YXR1cyB3aGVuIHNldHRp bmcgYXMgcmVhZG9ubHkgKi8NCisJaWYgKHZhbCkNCisJCXJldHVybiAwOw0KKw0KKwlpZiAobW1j X2Jsa19jaGVja193cChiZGV2KSAhPSBNTUNfQkxLX05PX1dQKQ0KKwkJcmV0dXJuIC1FQUNDRVM7 DQorDQorCXJldHVybiAwOw0KK30NCisNCiBzdGF0aWMgaW50IG1tY19ibGtfaW9jdGwoc3RydWN0 IGJsb2NrX2RldmljZSAqYmRldiwgZm1vZGVfdCBtb2RlLA0KIAl1bnNpZ25lZCBpbnQgY21kLCB1 bnNpZ25lZCBsb25nIGFyZykNCiB7DQpAQCAtODA5LDYgKzEwMjMsOCBAQCBzdGF0aWMgaW50IG1t Y19ibGtfaW9jdGwoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwgZm1vZGVfdCBtb2RlLA0KIAkJ CQkJTlVMTCk7DQogCQltbWNfYmxrX3B1dChtZCk7DQogCQlyZXR1cm4gcmV0Ow0KKwljYXNlIEJM S1JPU0VUOg0KKwkJcmV0dXJuIG1tY19ibGtfaW9jdGxfcm9zZXQoYmRldiwgYXJnKTsNCiAJZGVm YXVsdDoNCiAJCXJldHVybiAtRUlOVkFMOw0KIAl9DQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51 eC9tbWMvbW1jLmggYi9pbmNsdWRlL2xpbnV4L21tYy9tbWMuaA0KaW5kZXggMmM5ZDk4OC4uZjdj MTIzNyAxMDA2NDQNCi0tLSBhL2luY2x1ZGUvbGludXgvbW1jL21tYy5oDQorKysgYi9pbmNsdWRl L2xpbnV4L21tYy9tbWMuaA0KQEAgLTY5LDYgKzY5LDcgQEANCiAjZGVmaW5lIE1NQ19TRVRfV1JJ VEVfUFJPVCAgICAgICAyOCAgIC8qIGFjICAgWzMxOjBdIGRhdGEgYWRkciAgIFIxYiAqLw0KICNk ZWZpbmUgTU1DX0NMUl9XUklURV9QUk9UICAgICAgIDI5ICAgLyogYWMgICBbMzE6MF0gZGF0YSBh ZGRyICAgUjFiICovDQogI2RlZmluZSBNTUNfU0VORF9XUklURV9QUk9UICAgICAgMzAgICAvKiBh ZHRjIFszMTowXSB3cGRhdGEgYWRkciBSMSAgKi8NCisjZGVmaW5lIE1NQ19TRU5EX1dSSVRFX1BS T1RfVFlQRSAzMSAgIC8qIGFkdGMgWzMxOjBdIHdwZGF0YSBhZGRyIFIxICAqLw0KIA0KICAgLyog Y2xhc3MgNSAqLw0KICNkZWZpbmUgTU1DX0VSQVNFX0dST1VQX1NUQVJUICAgIDM1ICAgLyogYWMg ICBbMzE6MF0gZGF0YSBhZGRyICAgUjEgICovDQotLSANCjEuOC4xLjEuZGlydHkNCg== 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=-9.8 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,UNPARSEABLE_RELAY,URIBL_BLOCKED, USER_AGENT_GIT 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 C3525C3F2D7 for ; Wed, 4 Mar 2020 03:12:47 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 985CA2146E for ; Wed, 4 Mar 2020 03:12:47 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="Db5gVWyN"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="jYb7MVdA" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 985CA2146E Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=mediatek.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-mediatek-bounces+linux-mediatek=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-ID:Date:Subject:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=Pub2AGTYUZ22oKtzZ8DtYVw1hGqS9kR92CFPlKOAUhg=; b=Db5gVWyN32A+/C PqLeiHNBo9yN4JEICD5k++AXE3kzVNpmW3FsuAd6Tp4eET9OHIk5Iz0TPR9u6RaqBZ5h+P7+LuOtc cJTeVVGVYzfombCd+w+RoGLlMYgxHBW5WdCguAirh2U27gbAQApaD08M2VpgH1PspsFtYTCy7Tn/a Y9l5AyZOb5dtRRtgQNGQ/Y+J7D2OqDBTbt+gKWwfIDJ6+USdkzAoO5iJgQg4RpaXW99GJHQFL0o91 9dXh0QT42irybFq+NkN6xSZbVHkNb1JV6LyPpdvZGpIyG6WNFbdTS1BeaAlyiGHVKNamT1ii9/7eV GiFNaVelzRFcV9w2P0gA==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j9KSb-0002ih-CS; Wed, 04 Mar 2020 03:12:37 +0000 Received: from mailgw02.mediatek.com ([216.200.240.185]) by bombadil.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1j9KSV-0002gT-Ag for linux-mediatek@lists.infradead.org; Wed, 04 Mar 2020 03:12:35 +0000 X-UUID: 3c3ec8e5a7a74debb29369abe0b78cdc-20200303 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Transfer-Encoding:Content-Type:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=+OjRhnFwB7N+qUCZlu/luvxZ8XB1cxUBw5E13DY1Vig=; b=jYb7MVdAEqvJbOaA2eJDe6Qfk+Jo76IwnhSePs48yJqcaO2a7NauYtI27KqrMWmzwuhOKfIvS0EvfPVEmKN5/YDZKDnKuhAKlJJNjiofqrlBwNNE6j1c6UMduF5jg/at5By8R/B1kaaPUtvTlJi7KKR8Be/nahC5gaOWtRcASwc=; X-UUID: 3c3ec8e5a7a74debb29369abe0b78cdc-20200303 Received: from mtkcas67.mediatek.inc [(172.29.193.45)] by mailgw02.mediatek.com (envelope-from ) (musrelay.mediatek.com ESMTP with TLS) with ESMTP id 233308721; Tue, 03 Mar 2020 19:12:27 -0800 Received: from MTKMBS02N1.mediatek.inc (172.21.101.77) by MTKMBS62N1.mediatek.inc (172.29.193.41) with Microsoft SMTP Server (TLS) id 15.0.1395.4; Tue, 3 Mar 2020 19:13:18 -0800 Received: from MTKCAS06.mediatek.inc (172.21.101.30) by mtkmbs02n1.mediatek.inc (172.21.101.77) with Microsoft SMTP Server (TLS) id 15.0.1395.4; Wed, 4 Mar 2020 11:10:17 +0800 Received: from mtkswgap22.mediatek.inc (172.21.77.33) by MTKCAS06.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1395.4 via Frontend Transport; Wed, 4 Mar 2020 11:09:47 +0800 From: To: Subject: [RESEND PATCH v1 2/3] mmc: check write-protection status during BLKROSET ioctl Date: Wed, 4 Mar 2020 11:12:16 +0800 Message-ID: <1583291537-15053-3-git-send-email-light.hsieh@mediatek.com> X-Mailer: git-send-email 1.8.1.1.dirty In-Reply-To: <1583291537-15053-1-git-send-email-light.hsieh@mediatek.com> References: <1583291537-15053-1-git-send-email-light.hsieh@mediatek.com> MIME-Version: 1.0 X-MTK: N X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200303_191231_378388_F4439346 X-CRM114-Status: GOOD ( 21.30 ) X-BeenThere: linux-mediatek@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: axboe@kernel.dk, kuohong.wang@mediatek.com, linux-kernel@vger.kernel.org, Light Hsieh , linux-block@vger.kernel.org, linux-mediatek@lists.infradead.org, stanley.chu@mediatek.com Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "Linux-mediatek" Errors-To: linux-mediatek-bounces+linux-mediatek=archiver.kernel.org@lists.infradead.org From: Light Hsieh Since MMC layer does not implement BLKROSET ioctl, BLKROSET ioctl that tries to clear ro attribute of an mmcblk device will get -EINVAL from __blkdev_driver_ioctl(). blkdev_roset() regard -EINVAL as "unrecogized ioctl" and then clear the ro attribute un-conditionally. However, when eMMC write-protection (power-on, temporarily write, or permanent) is enabled in some area, this un-conditional clear of ro will lead to issue. From user's view, eMMC device is writable since ro is not set. But write operation sent to eMMC will get write-protection error. Since most write are asynchronus buffered write, such write-protection error won't be delivered to user who send the write operation. This patch implement BLKROSET in MMC layer. 1. For SD device, 0 is retured. 2. For setting ro to eMMC area, 0 is returned without any other check. 2. For clearing ro to eMMC area, write-proetction status is checked: 2a. For boot0 or boot1 partition, boot_wp_status get from EXTCSD is checked. -EACCES is returned when the target boot partition is write-protected; 0 is returned otherwise. 2b. For user area partition, one or more MMC_SEND_WRITE_PROT_TYPE commands are sent to get/check write-protection status of target address range. -EACCES is returned when target address range is fully/partially write-protected; 0 is returned otherwise. With the above implementation and correct ioctl parameters, return value of __blkdev_driver_ioctl() will be 0 or -EACCES. blkdev_roset() can continue to clear ro attribute when return value is 0, which means whole target eMMC address range is not write-protected. Signed-off-by: Light Hsieh --- block/ioctl.c | 2 +- drivers/mmc/core/block.c | 216 +++++++++++++++++++++++++++++++++++++++++++++++ include/linux/mmc/mmc.h | 1 + 3 files changed, 218 insertions(+), 1 deletion(-) diff --git a/block/ioctl.c b/block/ioctl.c index 127194b..af047a0 100644 --- a/block/ioctl.c +++ b/block/ioctl.c @@ -485,7 +485,7 @@ static int blkdev_roset(struct block_device *bdev, fmode_t mode, return -EACCES; ret = __blkdev_driver_ioctl(bdev, mode, cmd, arg); - if (!is_unrecognized_ioctl(ret)) + if (ret && !is_unrecognized_ioctl(ret)) return ret; if (get_user(n, (int __user *)arg)) return -EFAULT; diff --git a/drivers/mmc/core/block.c b/drivers/mmc/core/block.c index 663d879..ee85abf 100644 --- a/drivers/mmc/core/block.c +++ b/drivers/mmc/core/block.c @@ -778,6 +778,220 @@ static int mmc_blk_check_blkdev(struct block_device *bdev) return 0; } +#define MMC_BLK_NO_WP 0 +#define MMC_BLK_PARTIALLY_WP 1 +#define MMC_BLK_FULLY_WP 2 + +static int mmc_blk_check_disk_range_wp(struct gendisk *disk, + sector_t part_start, sector_t part_nr_sects) +{ + struct mmc_command cmd = {0}; + struct mmc_request mrq = {NULL}; + struct mmc_data data = {0}; + struct mmc_blk_data *md; + struct mmc_card *card; + struct scatterlist sg; + unsigned char *buf = NULL, status; + sector_t start, end, quot; + sector_t wp_grp_rem, wp_grp_total, wp_grp_found, status_query_cnt; + unsigned int remain; + int err = 0, i, j, k; + u8 boot_wp_status = 0; + + md = mmc_blk_get(disk); + if (!md) + return -EINVAL; + + if (!md->queue.card) { + err = -EINVAL; + goto out2; + } + + card = md->queue.card; + if (!mmc_card_mmc(card) || + md->part_type == EXT_CSD_PART_CONFIG_ACC_RPMB) { + err = MMC_BLK_NO_WP; + goto out2; + } + + if (md->part_type == 0) + goto check_user_area_wp_status; + + /* BOOT_WP_STATUS in EXT_CSD: + * |-----bit[7:4]-----|-------bit[3:2]--------|-------bit[1:0]--------| + * |-----reserved-----|----boot1 wp status----|----boot0 wp status----| + * boot0 area wp type:depending on bit[1:0] + * 0->not wp; 1->power on wp; 2->permanent wp; 3:reserved value + * boot1 area wp type:depending on bit[3:2] + * 0->not wp; 1->power on wp; 2->permanent wp; 3:reserved value + */ + if (md->part_type == EXT_CSD_PART_CONFIG_ACC_BOOT0) + boot_wp_status = card->ext_csd.boot_wp_status & 0x3; + else if (md->part_type == (EXT_CSD_PART_CONFIG_ACC_BOOT0 + 1)) + boot_wp_status = (card->ext_csd.boot_wp_status >> 2) & 0x3; + + if (boot_wp_status == 0x1 || boot_wp_status == 0x2) { + pr_notice("%s is fully write protected\n", disk->disk_name); + err = MMC_BLK_FULLY_WP; + } else + err = MMC_BLK_NO_WP; + goto out2; + +check_user_area_wp_status: + if (!card->wp_grp_size) { + pr_notice("Write protect group size cannot be 0!\n"); + err = -EINVAL; + goto out2; + } + + start = part_start; + quot = start; + remain = do_div(quot, card->wp_grp_size); + if (remain) { + pr_notice("Start 0x%llx of disk %s not write group aligned\n", + (unsigned long long)part_start, disk->disk_name); + start -= remain; + } + + end = part_start + part_nr_sects; + quot = end; + remain = do_div(quot, card->wp_grp_size); + if (remain) { + pr_notice("End 0x%llx of disk %s not write group aligned\n", + (unsigned long long)part_start, disk->disk_name); + end += card->wp_grp_size - remain; + } + wp_grp_total = end - start; + do_div(wp_grp_total, card->wp_grp_size); + wp_grp_rem = wp_grp_total; + wp_grp_found = 0; + + cmd.opcode = MMC_SEND_WRITE_PROT_TYPE; + cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC; + + buf = kmalloc(8, GFP_KERNEL); + if (!buf) { + err = -ENOMEM; + goto out2; + } + sg_init_one(&sg, buf, 8); + + data.blksz = 8; + data.blocks = 1; + data.flags = MMC_DATA_READ; + data.sg = &sg; + data.sg_len = 1; + mmc_set_data_timeout(&data, card); + + mrq.cmd = &cmd; + mrq.data = &data; + + mmc_get_card(card, NULL); + + err = mmc_blk_part_switch(card, md->part_type); + if (err) { + err = -EIO; + goto out; + } + + status_query_cnt = (wp_grp_total + 31) / 32; + for (i = 0; i < status_query_cnt; i++) { + cmd.arg = start + i * card->wp_grp_size * 32; + mmc_wait_for_req(card->host, &mrq); + if (cmd.error) { + pr_notice("%s: cmd error %d\n", __func__, cmd.error); + err = -EIO; + goto out; + } + + /* wp status is returned in 8 bytes. + * The 8 bytes are regarded as 64-bits bit-stream: + * +--------+--------+-------------------------+--------+ + * | byte 7 | byte 6 | ... | byte 0 | + * | bits | bits | | bits | + * |76543210|76543210| |76543210| + * +--------+--------+-------------------------+--------+ + * The 2 LSBits represent write-protect group status of + * the lowest address group being queried. + * The 2 MSBits represent write-protect group status of + * the highest address group being queried. + */ + /* Check write-protect group status from lowest address + * group to highest address group + */ + for (j = 0; j < 8; j++) { + status = buf[7 - j]; + for (k = 0; k < 8; k += 2) { + if (status & (3 << k)) + wp_grp_found++; + wp_grp_rem--; + if (!wp_grp_rem) + goto out; + } + } + + memset(buf, 0, 8); + } + +out: + mmc_put_card(card, NULL); + if (!wp_grp_rem) { + if (!wp_grp_found) + err = MMC_BLK_NO_WP; + else if (wp_grp_found == wp_grp_total) { + pr_notice("0x%llx ~ 0x%llx of %s is fully write protected\n", + (unsigned long long)part_start, + (unsigned long long)part_start + part_nr_sects, + disk->disk_name); + err = MMC_BLK_FULLY_WP; + } else { + pr_notice("0x%llx ~ 0x%llx of %s is %u%% write protected\n", + wp_grp_found * 100 / wp_grp_total, + (unsigned long long)part_start, + (unsigned long long)part_start + part_nr_sects, + disk->disk_name); + err = MMC_BLK_PARTIALLY_WP; + } + } + + kfree(buf); + +out2: + mmc_blk_put(md); + return err; +} + +static int mmc_blk_check_wp(struct block_device *bdev) +{ + if (!bdev->bd_disk || !bdev->bd_part) + return -EINVAL; + + return mmc_blk_check_disk_range_wp(bdev->bd_disk, + bdev->bd_part->start_sect, + bdev->bd_part->nr_sects); +} + +static int mmc_blk_ioctl_roset(struct block_device *bdev, + unsigned long arg) +{ + int val; + + /* Always return -EACCES to block layer on any error + * and then block layer will abort the remaining operation + */ + if (get_user(val, (int __user *)arg)) + return -EACCES; + + /* No need to check write-protect status when setting as readonly */ + if (val) + return 0; + + if (mmc_blk_check_wp(bdev) != MMC_BLK_NO_WP) + return -EACCES; + + return 0; +} + static int mmc_blk_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg) { @@ -809,6 +1023,8 @@ static int mmc_blk_ioctl(struct block_device *bdev, fmode_t mode, NULL); mmc_blk_put(md); return ret; + case BLKROSET: + return mmc_blk_ioctl_roset(bdev, arg); default: return -EINVAL; } diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h index 2c9d988..f7c1237 100644 --- a/include/linux/mmc/mmc.h +++ b/include/linux/mmc/mmc.h @@ -69,6 +69,7 @@ #define MMC_SET_WRITE_PROT 28 /* ac [31:0] data addr R1b */ #define MMC_CLR_WRITE_PROT 29 /* ac [31:0] data addr R1b */ #define MMC_SEND_WRITE_PROT 30 /* adtc [31:0] wpdata addr R1 */ +#define MMC_SEND_WRITE_PROT_TYPE 31 /* adtc [31:0] wpdata addr R1 */ /* class 5 */ #define MMC_ERASE_GROUP_START 35 /* ac [31:0] data addr R1 */ -- 1.8.1.1.dirty _______________________________________________ Linux-mediatek mailing list Linux-mediatek@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-mediatek