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,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 EB4D5C4361B for ; Tue, 8 Dec 2020 13:30:44 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id C417323A79 for ; Tue, 8 Dec 2020 13:30:44 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729466AbgLHNaU (ORCPT ); Tue, 8 Dec 2020 08:30:20 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:56534 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729462AbgLHNaT (ORCPT ); Tue, 8 Dec 2020 08:30:19 -0500 Received: from mail-ej1-x644.google.com (mail-ej1-x644.google.com [IPv6:2a00:1450:4864:20::644]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 37603C061749 for ; Tue, 8 Dec 2020 05:29:39 -0800 (PST) Received: by mail-ej1-x644.google.com with SMTP id m19so24542826ejj.11 for ; Tue, 08 Dec 2020 05:29:39 -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=ZDjPtFOmPb+UCVeLzwciBz5SQK3rSreSTXi0Ly+FfwU=; b=yPNHmXSpB5j+9cP4Q9axPSrZSft9mjC/PoHtyTYyPaN5Oc34iHmSLAPzxkjACM9ldj SSZsxFGX8cYk7J1voxvBY/qNQwv3pNQ9xUF/TBKfO50Qy+ZTssDdnhvvv9LXR1UHwP30 jNfDl2aEgEXcQMMcBSq9+E77cbIDr49wFSQxsc8qv8Pi0fzZ1dSPUOVYygiBXlsRSKYJ 9mSrlS/NJMWWGvirzbdSa0DeiNr2xtJrn9yZD9uNFsHlI/a8LIRWiZkwamv54Ixj63B7 CfiDgXgwuQZiDpDTopVC33j5qp7ziWCulFEWst6HmwOk76YLrMndtBuotKmJ6aEwNWMG waag== 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=ZDjPtFOmPb+UCVeLzwciBz5SQK3rSreSTXi0Ly+FfwU=; b=QHBRb6sIK7couq+qfrpflmh1jeVyF0CPAr0cWZ0gkjPZCzXexQikL7lct4fP+oNyEJ ZC4ukG+GW53AwbOmw9kObp1dQ1JdBVI/fTigVg7SW5aiH6wEwADm76VFiXwtKojy3f5Z jF+4CpM24foEujV3iQU9RpgneCq+J4z7uUalRKvGKPAIvwW2TRXi2z24+OKM+yNRlwNB TYlwr07F5sQ9nbSkXZq53SGgWVkhFDTkEWEgNh2VqH9BpVq8OvyeXgLDXu++xk1ygJso wCAv4/FIxtGZbCFln8r/IxUbP8B5ewpx/BqUohWBFpTap80/aN0MNhBJ9WKf9G8MFq40 eouQ== X-Gm-Message-State: AOAM533kxwo+Zgy3Ag5qVZEE4onuS8xWJbmHSdbUx4QJiqmB7rtTFj+d LYSw57h4+WqumNrCcagdiKvmDw== X-Google-Smtp-Source: ABdhPJy7SGIilHGBpw+HNU6zCAfxGMdMLOLNprGQzNVXPuMbaaa9Hl7pXG1v5Ur5PyYgTRJ2n3Cr7A== X-Received: by 2002:a17:906:7e43:: with SMTP id z3mr23015815ejr.67.1607434177928; Tue, 08 Dec 2020 05:29:37 -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 cf17sm17034969edb.16.2020.12.08.05.29.36 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 08 Dec 2020 05:29:36 -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 V2] nvme: enable char device per namespace Date: Tue, 8 Dec 2020 14:29:34 +0100 Message-Id: <20201208132934.625-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 thedeatures implemented by the device are supported by the kernel. User-space can therefore always issue IOCTLs to the NVMe driver using this char device. The char device is presented as /dev/nvmeXnYc. This naming aligns with nvme-cli filters, so the char device should be usable without tool changes. It also follows a new name conventio to avoid confusion with the existing hidden device (i.e., nvmeXcYnZ). 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 | 141 +++++++++++++++++++++++++++++++++++---- drivers/nvme/host/nvme.h | 8 +++ 2 files changed, 135 insertions(+), 14 deletions(-) diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c index 99f91efe3824..e446aaba5ccd 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_ns_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,18 @@ 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_ns_ioctl(bdev->bd_disk, cmd, arg); +} + +static long nvme_cdev_ioctl(struct file *file, unsigned int cmd, + unsigned long arg) +{ + return __nvme_ns_ioctl((struct gendisk *)file->private_data, cmd, arg); +} + #ifdef CONFIG_COMPAT struct nvme_user_io32 { __u8 opcode; @@ -1824,10 +1839,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_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,12 +1859,24 @@ static int nvme_open(struct block_device *bdev, fmode_t mode) return -ENXIO; } +static void __nvme_release(struct nvme_ns *ns) +{ + module_put(ns->ctrl->ops->module); + nvme_put_ns(ns); +} + +static int nvme_open(struct block_device *bdev, fmode_t mode) +{ + struct nvme_ns *ns = bdev->bd_disk->private_data; + + return __nvme_open(ns); +} + static void nvme_release(struct gendisk *disk, fmode_t mode) { struct nvme_ns *ns = disk->private_data; - module_put(ns->ctrl->ops->module); - nvme_put_ns(ns); + __nvme_release(ns); } static int nvme_getgeo(struct block_device *bdev, struct hd_geometry *geo) @@ -1863,6 +1888,26 @@ static int nvme_getgeo(struct block_device *bdev, struct hd_geometry *geo) return 0; } +static int nvme_cdev_open(struct inode *inode, struct file *file) +{ + struct nvme_ns *ns = container_of(inode->i_cdev, struct nvme_ns, cdev); + int ret; + + ret = __nvme_open(ns); + if (!ret) + file->private_data = ns->disk; + + return ret; +} + +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_release(ns); + return 0; +} + #ifdef CONFIG_BLK_DEV_INTEGRITY static void nvme_init_integrity(struct gendisk *disk, u16 ms, u8 pi_type, u32 max_integrity_segments) @@ -2346,6 +2391,14 @@ static const struct block_device_operations nvme_bdev_ops = { .pr_ops = &nvme_pr_ops, }; +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 +3396,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 +3530,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 +3927,35 @@ 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%dn%dc", 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 +4002,12 @@ static void nvme_alloc_ns(struct nvme_ctrl *ctrl, unsigned nsid, memcpy(disk->disk_name, disk_name, DISK_NAME_LEN); ns->disk = disk; + /* 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 + */ if (nvme_update_ns_info(ns, id)) - goto out_put_disk; + disk->flags |= GENHD_FL_HIDDEN; if ((ctrl->quirks & NVME_QUIRK_LIGHTNVM) && id->vs[0] == 0x1) { if (nvme_nvm_register(ns, disk_name, node)) { @@ -3929,9 +4023,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 +4830,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 +4877,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 E5E06C433FE for ; Tue, 8 Dec 2020 13:32:04 +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 8F58D23AA9 for ; Tue, 8 Dec 2020 13:32:04 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8F58D23AA9 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=QyvSdHpxzx0Qfpk9guPuIgLCPqGpZoyAC6mKJvfg88c=; b=2JM1/hNZyJatvuPsm60Qr1ioyl pPxVVJ9OxbCvgnS0Q/zqjj5sAJobuvgM67lJukwf5a0xLmWhxRg6r8uPK0NyN7b3QYMP/bcN8Gk6D ehxNLHQ2UYN/yZcVkaW7wMTplR8jn2fhfR8WvtOPOjAXDhr53VVTSFdZlJCEziBEtb1KI7FmBQD0+ 5+x0TqCjYfPVdGzSMqjuHO9Pw7u+k9HDZY2JH8FNG5V4P1x4eJ72DgaxuYXHXyd6lShMUXXY5d1KO QIteAIDJszQQHjg3n6xqSTmuPaNVA8O6PB940hv8XRCQkYORpyL8+tX4WFuL52m8tjhuUxeomclXk ORhN5LFw==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1kmd60-0004PP-Gj; Tue, 08 Dec 2020 13:32:00 +0000 Received: from mail-ej1-x644.google.com ([2a00:1450:4864:20::644]) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1kmd3k-00038T-6y for linux-nvme@lists.infradead.org; Tue, 08 Dec 2020 13:29:50 +0000 Received: by mail-ej1-x644.google.com with SMTP id lt17so24649890ejb.3 for ; Tue, 08 Dec 2020 05:29:39 -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=ZDjPtFOmPb+UCVeLzwciBz5SQK3rSreSTXi0Ly+FfwU=; b=yPNHmXSpB5j+9cP4Q9axPSrZSft9mjC/PoHtyTYyPaN5Oc34iHmSLAPzxkjACM9ldj SSZsxFGX8cYk7J1voxvBY/qNQwv3pNQ9xUF/TBKfO50Qy+ZTssDdnhvvv9LXR1UHwP30 jNfDl2aEgEXcQMMcBSq9+E77cbIDr49wFSQxsc8qv8Pi0fzZ1dSPUOVYygiBXlsRSKYJ 9mSrlS/NJMWWGvirzbdSa0DeiNr2xtJrn9yZD9uNFsHlI/a8LIRWiZkwamv54Ixj63B7 CfiDgXgwuQZiDpDTopVC33j5qp7ziWCulFEWst6HmwOk76YLrMndtBuotKmJ6aEwNWMG waag== 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=ZDjPtFOmPb+UCVeLzwciBz5SQK3rSreSTXi0Ly+FfwU=; b=F/aWJTp/PcTbM9VLjD++JP+jwORYK7p8Tokaxc5jSyf0RTBHVvbVJck1MfJj5yCR+D lwR4Fwz62NOlfCFU1E7+3wPiU5bIaw+fpC3T4cYlDnym+GsXQkRGXeU7ueHawC6Ya4kU c7r2XxLzKO15IOW1GT0t1j/ov0EkbQPoLEh5dzqZ2ubmDWnQpEdWHx8EaEbx0FTF3PMy fh9Thg+b9qHLyr6O4rWVFbgqkxlU7OITsFN5l0M3X54QlCKQEjGxQCv7XNI8gsPf1GL5 PdwBylc7Nr6ktrq+bM7/T032yLTX3peSj8ajwLxLjZ69chGGzfMf1beRmGlucns+dtGL ym3g== X-Gm-Message-State: AOAM533meZloGecsJahbGfwDnKUmNJe1NSRjnm0unvHGq5/YiM996sJF QMAKVaUhucOt4tSLBo+1Onhex2iUFkkrbx+t+9x+eg== X-Google-Smtp-Source: ABdhPJy7SGIilHGBpw+HNU6zCAfxGMdMLOLNprGQzNVXPuMbaaa9Hl7pXG1v5Ur5PyYgTRJ2n3Cr7A== X-Received: by 2002:a17:906:7e43:: with SMTP id z3mr23015815ejr.67.1607434177928; Tue, 08 Dec 2020 05:29:37 -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 cf17sm17034969edb.16.2020.12.08.05.29.36 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 08 Dec 2020 05:29:36 -0800 (PST) From: javier@javigon.com X-Google-Original-From: javier.gonz@samsung.com To: linux-nvme@lists.infradead.org Subject: [PATCH V2] nvme: enable char device per namespace Date: Tue, 8 Dec 2020 14:29:34 +0100 Message-Id: <20201208132934.625-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-20201208_082940_502522_7802833F X-CRM114-Status: GOOD ( 25.80 ) 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 YXlzCmluaXRpYWxpemVkLCBpbmRlcGVuZGVudGx5IG9mIHdoZXRoZXIgdGhlZGVhdHVyZXMgaW1w bGVtZW50ZWQgYnkgdGhlCmRldmljZSBhcmUgc3VwcG9ydGVkIGJ5IHRoZSBrZXJuZWwuIFVzZXIt c3BhY2UgY2FuIHRoZXJlZm9yZSBhbHdheXMKaXNzdWUgSU9DVExzIHRvIHRoZSBOVk1lIGRyaXZl ciB1c2luZyB0aGlzIGNoYXIgZGV2aWNlLgoKVGhlIGNoYXIgZGV2aWNlIGlzIHByZXNlbnRlZCBh cyAvZGV2L252bWVYblljLiBUaGlzIG5hbWluZyBhbGlnbnMgd2l0aApudm1lLWNsaSBmaWx0ZXJz LCBzbyB0aGUgY2hhciBkZXZpY2Ugc2hvdWxkIGJlIHVzYWJsZSB3aXRob3V0IHRvb2wKY2hhbmdl cy4gSXQgYWxzbyBmb2xsb3dzIGEgbmV3IG5hbWUgY29udmVudGlvIHRvIGF2b2lkIGNvbmZ1c2lv biB3aXRoCnRoZSBleGlzdGluZyBoaWRkZW4gZGV2aWNlIChpLmUuLCBudm1lWGNZblopLgoKQ2hh bmdlcyBzaW5jZSBWMToKCiAgLSBSZW1vdmUgcGF0Y2hlcyAxLTMgd2hpY2ggYXJlIGFscmVhZHkg cGlja2VkIHVwIGJ5IENocmlzdG9waAogIC0gQ2hhbmdlIHRoZSBjaGFyIGRldmljZSBhbmQgc3lz ZnMgZW50cmllcyB0byBudm1lWG5ZYyAvIGMgc2lnbmFscwogICAgY2hhciBkZXZpY2UKICAtIEFk ZHJlc3MgTWlud29vJ3MgY29tbWVudHMgb24gaW5saW5lIGZ1bmN0aW9ucyBhbmQgc3R5bGUKClNp Z25lZC1vZmYtYnk6IEphdmllciBHb256w6FsZXogPGphdmllci5nb256QHNhbXN1bmcuY29tPgot LS0KIGRyaXZlcnMvbnZtZS9ob3N0L2NvcmUuYyB8IDE0MSArKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKy0tLS0KIGRyaXZlcnMvbnZtZS9ob3N0L252bWUuaCB8ICAgOCArKysKIDIg ZmlsZXMgY2hhbmdlZCwgMTM1IGluc2VydGlvbnMoKyksIDE0IGRlbGV0aW9ucygtKQoKZGlmZiAt LWdpdCBhL2RyaXZlcnMvbnZtZS9ob3N0L2NvcmUuYyBiL2RyaXZlcnMvbnZtZS9ob3N0L2NvcmUu YwppbmRleCA5OWY5MWVmZTM4MjQuLmU0NDZhYWJhNWNjZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9u dm1lL2hvc3QvY29yZS5jCisrKyBiL2RyaXZlcnMvbnZtZS9ob3N0L2NvcmUuYwpAQCAtODYsNyAr ODYsOSBAQCBzdGF0aWMgREVGSU5FX01VVEVYKG52bWVfc3Vic3lzdGVtc19sb2NrKTsKIAogc3Rh dGljIERFRklORV9JREEobnZtZV9pbnN0YW5jZV9pZGEpOwogc3RhdGljIGRldl90IG52bWVfY3Ry bF9iYXNlX2Nocl9kZXZ0Oworc3RhdGljIGRldl90IG52bWVfbnNfYmFzZV9jaHJfZGV2dDsKIHN0 YXRpYyBzdHJ1Y3QgY2xhc3MgKm52bWVfY2xhc3M7CitzdGF0aWMgc3RydWN0IGNsYXNzICpudm1l X25zX2NsYXNzOwogc3RhdGljIHN0cnVjdCBjbGFzcyAqbnZtZV9zdWJzeXNfY2xhc3M7CiAKIHN0 YXRpYyB2b2lkIG52bWVfcHV0X3N1YnN5c3RlbShzdHJ1Y3QgbnZtZV9zdWJzeXN0ZW0gKnN1YnN5 cyk7CkBAIC01MzgsNiArNTQwLDcgQEAgc3RhdGljIHZvaWQgbnZtZV9mcmVlX25zKHN0cnVjdCBr cmVmICprcmVmKQogCWlmIChucy0+bmRldikKIAkJbnZtZV9udm1fdW5yZWdpc3Rlcihucyk7CiAK KwljZGV2X2RldmljZV9kZWwoJm5zLT5jZGV2LCAmbnMtPmNkZXZfZGV2aWNlKTsKIAlwdXRfZGlz ayhucy0+ZGlzayk7CiAJbnZtZV9wdXRfbnNfaGVhZChucy0+aGVhZCk7CiAJbnZtZV9wdXRfY3Ry bChucy0+Y3RybCk7CkBAIC0xNzM4LDE1ICsxNzQxLDE1IEBAIHN0YXRpYyBpbnQgbnZtZV9oYW5k bGVfY3RybF9pb2N0bChzdHJ1Y3QgbnZtZV9ucyAqbnMsIHVuc2lnbmVkIGludCBjbWQsCiAJcmV0 dXJuIHJldDsKIH0KIAotc3RhdGljIGludCBudm1lX2lvY3RsKHN0cnVjdCBibG9ja19kZXZpY2Ug KmJkZXYsIGZtb2RlX3QgbW9kZSwKLQkJdW5zaWduZWQgaW50IGNtZCwgdW5zaWduZWQgbG9uZyBh cmcpCitzdGF0aWMgaW50IF9fbnZtZV9uc19pb2N0bChzdHJ1Y3QgZ2VuZGlzayAqZGlzaywgdW5z aWduZWQgaW50IGNtZCwKKwkJCSAgIHVuc2lnbmVkIGxvbmcgYXJnKQogewogCXN0cnVjdCBudm1l X25zX2hlYWQgKmhlYWQgPSBOVUxMOwogCXZvaWQgX191c2VyICphcmdwID0gKHZvaWQgX191c2Vy ICopYXJnOwogCXN0cnVjdCBudm1lX25zICpuczsKIAlpbnQgc3JjdV9pZHgsIHJldDsKIAotCW5z ID0gbnZtZV9nZXRfbnNfZnJvbV9kaXNrKGJkZXYtPmJkX2Rpc2ssICZoZWFkLCAmc3JjdV9pZHgp OworCW5zID0gbnZtZV9nZXRfbnNfZnJvbV9kaXNrKGRpc2ssICZoZWFkLCAmc3JjdV9pZHgpOwog CWlmICh1bmxpa2VseSghbnMpKQogCQlyZXR1cm4gLUVXT1VMREJMT0NLOwogCkBAIC0xNzgzLDYg KzE3ODYsMTggQEAgc3RhdGljIGludCBudm1lX2lvY3RsKHN0cnVjdCBibG9ja19kZXZpY2UgKmJk ZXYsIGZtb2RlX3QgbW9kZSwKIAlyZXR1cm4gcmV0OwogfQogCitzdGF0aWMgaW50IG52bWVfaW9j dGwoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwgZm1vZGVfdCBtb2RlLAorCQkgICAgICB1bnNp Z25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKK3sKKwlyZXR1cm4gX19udm1lX25zX2lv Y3RsKGJkZXYtPmJkX2Rpc2ssIGNtZCwgYXJnKTsKK30KKworc3RhdGljIGxvbmcgbnZtZV9jZGV2 X2lvY3RsKHN0cnVjdCBmaWxlICpmaWxlLCB1bnNpZ25lZCBpbnQgY21kLAorCQkJICAgIHVuc2ln bmVkIGxvbmcgYXJnKQoreworCXJldHVybiBfX252bWVfbnNfaW9jdGwoKHN0cnVjdCBnZW5kaXNr ICopZmlsZS0+cHJpdmF0ZV9kYXRhLCBjbWQsIGFyZyk7Cit9CisKICNpZmRlZiBDT05GSUdfQ09N UEFUCiBzdHJ1Y3QgbnZtZV91c2VyX2lvMzIgewogCV9fdTgJb3Bjb2RlOwpAQCAtMTgyNCwxMCAr MTgzOSw4IEBAIHN0YXRpYyBpbnQgbnZtZV9jb21wYXRfaW9jdGwoc3RydWN0IGJsb2NrX2Rldmlj ZSAqYmRldiwgZm1vZGVfdCBtb2RlLAogI2RlZmluZSBudm1lX2NvbXBhdF9pb2N0bAlOVUxMCiAj ZW5kaWYgLyogQ09ORklHX0NPTVBBVCAqLwogCi1zdGF0aWMgaW50IG52bWVfb3BlbihzdHJ1Y3Qg YmxvY2tfZGV2aWNlICpiZGV2LCBmbW9kZV90IG1vZGUpCitzdGF0aWMgaW50IF9fbnZtZV9vcGVu KHN0cnVjdCBudm1lX25zICpucykKIHsKLQlzdHJ1Y3QgbnZtZV9ucyAqbnMgPSBiZGV2LT5iZF9k aXNrLT5wcml2YXRlX2RhdGE7Ci0KICNpZmRlZiBDT05GSUdfTlZNRV9NVUxUSVBBVEgKIAkvKiBz aG91bGQgbmV2ZXIgYmUgY2FsbGVkIGR1ZSB0byBHRU5IRF9GTF9ISURERU4gKi8KIAlpZiAoV0FS Tl9PTl9PTkNFKG5zLT5oZWFkLT5kaXNrKSkKQEAgLTE4NDYsMTIgKzE4NTksMjQgQEAgc3RhdGlj IGludCBudm1lX29wZW4oc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwgZm1vZGVfdCBtb2RlKQog CXJldHVybiAtRU5YSU87CiB9CiAKK3N0YXRpYyB2b2lkIF9fbnZtZV9yZWxlYXNlKHN0cnVjdCBu dm1lX25zICpucykKK3sKKwltb2R1bGVfcHV0KG5zLT5jdHJsLT5vcHMtPm1vZHVsZSk7CisJbnZt ZV9wdXRfbnMobnMpOworfQorCitzdGF0aWMgaW50IG52bWVfb3BlbihzdHJ1Y3QgYmxvY2tfZGV2 aWNlICpiZGV2LCBmbW9kZV90IG1vZGUpCit7CisJc3RydWN0IG52bWVfbnMgKm5zID0gYmRldi0+ YmRfZGlzay0+cHJpdmF0ZV9kYXRhOworCisJcmV0dXJuIF9fbnZtZV9vcGVuKG5zKTsKK30KKwog c3RhdGljIHZvaWQgbnZtZV9yZWxlYXNlKHN0cnVjdCBnZW5kaXNrICpkaXNrLCBmbW9kZV90IG1v ZGUpCiB7CiAJc3RydWN0IG52bWVfbnMgKm5zID0gZGlzay0+cHJpdmF0ZV9kYXRhOwogCi0JbW9k dWxlX3B1dChucy0+Y3RybC0+b3BzLT5tb2R1bGUpOwotCW52bWVfcHV0X25zKG5zKTsKKwlfX252 bWVfcmVsZWFzZShucyk7CiB9CiAKIHN0YXRpYyBpbnQgbnZtZV9nZXRnZW8oc3RydWN0IGJsb2Nr X2RldmljZSAqYmRldiwgc3RydWN0IGhkX2dlb21ldHJ5ICpnZW8pCkBAIC0xODYzLDYgKzE4ODgs MjYgQEAgc3RhdGljIGludCBudm1lX2dldGdlbyhzdHJ1Y3QgYmxvY2tfZGV2aWNlICpiZGV2LCBz dHJ1Y3QgaGRfZ2VvbWV0cnkgKmdlbykKIAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIGludCBudm1l X2NkZXZfb3BlbihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKK3sKKwlz dHJ1Y3QgbnZtZV9ucyAqbnMgPSBjb250YWluZXJfb2YoaW5vZGUtPmlfY2Rldiwgc3RydWN0IG52 bWVfbnMsIGNkZXYpOworCWludCByZXQ7CisKKwlyZXQgPSBfX252bWVfb3Blbihucyk7CisJaWYg KCFyZXQpCisJCWZpbGUtPnByaXZhdGVfZGF0YSA9IG5zLT5kaXNrOworCisJcmV0dXJuIHJldDsK K30KKworc3RhdGljIGludCBudm1lX2NkZXZfcmVsZWFzZShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBz dHJ1Y3QgZmlsZSAqZmlsZSkKK3sKKwlzdHJ1Y3QgbnZtZV9ucyAqbnMgPSBjb250YWluZXJfb2Yo aW5vZGUtPmlfY2Rldiwgc3RydWN0IG52bWVfbnMsIGNkZXYpOworCisJX19udm1lX3JlbGVhc2Uo bnMpOworCXJldHVybiAwOworfQorCiAjaWZkZWYgQ09ORklHX0JMS19ERVZfSU5URUdSSVRZCiBz dGF0aWMgdm9pZCBudm1lX2luaXRfaW50ZWdyaXR5KHN0cnVjdCBnZW5kaXNrICpkaXNrLCB1MTYg bXMsIHU4IHBpX3R5cGUsCiAJCQkJdTMyIG1heF9pbnRlZ3JpdHlfc2VnbWVudHMpCkBAIC0yMzQ2 LDYgKzIzOTEsMTQgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBibG9ja19kZXZpY2Vfb3BlcmF0aW9u cyBudm1lX2JkZXZfb3BzID0gewogCS5wcl9vcHMJCT0gJm52bWVfcHJfb3BzLAogfTsKIAorc3Rh dGljIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgbnZtZV9jZGV2X2ZvcHMgPSB7CisJLm93 bmVyCQk9IFRISVNfTU9EVUxFLAorCS5vcGVuCQk9IG52bWVfY2Rldl9vcGVuLAorCS5yZWxlYXNl CT0gbnZtZV9jZGV2X3JlbGVhc2UsCisJLnVubG9ja2VkX2lvY3RsCT0gbnZtZV9jZGV2X2lvY3Rs LAorCS5jb21wYXRfaW9jdGwJPSBjb21wYXRfcHRyX2lvY3RsLAorfTsKKwogI2lmZGVmIENPTkZJ R19OVk1FX01VTFRJUEFUSAogc3RhdGljIGludCBudm1lX25zX2hlYWRfb3BlbihzdHJ1Y3QgYmxv Y2tfZGV2aWNlICpiZGV2LCBmbW9kZV90IG1vZGUpCiB7CkBAIC0zMzQzLDYgKzMzOTYsOSBAQCBz dGF0aWMgaW5saW5lIHN0cnVjdCBudm1lX25zX2hlYWQgKmRldl90b19uc19oZWFkKHN0cnVjdCBk ZXZpY2UgKmRldikKIHsKIAlzdHJ1Y3QgZ2VuZGlzayAqZGlzayA9IGRldl90b19kaXNrKGRldik7 CiAKKwlpZiAoZGV2LT5jbGFzcyA9PSBudm1lX25zX2NsYXNzKQorCQlyZXR1cm4gbnZtZV9nZXRf bnNfZnJvbV9jZGV2KGRldiktPmhlYWQ7CisKIAlpZiAoZGlzay0+Zm9wcyA9PSAmbnZtZV9iZGV2 X29wcykKIAkJcmV0dXJuIG52bWVfZ2V0X25zX2Zyb21fZGV2KGRldiktPmhlYWQ7CiAJZWxzZQpA QCAtMzQ3NCw2ICszNTMwLDExIEBAIGNvbnN0IHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgKm52bWVf bnNfaWRfYXR0cl9ncm91cHNbXSA9IHsKIAlOVUxMLAogfTsKIAorY29uc3Qgc3RydWN0IGF0dHJp YnV0ZV9ncm91cCAqbnZtZV9uc19jaGFyX2lkX2F0dHJfZ3JvdXBzW10gPSB7CisJJm52bWVfbnNf aWRfYXR0cl9ncm91cCwKKwlOVUxMLAorfTsKKwogI2RlZmluZSBudm1lX3Nob3dfc3RyX2Z1bmN0 aW9uKGZpZWxkKQkJCQkJCVwKIHN0YXRpYyBzc2l6ZV90ICBmaWVsZCMjX3Nob3coc3RydWN0IGRl dmljZSAqZGV2LAkJCQlcCiAJCQkgICAgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsIGNo YXIgKmJ1ZikJCVwKQEAgLTM4NjYsNiArMzkyNywzNSBAQCBzdHJ1Y3QgbnZtZV9ucyAqbnZtZV9m aW5kX2dldF9ucyhzdHJ1Y3QgbnZtZV9jdHJsICpjdHJsLCB1bnNpZ25lZCBuc2lkKQogfQogRVhQ T1JUX1NZTUJPTF9OU19HUEwobnZtZV9maW5kX2dldF9ucywgTlZNRV9UQVJHRVRfUEFTU1RIUlUp OwogCitzdGF0aWMgaW50IG52bWVfYWxsb2NfY2hhcmRldl9ucyhzdHJ1Y3QgbnZtZV9jdHJsICpj dHJsLCBzdHJ1Y3QgbnZtZV9ucyAqbnMpCit7CisJY2hhciBjZGlza19uYW1lW0RJU0tfTkFNRV9M RU5dOworCWludCByZXQ7CisKKwlkZXZpY2VfaW5pdGlhbGl6ZSgmbnMtPmNkZXZfZGV2aWNlKTsK Kwlucy0+Y2Rldl9kZXZpY2UuZGV2dCA9IE1LREVWKE1BSk9SKG52bWVfbnNfYmFzZV9jaHJfZGV2 dCksCisJCQkJICAgICBucy0+aGVhZC0+aW5zdGFuY2UpOworCW5zLT5jZGV2X2RldmljZS5jbGFz cyA9IG52bWVfbnNfY2xhc3M7CisJbnMtPmNkZXZfZGV2aWNlLnBhcmVudCA9IGN0cmwtPmRldmlj ZTsKKwlucy0+Y2Rldl9kZXZpY2UuZ3JvdXBzID0gbnZtZV9uc19jaGFyX2lkX2F0dHJfZ3JvdXBz OworCWRldl9zZXRfZHJ2ZGF0YSgmbnMtPmNkZXZfZGV2aWNlLCBucyk7CisKKwlzcHJpbnRmKGNk aXNrX25hbWUsICJudm1lJWRuJWRjIiwgY3RybC0+aW5zdGFuY2UsIG5zLT5oZWFkLT5pbnN0YW5j ZSk7CisKKwlyZXQgPSBkZXZfc2V0X25hbWUoJm5zLT5jZGV2X2RldmljZSwgIiVzIiwgY2Rpc2tf bmFtZSk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCWNkZXZfaW5pdCgmbnMtPmNkZXYs ICZudm1lX2NkZXZfZm9wcyk7CisJbnMtPmNkZXYub3duZXIgPSBjdHJsLT5vcHMtPm1vZHVsZTsK KworCXJldCA9IGNkZXZfZGV2aWNlX2FkZCgmbnMtPmNkZXYsICZucy0+Y2Rldl9kZXZpY2UpOwor CWlmIChyZXQpCisJCWtmcmVlX2NvbnN0KG5zLT5jZGV2X2RldmljZS5rb2JqLm5hbWUpOworCisJ cmV0dXJuIHJldDsKK30KKwogc3RhdGljIHZvaWQgbnZtZV9hbGxvY19ucyhzdHJ1Y3QgbnZtZV9j dHJsICpjdHJsLCB1bnNpZ25lZCBuc2lkLAogCQlzdHJ1Y3QgbnZtZV9uc19pZHMgKmlkcykKIHsK QEAgLTM5MTIsOCArNDAwMiwxMiBAQCBzdGF0aWMgdm9pZCBudm1lX2FsbG9jX25zKHN0cnVjdCBu dm1lX2N0cmwgKmN0cmwsIHVuc2lnbmVkIG5zaWQsCiAJbWVtY3B5KGRpc2stPmRpc2tfbmFtZSwg ZGlza19uYW1lLCBESVNLX05BTUVfTEVOKTsKIAlucy0+ZGlzayA9IGRpc2s7CiAKKwkvKiBXaGVu IHRoZSBkZXZpY2UgZG9lcyBub3Qgc3VwcG9ydCBhbnkgb2YgdGhlIGZlYXR1cmVzIHJlcXVpcmVk IGJ5IHRoZQorCSAqIGtlcm5lbCAob3IgdmljZXZlcnNhKSwgaGlkZSB0aGUgYmxvY2sgZGV2aWNl LiBXZSBjYW4gc3RpbGwgcmVseSBvbgorCSAqIHRoZSBuYW1lc3BhY2UgY2hhciBkZXZpY2UgZm9y IHN1Ym1pdHRpbmcgSU9DVExzCisJICovCiAJaWYgKG52bWVfdXBkYXRlX25zX2luZm8obnMsIGlk KSkKLQkJZ290byBvdXRfcHV0X2Rpc2s7CisJCWRpc2stPmZsYWdzIHw9IEdFTkhEX0ZMX0hJRERF TjsKIAogCWlmICgoY3RybC0+cXVpcmtzICYgTlZNRV9RVUlSS19MSUdIVE5WTSkgJiYgaWQtPnZz WzBdID09IDB4MSkgewogCQlpZiAobnZtZV9udm1fcmVnaXN0ZXIobnMsIGRpc2tfbmFtZSwgbm9k ZSkpIHsKQEAgLTM5MjksOSArNDAyMywxMiBAQCBzdGF0aWMgdm9pZCBudm1lX2FsbG9jX25zKHN0 cnVjdCBudm1lX2N0cmwgKmN0cmwsIHVuc2lnbmVkIG5zaWQsCiAJbnZtZV9nZXRfY3RybChjdHJs KTsKIAogCWRldmljZV9hZGRfZGlzayhjdHJsLT5kZXZpY2UsIG5zLT5kaXNrLCBudm1lX25zX2lk X2F0dHJfZ3JvdXBzKTsKLQogCW52bWVfbXBhdGhfYWRkX2Rpc2sobnMsIGlkKTsKIAludm1lX2Zh dWx0X2luamVjdF9pbml0KCZucy0+ZmF1bHRfaW5qZWN0LCBucy0+ZGlzay0+ZGlza19uYW1lKTsK KworCWlmIChudm1lX2FsbG9jX2NoYXJkZXZfbnMoY3RybCwgbnMpKQorCQlnb3RvIG91dF9wdXRf ZGlzazsKKwogCWtmcmVlKGlkKTsKIAogCXJldHVybjsKQEAgLTQ3MzMsMjMgKzQ4MzAsMzggQEAg c3RhdGljIGludCBfX2luaXQgbnZtZV9jb3JlX2luaXQodm9pZCkKIAlpZiAocmVzdWx0IDwgMCkK IAkJZ290byBkZXN0cm95X2RlbGV0ZV93cTsKIAorCXJlc3VsdCA9IGFsbG9jX2NocmRldl9yZWdp b24oJm52bWVfbnNfYmFzZV9jaHJfZGV2dCwgMCwKKwkJCU5WTUVfTUlOT1JTLCAibnZtZWMiKTsK KwlpZiAocmVzdWx0IDwgMCkKKwkJZ290byB1bnJlZ2lzdGVyX2Rldl9jaHJkZXY7CisKIAludm1l X2NsYXNzID0gY2xhc3NfY3JlYXRlKFRISVNfTU9EVUxFLCAibnZtZSIpOwogCWlmIChJU19FUlIo bnZtZV9jbGFzcykpIHsKIAkJcmVzdWx0ID0gUFRSX0VSUihudm1lX2NsYXNzKTsKLQkJZ290byB1 bnJlZ2lzdGVyX2NocmRldjsKKwkJZ290byB1bnJlZ2lzdGVyX25zX2NocmRldjsKIAl9CiAJbnZt ZV9jbGFzcy0+ZGV2X3VldmVudCA9IG52bWVfY2xhc3NfdWV2ZW50OwogCisJbnZtZV9uc19jbGFz cyA9IGNsYXNzX2NyZWF0ZShUSElTX01PRFVMRSwgIm52bWUtbnMiKTsKKwlpZiAoSVNfRVJSKG52 bWVfbnNfY2xhc3MpKSB7CisJCXJlc3VsdCA9IFBUUl9FUlIobnZtZV9uc19jbGFzcyk7CisJCWdv dG8gZGVzdHJveV9kZXZfY2xhc3M7CisJfQorCiAJbnZtZV9zdWJzeXNfY2xhc3MgPSBjbGFzc19j cmVhdGUoVEhJU19NT0RVTEUsICJudm1lLXN1YnN5c3RlbSIpOwogCWlmIChJU19FUlIobnZtZV9z dWJzeXNfY2xhc3MpKSB7CiAJCXJlc3VsdCA9IFBUUl9FUlIobnZtZV9zdWJzeXNfY2xhc3MpOwot CQlnb3RvIGRlc3Ryb3lfY2xhc3M7CisJCWdvdG8gZGVzdHJveV9uc19jbGFzczsKIAl9CiAJcmV0 dXJuIDA7CiAKLWRlc3Ryb3lfY2xhc3M6CitkZXN0cm95X25zX2NsYXNzOgorCWNsYXNzX2Rlc3Ry b3kobnZtZV9uc19jbGFzcyk7CitkZXN0cm95X2Rldl9jbGFzczoKIAljbGFzc19kZXN0cm95KG52 bWVfY2xhc3MpOwotdW5yZWdpc3Rlcl9jaHJkZXY6Cit1bnJlZ2lzdGVyX25zX2NocmRldjoKKwl1 bnJlZ2lzdGVyX2NocmRldl9yZWdpb24obnZtZV9uc19iYXNlX2Nocl9kZXZ0LCBOVk1FX01JTk9S Uyk7Cit1bnJlZ2lzdGVyX2Rldl9jaHJkZXY6CiAJdW5yZWdpc3Rlcl9jaHJkZXZfcmVnaW9uKG52 bWVfY3RybF9iYXNlX2Nocl9kZXZ0LCBOVk1FX01JTk9SUyk7CiBkZXN0cm95X2RlbGV0ZV93cToK IAlkZXN0cm95X3dvcmtxdWV1ZShudm1lX2RlbGV0ZV93cSk7CkBAIC00NzY1LDYgKzQ4NzcsNyBA QCBzdGF0aWMgdm9pZCBfX2V4aXQgbnZtZV9jb3JlX2V4aXQodm9pZCkKIHsKIAljbGFzc19kZXN0 cm95KG52bWVfc3Vic3lzX2NsYXNzKTsKIAljbGFzc19kZXN0cm95KG52bWVfY2xhc3MpOworCXVu cmVnaXN0ZXJfY2hyZGV2X3JlZ2lvbihudm1lX25zX2Jhc2VfY2hyX2RldnQsIE5WTUVfTUlOT1JT KTsKIAl1bnJlZ2lzdGVyX2NocmRldl9yZWdpb24obnZtZV9jdHJsX2Jhc2VfY2hyX2RldnQsIE5W TUVfTUlOT1JTKTsKIAlkZXN0cm95X3dvcmtxdWV1ZShudm1lX2RlbGV0ZV93cSk7CiAJZGVzdHJv eV93b3JrcXVldWUobnZtZV9yZXNldF93cSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL252bWUvaG9z dC9udm1lLmggYi9kcml2ZXJzL252bWUvaG9zdC9udm1lLmgKaW5kZXggYmZjZWRmYTRiMDU3Li4x ZGQ5OWYyMDdhZWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbnZtZS9ob3N0L252bWUuaAorKysgYi9k cml2ZXJzL252bWUvaG9zdC9udm1lLmgKQEAgLTQzOSw2ICs0MzksOSBAQCBzdHJ1Y3QgbnZtZV9u cyB7CiAJc3RydWN0IGtyZWYga3JlZjsKIAlzdHJ1Y3QgbnZtZV9uc19oZWFkICpoZWFkOwogCisJ c3RydWN0IGRldmljZSBjZGV2X2RldmljZTsJLyogY2hhciBkZXZpY2UgKi8KKwlzdHJ1Y3QgY2Rl diBjZGV2OworCiAJaW50IGxiYV9zaGlmdDsKIAl1MTYgbXM7CiAJdTE2IHNnczsKQEAgLTgxOCw2 ICs4MjEsMTEgQEAgc3RhdGljIGlubGluZSBzdHJ1Y3QgbnZtZV9ucyAqbnZtZV9nZXRfbnNfZnJv bV9kZXYoc3RydWN0IGRldmljZSAqZGV2KQogCXJldHVybiBkZXZfdG9fZGlzayhkZXYpLT5wcml2 YXRlX2RhdGE7CiB9CiAKK3N0YXRpYyBpbmxpbmUgc3RydWN0IG52bWVfbnMgKm52bWVfZ2V0X25z X2Zyb21fY2RldihzdHJ1Y3QgZGV2aWNlICpkZXYpCit7CisJcmV0dXJuIGRldl9nZXRfZHJ2ZGF0 YShkZXYpOworfQorCiAjaWZkZWYgQ09ORklHX05WTUVfSFdNT04KIGludCBudm1lX2h3bW9uX2lu aXQoc3RydWN0IG52bWVfY3RybCAqY3RybCk7CiAjZWxzZQotLSAKMi4xNy4xCgoKX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KTGludXgtbnZtZSBtYWlsaW5n IGxpc3QKTGludXgtbnZtZUBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRl YWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtbnZtZQo=