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 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 smtp.lore.kernel.org (Postfix) with ESMTPS id 0B71DC433EF for ; Tue, 25 Jan 2022 10:50:24 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=HpyjiSZ61bO0VAR34VYB+HeNiGGGlqaoDKfbOeFPqeg=; b=cQez1+FzehTaxo jsGVyaBPC0WmC6Elr2DIIZENdXW23WsFbpYe4D8H1nibA4sKChcW+tVo1kBIfD2/84s44X5HMx0kB URMseoSoezqzVvtIX7jqWazuUbHy7mqNr6G8rTiHM+fufhad+yII2WkZr+P7L0p2h8zroqS0hNPPf 5buYBihgXrrMZgo2qOHZluj9BZYNGNX8lypexhPKKFuqZs8CQce1BKceK5pgxVmHAWpW43Naq2PWy 7+pJJjiUzAqfjtS4fRIWw64qtcj2liGBthSGlKlQcBz1Rf5XgbUz/42pIUrGYpYsQRZ0kCBE+C9tI +4bPU1TrhlSz+dNtkUCw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nCJOT-007W86-4I; Tue, 25 Jan 2022 10:49:45 +0000 Received: from mail-lf1-x12b.google.com ([2a00:1450:4864:20::12b]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1nCJNN-007Vq9-Qo for linux-mtd@lists.infradead.org; Tue, 25 Jan 2022 10:48:40 +0000 Received: by mail-lf1-x12b.google.com with SMTP id n8so15539548lfq.4 for ; Tue, 25 Jan 2022 02:48:37 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kempniu.pl; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=Sf9nrV5/kUOfqh7Ut1el0haMtz7O6/Ny9NDQ0JFCQPM=; b=pSbHTYznoEntrQOfMJgW8oBiLaIAnaz+fivV0dJK37Pn6EFNyiEpzzTsOqvzujO15m E5IXRmVel55lbvo/aQmMYJhkjbXX3rKn8zimo9H3KzZChS2slwWUl2dS1t/I1943ZPxq 9lHpNnuwyFxWF5fSDNNt3OCyERwGkQ09WE8Qc= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=Sf9nrV5/kUOfqh7Ut1el0haMtz7O6/Ny9NDQ0JFCQPM=; b=VcFnmyzlvdA6SanLcZkTrD/DmeZW3VF3iQX3/eji4AN/W2UWFn7UwvTvBLtt4pH/B2 weD99q0XRSsqL/7r/xDlxePYY+g+rcCRVXNvyIO7QPfsj97w5IYoET/0HEwVR96ERdD6 VIHXw47AaM/Op5+/ACK2N56/OpDede3dWQji6I45vr1s0wWfUIH8Q4P2Rp1jhzR/CcHq KZ+OeO86SLXjvCvZzwMz8J6peTahMnVSwhLZP0dOZb2Fm+6LIfIhaMBYYmEBmXBs+1JL 4VMzWjkhx7rTpxnpf0fqKUUpyhIjvg/rmGrE8lfHczB3o1jcEM+QH2j09d8uvRa78lfi zQyQ== X-Gm-Message-State: AOAM531xkTQqEGwcjFy/b/nvE3Oddsi2p1UuDh39EOf9elfkYnxErsKb 8tbDPNpXkdOyFaueIN03mkG7Cg== X-Google-Smtp-Source: ABdhPJyVXeacxbN+b4V6r34793Ew+j+qOhKWV1p/c0+XiPNFprQm+umQesxyMzMWTnt+CSrQghWVwg== X-Received: by 2002:a05:6512:22c6:: with SMTP id g6mr15738795lfu.1.1643107715715; Tue, 25 Jan 2022 02:48:35 -0800 (PST) Received: from larwa.hq.kempniu.pl ([2001:470:64df:111::221]) by smtp.gmail.com with ESMTPSA id d16sm461896ljj.74.2022.01.25.02.48.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 25 Jan 2022 02:48:35 -0800 (PST) From: =?UTF-8?q?Micha=C5=82=20K=C4=99pie=C5=84?= To: Miquel Raynal , Richard Weinberger , Vignesh Raghavendra Cc: Boris Brezillon , linux-mtd@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH v3 4/4] mtdchar: add MEMREAD ioctl Date: Tue, 25 Jan 2022 11:48:22 +0100 Message-Id: <20220125104822.8420-5-kernel@kempniu.pl> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20220125104822.8420-1-kernel@kempniu.pl> References: <20220125104822.8420-1-kernel@kempniu.pl> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220125_024837_945433_361CECE8 X-CRM114-Status: GOOD ( 39.83 ) X-BeenThere: linux-mtd@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Linux MTD discussion mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-mtd" Errors-To: linux-mtd-bounces+linux-mtd=archiver.kernel.org@lists.infradead.org VXNlci1zcGFjZSBhcHBsaWNhdGlvbnMgbWFraW5nIHVzZSBvZiBNVEQgZGV2aWNlcyB2aWEgL2Rl di9tdGQqCmNoYXJhY3RlciBkZXZpY2VzIGN1cnJlbnRseSBoYXZlIGxpbWl0ZWQgY2FwYWJpbGl0 aWVzIGZvciByZWFkaW5nIGRhdGE6CgogIC0gb25seSBkZXByZWNhdGVkIG1ldGhvZHMgb2YgYWNj ZXNzaW5nIE9PQiBsYXlvdXQgaW5mb3JtYXRpb24gZXhpc3QsCgogIC0gdGhlcmUgaXMgbm8gd2F5 IHRvIGV4cGxpY2l0bHkgc3BlY2lmeSBNVEQgb3BlcmF0aW9uIG1vZGUgdG8gdXNlOyBpdAogICAg aXMgYXV0by1zZWxlY3RlZCBiYXNlZCBvbiB0aGUgTVREIGZpbGUgbW9kZSAoTVREX0ZJTEVfTU9E RV8qKSBzZXQKICAgIGZvciB0aGUgY2hhcmFjdGVyIGRldmljZTsgaW4gcGFydGljdWxhciwgdGhp cyBwcmV2ZW50cyB1c2luZwogICAgTVREX09QU19BVVRPX09PQiBmb3IgcmVhZHMsCgogIC0gYWxs IGV4aXN0aW5nIHVzZXItc3BhY2UgaW50ZXJmYWNlcyB3aGljaCBjYXVzZSBtdGRfcmVhZCgpIG9y CiAgICBtdGRfcmVhZF9vb2IoKSB0byBiZSBjYWxsZWQgKHZpYSBtdGRjaGFyX3JlYWQoKSBhbmQK ICAgIG10ZGNoYXJfcmVhZF9vb2IoKSwgcmVzcGVjdGl2ZWx5KSByZXR1cm4gc3VjY2VzcyBldmVu IHdoZW4gdGhvc2UKICAgIGZ1bmN0aW9ucyByZXR1cm4gLUVVQ0xFQU4gb3IgLUVCQURNU0c7IHRo aXMgcmVuZGVycyB1c2VyLXNwYWNlCiAgICBhcHBsaWNhdGlvbnMgdXNpbmcgdGhlc2UgaW50ZXJm YWNlcyB1bmF3YXJlIG9mIGFueSBjb3JyZWN0ZWQKICAgIGJpdGZsaXBzIG9yIHVuY29ycmVjdGFi bGUgRUNDIGVycm9ycyBkZXRlY3RlZCBkdXJpbmcgcmVhZHMuCgpOb3RlIHRoYXQgdGhlIGV4aXN0 aW5nIE1FTVdSSVRFIGlvY3RsIGFsbG93cyB0aGUgTVREIG9wZXJhdGlvbiBtb2RlIHRvCmJlIGV4 cGxpY2l0bHkgc2V0LCBhbGxvd2luZyB1c2VyLXNwYWNlIGFwcGxpY2F0aW9ucyB0byB3cml0ZSBw YWdlIGRhdGEKYW5kIE9PQiBkYXRhIHdpdGhvdXQgcmVxdWlyaW5nIHRoZW0gdG8ga25vdyBhbnl0 aGluZyBhYm91dCB0aGUgT09CCmxheW91dCBvZiB0aGUgTVREIGRldmljZSB0aGV5IGFyZSB3cml0 aW5nIHRvIChNVERfT1BTX0FVVE9fT09CKS4gIEFsc28sCnRoZSBNRU1XUklURSBpb2N0bCBkb2Vz IG5vdCBtYW5nbGUgdGhlIHJldHVybiB2YWx1ZSBvZiBtdGRfd3JpdGVfb29iKCkuCgpBZGQgYSBu ZXcgaW9jdGwsIE1FTVJFQUQsIHdoaWNoIGFkZHJlc3NlcyB0aGUgYWJvdmUgaXNzdWVzLiAgSXQg aXMKaW50ZW5kZWQgdG8gYmUgYSByZWFkLXNpZGUgY291bnRlcnBhcnQgb2YgdGhlIGV4aXN0aW5n IE1FTVdSSVRFIGlvY3RsLgpTaW1pbGFybHkgdG8gdGhlIGxhdHRlciwgdGhlIHJlYWQgb3BlcmF0 aW9uIGlzIHBlcmZvcm1lZCBpbiBhIGxvb3Agd2hpY2gKcHJvY2Vzc2VzIGF0IG1vc3QgbXRkLT5l cmFzZXNpemUgYnl0ZXMgaW4gZWFjaCBpdGVyYXRpb24uICBUaGlzIGlzIGRvbmUKdG8gcHJldmVu dCB1bmJvdW5kZWQgbWVtb3J5IGFsbG9jYXRpb25zIGNhdXNlZCBieSBjYWxsaW5nIGttYWxsb2Mo KSB3aXRoCnRoZSAnc2l6ZScgYXJndW1lbnQgdGFrZW4gZGlyZWN0bHkgZnJvbSB0aGUgc3RydWN0 IG10ZF9yZWFkX3JlcSBwcm92aWRlZApieSB1c2VyIHNwYWNlLiAgSG93ZXZlciwgdGhlIG5ldyBp b2N0bCBpcyBpbXBsZW1lbnRlZCBzbyB0aGF0IHRoZSB2YWx1ZXMKaXQgcmV0dXJucyBtYXRjaCB0 aG9zZSB0aGF0IHdvdWxkIGhhdmUgYmVlbiByZXR1cm5lZCBpZiBqdXN0IGEgc2luZ2xlCm10ZF9y ZWFkX29vYigpIGNhbGwgd2FzIGlzc3VlZCB0byBoYW5kbGUgdGhlIGVudGlyZSByZWFkIG9wZXJh dGlvbiBpbgpvbmUgZ28uCgpOb3RlIHRoYXQgd2hpbGUganVzdCByZXR1cm5pbmcgLUVVQ0xFQU4g b3IgLUVCQURNU0cgdG8gdXNlciBzcGFjZSB3b3VsZAphbHJlYWR5IGJlIGEgdmFsaWQgYW5kIHVz ZWZ1bCBpbmRpY2F0aW9uIG9mIHRoZSBFQ0MgYWxnb3JpdGhtIGRldGVjdGluZwplcnJvcnMgZHVy aW5nIGEgcmVhZCBvcGVyYXRpb24sIHRoYXQgc2lnbmFsIHdvdWxkIG5vdCBiZSBncmFudWxhciBl bm91Z2gKdG8gY292ZXIgYWxsIHVzZSBjYXNlcy4gIEZvciBleGFtcGxlLCBrbm93aW5nIHRoZSBt YXhpbXVtIG51bWJlciBvZgpiaXRmbGlwcyBkZXRlY3RlZCBpbiBhIHNpbmdsZSBFQ0Mgc3RlcCBk dXJpbmcgYSByZWFkIG9wZXJhdGlvbiBwZXJmb3JtZWQKb24gYSBnaXZlbiBwYWdlIG1heSBiZSB1 c2VmdWwgd2hlbiBkZWFsaW5nIHdpdGggYW4gTVREIHBhcnRpdGlvbiB3aG9zZQpFQ0MgbGF5b3V0 IHZhcmllcyBhY3Jvc3MgcGFnZXMgKGUuZy4gYSBwYXJ0aXRpb24gY29uc2lzdGluZyBvZiBhCmJv b3Rsb2FkZXIgYXJlYSB1c2luZyBhICJjdXN0b20iIEVDQyBsYXlvdXQgZm9sbG93ZWQgYnkgZGF0 YSBwYWdlcyB1c2luZwphICJzdGFuZGFyZCIgRUNDIGxheW91dCkuICBUbyBhZGRyZXNzIHRoYXQs IGluY2x1ZGUgRUNDIHN0YXRpc3RpY3MgaW4KdGhlIHN0cnVjdHVyZSByZXR1cm5lZCB0byB1c2Vy IHNwYWNlIGJ5IHRoZSBuZXcgTUVNUkVBRCBpb2N0bC4KCkxpbms6IGh0dHBzOi8vd3d3LmluZnJh ZGVhZC5vcmcvcGlwZXJtYWlsL2xpbnV4LW10ZC8yMDE2LUFwcmlsLzA2NzA4NS5odG1sCgpTdWdn ZXN0ZWQtYnk6IEJvcmlzIEJyZXppbGxvbiA8Ym9yaXMuYnJlemlsbG9uQGNvbGxhYm9yYS5jb20+ ClNpZ25lZC1vZmYtYnk6IE1pY2hhxYIgS8SZcGllxYQgPGtlcm5lbEBrZW1wbml1LnBsPgotLS0K IGRyaXZlcnMvbXRkL210ZGNoYXIuYyAgICAgIHwgMTM2ICsrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysKIGluY2x1ZGUvdWFwaS9tdGQvbXRkLWFiaS5oIHwgIDY0ICsrKysrKysr KysrKysrKy0tCiAyIGZpbGVzIGNoYW5nZWQsIDE5NSBpbnNlcnRpb25zKCspLCA1IGRlbGV0aW9u cygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL210ZGNoYXIuYyBiL2RyaXZlcnMvbXRkL210 ZGNoYXIuYwppbmRleCBkMGY5YzRiMDI4NWMuLjY4Y2M5MWQ4MmE1ZCAxMDA2NDQKLS0tIGEvZHJp dmVycy9tdGQvbXRkY2hhci5jCisrKyBiL2RyaXZlcnMvbXRkL210ZGNoYXIuYwpAQCAtNjg1LDYg KzY4NSwxMzQgQEAgc3RhdGljIGludCBtdGRjaGFyX3dyaXRlX2lvY3RsKHN0cnVjdCBtdGRfaW5m byAqbXRkLAogCXJldHVybiByZXQ7CiB9CiAKK3N0YXRpYyBpbnQgbXRkY2hhcl9yZWFkX2lvY3Rs KHN0cnVjdCBtdGRfaW5mbyAqbXRkLAorCQlzdHJ1Y3QgbXRkX3JlYWRfcmVxIF9fdXNlciAqYXJn cCkKK3sKKwlzdHJ1Y3QgbXRkX2luZm8gKm1hc3RlciA9IG10ZF9nZXRfbWFzdGVyKG10ZCk7CisJ c3RydWN0IG10ZF9yZWFkX3JlcSByZXE7CisJdm9pZCBfX3VzZXIgKnVzcl9kYXRhLCAqdXNyX29v YjsKKwl1aW50OF90ICpkYXRidWYgPSBOVUxMLCAqb29iYnVmID0gTlVMTDsKKwlzaXplX3QgZGF0 YnVmX2xlbiwgb29iYnVmX2xlbjsKKwlzaXplX3Qgb3JpZ19sZW4sIG9yaWdfb29ibGVuOworCWlu dCByZXQgPSAwOworCisJaWYgKGNvcHlfZnJvbV91c2VyKCZyZXEsIGFyZ3AsIHNpemVvZihyZXEp KSkKKwkJcmV0dXJuIC1FRkFVTFQ7CisKKwlvcmlnX2xlbiA9IHJlcS5sZW47CisJb3JpZ19vb2Js ZW4gPSByZXEub29ibGVuOworCisJdXNyX2RhdGEgPSAodm9pZCBfX3VzZXIgKikodWludHB0cl90 KXJlcS51c3JfZGF0YTsKKwl1c3Jfb29iID0gKHZvaWQgX191c2VyICopKHVpbnRwdHJfdClyZXEu dXNyX29vYjsKKworCWlmICghbWFzdGVyLT5fcmVhZF9vb2IpCisJCXJldHVybiAtRU9QTk9UU1VQ UDsKKworCWlmICghdXNyX2RhdGEpCisJCXJlcS5sZW4gPSAwOworCisJaWYgKCF1c3Jfb29iKQor CQlyZXEub29ibGVuID0gMDsKKworCXJlcS5lY2Nfc3RhdHMudW5jb3JyZWN0YWJsZV9lcnJvcnMg PSAwOworCXJlcS5lY2Nfc3RhdHMuY29ycmVjdGVkX2JpdGZsaXBzID0gMDsKKwlyZXEuZWNjX3N0 YXRzLm1heF9iaXRmbGlwcyA9IDA7CisKKwlpZiAocmVxLnN0YXJ0ICsgcmVxLmxlbiA+IG10ZC0+ c2l6ZSkgeworCQlyZXQgPSAtRUlOVkFMOworCQlnb3RvIG91dDsKKwl9CisKKwlkYXRidWZfbGVu ID0gbWluX3Qoc2l6ZV90LCByZXEubGVuLCBtdGQtPmVyYXNlc2l6ZSk7CisJaWYgKGRhdGJ1Zl9s ZW4gPiAwKSB7CisJCWRhdGJ1ZiA9IGttYWxsb2MoZGF0YnVmX2xlbiwgR0ZQX0tFUk5FTCk7CisJ CWlmICghZGF0YnVmKSB7CisJCQlyZXQgPSAtRU5PTUVNOworCQkJZ290byBvdXQ7CisJCX0KKwl9 CisKKwlvb2JidWZfbGVuID0gbWluX3Qoc2l6ZV90LCByZXEub29ibGVuLCBtdGQtPmVyYXNlc2l6 ZSk7CisJaWYgKG9vYmJ1Zl9sZW4gPiAwKSB7CisJCW9vYmJ1ZiA9IGttYWxsb2Mob29iYnVmX2xl biwgR0ZQX0tFUk5FTCk7CisJCWlmICghb29iYnVmKSB7CisJCQlyZXQgPSAtRU5PTUVNOworCQkJ Z290byBvdXQ7CisJCX0KKwl9CisKKwl3aGlsZSAocmVxLmxlbiA+IDAgfHwgKCF1c3JfZGF0YSAm JiByZXEub29ibGVuID4gMCkpIHsKKwkJc3RydWN0IG10ZF9yZXFfc3RhdHMgc3RhdHM7CisJCXN0 cnVjdCBtdGRfb29iX29wcyBvcHMgPSB7CisJCQkubW9kZSA9IHJlcS5tb2RlLAorCQkJLmxlbiA9 IG1pbl90KHNpemVfdCwgcmVxLmxlbiwgZGF0YnVmX2xlbiksCisJCQkub29ibGVuID0gbWluX3Qo c2l6ZV90LCByZXEub29ibGVuLCBvb2JidWZfbGVuKSwKKwkJCS5kYXRidWYgPSBkYXRidWYsCisJ CQkub29iYnVmID0gb29iYnVmLAorCQkJLnN0YXRzID0gJnN0YXRzLAorCQl9OworCisJCS8qCisJ CSAqIFNob3J0ZW4gbm9uLXBhZ2UtYWxpZ25lZCwgZXJhc2VibG9jay1zaXplZCByZWFkcyBzbyB0 aGF0IHRoZQorCQkgKiByZWFkIGVuZHMgb24gYW4gZXJhc2VibG9jayBib3VuZGFyeS4gIFRoaXMg aXMgbmVjZXNzYXJ5IGluCisJCSAqIG9yZGVyIHRvIHByZXZlbnQgT09CIGRhdGEgZm9yIHNvbWUg cGFnZXMgZnJvbSBiZWluZworCQkgKiBkdXBsaWNhdGVkIGluIHRoZSBvdXRwdXQgb2Ygbm9uLXBh Z2UtYWxpZ25lZCByZWFkcyByZXF1aXJpbmcKKwkJICogbXVsdGlwbGUgbXRkX3JlYWRfb29iKCkg Y2FsbHMgdG8gYmUgY29tcGxldGVkLgorCQkgKi8KKwkJaWYgKG9wcy5sZW4gPT0gbXRkLT5lcmFz ZXNpemUpCisJCQlvcHMubGVuIC09IG10ZF9tb2RfYnlfd3MocmVxLnN0YXJ0ICsgb3BzLmxlbiwg bXRkKTsKKworCQlyZXQgPSBtdGRfcmVhZF9vb2IobXRkLCAobG9mZl90KXJlcS5zdGFydCwgJm9w cyk7CisKKwkJcmVxLmVjY19zdGF0cy51bmNvcnJlY3RhYmxlX2Vycm9ycyArPQorCQkJc3RhdHMu dW5jb3JyZWN0YWJsZV9lcnJvcnM7CisJCXJlcS5lY2Nfc3RhdHMuY29ycmVjdGVkX2JpdGZsaXBz ICs9IHN0YXRzLmNvcnJlY3RlZF9iaXRmbGlwczsKKwkJcmVxLmVjY19zdGF0cy5tYXhfYml0Zmxp cHMgPQorCQkJbWF4KHJlcS5lY2Nfc3RhdHMubWF4X2JpdGZsaXBzLCBzdGF0cy5tYXhfYml0Zmxp cHMpOworCisJCWlmIChyZXQgJiYgIW10ZF9pc19iaXRmbGlwX29yX2VjY2VycihyZXQpKQorCQkJ YnJlYWs7CisKKwkJaWYgKGNvcHlfdG9fdXNlcih1c3JfZGF0YSwgb3BzLmRhdGJ1Ziwgb3BzLnJl dGxlbikgfHwKKwkJICAgIGNvcHlfdG9fdXNlcih1c3Jfb29iLCBvcHMub29iYnVmLCBvcHMub29i cmV0bGVuKSkgeworCQkJcmV0ID0gLUVGQVVMVDsKKwkJCWJyZWFrOworCQl9CisKKwkJcmVxLnN0 YXJ0ICs9IG9wcy5yZXRsZW47CisJCXJlcS5sZW4gLT0gb3BzLnJldGxlbjsKKwkJdXNyX2RhdGEg Kz0gb3BzLnJldGxlbjsKKworCQlyZXEub29ibGVuIC09IG9wcy5vb2JyZXRsZW47CisJCXVzcl9v b2IgKz0gb3BzLm9vYnJldGxlbjsKKwl9CisKKwkvKgorCSAqIEFzIG11bHRpcGxlIGl0ZXJhdGlv bnMgb2YgdGhlIGFib3ZlIGxvb3AgKGFuZCB0aGVyZWZvcmUgbXVsdGlwbGUKKwkgKiBtdGRfcmVh ZF9vb2IoKSBjYWxscykgbWF5IGJlIG5lY2Vzc2FyeSB0byBjb21wbGV0ZSB0aGUgcmVhZCByZXF1 ZXN0LAorCSAqIGFkanVzdCB0aGUgZmluYWwgcmV0dXJuIGNvZGUgdG8gZW5zdXJlIGl0IGFjY291 bnRzIGZvciBhbGwgZGV0ZWN0ZWQKKwkgKiBFQ0MgZXJyb3JzLgorCSAqLworCWlmICghcmV0IHx8 IG10ZF9pc19iaXRmbGlwKHJldCkpIHsKKwkJaWYgKHJlcS5lY2Nfc3RhdHMudW5jb3JyZWN0YWJs ZV9lcnJvcnMgPiAwKQorCQkJcmV0ID0gLUVCQURNU0c7CisJCWVsc2UgaWYgKHJlcS5lY2Nfc3Rh dHMuY29ycmVjdGVkX2JpdGZsaXBzID4gMCkKKwkJCXJldCA9IC1FVUNMRUFOOworCX0KKworb3V0 OgorCXJlcS5sZW4gPSBvcmlnX2xlbiAtIHJlcS5sZW47CisJcmVxLm9vYmxlbiA9IG9yaWdfb29i bGVuIC0gcmVxLm9vYmxlbjsKKworCWlmIChjb3B5X3RvX3VzZXIoYXJncCwgJnJlcSwgc2l6ZW9m KHJlcSkpKQorCQlyZXQgPSAtRUZBVUxUOworCisJa2ZyZWUoZGF0YnVmKTsKKwlrZnJlZShvb2Ji dWYpOworCisJcmV0dXJuIHJldDsKK30KKwogc3RhdGljIGludCBtdGRjaGFyX2lvY3RsKHN0cnVj dCBmaWxlICpmaWxlLCB1X2ludCBjbWQsIHVfbG9uZyBhcmcpCiB7CiAJc3RydWN0IG10ZF9maWxl X2luZm8gKm1maSA9IGZpbGUtPnByaXZhdGVfZGF0YTsKQEAgLTcwNyw2ICs4MzUsNyBAQCBzdGF0 aWMgaW50IG10ZGNoYXJfaW9jdGwoc3RydWN0IGZpbGUgKmZpbGUsIHVfaW50IGNtZCwgdV9sb25n IGFyZykKIAljYXNlIE1FTUdFVElORk86CiAJY2FzZSBNRU1SRUFET09COgogCWNhc2UgTUVNUkVB RE9PQjY0OgorCWNhc2UgTUVNUkVBRDoKIAljYXNlIE1FTUlTTE9DS0VEOgogCWNhc2UgTUVNR0VU T09CU0VMOgogCWNhc2UgTUVNR0VUQkFEQkxPQ0s6CkBAIC04ODEsNiArMTAxMCwxMyBAQCBzdGF0 aWMgaW50IG10ZGNoYXJfaW9jdGwoc3RydWN0IGZpbGUgKmZpbGUsIHVfaW50IGNtZCwgdV9sb25n IGFyZykKIAkJYnJlYWs7CiAJfQogCisJY2FzZSBNRU1SRUFEOgorCXsKKwkJcmV0ID0gbXRkY2hh cl9yZWFkX2lvY3RsKG10ZCwKKwkJICAgICAgKHN0cnVjdCBtdGRfcmVhZF9yZXEgX191c2VyICop YXJnKTsKKwkJYnJlYWs7CisJfQorCiAJY2FzZSBNRU1MT0NLOgogCXsKIAkJc3RydWN0IGVyYXNl X2luZm9fdXNlciBlaW5mbzsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvdWFwaS9tdGQvbXRkLWFiaS5o IGIvaW5jbHVkZS91YXBpL210ZC9tdGQtYWJpLmgKaW5kZXggYjg2OTk5MGMyZGIyLi5iYzY4ZjI2 NmMxNzQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvdWFwaS9tdGQvbXRkLWFiaS5oCisrKyBiL2luY2x1 ZGUvdWFwaS9tdGQvbXRkLWFiaS5oCkBAIC01NSw5ICs1NSw5IEBAIHN0cnVjdCBtdGRfb29iX2J1 ZjY0IHsKICAqIEBNVERfT1BTX1JBVzoJZGF0YSBhcmUgdHJhbnNmZXJyZWQgYXMtaXMsIHdpdGgg bm8gZXJyb3IgY29ycmVjdGlvbjsKICAqCQkJdGhpcyBtb2RlIGltcGxpZXMgJU1URF9PUFNfUExB Q0VfT09CCiAgKgotICogVGhlc2UgbW9kZXMgY2FuIGJlIHBhc3NlZCB0byBpb2N0bChNRU1XUklU RSkgYW5kIGFyZSBhbHNvIHVzZWQgaW50ZXJuYWxseS4KLSAqIFNlZSBub3RlcyBvbiAiTVREIGZp bGUgbW9kZXMiIGZvciBkaXNjdXNzaW9uIG9uICVNVERfT1BTX1JBVyB2cy4KLSAqICVNVERfRklM RV9NT0RFX1JBVy4KKyAqIFRoZXNlIG1vZGVzIGNhbiBiZSBwYXNzZWQgdG8gaW9jdGwoTUVNV1JJ VEUpIGFuZCBpb2N0bChNRU1SRUFEKTsgdGhleSBhcmUKKyAqIGFsc28gdXNlZCBpbnRlcm5hbGx5 LiBTZWUgbm90ZXMgb24gIk1URCBmaWxlIG1vZGVzIiBmb3IgZGlzY3Vzc2lvbiBvbgorICogJU1U RF9PUFNfUkFXIHZzLiAlTVREX0ZJTEVfTU9ERV9SQVcuCiAgKi8KIGVudW0gewogCU1URF9PUFNf UExBQ0VfT09CID0gMCwKQEAgLTkxLDYgKzkxLDUzIEBAIHN0cnVjdCBtdGRfd3JpdGVfcmVxIHsK IAlfX3U4IHBhZGRpbmdbN107CiB9OwogCisvKioKKyAqIHN0cnVjdCBtdGRfcmVhZF9yZXFfZWNj X3N0YXRzIC0gRUNDIHN0YXRpc3RpY3MgZm9yIGEgcmVhZCBvcGVyYXRpb24KKyAqCisgKiBAdW5j b3JyZWN0YWJsZV9lcnJvcnM6IHRoZSBudW1iZXIgb2YgdW5jb3JyZWN0YWJsZSBlcnJvcnMgdGhh dCBoYXBwZW5lZAorICoJCQkgIGR1cmluZyB0aGUgcmVhZCBvcGVyYXRpb24KKyAqIEBjb3JyZWN0 ZWRfYml0ZmxpcHM6IHRoZSBudW1iZXIgb2YgYml0ZmxpcHMgY29ycmVjdGVkIGR1cmluZyB0aGUg cmVhZAorICoJCQlvcGVyYXRpb24KKyAqIEBtYXhfYml0ZmxpcHM6IHRoZSBtYXhpbXVtIG51bWJl ciBvZiBiaXRmbGlwcyBkZXRlY3RlZCBpbiBhbnkgc2luZ2xlIEVDQworICoJCSAgc3RlcCBmb3Ig dGhlIGRhdGEgcmVhZCBkdXJpbmcgdGhlIG9wZXJhdGlvbjsgdGhpcyBpbmZvcm1hdGlvbgorICoJ CSAgY2FuIGJlIHVzZWQgdG8gZGVjaWRlIHdoZXRoZXIgdGhlIGRhdGEgc3RvcmVkIGluIGEgc3Bl Y2lmaWMKKyAqCQkgIHJlZ2lvbiBvZiB0aGUgTVREIGRldmljZSBzaG91bGQgYmUgbW92ZWQgc29t ZXdoZXJlIGVsc2UgdG8KKyAqCQkgIGF2b2lkIGRhdGEgbG9zcy4KKyAqLworc3RydWN0IG10ZF9y ZWFkX3JlcV9lY2Nfc3RhdHMgeworCV9fdTMyIHVuY29ycmVjdGFibGVfZXJyb3JzOworCV9fdTMy IGNvcnJlY3RlZF9iaXRmbGlwczsKKwlfX3UzMiBtYXhfYml0ZmxpcHM7Cit9OworCisvKioKKyAq IHN0cnVjdCBtdGRfcmVhZF9yZXEgLSBkYXRhIHN0cnVjdHVyZSBmb3IgcmVxdWVzdGluZyBhIHJl YWQgb3BlcmF0aW9uCisgKgorICogQHN0YXJ0OglzdGFydCBhZGRyZXNzCisgKiBAbGVuOglsZW5n dGggb2YgZGF0YSBidWZmZXIKKyAqIEBvb2JsZW46CWxlbmd0aCBvZiBPT0IgYnVmZmVyCisgKiBA dXNyX2RhdGE6CXVzZXItcHJvdmlkZWQgZGF0YSBidWZmZXIKKyAqIEB1c3Jfb29iOgl1c2VyLXBy b3ZpZGVkIE9PQiBidWZmZXIKKyAqIEBtb2RlOglNVEQgbW9kZSAoc2VlICJNVEQgb3BlcmF0aW9u IG1vZGVzIikKKyAqIEBwYWRkaW5nOglyZXNlcnZlZCwgbXVzdCBiZSBzZXQgdG8gMAorICogQGVj Y19zdGF0czoJRUNDIHN0YXRpc3RpY3MgZm9yIHRoZSByZWFkIG9wZXJhdGlvbgorICoKKyAqIFRo aXMgc3RydWN0dXJlIHN1cHBvcnRzIGlvY3RsKE1FTVJFQUQpIG9wZXJhdGlvbnMsIGFsbG93aW5n IGRhdGEgYW5kL29yIE9PQgorICogcmVhZHMgaW4gdmFyaW91cyBtb2Rlcy4gVG8gcmVhZCBmcm9t IE9PQi1vbmx5LCBzZXQgQHVzcl9kYXRhID09IE5VTEwsIGFuZCB0bworICogcmVhZCBkYXRhLW9u bHksIHNldCBAdXNyX29vYiA9PSBOVUxMLiBIb3dldmVyLCBzZXR0aW5nIGJvdGggQHVzcl9kYXRh IGFuZAorICogQHVzcl9vb2IgdG8gTlVMTCBpcyBub3QgYWxsb3dlZC4KKyAqLworc3RydWN0IG10 ZF9yZWFkX3JlcSB7CisJX191NjQgc3RhcnQ7CisJX191NjQgbGVuOworCV9fdTY0IG9vYmxlbjsK KwlfX3U2NCB1c3JfZGF0YTsKKwlfX3U2NCB1c3Jfb29iOworCV9fdTggbW9kZTsKKwlfX3U4IHBh ZGRpbmdbN107CisJc3RydWN0IG10ZF9yZWFkX3JlcV9lY2Nfc3RhdHMgZWNjX3N0YXRzOworfTsK KwogI2RlZmluZSBNVERfQUJTRU5UCQkwCiAjZGVmaW5lIE1URF9SQU0JCQkxCiAjZGVmaW5lIE1U RF9ST00JCQkyCkBAIC0yMDcsNiArMjU0LDEyIEBAIHN0cnVjdCBvdHBfaW5mbyB7CiAjZGVmaW5l IE1FTVdSSVRFCQlfSU9XUignTScsIDI0LCBzdHJ1Y3QgbXRkX3dyaXRlX3JlcSkKIC8qIEVyYXNl IGEgZ2l2ZW4gcmFuZ2Ugb2YgdXNlciBkYXRhIChtdXN0IGJlIGluIG1vZGUgJU1URF9GSUxFX01P REVfT1RQX1VTRVIpICovCiAjZGVmaW5lIE9UUEVSQVNFCQlfSU9XKCdNJywgMjUsIHN0cnVjdCBv dHBfaW5mbykKKy8qCisgKiBNb3N0IGdlbmVyaWMgcmVhZCBpbnRlcmZhY2U7IGNhbiByZWFkIGlu LWJhbmQgYW5kL29yIG91dC1vZi1iYW5kIGluIHZhcmlvdXMKKyAqIG1vZGVzIChzZWUgInN0cnVj dCBtdGRfcmVhZF9yZXEiKS4gVGhpcyBpb2N0bCBpcyBub3Qgc3VwcG9ydGVkIGZvciBmbGFzaGVz CisgKiB3aXRob3V0IE9PQiwgZS5nLiwgTk9SIGZsYXNoLgorICovCisjZGVmaW5lIE1FTVJFQUQJ CQlfSU9XUignTScsIDI2LCBzdHJ1Y3QgbXRkX3JlYWRfcmVxKQogCiAvKgogICogT2Jzb2xldGUg bGVnYWN5IGludGVyZmFjZS4gS2VlcCBpdCBpbiBvcmRlciBub3QgdG8gYnJlYWsgdXNlcnNwYWNl CkBAIC0yNzAsOCArMzIzLDkgQEAgc3RydWN0IG10ZF9lY2Nfc3RhdHMgewogICogTm90ZTogJU1U RF9GSUxFX01PREVfUkFXIHByb3ZpZGVzIHRoZSBzYW1lIGZ1bmN0aW9uYWxpdHkgYXMgJU1URF9P UFNfUkFXIC0KICAqIHJhdyBhY2Nlc3MgdG8gdGhlIGZsYXNoLCB3aXRob3V0IGVycm9yIGNvcnJl Y3Rpb24gb3IgYXV0b3BsYWNlbWVudCBzY2hlbWVzLgogICogV2hlcmV2ZXIgcG9zc2libGUsIHRo ZSBNVERfT1BTXyogbW9kZSB3aWxsIG92ZXJyaWRlIHRoZSBNVERfRklMRV9NT0RFXyogbW9kZQot ICogKGUuZy4sIHdoZW4gdXNpbmcgaW9jdGwoTUVNV1JJVEUpKSwgYnV0IGluIHNvbWUgY2FzZXMs IHRoZSBNVERfRklMRV9NT0RFIGlzCi0gKiB1c2VkIG91dCBvZiBuZWNlc3NpdHkgKGUuZy4sIGB3 cml0ZSgpJywgaW9jdGwoTUVNV1JJVEVPT0I2NCkpLgorICogKGUuZy4sIHdoZW4gdXNpbmcgaW9j dGwoTUVNV1JJVEUpIG9yIGlvY3RsKE1FTVJFQUQpKSwgYnV0IGluIHNvbWUgY2FzZXMsIHRoZQor ICogTVREX0ZJTEVfTU9ERSBpcyB1c2VkIG91dCBvZiBuZWNlc3NpdHkgKGUuZy4sIGB3cml0ZSgp JywKKyAqIGlvY3RsKE1FTVdSSVRFT09CNjQpKS4KICAqLwogZW51bSBtdGRfZmlsZV9tb2RlcyB7 CiAJTVREX0ZJTEVfTU9ERV9OT1JNQUwgPSBNVERfT1RQX09GRiwKLS0gCjIuMzQuMQoKCl9fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpMaW51eCBN VEQgZGlzY3Vzc2lvbiBtYWlsaW5nIGxpc3QKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFp bG1hbi9saXN0aW5mby9saW51eC1tdGQvCg== 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 Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 39D9CC433EF for ; Tue, 25 Jan 2022 10:52:04 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1378913AbiAYKvy (ORCPT ); Tue, 25 Jan 2022 05:51:54 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:43646 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1377120AbiAYKsi (ORCPT ); Tue, 25 Jan 2022 05:48:38 -0500 Received: from mail-lf1-x133.google.com (mail-lf1-x133.google.com [IPv6:2a00:1450:4864:20::133]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 73A7FC061763 for ; Tue, 25 Jan 2022 02:48:37 -0800 (PST) Received: by mail-lf1-x133.google.com with SMTP id p27so55990835lfa.1 for ; Tue, 25 Jan 2022 02:48:37 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kempniu.pl; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=Sf9nrV5/kUOfqh7Ut1el0haMtz7O6/Ny9NDQ0JFCQPM=; b=pSbHTYznoEntrQOfMJgW8oBiLaIAnaz+fivV0dJK37Pn6EFNyiEpzzTsOqvzujO15m E5IXRmVel55lbvo/aQmMYJhkjbXX3rKn8zimo9H3KzZChS2slwWUl2dS1t/I1943ZPxq 9lHpNnuwyFxWF5fSDNNt3OCyERwGkQ09WE8Qc= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=Sf9nrV5/kUOfqh7Ut1el0haMtz7O6/Ny9NDQ0JFCQPM=; b=jgHyrg88ACmeKDWrxtTP8a6o9PBDMMmlD+bZ9V2Cuka5HejRw7kHDFhn8sm98gm4SX nbdtEgXyfZxzzvjOXWqlX9htWps6Xb3W24NX+gkKgBaY/qVg4wNxbpgAUP//SqXb8xzb cc0Ct03pzKgG7wyP04vA0Okhehqq/soXjwsShdErS0j04zCGvH82AkyRInrx7FZSPImP 6NGr6+5v6T7yF31LSQdFJQEBq1pSbz2GCevzDTI7t0JQQMv+01qUkq4TDTtDFx2fk2eJ w+3juwCtwShEAI/QkXkE1intEWR1Pga2a9gfLYzNYZUUAEVOBg+Y+p5vVVgG8jzYFI7g PAYw== X-Gm-Message-State: AOAM532tbeIQYH0y7+CqVn4NjC8ymatH83gV+hMghNLTLFPOS5RNuYBv aHcT0isb6RRXkchmYn01eJ1pvg== X-Google-Smtp-Source: ABdhPJyVXeacxbN+b4V6r34793Ew+j+qOhKWV1p/c0+XiPNFprQm+umQesxyMzMWTnt+CSrQghWVwg== X-Received: by 2002:a05:6512:22c6:: with SMTP id g6mr15738795lfu.1.1643107715715; Tue, 25 Jan 2022 02:48:35 -0800 (PST) Received: from larwa.hq.kempniu.pl ([2001:470:64df:111::221]) by smtp.gmail.com with ESMTPSA id d16sm461896ljj.74.2022.01.25.02.48.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 25 Jan 2022 02:48:35 -0800 (PST) From: =?UTF-8?q?Micha=C5=82=20K=C4=99pie=C5=84?= To: Miquel Raynal , Richard Weinberger , Vignesh Raghavendra Cc: Boris Brezillon , linux-mtd@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH v3 4/4] mtdchar: add MEMREAD ioctl Date: Tue, 25 Jan 2022 11:48:22 +0100 Message-Id: <20220125104822.8420-5-kernel@kempniu.pl> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20220125104822.8420-1-kernel@kempniu.pl> References: <20220125104822.8420-1-kernel@kempniu.pl> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org User-space applications making use of MTD devices via /dev/mtd* character devices currently have limited capabilities for reading data: - only deprecated methods of accessing OOB layout information exist, - there is no way to explicitly specify MTD operation mode to use; it is auto-selected based on the MTD file mode (MTD_FILE_MODE_*) set for the character device; in particular, this prevents using MTD_OPS_AUTO_OOB for reads, - all existing user-space interfaces which cause mtd_read() or mtd_read_oob() to be called (via mtdchar_read() and mtdchar_read_oob(), respectively) return success even when those functions return -EUCLEAN or -EBADMSG; this renders user-space applications using these interfaces unaware of any corrected bitflips or uncorrectable ECC errors detected during reads. Note that the existing MEMWRITE ioctl allows the MTD operation mode to be explicitly set, allowing user-space applications to write page data and OOB data without requiring them to know anything about the OOB layout of the MTD device they are writing to (MTD_OPS_AUTO_OOB). Also, the MEMWRITE ioctl does not mangle the return value of mtd_write_oob(). Add a new ioctl, MEMREAD, which addresses the above issues. It is intended to be a read-side counterpart of the existing MEMWRITE ioctl. Similarly to the latter, the read operation is performed in a loop which processes at most mtd->erasesize bytes in each iteration. This is done to prevent unbounded memory allocations caused by calling kmalloc() with the 'size' argument taken directly from the struct mtd_read_req provided by user space. However, the new ioctl is implemented so that the values it returns match those that would have been returned if just a single mtd_read_oob() call was issued to handle the entire read operation in one go. Note that while just returning -EUCLEAN or -EBADMSG to user space would already be a valid and useful indication of the ECC algorithm detecting errors during a read operation, that signal would not be granular enough to cover all use cases. For example, knowing the maximum number of bitflips detected in a single ECC step during a read operation performed on a given page may be useful when dealing with an MTD partition whose ECC layout varies across pages (e.g. a partition consisting of a bootloader area using a "custom" ECC layout followed by data pages using a "standard" ECC layout). To address that, include ECC statistics in the structure returned to user space by the new MEMREAD ioctl. Link: https://www.infradead.org/pipermail/linux-mtd/2016-April/067085.html Suggested-by: Boris Brezillon Signed-off-by: Michał Kępień --- drivers/mtd/mtdchar.c | 136 +++++++++++++++++++++++++++++++++++++ include/uapi/mtd/mtd-abi.h | 64 +++++++++++++++-- 2 files changed, 195 insertions(+), 5 deletions(-) diff --git a/drivers/mtd/mtdchar.c b/drivers/mtd/mtdchar.c index d0f9c4b0285c..68cc91d82a5d 100644 --- a/drivers/mtd/mtdchar.c +++ b/drivers/mtd/mtdchar.c @@ -685,6 +685,134 @@ static int mtdchar_write_ioctl(struct mtd_info *mtd, return ret; } +static int mtdchar_read_ioctl(struct mtd_info *mtd, + struct mtd_read_req __user *argp) +{ + struct mtd_info *master = mtd_get_master(mtd); + struct mtd_read_req req; + void __user *usr_data, *usr_oob; + uint8_t *datbuf = NULL, *oobbuf = NULL; + size_t datbuf_len, oobbuf_len; + size_t orig_len, orig_ooblen; + int ret = 0; + + if (copy_from_user(&req, argp, sizeof(req))) + return -EFAULT; + + orig_len = req.len; + orig_ooblen = req.ooblen; + + usr_data = (void __user *)(uintptr_t)req.usr_data; + usr_oob = (void __user *)(uintptr_t)req.usr_oob; + + if (!master->_read_oob) + return -EOPNOTSUPP; + + if (!usr_data) + req.len = 0; + + if (!usr_oob) + req.ooblen = 0; + + req.ecc_stats.uncorrectable_errors = 0; + req.ecc_stats.corrected_bitflips = 0; + req.ecc_stats.max_bitflips = 0; + + if (req.start + req.len > mtd->size) { + ret = -EINVAL; + goto out; + } + + datbuf_len = min_t(size_t, req.len, mtd->erasesize); + if (datbuf_len > 0) { + datbuf = kmalloc(datbuf_len, GFP_KERNEL); + if (!datbuf) { + ret = -ENOMEM; + goto out; + } + } + + oobbuf_len = min_t(size_t, req.ooblen, mtd->erasesize); + if (oobbuf_len > 0) { + oobbuf = kmalloc(oobbuf_len, GFP_KERNEL); + if (!oobbuf) { + ret = -ENOMEM; + goto out; + } + } + + while (req.len > 0 || (!usr_data && req.ooblen > 0)) { + struct mtd_req_stats stats; + struct mtd_oob_ops ops = { + .mode = req.mode, + .len = min_t(size_t, req.len, datbuf_len), + .ooblen = min_t(size_t, req.ooblen, oobbuf_len), + .datbuf = datbuf, + .oobbuf = oobbuf, + .stats = &stats, + }; + + /* + * Shorten non-page-aligned, eraseblock-sized reads so that the + * read ends on an eraseblock boundary. This is necessary in + * order to prevent OOB data for some pages from being + * duplicated in the output of non-page-aligned reads requiring + * multiple mtd_read_oob() calls to be completed. + */ + if (ops.len == mtd->erasesize) + ops.len -= mtd_mod_by_ws(req.start + ops.len, mtd); + + ret = mtd_read_oob(mtd, (loff_t)req.start, &ops); + + req.ecc_stats.uncorrectable_errors += + stats.uncorrectable_errors; + req.ecc_stats.corrected_bitflips += stats.corrected_bitflips; + req.ecc_stats.max_bitflips = + max(req.ecc_stats.max_bitflips, stats.max_bitflips); + + if (ret && !mtd_is_bitflip_or_eccerr(ret)) + break; + + if (copy_to_user(usr_data, ops.datbuf, ops.retlen) || + copy_to_user(usr_oob, ops.oobbuf, ops.oobretlen)) { + ret = -EFAULT; + break; + } + + req.start += ops.retlen; + req.len -= ops.retlen; + usr_data += ops.retlen; + + req.ooblen -= ops.oobretlen; + usr_oob += ops.oobretlen; + } + + /* + * As multiple iterations of the above loop (and therefore multiple + * mtd_read_oob() calls) may be necessary to complete the read request, + * adjust the final return code to ensure it accounts for all detected + * ECC errors. + */ + if (!ret || mtd_is_bitflip(ret)) { + if (req.ecc_stats.uncorrectable_errors > 0) + ret = -EBADMSG; + else if (req.ecc_stats.corrected_bitflips > 0) + ret = -EUCLEAN; + } + +out: + req.len = orig_len - req.len; + req.ooblen = orig_ooblen - req.ooblen; + + if (copy_to_user(argp, &req, sizeof(req))) + ret = -EFAULT; + + kfree(datbuf); + kfree(oobbuf); + + return ret; +} + static int mtdchar_ioctl(struct file *file, u_int cmd, u_long arg) { struct mtd_file_info *mfi = file->private_data; @@ -707,6 +835,7 @@ static int mtdchar_ioctl(struct file *file, u_int cmd, u_long arg) case MEMGETINFO: case MEMREADOOB: case MEMREADOOB64: + case MEMREAD: case MEMISLOCKED: case MEMGETOOBSEL: case MEMGETBADBLOCK: @@ -881,6 +1010,13 @@ static int mtdchar_ioctl(struct file *file, u_int cmd, u_long arg) break; } + case MEMREAD: + { + ret = mtdchar_read_ioctl(mtd, + (struct mtd_read_req __user *)arg); + break; + } + case MEMLOCK: { struct erase_info_user einfo; diff --git a/include/uapi/mtd/mtd-abi.h b/include/uapi/mtd/mtd-abi.h index b869990c2db2..bc68f266c174 100644 --- a/include/uapi/mtd/mtd-abi.h +++ b/include/uapi/mtd/mtd-abi.h @@ -55,9 +55,9 @@ struct mtd_oob_buf64 { * @MTD_OPS_RAW: data are transferred as-is, with no error correction; * this mode implies %MTD_OPS_PLACE_OOB * - * These modes can be passed to ioctl(MEMWRITE) and are also used internally. - * See notes on "MTD file modes" for discussion on %MTD_OPS_RAW vs. - * %MTD_FILE_MODE_RAW. + * These modes can be passed to ioctl(MEMWRITE) and ioctl(MEMREAD); they are + * also used internally. See notes on "MTD file modes" for discussion on + * %MTD_OPS_RAW vs. %MTD_FILE_MODE_RAW. */ enum { MTD_OPS_PLACE_OOB = 0, @@ -91,6 +91,53 @@ struct mtd_write_req { __u8 padding[7]; }; +/** + * struct mtd_read_req_ecc_stats - ECC statistics for a read operation + * + * @uncorrectable_errors: the number of uncorrectable errors that happened + * during the read operation + * @corrected_bitflips: the number of bitflips corrected during the read + * operation + * @max_bitflips: the maximum number of bitflips detected in any single ECC + * step for the data read during the operation; this information + * can be used to decide whether the data stored in a specific + * region of the MTD device should be moved somewhere else to + * avoid data loss. + */ +struct mtd_read_req_ecc_stats { + __u32 uncorrectable_errors; + __u32 corrected_bitflips; + __u32 max_bitflips; +}; + +/** + * struct mtd_read_req - data structure for requesting a read operation + * + * @start: start address + * @len: length of data buffer + * @ooblen: length of OOB buffer + * @usr_data: user-provided data buffer + * @usr_oob: user-provided OOB buffer + * @mode: MTD mode (see "MTD operation modes") + * @padding: reserved, must be set to 0 + * @ecc_stats: ECC statistics for the read operation + * + * This structure supports ioctl(MEMREAD) operations, allowing data and/or OOB + * reads in various modes. To read from OOB-only, set @usr_data == NULL, and to + * read data-only, set @usr_oob == NULL. However, setting both @usr_data and + * @usr_oob to NULL is not allowed. + */ +struct mtd_read_req { + __u64 start; + __u64 len; + __u64 ooblen; + __u64 usr_data; + __u64 usr_oob; + __u8 mode; + __u8 padding[7]; + struct mtd_read_req_ecc_stats ecc_stats; +}; + #define MTD_ABSENT 0 #define MTD_RAM 1 #define MTD_ROM 2 @@ -207,6 +254,12 @@ struct otp_info { #define MEMWRITE _IOWR('M', 24, struct mtd_write_req) /* Erase a given range of user data (must be in mode %MTD_FILE_MODE_OTP_USER) */ #define OTPERASE _IOW('M', 25, struct otp_info) +/* + * Most generic read interface; can read in-band and/or out-of-band in various + * modes (see "struct mtd_read_req"). This ioctl is not supported for flashes + * without OOB, e.g., NOR flash. + */ +#define MEMREAD _IOWR('M', 26, struct mtd_read_req) /* * Obsolete legacy interface. Keep it in order not to break userspace @@ -270,8 +323,9 @@ struct mtd_ecc_stats { * Note: %MTD_FILE_MODE_RAW provides the same functionality as %MTD_OPS_RAW - * raw access to the flash, without error correction or autoplacement schemes. * Wherever possible, the MTD_OPS_* mode will override the MTD_FILE_MODE_* mode - * (e.g., when using ioctl(MEMWRITE)), but in some cases, the MTD_FILE_MODE is - * used out of necessity (e.g., `write()', ioctl(MEMWRITEOOB64)). + * (e.g., when using ioctl(MEMWRITE) or ioctl(MEMREAD)), but in some cases, the + * MTD_FILE_MODE is used out of necessity (e.g., `write()', + * ioctl(MEMWRITEOOB64)). */ enum mtd_file_modes { MTD_FILE_MODE_NORMAL = MTD_OTP_OFF, -- 2.34.1