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=-16.7 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,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 13C70C4361B for ; Wed, 9 Dec 2020 12:44:20 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id DCBB823BE0 for ; Wed, 9 Dec 2020 12:44:19 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1731759AbgLIMoD (ORCPT ); Wed, 9 Dec 2020 07:44:03 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:48340 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1731740AbgLIMn7 (ORCPT ); Wed, 9 Dec 2020 07:43:59 -0500 Received: from mail-ed1-x543.google.com (mail-ed1-x543.google.com [IPv6:2a00:1450:4864:20::543]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E79FBC0613D6 for ; Wed, 9 Dec 2020 04:43:18 -0800 (PST) Received: by mail-ed1-x543.google.com with SMTP id b73so1360475edf.13 for ; Wed, 09 Dec 2020 04:43:18 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=javigon-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=sqhsxuS2emImV6XGj8F5LGT5a7h8FnexIO/q9STo0QE=; b=PT8U3bHEQXPoXJ5ExamxougC0DgcAvqbQJsvB4nvxFVI2HQSv2AWnUkLjv+dneykM6 r9KaB13ysjtXmM8zc+YE7LLZkEKvRVygOsFWs3d3H7xQ2SRgYXtG/lwi11/dshYEJrzB WCDUop7Nzq4y9fdMLT9n0h1RCf/p3vIoxVl3iQfvhHc16J8TgKSpO2GCi+hqT/l7vxB0 0lToG18J3h5CV6Qx3pk9wXqDwTsR1abS16nFwNlZNAE7bWHF+c/tZ8qUBScc6Bw70AUF SnUIh93Vu5/9WayCCEmZwiekhVmxDiTg+BkTc2VMmc0v9Py6Tt09r5i6b3hJ9VY5nx8K pMtw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=sqhsxuS2emImV6XGj8F5LGT5a7h8FnexIO/q9STo0QE=; b=nHHSF1uAkzmh4Si6ZMfS1xYIKEUFwP8AaT2bBdpjjASKk+C52TswZbfvQnkvFibbzp tA4jTSWi+qUiX0WwR0RC08u2fsErM5KEsjx28Asx1qD1VhWl2jFcrE0Rt68ivvDk9mre pPV5OcAtNmYEZsyg+1s/9C6NJ1U7hIrKeRJXDPdKTMUVyHdFOAUb3nEgyx/XqzIw7h18 oIOM7ccLP5s8asMIc3lH2WHz2/Oy49ryS8eZBiv1AQy0rSsVEKjnw2ml1zyB3/LwkbAl 2ZJfMka/EmqJKjh0EpjZAarkvFdw6OTlBfqyKpxLmAkkkp+2u0sl1ClHfhp8P+rQU4Cf HFig== X-Gm-Message-State: AOAM532xiftiC8CY9WCtDz6v+JV0VTce6vO/EGknx4kIud1xm0ddF8q7 sHEIDEx7ezZAq9GtBCy++iFCeA== X-Google-Smtp-Source: ABdhPJzz0KEZoG6DqaNhSTPjJ01ty8n7RfP/UOdBfD1QU1WeGhBqH1vHnJoi1GOZcwjTgpb8igyIaw== X-Received: by 2002:a50:b264:: with SMTP id o91mr1810340edd.7.1607517797639; Wed, 09 Dec 2020 04:43:17 -0800 (PST) Received: from ch-wrk-javier.cnexlabs.com (5.186.124.214.cgn.fibianet.dk. [5.186.124.214]) by smtp.gmail.com with ESMTPSA id f8sm1546693eds.19.2020.12.09.04.43.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 09 Dec 2020 04:43:16 -0800 (PST) From: javier@javigon.com X-Google-Original-From: javier.gonz@samsung.com To: linux-nvme@lists.infradead.org Cc: linux-block@vger.kernel.org, hch@lst.de, kbusch@kernel.org, sagi@grimberg.me, minwoo.im.dev@gmail.com, =?UTF-8?q?Javier=20Gonz=C3=A1lez?= Subject: [PATCH V3] nvme: enable char device per namespace Date: Wed, 9 Dec 2020 13:43:13 +0100 Message-Id: <20201209124313.20723-1-javier.gonz@samsung.com> X-Mailer: git-send-email 2.17.1 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org From: Javier González Create a char device per NVMe namespace. This char device is always initialized, independently of whether the features implemented by the device are supported by the kernel. User-space can therefore always issue IOCTLs to the NVMe driver using the char device. The char device is presented as /dev/generic-nvmeXcYnZ. This naming scheme follows the convention of the hidden device (nvmeXcYnZ). Support for multipath will follow. Keith: Regarding nvme-cli support, what do you think about reporting the char device as existing block devices? If this is OK with you, I will submit patches for the filters. Changes since V2: - Apply a number of naming and code structure improvements (from Christoph) - Use i_cdev to pull struct nvme_ns in the ioctl path instead of populating file->private_data (from Christoph) - Change char device and sysfs entries to /dev/generic-nvmeXcYnZ to follow the hidden device naming scheme (from Christoph and Keith) Changes since V1: - Remove patches 1-3 which are already picked up by Christoph - Change the char device and sysfs entries to nvmeXnYc / c signals char device - Address Minwoo's comments on inline functions and style Signed-off-by: Javier González --- drivers/nvme/host/core.c | 142 ++++++++++++++++++++++++++++++++++----- drivers/nvme/host/nvme.h | 8 +++ 2 files changed, 134 insertions(+), 16 deletions(-) diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c index 99f91efe3824..006ac8ee9c7c 100644 --- a/drivers/nvme/host/core.c +++ b/drivers/nvme/host/core.c @@ -86,7 +86,9 @@ static DEFINE_MUTEX(nvme_subsystems_lock); static DEFINE_IDA(nvme_instance_ida); static dev_t nvme_ctrl_base_chr_devt; +static dev_t nvme_ns_base_chr_devt; static struct class *nvme_class; +static struct class *nvme_ns_class; static struct class *nvme_subsys_class; static void nvme_put_subsystem(struct nvme_subsystem *subsys); @@ -538,6 +540,7 @@ static void nvme_free_ns(struct kref *kref) if (ns->ndev) nvme_nvm_unregister(ns); + cdev_device_del(&ns->cdev, &ns->cdev_device); put_disk(ns->disk); nvme_put_ns_head(ns->head); nvme_put_ctrl(ns->ctrl); @@ -1738,15 +1741,15 @@ static int nvme_handle_ctrl_ioctl(struct nvme_ns *ns, unsigned int cmd, return ret; } -static int nvme_ioctl(struct block_device *bdev, fmode_t mode, - unsigned int cmd, unsigned long arg) +static int nvme_disk_ioctl(struct gendisk *disk, unsigned int cmd, + unsigned long arg) { struct nvme_ns_head *head = NULL; void __user *argp = (void __user *)arg; struct nvme_ns *ns; int srcu_idx, ret; - ns = nvme_get_ns_from_disk(bdev->bd_disk, &head, &srcu_idx); + ns = nvme_get_ns_from_disk(disk, &head, &srcu_idx); if (unlikely(!ns)) return -EWOULDBLOCK; @@ -1783,6 +1786,12 @@ static int nvme_ioctl(struct block_device *bdev, fmode_t mode, return ret; } +static int nvme_ioctl(struct block_device *bdev, fmode_t mode, + unsigned int cmd, unsigned long arg) +{ + return nvme_disk_ioctl(bdev->bd_disk, cmd, arg); +} + #ifdef CONFIG_COMPAT struct nvme_user_io32 { __u8 opcode; @@ -1824,10 +1833,8 @@ static int nvme_compat_ioctl(struct block_device *bdev, fmode_t mode, #define nvme_compat_ioctl NULL #endif /* CONFIG_COMPAT */ -static int nvme_open(struct block_device *bdev, fmode_t mode) +static int nvme_ns_open(struct nvme_ns *ns) { - struct nvme_ns *ns = bdev->bd_disk->private_data; - #ifdef CONFIG_NVME_MULTIPATH /* should never be called due to GENHD_FL_HIDDEN */ if (WARN_ON_ONCE(ns->head->disk)) @@ -1846,14 +1853,22 @@ static int nvme_open(struct block_device *bdev, fmode_t mode) return -ENXIO; } -static void nvme_release(struct gendisk *disk, fmode_t mode) +static void nvme_ns_release(struct nvme_ns *ns) { - struct nvme_ns *ns = disk->private_data; - module_put(ns->ctrl->ops->module); nvme_put_ns(ns); } +static int nvme_open(struct block_device *bdev, fmode_t mode) +{ + return nvme_ns_open(bdev->bd_disk->private_data); +} + +static void nvme_release(struct gendisk *disk, fmode_t mode) +{ + nvme_ns_release(disk->private_data); +} + static int nvme_getgeo(struct block_device *bdev, struct hd_geometry *geo) { /* some standard values */ @@ -2209,6 +2224,13 @@ static int nvme_update_ns_info(struct nvme_ns *ns, struct nvme_id_ns *id) return 0; out_unfreeze: + /* + * When the device does not support any of the features required by the + * kernel (or viceversa), hide the block device. We can still rely on + * the namespace char device for submitting IOCTLs + */ + ns->disk->flags |= GENHD_FL_HIDDEN; + blk_mq_unfreeze_queue(ns->disk->queue); return ret; } @@ -2346,6 +2368,38 @@ static const struct block_device_operations nvme_bdev_ops = { .pr_ops = &nvme_pr_ops, }; +static int nvme_cdev_open(struct inode *inode, struct file *file) +{ + struct nvme_ns *ns = container_of(inode->i_cdev, struct nvme_ns, cdev); + + return nvme_ns_open(ns); +} + +static int nvme_cdev_release(struct inode *inode, struct file *file) +{ + struct nvme_ns *ns = container_of(inode->i_cdev, struct nvme_ns, cdev); + + nvme_ns_release(ns); + return 0; +} + +static long nvme_cdev_ioctl(struct file *file, unsigned int cmd, + unsigned long arg) +{ + struct nvme_ns *ns = container_of(file->f_inode->i_cdev, + struct nvme_ns, cdev); + + return nvme_disk_ioctl(ns->disk, cmd, arg); +} + +static const struct file_operations nvme_cdev_fops = { + .owner = THIS_MODULE, + .open = nvme_cdev_open, + .release = nvme_cdev_release, + .unlocked_ioctl = nvme_cdev_ioctl, + .compat_ioctl = compat_ptr_ioctl, +}; + #ifdef CONFIG_NVME_MULTIPATH static int nvme_ns_head_open(struct block_device *bdev, fmode_t mode) { @@ -3343,6 +3397,9 @@ static inline struct nvme_ns_head *dev_to_ns_head(struct device *dev) { struct gendisk *disk = dev_to_disk(dev); + if (dev->class == nvme_ns_class) + return nvme_get_ns_from_cdev(dev)->head; + if (disk->fops == &nvme_bdev_ops) return nvme_get_ns_from_dev(dev)->head; else @@ -3474,6 +3531,11 @@ const struct attribute_group *nvme_ns_id_attr_groups[] = { NULL, }; +const struct attribute_group *nvme_ns_char_id_attr_groups[] = { + &nvme_ns_id_attr_group, + NULL, +}; + #define nvme_show_str_function(field) \ static ssize_t field##_show(struct device *dev, \ struct device_attribute *attr, char *buf) \ @@ -3866,6 +3928,36 @@ struct nvme_ns *nvme_find_get_ns(struct nvme_ctrl *ctrl, unsigned nsid) } EXPORT_SYMBOL_NS_GPL(nvme_find_get_ns, NVME_TARGET_PASSTHRU); +static int nvme_alloc_chardev_ns(struct nvme_ctrl *ctrl, struct nvme_ns *ns) +{ + char cdisk_name[DISK_NAME_LEN]; + int ret; + + device_initialize(&ns->cdev_device); + ns->cdev_device.devt = MKDEV(MAJOR(nvme_ns_base_chr_devt), + ns->head->instance); + ns->cdev_device.class = nvme_ns_class; + ns->cdev_device.parent = ctrl->device; + ns->cdev_device.groups = nvme_ns_char_id_attr_groups; + dev_set_drvdata(&ns->cdev_device, ns); + + sprintf(cdisk_name, "nvme-generic-%dc%dn%d", ctrl->subsys->instance, + ctrl->instance, ns->head->instance); + + ret = dev_set_name(&ns->cdev_device, "%s", cdisk_name); + if (ret) + return ret; + + cdev_init(&ns->cdev, &nvme_cdev_fops); + ns->cdev.owner = ctrl->ops->module; + + ret = cdev_device_add(&ns->cdev, &ns->cdev_device); + if (ret) + kfree_const(ns->cdev_device.kobj.name); + + return ret; +} + static void nvme_alloc_ns(struct nvme_ctrl *ctrl, unsigned nsid, struct nvme_ns_ids *ids) { @@ -3912,8 +4004,7 @@ static void nvme_alloc_ns(struct nvme_ctrl *ctrl, unsigned nsid, memcpy(disk->disk_name, disk_name, DISK_NAME_LEN); ns->disk = disk; - if (nvme_update_ns_info(ns, id)) - goto out_put_disk; + nvme_update_ns_info(ns, id); if ((ctrl->quirks & NVME_QUIRK_LIGHTNVM) && id->vs[0] == 0x1) { if (nvme_nvm_register(ns, disk_name, node)) { @@ -3929,9 +4020,12 @@ static void nvme_alloc_ns(struct nvme_ctrl *ctrl, unsigned nsid, nvme_get_ctrl(ctrl); device_add_disk(ctrl->device, ns->disk, nvme_ns_id_attr_groups); - nvme_mpath_add_disk(ns, id); nvme_fault_inject_init(&ns->fault_inject, ns->disk->disk_name); + + if (nvme_alloc_chardev_ns(ctrl, ns)) + goto out_put_disk; + kfree(id); return; @@ -4733,23 +4827,38 @@ static int __init nvme_core_init(void) if (result < 0) goto destroy_delete_wq; + result = alloc_chrdev_region(&nvme_ns_base_chr_devt, 0, + NVME_MINORS, "nvmec"); + if (result < 0) + goto unregister_dev_chrdev; + nvme_class = class_create(THIS_MODULE, "nvme"); if (IS_ERR(nvme_class)) { result = PTR_ERR(nvme_class); - goto unregister_chrdev; + goto unregister_ns_chrdev; } nvme_class->dev_uevent = nvme_class_uevent; + nvme_ns_class = class_create(THIS_MODULE, "nvme-ns"); + if (IS_ERR(nvme_ns_class)) { + result = PTR_ERR(nvme_ns_class); + goto destroy_dev_class; + } + nvme_subsys_class = class_create(THIS_MODULE, "nvme-subsystem"); if (IS_ERR(nvme_subsys_class)) { result = PTR_ERR(nvme_subsys_class); - goto destroy_class; + goto destroy_ns_class; } return 0; -destroy_class: +destroy_ns_class: + class_destroy(nvme_ns_class); +destroy_dev_class: class_destroy(nvme_class); -unregister_chrdev: +unregister_ns_chrdev: + unregister_chrdev_region(nvme_ns_base_chr_devt, NVME_MINORS); +unregister_dev_chrdev: unregister_chrdev_region(nvme_ctrl_base_chr_devt, NVME_MINORS); destroy_delete_wq: destroy_workqueue(nvme_delete_wq); @@ -4765,6 +4874,7 @@ static void __exit nvme_core_exit(void) { class_destroy(nvme_subsys_class); class_destroy(nvme_class); + unregister_chrdev_region(nvme_ns_base_chr_devt, NVME_MINORS); unregister_chrdev_region(nvme_ctrl_base_chr_devt, NVME_MINORS); destroy_workqueue(nvme_delete_wq); destroy_workqueue(nvme_reset_wq); diff --git a/drivers/nvme/host/nvme.h b/drivers/nvme/host/nvme.h index bfcedfa4b057..1dd99f207aee 100644 --- a/drivers/nvme/host/nvme.h +++ b/drivers/nvme/host/nvme.h @@ -439,6 +439,9 @@ struct nvme_ns { struct kref kref; struct nvme_ns_head *head; + struct device cdev_device; /* char device */ + struct cdev cdev; + int lba_shift; u16 ms; u16 sgs; @@ -818,6 +821,11 @@ static inline struct nvme_ns *nvme_get_ns_from_dev(struct device *dev) return dev_to_disk(dev)->private_data; } +static inline struct nvme_ns *nvme_get_ns_from_cdev(struct device *dev) +{ + return dev_get_drvdata(dev); +} + #ifdef CONFIG_NVME_HWMON int nvme_hwmon_init(struct nvme_ctrl *ctrl); #else -- 2.17.1 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=-16.8 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,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 B5C4DC4361B for ; Wed, 9 Dec 2020 12:43:32 +0000 (UTC) Received: from merlin.infradead.org (merlin.infradead.org [205.233.59.134]) (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 4ED2523BC7 for ; Wed, 9 Dec 2020 12:43:32 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 4ED2523BC7 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=javigon.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-nvme-bounces+linux-nvme=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=merlin.20170209; h=Sender:Content-Transfer-Encoding: Content-Type:Cc:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:MIME-Version: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:In-Reply-To:References:List-Owner; bh=W3e5c0ij9dK4obpnfPBHElAexsv/WmzUytHdrntg+ts=; b=YABnlHszv4k4VT+LRh0kdnIMI0 9e7XnGQslQJBnUjIbIAor4/HwesiGd+PYhioHzE5IMFUdu4gLByB5+T1VvvERH3GDnGsnJUT0FPdV 118/cGGhvb3+fNqMsEBYY0aGsHl8buktegzhndkx18q11hu3VPy+9D5JIqrV733Cb07vF3QWEiICd SK/smLEZPyo/9szM0OiALsRcppdbyw/HpaHIIHXHhTWOPPx8wXcF7ZABEadC+ddy/KnG9kw3/OlXV 6O9aPwTNMbNwGHxkluWOk4gVYzqZrpISzZAbwsTWhsXno4TAn38EpYqyDprbfc5+GjzvESD9a/9JI 0P+YNuJA==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1kmyoW-0007hT-3P; Wed, 09 Dec 2020 12:43:24 +0000 Received: from mail-ed1-x541.google.com ([2a00:1450:4864:20::541]) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1kmyoT-0007h0-9m for linux-nvme@lists.infradead.org; Wed, 09 Dec 2020 12:43:22 +0000 Received: by mail-ed1-x541.google.com with SMTP id dk8so1406410edb.1 for ; Wed, 09 Dec 2020 04:43:18 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=javigon-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=sqhsxuS2emImV6XGj8F5LGT5a7h8FnexIO/q9STo0QE=; b=PT8U3bHEQXPoXJ5ExamxougC0DgcAvqbQJsvB4nvxFVI2HQSv2AWnUkLjv+dneykM6 r9KaB13ysjtXmM8zc+YE7LLZkEKvRVygOsFWs3d3H7xQ2SRgYXtG/lwi11/dshYEJrzB WCDUop7Nzq4y9fdMLT9n0h1RCf/p3vIoxVl3iQfvhHc16J8TgKSpO2GCi+hqT/l7vxB0 0lToG18J3h5CV6Qx3pk9wXqDwTsR1abS16nFwNlZNAE7bWHF+c/tZ8qUBScc6Bw70AUF SnUIh93Vu5/9WayCCEmZwiekhVmxDiTg+BkTc2VMmc0v9Py6Tt09r5i6b3hJ9VY5nx8K pMtw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=sqhsxuS2emImV6XGj8F5LGT5a7h8FnexIO/q9STo0QE=; b=a6dFrp711E3attSlnaTNjN9TSd8z9mgZwcdPmx8KXxns5RDk+lbx3SHFM+sajkH5xO nZVq8KoW1FezkKPlQxkv8J7oKhtKPwQRmoRvnXmvylh037/xqrYvoUb1MDznKlO+kIC+ hy1b6K6UxKj9pCjM1ZS2o1a0sEVALYx8aH827Ydj3ivQDZWc0gy73v625IuH4QJQTHlj sNTw9DrAw3FtpMuvTRpTW6+Q9fWrP4bO0W5fTTUef3yauVR9bABxrNGe9iZqPtBIzXbT q5txwX4KBusHmA8wyreW172LpxiLr9oDcugzM+SUgZpyinp6baJUaLXH7gWgiVSCrzLe nhAA== X-Gm-Message-State: AOAM533QyeomZKrkDof4U8XI4EAw5BQdomY7WmmU5lVWNqjOJ/LjYpSO 91M9oGrdJfgiTnu7d/ekv8cuvOerg8NgyXB53DJfDw== X-Google-Smtp-Source: ABdhPJzz0KEZoG6DqaNhSTPjJ01ty8n7RfP/UOdBfD1QU1WeGhBqH1vHnJoi1GOZcwjTgpb8igyIaw== X-Received: by 2002:a50:b264:: with SMTP id o91mr1810340edd.7.1607517797639; Wed, 09 Dec 2020 04:43:17 -0800 (PST) Received: from ch-wrk-javier.cnexlabs.com (5.186.124.214.cgn.fibianet.dk. [5.186.124.214]) by smtp.gmail.com with ESMTPSA id f8sm1546693eds.19.2020.12.09.04.43.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 09 Dec 2020 04:43:16 -0800 (PST) From: javier@javigon.com X-Google-Original-From: javier.gonz@samsung.com To: linux-nvme@lists.infradead.org Subject: [PATCH V3] nvme: enable char device per namespace Date: Wed, 9 Dec 2020 13:43:13 +0100 Message-Id: <20201209124313.20723-1-javier.gonz@samsung.com> X-Mailer: git-send-email 2.17.1 MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20201209_074321_460122_90EA0C9E X-CRM114-Status: GOOD ( 28.11 ) X-BeenThere: linux-nvme@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: sagi@grimberg.me, linux-block@vger.kernel.org, minwoo.im.dev@gmail.com, kbusch@kernel.org, =?UTF-8?q?Javier=20Gonz=C3=A1lez?= , hch@lst.de Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "Linux-nvme" Errors-To: linux-nvme-bounces+linux-nvme=archiver.kernel.org@lists.infradead.org RnJvbTogSmF2aWVyIEdvbnrDoWxleiA8amF2aWVyLmdvbnpAc2Ftc3VuZy5jb20+CgpDcmVhdGUg YSBjaGFyIGRldmljZSBwZXIgTlZNZSBuYW1lc3BhY2UuIFRoaXMgY2hhciBkZXZpY2UgaXMgYWx3 YXlzCmluaXRpYWxpemVkLCBpbmRlcGVuZGVudGx5IG9mIHdoZXRoZXIgdGhlIGZlYXR1cmVzIGlt cGxlbWVudGVkIGJ5IHRoZQpkZXZpY2UgYXJlIHN1cHBvcnRlZCBieSB0aGUga2VybmVsLiBVc2Vy LXNwYWNlIGNhbiB0aGVyZWZvcmUgYWx3YXlzCmlzc3VlIElPQ1RMcyB0byB0aGUgTlZNZSBkcml2 ZXIgdXNpbmcgdGhlIGNoYXIgZGV2aWNlLgoKVGhlIGNoYXIgZGV2aWNlIGlzIHByZXNlbnRlZCBh cyAvZGV2L2dlbmVyaWMtbnZtZVhjWW5aLiBUaGlzIG5hbWluZwpzY2hlbWUgZm9sbG93cyB0aGUg Y29udmVudGlvbiBvZiB0aGUgaGlkZGVuIGRldmljZSAobnZtZVhjWW5aKS4gU3VwcG9ydApmb3Ig bXVsdGlwYXRoIHdpbGwgZm9sbG93LgoKS2VpdGg6IFJlZ2FyZGluZyBudm1lLWNsaSBzdXBwb3J0 LCB3aGF0IGRvIHlvdSB0aGluayBhYm91dCByZXBvcnRpbmcgdGhlCmNoYXIgZGV2aWNlIGFzIGV4 aXN0aW5nIGJsb2NrIGRldmljZXM/IElmIHRoaXMgaXMgT0sgd2l0aCB5b3UsIEkgd2lsbApzdWJt aXQgcGF0Y2hlcyBmb3IgdGhlIGZpbHRlcnMuCgpDaGFuZ2VzIHNpbmNlIFYyOgogIC0gQXBwbHkg YSBudW1iZXIgb2YgbmFtaW5nIGFuZCBjb2RlIHN0cnVjdHVyZSBpbXByb3ZlbWVudHMgKGZyb20K ICAgIENocmlzdG9waCkKICAtIFVzZSBpX2NkZXYgdG8gcHVsbCBzdHJ1Y3QgbnZtZV9ucyBpbiB0 aGUgaW9jdGwgcGF0aCBpbnN0ZWFkIG9mCiAgICBwb3B1bGF0aW5nIGZpbGUtPnByaXZhdGVfZGF0 YSAoZnJvbSBDaHJpc3RvcGgpCiAgLSBDaGFuZ2UgY2hhciBkZXZpY2UgYW5kIHN5c2ZzIGVudHJp ZXMgdG8gL2Rldi9nZW5lcmljLW52bWVYY1luWiB0bwogICAgZm9sbG93IHRoZSBoaWRkZW4gZGV2 aWNlIG5hbWluZyBzY2hlbWUgKGZyb20gQ2hyaXN0b3BoIGFuZCBLZWl0aCkKCkNoYW5nZXMgc2lu Y2UgVjE6CiAgLSBSZW1vdmUgcGF0Y2hlcyAxLTMgd2hpY2ggYXJlIGFscmVhZHkgcGlja2VkIHVw IGJ5IENocmlzdG9waAogIC0gQ2hhbmdlIHRoZSBjaGFyIGRldmljZSBhbmQgc3lzZnMgZW50cmll cyB0byBudm1lWG5ZYyAvIGMgc2lnbmFscwogICAgY2hhciBkZXZpY2UKICAtIEFkZHJlc3MgTWlu d29vJ3MgY29tbWVudHMgb24gaW5saW5lIGZ1bmN0aW9ucyBhbmQgc3R5bGUKClNpZ25lZC1vZmYt Ynk6IEphdmllciBHb256w6FsZXogPGphdmllci5nb256QHNhbXN1bmcuY29tPgotLS0KIGRyaXZl cnMvbnZtZS9ob3N0L2NvcmUuYyB8IDE0MiArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrLS0tLS0KIGRyaXZlcnMvbnZtZS9ob3N0L252bWUuaCB8ICAgOCArKysKIDIgZmlsZXMgY2hh bmdlZCwgMTM0IGluc2VydGlvbnMoKyksIDE2IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2Ry aXZlcnMvbnZtZS9ob3N0L2NvcmUuYyBiL2RyaXZlcnMvbnZtZS9ob3N0L2NvcmUuYwppbmRleCA5 OWY5MWVmZTM4MjQuLjAwNmFjOGVlOWM3YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9udm1lL2hvc3Qv Y29yZS5jCisrKyBiL2RyaXZlcnMvbnZtZS9ob3N0L2NvcmUuYwpAQCAtODYsNyArODYsOSBAQCBz dGF0aWMgREVGSU5FX01VVEVYKG52bWVfc3Vic3lzdGVtc19sb2NrKTsKIAogc3RhdGljIERFRklO RV9JREEobnZtZV9pbnN0YW5jZV9pZGEpOwogc3RhdGljIGRldl90IG52bWVfY3RybF9iYXNlX2No cl9kZXZ0Oworc3RhdGljIGRldl90IG52bWVfbnNfYmFzZV9jaHJfZGV2dDsKIHN0YXRpYyBzdHJ1 Y3QgY2xhc3MgKm52bWVfY2xhc3M7CitzdGF0aWMgc3RydWN0IGNsYXNzICpudm1lX25zX2NsYXNz Owogc3RhdGljIHN0cnVjdCBjbGFzcyAqbnZtZV9zdWJzeXNfY2xhc3M7CiAKIHN0YXRpYyB2b2lk IG52bWVfcHV0X3N1YnN5c3RlbShzdHJ1Y3QgbnZtZV9zdWJzeXN0ZW0gKnN1YnN5cyk7CkBAIC01 MzgsNiArNTQwLDcgQEAgc3RhdGljIHZvaWQgbnZtZV9mcmVlX25zKHN0cnVjdCBrcmVmICprcmVm KQogCWlmIChucy0+bmRldikKIAkJbnZtZV9udm1fdW5yZWdpc3Rlcihucyk7CiAKKwljZGV2X2Rl dmljZV9kZWwoJm5zLT5jZGV2LCAmbnMtPmNkZXZfZGV2aWNlKTsKIAlwdXRfZGlzayhucy0+ZGlz ayk7CiAJbnZtZV9wdXRfbnNfaGVhZChucy0+aGVhZCk7CiAJbnZtZV9wdXRfY3RybChucy0+Y3Ry bCk7CkBAIC0xNzM4LDE1ICsxNzQxLDE1IEBAIHN0YXRpYyBpbnQgbnZtZV9oYW5kbGVfY3RybF9p b2N0bChzdHJ1Y3QgbnZtZV9ucyAqbnMsIHVuc2lnbmVkIGludCBjbWQsCiAJcmV0dXJuIHJldDsK IH0KIAotc3RhdGljIGludCBudm1lX2lvY3RsKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYsIGZt b2RlX3QgbW9kZSwKLQkJdW5zaWduZWQgaW50IGNtZCwgdW5zaWduZWQgbG9uZyBhcmcpCitzdGF0 aWMgaW50IG52bWVfZGlza19pb2N0bChzdHJ1Y3QgZ2VuZGlzayAqZGlzaywgdW5zaWduZWQgaW50 IGNtZCwKKwkJCSAgIHVuc2lnbmVkIGxvbmcgYXJnKQogewogCXN0cnVjdCBudm1lX25zX2hlYWQg KmhlYWQgPSBOVUxMOwogCXZvaWQgX191c2VyICphcmdwID0gKHZvaWQgX191c2VyICopYXJnOwog CXN0cnVjdCBudm1lX25zICpuczsKIAlpbnQgc3JjdV9pZHgsIHJldDsKIAotCW5zID0gbnZtZV9n ZXRfbnNfZnJvbV9kaXNrKGJkZXYtPmJkX2Rpc2ssICZoZWFkLCAmc3JjdV9pZHgpOworCW5zID0g bnZtZV9nZXRfbnNfZnJvbV9kaXNrKGRpc2ssICZoZWFkLCAmc3JjdV9pZHgpOwogCWlmICh1bmxp a2VseSghbnMpKQogCQlyZXR1cm4gLUVXT1VMREJMT0NLOwogCkBAIC0xNzgzLDYgKzE3ODYsMTIg QEAgc3RhdGljIGludCBudm1lX2lvY3RsKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYsIGZtb2Rl X3QgbW9kZSwKIAlyZXR1cm4gcmV0OwogfQogCitzdGF0aWMgaW50IG52bWVfaW9jdGwoc3RydWN0 IGJsb2NrX2RldmljZSAqYmRldiwgZm1vZGVfdCBtb2RlLAorCQkgICAgICB1bnNpZ25lZCBpbnQg Y21kLCB1bnNpZ25lZCBsb25nIGFyZykKK3sKKwlyZXR1cm4gbnZtZV9kaXNrX2lvY3RsKGJkZXYt PmJkX2Rpc2ssIGNtZCwgYXJnKTsKK30KKwogI2lmZGVmIENPTkZJR19DT01QQVQKIHN0cnVjdCBu dm1lX3VzZXJfaW8zMiB7CiAJX191OAlvcGNvZGU7CkBAIC0xODI0LDEwICsxODMzLDggQEAgc3Rh dGljIGludCBudm1lX2NvbXBhdF9pb2N0bChzdHJ1Y3QgYmxvY2tfZGV2aWNlICpiZGV2LCBmbW9k ZV90IG1vZGUsCiAjZGVmaW5lIG52bWVfY29tcGF0X2lvY3RsCU5VTEwKICNlbmRpZiAvKiBDT05G SUdfQ09NUEFUICovCiAKLXN0YXRpYyBpbnQgbnZtZV9vcGVuKHN0cnVjdCBibG9ja19kZXZpY2Ug KmJkZXYsIGZtb2RlX3QgbW9kZSkKK3N0YXRpYyBpbnQgbnZtZV9uc19vcGVuKHN0cnVjdCBudm1l X25zICpucykKIHsKLQlzdHJ1Y3QgbnZtZV9ucyAqbnMgPSBiZGV2LT5iZF9kaXNrLT5wcml2YXRl X2RhdGE7Ci0KICNpZmRlZiBDT05GSUdfTlZNRV9NVUxUSVBBVEgKIAkvKiBzaG91bGQgbmV2ZXIg YmUgY2FsbGVkIGR1ZSB0byBHRU5IRF9GTF9ISURERU4gKi8KIAlpZiAoV0FSTl9PTl9PTkNFKG5z LT5oZWFkLT5kaXNrKSkKQEAgLTE4NDYsMTQgKzE4NTMsMjIgQEAgc3RhdGljIGludCBudm1lX29w ZW4oc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwgZm1vZGVfdCBtb2RlKQogCXJldHVybiAtRU5Y SU87CiB9CiAKLXN0YXRpYyB2b2lkIG52bWVfcmVsZWFzZShzdHJ1Y3QgZ2VuZGlzayAqZGlzaywg Zm1vZGVfdCBtb2RlKQorc3RhdGljIHZvaWQgbnZtZV9uc19yZWxlYXNlKHN0cnVjdCBudm1lX25z ICpucykKIHsKLQlzdHJ1Y3QgbnZtZV9ucyAqbnMgPSBkaXNrLT5wcml2YXRlX2RhdGE7Ci0KIAlt b2R1bGVfcHV0KG5zLT5jdHJsLT5vcHMtPm1vZHVsZSk7CiAJbnZtZV9wdXRfbnMobnMpOwogfQog CitzdGF0aWMgaW50IG52bWVfb3BlbihzdHJ1Y3QgYmxvY2tfZGV2aWNlICpiZGV2LCBmbW9kZV90 IG1vZGUpCit7CisJcmV0dXJuIG52bWVfbnNfb3BlbihiZGV2LT5iZF9kaXNrLT5wcml2YXRlX2Rh dGEpOworfQorCitzdGF0aWMgdm9pZCBudm1lX3JlbGVhc2Uoc3RydWN0IGdlbmRpc2sgKmRpc2ss IGZtb2RlX3QgbW9kZSkKK3sKKwludm1lX25zX3JlbGVhc2UoZGlzay0+cHJpdmF0ZV9kYXRhKTsK K30KKwogc3RhdGljIGludCBudm1lX2dldGdlbyhzdHJ1Y3QgYmxvY2tfZGV2aWNlICpiZGV2LCBz dHJ1Y3QgaGRfZ2VvbWV0cnkgKmdlbykKIHsKIAkvKiBzb21lIHN0YW5kYXJkIHZhbHVlcyAqLwpA QCAtMjIwOSw2ICsyMjI0LDEzIEBAIHN0YXRpYyBpbnQgbnZtZV91cGRhdGVfbnNfaW5mbyhzdHJ1 Y3QgbnZtZV9ucyAqbnMsIHN0cnVjdCBudm1lX2lkX25zICppZCkKIAlyZXR1cm4gMDsKIAogb3V0 X3VuZnJlZXplOgorCS8qCisJICogV2hlbiB0aGUgZGV2aWNlIGRvZXMgbm90IHN1cHBvcnQgYW55 IG9mIHRoZSBmZWF0dXJlcyByZXF1aXJlZCBieSB0aGUKKwkgKiBrZXJuZWwgKG9yIHZpY2V2ZXJz YSksIGhpZGUgdGhlIGJsb2NrIGRldmljZS4gV2UgY2FuIHN0aWxsIHJlbHkgb24KKwkgKiB0aGUg bmFtZXNwYWNlIGNoYXIgZGV2aWNlIGZvciBzdWJtaXR0aW5nIElPQ1RMcworCSAqLworCW5zLT5k aXNrLT5mbGFncyB8PSBHRU5IRF9GTF9ISURERU47CisKIAlibGtfbXFfdW5mcmVlemVfcXVldWUo bnMtPmRpc2stPnF1ZXVlKTsKIAlyZXR1cm4gcmV0OwogfQpAQCAtMjM0Niw2ICsyMzY4LDM4IEBA IHN0YXRpYyBjb25zdCBzdHJ1Y3QgYmxvY2tfZGV2aWNlX29wZXJhdGlvbnMgbnZtZV9iZGV2X29w cyA9IHsKIAkucHJfb3BzCQk9ICZudm1lX3ByX29wcywKIH07CiAKK3N0YXRpYyBpbnQgbnZtZV9j ZGV2X29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCit7CisJc3Ry dWN0IG52bWVfbnMgKm5zID0gY29udGFpbmVyX29mKGlub2RlLT5pX2NkZXYsIHN0cnVjdCBudm1l X25zLCBjZGV2KTsKKworCXJldHVybiBudm1lX25zX29wZW4obnMpOworfQorCitzdGF0aWMgaW50 IG52bWVfY2Rldl9yZWxlYXNlKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxl KQoreworCXN0cnVjdCBudm1lX25zICpucyA9IGNvbnRhaW5lcl9vZihpbm9kZS0+aV9jZGV2LCBz dHJ1Y3QgbnZtZV9ucywgY2Rldik7CisKKwludm1lX25zX3JlbGVhc2UobnMpOworCXJldHVybiAw OworfQorCitzdGF0aWMgbG9uZyBudm1lX2NkZXZfaW9jdGwoc3RydWN0IGZpbGUgKmZpbGUsIHVu c2lnbmVkIGludCBjbWQsCisJCQkgICAgdW5zaWduZWQgbG9uZyBhcmcpCit7CisJc3RydWN0IG52 bWVfbnMgKm5zID0gY29udGFpbmVyX29mKGZpbGUtPmZfaW5vZGUtPmlfY2RldiwKKwkJCQlzdHJ1 Y3QgbnZtZV9ucywgY2Rldik7CisKKwlyZXR1cm4gbnZtZV9kaXNrX2lvY3RsKG5zLT5kaXNrLCBj bWQsIGFyZyk7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIG52bWVf Y2Rldl9mb3BzID0geworCS5vd25lcgkJPSBUSElTX01PRFVMRSwKKwkub3BlbgkJPSBudm1lX2Nk ZXZfb3BlbiwKKwkucmVsZWFzZQk9IG52bWVfY2Rldl9yZWxlYXNlLAorCS51bmxvY2tlZF9pb2N0 bAk9IG52bWVfY2Rldl9pb2N0bCwKKwkuY29tcGF0X2lvY3RsCT0gY29tcGF0X3B0cl9pb2N0bCwK K307CisKICNpZmRlZiBDT05GSUdfTlZNRV9NVUxUSVBBVEgKIHN0YXRpYyBpbnQgbnZtZV9uc19o ZWFkX29wZW4oc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwgZm1vZGVfdCBtb2RlKQogewpAQCAt MzM0Myw2ICszMzk3LDkgQEAgc3RhdGljIGlubGluZSBzdHJ1Y3QgbnZtZV9uc19oZWFkICpkZXZf dG9fbnNfaGVhZChzdHJ1Y3QgZGV2aWNlICpkZXYpCiB7CiAJc3RydWN0IGdlbmRpc2sgKmRpc2sg PSBkZXZfdG9fZGlzayhkZXYpOwogCisJaWYgKGRldi0+Y2xhc3MgPT0gbnZtZV9uc19jbGFzcykK KwkJcmV0dXJuIG52bWVfZ2V0X25zX2Zyb21fY2RldihkZXYpLT5oZWFkOworCiAJaWYgKGRpc2st PmZvcHMgPT0gJm52bWVfYmRldl9vcHMpCiAJCXJldHVybiBudm1lX2dldF9uc19mcm9tX2Rldihk ZXYpLT5oZWFkOwogCWVsc2UKQEAgLTM0NzQsNiArMzUzMSwxMSBAQCBjb25zdCBzdHJ1Y3QgYXR0 cmlidXRlX2dyb3VwICpudm1lX25zX2lkX2F0dHJfZ3JvdXBzW10gPSB7CiAJTlVMTCwKIH07CiAK K2NvbnN0IHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgKm52bWVfbnNfY2hhcl9pZF9hdHRyX2dyb3Vw c1tdID0geworCSZudm1lX25zX2lkX2F0dHJfZ3JvdXAsCisJTlVMTCwKK307CisKICNkZWZpbmUg bnZtZV9zaG93X3N0cl9mdW5jdGlvbihmaWVsZCkJCQkJCQlcCiBzdGF0aWMgc3NpemVfdCAgZmll bGQjI19zaG93KHN0cnVjdCBkZXZpY2UgKmRldiwJCQkJXAogCQkJICAgIHN0cnVjdCBkZXZpY2Vf YXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpCQlcCkBAIC0zODY2LDYgKzM5MjgsMzYgQEAgc3Ry dWN0IG52bWVfbnMgKm52bWVfZmluZF9nZXRfbnMoc3RydWN0IG52bWVfY3RybCAqY3RybCwgdW5z aWduZWQgbnNpZCkKIH0KIEVYUE9SVF9TWU1CT0xfTlNfR1BMKG52bWVfZmluZF9nZXRfbnMsIE5W TUVfVEFSR0VUX1BBU1NUSFJVKTsKIAorc3RhdGljIGludCBudm1lX2FsbG9jX2NoYXJkZXZfbnMo c3RydWN0IG52bWVfY3RybCAqY3RybCwgc3RydWN0IG52bWVfbnMgKm5zKQoreworCWNoYXIgY2Rp c2tfbmFtZVtESVNLX05BTUVfTEVOXTsKKwlpbnQgcmV0OworCisJZGV2aWNlX2luaXRpYWxpemUo Jm5zLT5jZGV2X2RldmljZSk7CisJbnMtPmNkZXZfZGV2aWNlLmRldnQgPSBNS0RFVihNQUpPUihu dm1lX25zX2Jhc2VfY2hyX2RldnQpLAorCQkJCSAgICAgbnMtPmhlYWQtPmluc3RhbmNlKTsKKwlu cy0+Y2Rldl9kZXZpY2UuY2xhc3MgPSBudm1lX25zX2NsYXNzOworCW5zLT5jZGV2X2RldmljZS5w YXJlbnQgPSBjdHJsLT5kZXZpY2U7CisJbnMtPmNkZXZfZGV2aWNlLmdyb3VwcyA9IG52bWVfbnNf Y2hhcl9pZF9hdHRyX2dyb3VwczsKKwlkZXZfc2V0X2RydmRhdGEoJm5zLT5jZGV2X2RldmljZSwg bnMpOworCisJc3ByaW50ZihjZGlza19uYW1lLCAibnZtZS1nZW5lcmljLSVkYyVkbiVkIiwgY3Ry bC0+c3Vic3lzLT5pbnN0YW5jZSwKKwkJY3RybC0+aW5zdGFuY2UsIG5zLT5oZWFkLT5pbnN0YW5j ZSk7CisKKwlyZXQgPSBkZXZfc2V0X25hbWUoJm5zLT5jZGV2X2RldmljZSwgIiVzIiwgY2Rpc2tf bmFtZSk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCWNkZXZfaW5pdCgmbnMtPmNkZXYs ICZudm1lX2NkZXZfZm9wcyk7CisJbnMtPmNkZXYub3duZXIgPSBjdHJsLT5vcHMtPm1vZHVsZTsK KworCXJldCA9IGNkZXZfZGV2aWNlX2FkZCgmbnMtPmNkZXYsICZucy0+Y2Rldl9kZXZpY2UpOwor CWlmIChyZXQpCisJCWtmcmVlX2NvbnN0KG5zLT5jZGV2X2RldmljZS5rb2JqLm5hbWUpOworCisJ cmV0dXJuIHJldDsKK30KKwogc3RhdGljIHZvaWQgbnZtZV9hbGxvY19ucyhzdHJ1Y3QgbnZtZV9j dHJsICpjdHJsLCB1bnNpZ25lZCBuc2lkLAogCQlzdHJ1Y3QgbnZtZV9uc19pZHMgKmlkcykKIHsK QEAgLTM5MTIsOCArNDAwNCw3IEBAIHN0YXRpYyB2b2lkIG52bWVfYWxsb2NfbnMoc3RydWN0IG52 bWVfY3RybCAqY3RybCwgdW5zaWduZWQgbnNpZCwKIAltZW1jcHkoZGlzay0+ZGlza19uYW1lLCBk aXNrX25hbWUsIERJU0tfTkFNRV9MRU4pOwogCW5zLT5kaXNrID0gZGlzazsKIAotCWlmIChudm1l X3VwZGF0ZV9uc19pbmZvKG5zLCBpZCkpCi0JCWdvdG8gb3V0X3B1dF9kaXNrOworCW52bWVfdXBk YXRlX25zX2luZm8obnMsIGlkKTsKIAogCWlmICgoY3RybC0+cXVpcmtzICYgTlZNRV9RVUlSS19M SUdIVE5WTSkgJiYgaWQtPnZzWzBdID09IDB4MSkgewogCQlpZiAobnZtZV9udm1fcmVnaXN0ZXIo bnMsIGRpc2tfbmFtZSwgbm9kZSkpIHsKQEAgLTM5MjksOSArNDAyMCwxMiBAQCBzdGF0aWMgdm9p ZCBudm1lX2FsbG9jX25zKHN0cnVjdCBudm1lX2N0cmwgKmN0cmwsIHVuc2lnbmVkIG5zaWQsCiAJ bnZtZV9nZXRfY3RybChjdHJsKTsKIAogCWRldmljZV9hZGRfZGlzayhjdHJsLT5kZXZpY2UsIG5z LT5kaXNrLCBudm1lX25zX2lkX2F0dHJfZ3JvdXBzKTsKLQogCW52bWVfbXBhdGhfYWRkX2Rpc2so bnMsIGlkKTsKIAludm1lX2ZhdWx0X2luamVjdF9pbml0KCZucy0+ZmF1bHRfaW5qZWN0LCBucy0+ ZGlzay0+ZGlza19uYW1lKTsKKworCWlmIChudm1lX2FsbG9jX2NoYXJkZXZfbnMoY3RybCwgbnMp KQorCQlnb3RvIG91dF9wdXRfZGlzazsKKwogCWtmcmVlKGlkKTsKIAogCXJldHVybjsKQEAgLTQ3 MzMsMjMgKzQ4MjcsMzggQEAgc3RhdGljIGludCBfX2luaXQgbnZtZV9jb3JlX2luaXQodm9pZCkK IAlpZiAocmVzdWx0IDwgMCkKIAkJZ290byBkZXN0cm95X2RlbGV0ZV93cTsKIAorCXJlc3VsdCA9 IGFsbG9jX2NocmRldl9yZWdpb24oJm52bWVfbnNfYmFzZV9jaHJfZGV2dCwgMCwKKwkJCU5WTUVf TUlOT1JTLCAibnZtZWMiKTsKKwlpZiAocmVzdWx0IDwgMCkKKwkJZ290byB1bnJlZ2lzdGVyX2Rl dl9jaHJkZXY7CisKIAludm1lX2NsYXNzID0gY2xhc3NfY3JlYXRlKFRISVNfTU9EVUxFLCAibnZt ZSIpOwogCWlmIChJU19FUlIobnZtZV9jbGFzcykpIHsKIAkJcmVzdWx0ID0gUFRSX0VSUihudm1l X2NsYXNzKTsKLQkJZ290byB1bnJlZ2lzdGVyX2NocmRldjsKKwkJZ290byB1bnJlZ2lzdGVyX25z X2NocmRldjsKIAl9CiAJbnZtZV9jbGFzcy0+ZGV2X3VldmVudCA9IG52bWVfY2xhc3NfdWV2ZW50 OwogCisJbnZtZV9uc19jbGFzcyA9IGNsYXNzX2NyZWF0ZShUSElTX01PRFVMRSwgIm52bWUtbnMi KTsKKwlpZiAoSVNfRVJSKG52bWVfbnNfY2xhc3MpKSB7CisJCXJlc3VsdCA9IFBUUl9FUlIobnZt ZV9uc19jbGFzcyk7CisJCWdvdG8gZGVzdHJveV9kZXZfY2xhc3M7CisJfQorCiAJbnZtZV9zdWJz eXNfY2xhc3MgPSBjbGFzc19jcmVhdGUoVEhJU19NT0RVTEUsICJudm1lLXN1YnN5c3RlbSIpOwog CWlmIChJU19FUlIobnZtZV9zdWJzeXNfY2xhc3MpKSB7CiAJCXJlc3VsdCA9IFBUUl9FUlIobnZt ZV9zdWJzeXNfY2xhc3MpOwotCQlnb3RvIGRlc3Ryb3lfY2xhc3M7CisJCWdvdG8gZGVzdHJveV9u c19jbGFzczsKIAl9CiAJcmV0dXJuIDA7CiAKLWRlc3Ryb3lfY2xhc3M6CitkZXN0cm95X25zX2Ns YXNzOgorCWNsYXNzX2Rlc3Ryb3kobnZtZV9uc19jbGFzcyk7CitkZXN0cm95X2Rldl9jbGFzczoK IAljbGFzc19kZXN0cm95KG52bWVfY2xhc3MpOwotdW5yZWdpc3Rlcl9jaHJkZXY6Cit1bnJlZ2lz dGVyX25zX2NocmRldjoKKwl1bnJlZ2lzdGVyX2NocmRldl9yZWdpb24obnZtZV9uc19iYXNlX2No cl9kZXZ0LCBOVk1FX01JTk9SUyk7Cit1bnJlZ2lzdGVyX2Rldl9jaHJkZXY6CiAJdW5yZWdpc3Rl cl9jaHJkZXZfcmVnaW9uKG52bWVfY3RybF9iYXNlX2Nocl9kZXZ0LCBOVk1FX01JTk9SUyk7CiBk ZXN0cm95X2RlbGV0ZV93cToKIAlkZXN0cm95X3dvcmtxdWV1ZShudm1lX2RlbGV0ZV93cSk7CkBA IC00NzY1LDYgKzQ4NzQsNyBAQCBzdGF0aWMgdm9pZCBfX2V4aXQgbnZtZV9jb3JlX2V4aXQodm9p ZCkKIHsKIAljbGFzc19kZXN0cm95KG52bWVfc3Vic3lzX2NsYXNzKTsKIAljbGFzc19kZXN0cm95 KG52bWVfY2xhc3MpOworCXVucmVnaXN0ZXJfY2hyZGV2X3JlZ2lvbihudm1lX25zX2Jhc2VfY2hy X2RldnQsIE5WTUVfTUlOT1JTKTsKIAl1bnJlZ2lzdGVyX2NocmRldl9yZWdpb24obnZtZV9jdHJs X2Jhc2VfY2hyX2RldnQsIE5WTUVfTUlOT1JTKTsKIAlkZXN0cm95X3dvcmtxdWV1ZShudm1lX2Rl bGV0ZV93cSk7CiAJZGVzdHJveV93b3JrcXVldWUobnZtZV9yZXNldF93cSk7CmRpZmYgLS1naXQg YS9kcml2ZXJzL252bWUvaG9zdC9udm1lLmggYi9kcml2ZXJzL252bWUvaG9zdC9udm1lLmgKaW5k ZXggYmZjZWRmYTRiMDU3Li4xZGQ5OWYyMDdhZWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbnZtZS9o b3N0L252bWUuaAorKysgYi9kcml2ZXJzL252bWUvaG9zdC9udm1lLmgKQEAgLTQzOSw2ICs0Mzks OSBAQCBzdHJ1Y3QgbnZtZV9ucyB7CiAJc3RydWN0IGtyZWYga3JlZjsKIAlzdHJ1Y3QgbnZtZV9u c19oZWFkICpoZWFkOwogCisJc3RydWN0IGRldmljZSBjZGV2X2RldmljZTsJLyogY2hhciBkZXZp Y2UgKi8KKwlzdHJ1Y3QgY2RldiBjZGV2OworCiAJaW50IGxiYV9zaGlmdDsKIAl1MTYgbXM7CiAJ dTE2IHNnczsKQEAgLTgxOCw2ICs4MjEsMTEgQEAgc3RhdGljIGlubGluZSBzdHJ1Y3QgbnZtZV9u cyAqbnZtZV9nZXRfbnNfZnJvbV9kZXYoc3RydWN0IGRldmljZSAqZGV2KQogCXJldHVybiBkZXZf dG9fZGlzayhkZXYpLT5wcml2YXRlX2RhdGE7CiB9CiAKK3N0YXRpYyBpbmxpbmUgc3RydWN0IG52 bWVfbnMgKm52bWVfZ2V0X25zX2Zyb21fY2RldihzdHJ1Y3QgZGV2aWNlICpkZXYpCit7CisJcmV0 dXJuIGRldl9nZXRfZHJ2ZGF0YShkZXYpOworfQorCiAjaWZkZWYgQ09ORklHX05WTUVfSFdNT04K IGludCBudm1lX2h3bW9uX2luaXQoc3RydWN0IG52bWVfY3RybCAqY3RybCk7CiAjZWxzZQotLSAK Mi4xNy4xCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K TGludXgtbnZtZSBtYWlsaW5nIGxpc3QKTGludXgtbnZtZUBsaXN0cy5pbmZyYWRlYWQub3JnCmh0 dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtbnZtZQo=