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=-18.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,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 8C299C433F5 for ; Mon, 20 Sep 2021 07:02:33 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 5ED1360EE2 for ; Mon, 20 Sep 2021 07:02:33 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233470AbhITHD6 (ORCPT ); Mon, 20 Sep 2021 03:03:58 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:33624 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231668AbhITHD4 (ORCPT ); Mon, 20 Sep 2021 03:03:56 -0400 Received: from mail-lf1-x130.google.com (mail-lf1-x130.google.com [IPv6:2a00:1450:4864:20::130]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5194AC061574 for ; Mon, 20 Sep 2021 00:02:30 -0700 (PDT) Received: by mail-lf1-x130.google.com with SMTP id i25so64008267lfg.6 for ; Mon, 20 Sep 2021 00:02:30 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kempniu.pl; s=google; h=from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=uwX463CfZcgcAEGDKTQtHmIWmuhaxRyDNTp5tk3A/KU=; b=D57tUjfGKE06ipxPR5P/669BPlTAG/z2zkLzGnL3jZeR2GBp0t6GEGgEjHty2YJUUg 0gYq3WVTJ3Ajki7NEG+gPcw/DR2hDbW9CPF75MYRygBkLvLEOMrJpjZ7hvtKSE14n04A 5W3vtJCEiHdEWh8XzAjifehywwocmQUQ5fpSA= 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:mime-version :content-transfer-encoding; bh=uwX463CfZcgcAEGDKTQtHmIWmuhaxRyDNTp5tk3A/KU=; b=EW0RNfGBrS6JIbIljHvoxqoKziqvb6Gn3sA5/dw5uPEpJL2+vE5XXgp/2bC1jNqgC2 GBKWIc1l5U714QZ73N1Dx87DYKKZ6iFYGP2WJfDQRELwpU35ETkSXxDHwA3D9u32ZgeA AfoO44te2l0rpyBPJfAUCu8sUCMcwddVXJD+UpsZLJO3M641Db4/+XsMwtN6azSG8O1F pMRT9xKnot3sdbijZeps6/4uV78LN4Y12/KWwAQpuW29xvcMrpTXdy16jq8MHAS5FfbY WfOYmX3/VMOmuLETVU9rsO/rfZ3oO/3W6eEBEscm56PEwGpF3H1Ghwj9XMcg19gC3C+5 ShCQ== X-Gm-Message-State: AOAM531Ptg/4PTcw5rZNe6allAP+681ucmVsPtgdeG2IgnygnkvG4a1R bfJCIL5psAQmnBcWdNVMn/SJWQ== X-Google-Smtp-Source: ABdhPJytlcqh48wCpOcBvVgtRr+vTQplqLvN+bYsTDdT2/dyjBZAlfjsHQtBMBXBO3l1MXzbh+4sIw== X-Received: by 2002:a2e:a36c:: with SMTP id i12mr21816389ljn.427.1632121348630; Mon, 20 Sep 2021 00:02:28 -0700 (PDT) Received: from larwa.hq.kempniu.pl ([2001:470:64df:111::e02]) by smtp.gmail.com with ESMTPSA id s30sm1286415lfb.90.2021.09.20.00.02.27 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 20 Sep 2021 00:02:27 -0700 (PDT) From: =?UTF-8?q?Micha=C5=82=20K=C4=99pie=C5=84?= To: Miquel Raynal , Richard Weinberger , Vignesh Raghavendra Cc: linux-mtd@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH] mtd: add MEMREAD ioctl Date: Mon, 20 Sep 2021 09:02:21 +0200 Message-Id: <20210920070221.10173-1-kernel@kempniu.pl> X-Mailer: git-send-email 2.33.0 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. Update include/uapi/mtd/mtd-abi.h accordingly. Signed-off-by: Michał Kępień --- This patch is a shameless calque^W^W^Wheavily inspired by MEMWRITE code, so quite a lot of copy-pasting happened. I guess it is somewhat expected when adding a read-side counterpart of existing code which takes care of writes, but please excuse me if I went too far. Note that "scripts/checkpatch.pl --strict" returns two alignment warnings for this patch. Given that existing code triggers the same warnings, I assumed that local consistency trumps checkpatch.pl's complaints. drivers/mtd/mtdchar.c | 60 ++++++++++++++++++++++++++++++++++++++ include/uapi/mtd/mtd-abi.h | 43 +++++++++++++++++++++++---- 2 files changed, 98 insertions(+), 5 deletions(-) diff --git a/drivers/mtd/mtdchar.c b/drivers/mtd/mtdchar.c index 155e991d9d75..92e0024bdcf7 100644 --- a/drivers/mtd/mtdchar.c +++ b/drivers/mtd/mtdchar.c @@ -621,6 +621,58 @@ 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; + struct mtd_oob_ops ops = {}; + void __user *usr_data, *usr_oob; + int ret; + + if (copy_from_user(&req, argp, sizeof(req))) + return -EFAULT; + + usr_data = (void __user *)(uintptr_t)req.usr_data; + usr_oob = (void __user *)(uintptr_t)req.usr_oob; + + if (!master->_read_oob) + return -EOPNOTSUPP; + ops.mode = req.mode; + ops.len = (size_t)req.len; + ops.ooblen = (size_t)req.ooblen; + ops.ooboffs = 0; + + if (usr_data) { + ops.datbuf = kmalloc(ops.len, GFP_KERNEL); + if (IS_ERR(ops.datbuf)) + return PTR_ERR(ops.datbuf); + } else { + ops.datbuf = NULL; + } + + if (usr_oob) { + ops.oobbuf = kmalloc(ops.ooblen, GFP_KERNEL); + if (IS_ERR(ops.oobbuf)) { + kfree(ops.datbuf); + return PTR_ERR(ops.oobbuf); + } + } else { + ops.oobbuf = NULL; + } + + ret = mtd_read_oob(mtd, (loff_t)req.start, &ops); + + if (copy_to_user(usr_data, ops.datbuf, ops.retlen) || + copy_to_user(usr_oob, ops.oobbuf, ops.oobretlen)) + ret = -EFAULT; + + kfree(ops.datbuf); + kfree(ops.oobbuf); + + return ret; +} + static int mtdchar_ioctl(struct file *file, u_int cmd, u_long arg) { struct mtd_file_info *mfi = file->private_data; @@ -643,6 +695,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: @@ -817,6 +870,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..337e6e597fad 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,32 @@ struct mtd_write_req { __u8 padding[7]; }; +/** + * 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 + * + * 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]; +}; + #define MTD_ABSENT 0 #define MTD_RAM 1 #define MTD_ROM 2 @@ -207,6 +233,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 +302,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.33.0 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=-18.2 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,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 B35ACC433EF for ; Mon, 20 Sep 2021 07:03:30 +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 5764B60FF2 for ; Mon, 20 Sep 2021 07:03:30 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org 5764B60FF2 Authentication-Results: mail.kernel.org; dmarc=fail (p=reject dis=none) header.from=kempniu.pl Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=lists.infradead.org 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: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:In-Reply-To:References: List-Owner; bh=EX3quoWtxDPgNzbtDpbn4qPZf0/n3tAFPb1q+jN4f3U=; b=4wrV7SxgLXetlX iSKvb7Jqw2bVkJ8DSl2N/Hsn4A+Etw/ilUefLI2Wyjz/O85ReOev7DSvuf9NCMFxpH9t3Y7AhYFek Xe6ck98Z9vZUKl2bWH4YNkQOse1CB74J9FPUO72dqvMluYe/es9xu7EunEgDApouVscx0ErIKFb9p lPAbxs+QvVOCPEPVCVXZWdEx5bfBBKqsCQa7u1jNYTWAw1kBHS7lUoVLKu3gblKbhZyOwV8emEkHv 4tbOpnQCW/e3Z7S7pMQBMnjC+NHS33ZOYPEh7yic+CdrCl2DAkD+1esP7enNzMRrVR/ygZJo2vZ28 PUDn6ml3qkMvEVjbAMVg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1mSDJy-000jLg-Kr; Mon, 20 Sep 2021 07:02:34 +0000 Received: from mail-lf1-x130.google.com ([2a00:1450:4864:20::130]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1mSDJv-000jKT-5e for linux-mtd@lists.infradead.org; Mon, 20 Sep 2021 07:02:33 +0000 Received: by mail-lf1-x130.google.com with SMTP id m3so61289404lfu.2 for ; Mon, 20 Sep 2021 00:02:29 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kempniu.pl; s=google; h=from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=uwX463CfZcgcAEGDKTQtHmIWmuhaxRyDNTp5tk3A/KU=; b=D57tUjfGKE06ipxPR5P/669BPlTAG/z2zkLzGnL3jZeR2GBp0t6GEGgEjHty2YJUUg 0gYq3WVTJ3Ajki7NEG+gPcw/DR2hDbW9CPF75MYRygBkLvLEOMrJpjZ7hvtKSE14n04A 5W3vtJCEiHdEWh8XzAjifehywwocmQUQ5fpSA= 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:mime-version :content-transfer-encoding; bh=uwX463CfZcgcAEGDKTQtHmIWmuhaxRyDNTp5tk3A/KU=; b=c8hv/8WxCIqkknFzhEBZbkrowHibAnzB4DuSqfxISRCf/ro8R/80Y4ATHg14uvPTvT nSnX8/7iMFKxLOYnxXFgHKFa0WGRESRVWzmsn9veK/I2cr5eu46OFH0wntAGnGHvyk/T 8MqU8rBVv4S6zukjlyxcUMJnkxDOHTwRh8pSr47xhPvrXTNSzLMJDiB6QDrIZvqek13C 5o1XFLXFKLiokZzi9k+3ot5ZUP+4zhpbxAheFBGvTKxP3a1pgRjpkvikchY6Wp8ka8g2 6A+OiVfSzDYtzHKWWEkBJp6gBMafHCVOpPQZgSgusehmqkwTwqZ51a31omWkohm/Z3u6 jB9A== X-Gm-Message-State: AOAM531XglLecTlCl02/7VGXy7rHVLQ4gmq7cE9/tQ4SBi8zsXI0bi5R FeEDQnN+lZu/06fy1ZnyqfqIrQ== X-Google-Smtp-Source: ABdhPJytlcqh48wCpOcBvVgtRr+vTQplqLvN+bYsTDdT2/dyjBZAlfjsHQtBMBXBO3l1MXzbh+4sIw== X-Received: by 2002:a2e:a36c:: with SMTP id i12mr21816389ljn.427.1632121348630; Mon, 20 Sep 2021 00:02:28 -0700 (PDT) Received: from larwa.hq.kempniu.pl ([2001:470:64df:111::e02]) by smtp.gmail.com with ESMTPSA id s30sm1286415lfb.90.2021.09.20.00.02.27 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 20 Sep 2021 00:02:27 -0700 (PDT) From: =?UTF-8?q?Micha=C5=82=20K=C4=99pie=C5=84?= To: Miquel Raynal , Richard Weinberger , Vignesh Raghavendra Cc: linux-mtd@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH] mtd: add MEMREAD ioctl Date: Mon, 20 Sep 2021 09:02:21 +0200 Message-Id: <20210920070221.10173-1-kernel@kempniu.pl> X-Mailer: git-send-email 2.33.0 MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210920_000231_340401_F2F28CB0 X-CRM114-Status: GOOD ( 28.90 ) 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 IE1FTVdSSVRFIGlvY3RsLgoKVXBkYXRlIGluY2x1ZGUvdWFwaS9tdGQvbXRkLWFiaS5oIGFjY29y ZGluZ2x5LgoKU2lnbmVkLW9mZi1ieTogTWljaGHFgiBLxJlwaWXFhCA8a2VybmVsQGtlbXBuaXUu cGw+Ci0tLQpUaGlzIHBhdGNoIGlzIGEgc2hhbWVsZXNzIGNhbHF1ZV5XXldeV2hlYXZpbHkgaW5z cGlyZWQgYnkgTUVNV1JJVEUgY29kZSwKc28gcXVpdGUgYSBsb3Qgb2YgY29weS1wYXN0aW5nIGhh cHBlbmVkLiAgSSBndWVzcyBpdCBpcyBzb21ld2hhdApleHBlY3RlZCB3aGVuIGFkZGluZyBhIHJl YWQtc2lkZSBjb3VudGVycGFydCBvZiBleGlzdGluZyBjb2RlIHdoaWNoCnRha2VzIGNhcmUgb2Yg d3JpdGVzLCBidXQgcGxlYXNlIGV4Y3VzZSBtZSBpZiBJIHdlbnQgdG9vIGZhci4KCk5vdGUgdGhh dCAic2NyaXB0cy9jaGVja3BhdGNoLnBsIC0tc3RyaWN0IiByZXR1cm5zIHR3byBhbGlnbm1lbnQK d2FybmluZ3MgZm9yIHRoaXMgcGF0Y2guICBHaXZlbiB0aGF0IGV4aXN0aW5nIGNvZGUgdHJpZ2dl cnMgdGhlIHNhbWUKd2FybmluZ3MsIEkgYXNzdW1lZCB0aGF0IGxvY2FsIGNvbnNpc3RlbmN5IHRy dW1wcyBjaGVja3BhdGNoLnBsJ3MKY29tcGxhaW50cy4KCiBkcml2ZXJzL210ZC9tdGRjaGFyLmMg ICAgICB8IDYwICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBpbmNsdWRl L3VhcGkvbXRkL210ZC1hYmkuaCB8IDQzICsrKysrKysrKysrKysrKysrKysrKysrLS0tLQogMiBm aWxlcyBjaGFuZ2VkLCA5OCBpbnNlcnRpb25zKCspLCA1IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdp dCBhL2RyaXZlcnMvbXRkL210ZGNoYXIuYyBiL2RyaXZlcnMvbXRkL210ZGNoYXIuYwppbmRleCAx NTVlOTkxZDlkNzUuLjkyZTAwMjRiZGNmNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvbXRkY2hh ci5jCisrKyBiL2RyaXZlcnMvbXRkL210ZGNoYXIuYwpAQCAtNjIxLDYgKzYyMSw1OCBAQCBzdGF0 aWMgaW50IG10ZGNoYXJfd3JpdGVfaW9jdGwoc3RydWN0IG10ZF9pbmZvICptdGQsCiAJcmV0dXJu IHJldDsKIH0KIAorc3RhdGljIGludCBtdGRjaGFyX3JlYWRfaW9jdGwoc3RydWN0IG10ZF9pbmZv ICptdGQsCisJCXN0cnVjdCBtdGRfcmVhZF9yZXEgX191c2VyICphcmdwKQoreworCXN0cnVjdCBt dGRfaW5mbyAqbWFzdGVyID0gbXRkX2dldF9tYXN0ZXIobXRkKTsKKwlzdHJ1Y3QgbXRkX3JlYWRf cmVxIHJlcTsKKwlzdHJ1Y3QgbXRkX29vYl9vcHMgb3BzID0ge307CisJdm9pZCBfX3VzZXIgKnVz cl9kYXRhLCAqdXNyX29vYjsKKwlpbnQgcmV0OworCisJaWYgKGNvcHlfZnJvbV91c2VyKCZyZXEs IGFyZ3AsIHNpemVvZihyZXEpKSkKKwkJcmV0dXJuIC1FRkFVTFQ7CisKKwl1c3JfZGF0YSA9ICh2 b2lkIF9fdXNlciAqKSh1aW50cHRyX3QpcmVxLnVzcl9kYXRhOworCXVzcl9vb2IgPSAodm9pZCBf X3VzZXIgKikodWludHB0cl90KXJlcS51c3Jfb29iOworCisJaWYgKCFtYXN0ZXItPl9yZWFkX29v YikKKwkJcmV0dXJuIC1FT1BOT1RTVVBQOworCW9wcy5tb2RlID0gcmVxLm1vZGU7CisJb3BzLmxl biA9IChzaXplX3QpcmVxLmxlbjsKKwlvcHMub29ibGVuID0gKHNpemVfdClyZXEub29ibGVuOwor CW9wcy5vb2JvZmZzID0gMDsKKworCWlmICh1c3JfZGF0YSkgeworCQlvcHMuZGF0YnVmID0ga21h bGxvYyhvcHMubGVuLCBHRlBfS0VSTkVMKTsKKwkJaWYgKElTX0VSUihvcHMuZGF0YnVmKSkKKwkJ CXJldHVybiBQVFJfRVJSKG9wcy5kYXRidWYpOworCX0gZWxzZSB7CisJCW9wcy5kYXRidWYgPSBO VUxMOworCX0KKworCWlmICh1c3Jfb29iKSB7CisJCW9wcy5vb2JidWYgPSBrbWFsbG9jKG9wcy5v b2JsZW4sIEdGUF9LRVJORUwpOworCQlpZiAoSVNfRVJSKG9wcy5vb2JidWYpKSB7CisJCQlrZnJl ZShvcHMuZGF0YnVmKTsKKwkJCXJldHVybiBQVFJfRVJSKG9wcy5vb2JidWYpOworCQl9CisJfSBl bHNlIHsKKwkJb3BzLm9vYmJ1ZiA9IE5VTEw7CisJfQorCisJcmV0ID0gbXRkX3JlYWRfb29iKG10 ZCwgKGxvZmZfdClyZXEuc3RhcnQsICZvcHMpOworCisJaWYgKGNvcHlfdG9fdXNlcih1c3JfZGF0 YSwgb3BzLmRhdGJ1Ziwgb3BzLnJldGxlbikgfHwKKwkgICAgY29weV90b191c2VyKHVzcl9vb2Is IG9wcy5vb2JidWYsIG9wcy5vb2JyZXRsZW4pKQorCQlyZXQgPSAtRUZBVUxUOworCisJa2ZyZWUo b3BzLmRhdGJ1Zik7CisJa2ZyZWUob3BzLm9vYmJ1Zik7CisKKwlyZXR1cm4gcmV0OworfQorCiBz dGF0aWMgaW50IG10ZGNoYXJfaW9jdGwoc3RydWN0IGZpbGUgKmZpbGUsIHVfaW50IGNtZCwgdV9s b25nIGFyZykKIHsKIAlzdHJ1Y3QgbXRkX2ZpbGVfaW5mbyAqbWZpID0gZmlsZS0+cHJpdmF0ZV9k YXRhOwpAQCAtNjQzLDYgKzY5NSw3IEBAIHN0YXRpYyBpbnQgbXRkY2hhcl9pb2N0bChzdHJ1Y3Qg ZmlsZSAqZmlsZSwgdV9pbnQgY21kLCB1X2xvbmcgYXJnKQogCWNhc2UgTUVNR0VUSU5GTzoKIAlj YXNlIE1FTVJFQURPT0I6CiAJY2FzZSBNRU1SRUFET09CNjQ6CisJY2FzZSBNRU1SRUFEOgogCWNh c2UgTUVNSVNMT0NLRUQ6CiAJY2FzZSBNRU1HRVRPT0JTRUw6CiAJY2FzZSBNRU1HRVRCQURCTE9D SzoKQEAgLTgxNyw2ICs4NzAsMTMgQEAgc3RhdGljIGludCBtdGRjaGFyX2lvY3RsKHN0cnVjdCBm aWxlICpmaWxlLCB1X2ludCBjbWQsIHVfbG9uZyBhcmcpCiAJCWJyZWFrOwogCX0KIAorCWNhc2Ug TUVNUkVBRDoKKwl7CisJCXJldCA9IG10ZGNoYXJfcmVhZF9pb2N0bChtdGQsCisJCSAgICAgIChz dHJ1Y3QgbXRkX3JlYWRfcmVxIF9fdXNlciAqKWFyZyk7CisJCWJyZWFrOworCX0KKwogCWNhc2Ug TUVNTE9DSzoKIAl7CiAJCXN0cnVjdCBlcmFzZV9pbmZvX3VzZXIgZWluZm87CmRpZmYgLS1naXQg YS9pbmNsdWRlL3VhcGkvbXRkL210ZC1hYmkuaCBiL2luY2x1ZGUvdWFwaS9tdGQvbXRkLWFiaS5o CmluZGV4IGI4Njk5OTBjMmRiMi4uMzM3ZTZlNTk3ZmFkIDEwMDY0NAotLS0gYS9pbmNsdWRlL3Vh cGkvbXRkL210ZC1hYmkuaAorKysgYi9pbmNsdWRlL3VhcGkvbXRkL210ZC1hYmkuaApAQCAtNTUs OSArNTUsOSBAQCBzdHJ1Y3QgbXRkX29vYl9idWY2NCB7CiAgKiBATVREX09QU19SQVc6CWRhdGEg YXJlIHRyYW5zZmVycmVkIGFzLWlzLCB3aXRoIG5vIGVycm9yIGNvcnJlY3Rpb247CiAgKgkJCXRo aXMgbW9kZSBpbXBsaWVzICVNVERfT1BTX1BMQUNFX09PQgogICoKLSAqIFRoZXNlIG1vZGVzIGNh biBiZSBwYXNzZWQgdG8gaW9jdGwoTUVNV1JJVEUpIGFuZCBhcmUgYWxzbyB1c2VkIGludGVybmFs bHkuCi0gKiBTZWUgbm90ZXMgb24gIk1URCBmaWxlIG1vZGVzIiBmb3IgZGlzY3Vzc2lvbiBvbiAl TVREX09QU19SQVcgdnMuCi0gKiAlTVREX0ZJTEVfTU9ERV9SQVcuCisgKiBUaGVzZSBtb2RlcyBj YW4gYmUgcGFzc2VkIHRvIGlvY3RsKE1FTVdSSVRFKSBhbmQgaW9jdGwoTUVNUkVBRCk7IHRoZXkg YXJlCisgKiBhbHNvIHVzZWQgaW50ZXJuYWxseS4gU2VlIG5vdGVzIG9uICJNVEQgZmlsZSBtb2Rl cyIgZm9yIGRpc2N1c3Npb24gb24KKyAqICVNVERfT1BTX1JBVyB2cy4gJU1URF9GSUxFX01PREVf UkFXLgogICovCiBlbnVtIHsKIAlNVERfT1BTX1BMQUNFX09PQiA9IDAsCkBAIC05MSw2ICs5MSwz MiBAQCBzdHJ1Y3QgbXRkX3dyaXRlX3JlcSB7CiAJX191OCBwYWRkaW5nWzddOwogfTsKIAorLyoq CisgKiBzdHJ1Y3QgbXRkX3JlYWRfcmVxIC0gZGF0YSBzdHJ1Y3R1cmUgZm9yIHJlcXVlc3Rpbmcg YSByZWFkIG9wZXJhdGlvbgorICoKKyAqIEBzdGFydDoJc3RhcnQgYWRkcmVzcworICogQGxlbjoJ bGVuZ3RoIG9mIGRhdGEgYnVmZmVyCisgKiBAb29ibGVuOglsZW5ndGggb2YgT09CIGJ1ZmZlcgor ICogQHVzcl9kYXRhOgl1c2VyLXByb3ZpZGVkIGRhdGEgYnVmZmVyCisgKiBAdXNyX29vYjoJdXNl ci1wcm92aWRlZCBPT0IgYnVmZmVyCisgKiBAbW9kZToJTVREIG1vZGUgKHNlZSAiTVREIG9wZXJh dGlvbiBtb2RlcyIpCisgKiBAcGFkZGluZzoJcmVzZXJ2ZWQsIG11c3QgYmUgc2V0IHRvIDAKKyAq CisgKiBUaGlzIHN0cnVjdHVyZSBzdXBwb3J0cyBpb2N0bChNRU1SRUFEKSBvcGVyYXRpb25zLCBh bGxvd2luZyBkYXRhIGFuZC9vciBPT0IKKyAqIHJlYWRzIGluIHZhcmlvdXMgbW9kZXMuIFRvIHJl YWQgZnJvbSBPT0Itb25seSwgc2V0IEB1c3JfZGF0YSA9PSBOVUxMLCBhbmQgdG8KKyAqIHJlYWQg ZGF0YS1vbmx5LCBzZXQgQHVzcl9vb2IgPT0gTlVMTC4gSG93ZXZlciwgc2V0dGluZyBib3RoIEB1 c3JfZGF0YSBhbmQKKyAqIEB1c3Jfb29iIHRvIE5VTEwgaXMgbm90IGFsbG93ZWQuCisgKi8KK3N0 cnVjdCBtdGRfcmVhZF9yZXEgeworCV9fdTY0IHN0YXJ0OworCV9fdTY0IGxlbjsKKwlfX3U2NCBv b2JsZW47CisJX191NjQgdXNyX2RhdGE7CisJX191NjQgdXNyX29vYjsKKwlfX3U4IG1vZGU7CisJ X191OCBwYWRkaW5nWzddOworfTsKKwogI2RlZmluZSBNVERfQUJTRU5UCQkwCiAjZGVmaW5lIE1U RF9SQU0JCQkxCiAjZGVmaW5lIE1URF9ST00JCQkyCkBAIC0yMDcsNiArMjMzLDEyIEBAIHN0cnVj dCBvdHBfaW5mbyB7CiAjZGVmaW5lIE1FTVdSSVRFCQlfSU9XUignTScsIDI0LCBzdHJ1Y3QgbXRk X3dyaXRlX3JlcSkKIC8qIEVyYXNlIGEgZ2l2ZW4gcmFuZ2Ugb2YgdXNlciBkYXRhIChtdXN0IGJl IGluIG1vZGUgJU1URF9GSUxFX01PREVfT1RQX1VTRVIpICovCiAjZGVmaW5lIE9UUEVSQVNFCQlf SU9XKCdNJywgMjUsIHN0cnVjdCBvdHBfaW5mbykKKy8qCisgKiBNb3N0IGdlbmVyaWMgcmVhZCBp bnRlcmZhY2U7IGNhbiByZWFkIGluLWJhbmQgYW5kL29yIG91dC1vZi1iYW5kIGluIHZhcmlvdXMK KyAqIG1vZGVzIChzZWUgInN0cnVjdCBtdGRfcmVhZF9yZXEiKS4gVGhpcyBpb2N0bCBpcyBub3Qg c3VwcG9ydGVkIGZvciBmbGFzaGVzCisgKiB3aXRob3V0IE9PQiwgZS5nLiwgTk9SIGZsYXNoLgor ICovCisjZGVmaW5lIE1FTVJFQUQJCQlfSU9XUignTScsIDI2LCBzdHJ1Y3QgbXRkX3JlYWRfcmVx KQogCiAvKgogICogT2Jzb2xldGUgbGVnYWN5IGludGVyZmFjZS4gS2VlcCBpdCBpbiBvcmRlciBu b3QgdG8gYnJlYWsgdXNlcnNwYWNlCkBAIC0yNzAsOCArMzAyLDkgQEAgc3RydWN0IG10ZF9lY2Nf c3RhdHMgewogICogTm90ZTogJU1URF9GSUxFX01PREVfUkFXIHByb3ZpZGVzIHRoZSBzYW1lIGZ1 bmN0aW9uYWxpdHkgYXMgJU1URF9PUFNfUkFXIC0KICAqIHJhdyBhY2Nlc3MgdG8gdGhlIGZsYXNo LCB3aXRob3V0IGVycm9yIGNvcnJlY3Rpb24gb3IgYXV0b3BsYWNlbWVudCBzY2hlbWVzLgogICog V2hlcmV2ZXIgcG9zc2libGUsIHRoZSBNVERfT1BTXyogbW9kZSB3aWxsIG92ZXJyaWRlIHRoZSBN VERfRklMRV9NT0RFXyogbW9kZQotICogKGUuZy4sIHdoZW4gdXNpbmcgaW9jdGwoTUVNV1JJVEUp KSwgYnV0IGluIHNvbWUgY2FzZXMsIHRoZSBNVERfRklMRV9NT0RFIGlzCi0gKiB1c2VkIG91dCBv ZiBuZWNlc3NpdHkgKGUuZy4sIGB3cml0ZSgpJywgaW9jdGwoTUVNV1JJVEVPT0I2NCkpLgorICog KGUuZy4sIHdoZW4gdXNpbmcgaW9jdGwoTUVNV1JJVEUpIG9yIGlvY3RsKE1FTVJFQUQpKSwgYnV0 IGluIHNvbWUgY2FzZXMsIHRoZQorICogTVREX0ZJTEVfTU9ERSBpcyB1c2VkIG91dCBvZiBuZWNl c3NpdHkgKGUuZy4sIGB3cml0ZSgpJywKKyAqIGlvY3RsKE1FTVdSSVRFT09CNjQpKS4KICAqLwog ZW51bSBtdGRfZmlsZV9tb2RlcyB7CiAJTVREX0ZJTEVfTU9ERV9OT1JNQUwgPSBNVERfT1RQX09G RiwKLS0gCjIuMzMuMAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fXwpMaW51eCBNVEQgZGlzY3Vzc2lvbiBtYWlsaW5nIGxpc3QKaHR0cDovL2xp c3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1tdGQvCg==