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,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 91101C4361B for ; Wed, 16 Dec 2020 18:19:31 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 43912253A1 for ; Wed, 16 Dec 2020 18:19:31 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1730023AbgLPSTP (ORCPT ); Wed, 16 Dec 2020 13:19:15 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:47554 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1730021AbgLPSTP (ORCPT ); Wed, 16 Dec 2020 13:19:15 -0500 Received: from mail-ej1-x632.google.com (mail-ej1-x632.google.com [IPv6:2a00:1450:4864:20::632]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5217DC061794 for ; Wed, 16 Dec 2020 10:18:34 -0800 (PST) Received: by mail-ej1-x632.google.com with SMTP id n26so34098518eju.6 for ; Wed, 16 Dec 2020 10:18:34 -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=SX4WelKyM2LV1FT7S52XDF7hvQFsLxridjGFW3RI2lU=; b=vSUNcXWMTfyoHP2nzczHokA2n/lyzQ+CWFJPKZft5FF7qFySc1xTVJXPG6ZsPq5xJ8 wqgUdgUccD7jpFsh2TEZ9rg1+aOe7Fq3kCF/AboLA1gp6B1lLXDjYrwlFUlApLh+ee7H aRb4/bNtpBgbpfzpYQoCc5/Eme0mwRJ3Ax/esQNNfoswTLIZN65NzC2UkkkEI9WgQEaP u4gjDHsgiq4zIS15jWqmDYiAYTc0kHsDrKib/VIu9q6MLjBQlD8l6zMHpxbNVHNwzQHk OCO6jJcQTfPX/YwusAJAMauR4WBn9KeOKd2IosXf3AXra1t+DqkjXrZO9wDWy0WEr1g4 q+Tw== 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=SX4WelKyM2LV1FT7S52XDF7hvQFsLxridjGFW3RI2lU=; b=SZrLxj4QBslT5BKKmdHtdT5RS5oPKjsF7varAm+ZCxHT0ljtmtEAVEWkR38HpzlJOj M8qlZRN2WwkHZPkIVZmP4G3JlEM3pWyMBqe1R4pl/ey6HOGjnugbYSwXXHm4KF5VELSP axPhcdnvq0pG7/ZEdaH7qfS9mrsbRSYct8+qg1MsufYcNIa+2sgtudrD9aLWRO1+YNxT ryhDgoIiNKB3QlTm18IYAYPyDyaNW+tSjVcn3Y4F2BneacNYyasDpcbsJ5V2ab29qXt6 kaPrrPlm4ujJBEd+Ya8BkxZYdInKxj7Er+1k0zNibJbAHAatWZWMLSVqpTNxCsHn46dZ JVCw== X-Gm-Message-State: AOAM530afE18eg8ooiGHhssoWXORgXPJ58nNoHo/J7svq98g7oiZawRs 5Tzu4+0EML2RG88VdEs+scIL6Q== X-Google-Smtp-Source: ABdhPJzOlKMu10aiozk9lIAYsQknU0+AkKB2jgOsAXrfn23PeE4qEQ0UWoTTJ+OV7ivX6NhmAU+Kmg== X-Received: by 2002:a17:906:cecd:: with SMTP id si13mr11946308ejb.441.1608142712797; Wed, 16 Dec 2020 10:18:32 -0800 (PST) Received: from ch-wrk-javier.localdomain (5.186.124.214.cgn.fibianet.dk. [5.186.124.214]) by smtp.gmail.com with ESMTPSA id k23sm1948451ejs.100.2020.12.16.10.18.31 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Dec 2020 10:18:32 -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 V4] nvme: enable char device per namespace Date: Wed, 16 Dec 2020 19:18:28 +0100 Message-Id: <20201216181828.21040-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, should the generic handle show up in place such as 'nvme list'? If so, I can send a patch for the filters. Changes since V3 (merged patch from keith) - Use a dedicated ida for the generic handle - Do not abort namespace greation if the generic handle fails 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 | 159 +++++++++++++++++++++++++++++++++++---- drivers/nvme/host/nvme.h | 9 +++ 2 files changed, 152 insertions(+), 16 deletions(-) diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c index 99f91efe3824..d1ee462f41fa 100644 --- a/drivers/nvme/host/core.c +++ b/drivers/nvme/host/core.c @@ -86,7 +86,11 @@ static DEFINE_MUTEX(nvme_subsystems_lock); static DEFINE_IDA(nvme_instance_ida); static dev_t nvme_ctrl_base_chr_devt; + +static DEFINE_IDA(nvme_gen_minor_ida); +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); @@ -537,7 +541,10 @@ static void nvme_free_ns(struct kref *kref) if (ns->ndev) nvme_nvm_unregister(ns); + if (ns->minor) + ida_simple_remove(&nvme_gen_minor_ida, ns->minor - 1); + 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 +1745,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 +1790,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 +1837,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 +1857,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 +2228,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 +2372,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 +3401,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 +3535,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 +3932,47 @@ 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; + + ret = ida_simple_get(&nvme_gen_minor_ida, 0, 0, GFP_KERNEL); + if (ret < 0) + return ret; + + ns->minor = ret + 1; + device_initialize(&ns->cdev_device); + ns->cdev_device.devt = MKDEV(MAJOR(nvme_ns_base_chr_devt), ret); + 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) + goto put_ida; + + cdev_init(&ns->cdev, &nvme_cdev_fops); + ns->cdev.owner = ctrl->ops->module; + + ret = cdev_device_add(&ns->cdev, &ns->cdev_device); + if (ret) + goto free_kobj; + + return ret; + +free_kobj: + kfree_const(ns->cdev_device.kobj.name); +put_ida: + ida_simple_remove(&nvme_gen_minor_ida, ns->minor - 1); + ns->minor = 0; + return ret; +} + static void nvme_alloc_ns(struct nvme_ctrl *ctrl, unsigned nsid, struct nvme_ns_ids *ids) { @@ -3912,8 +4019,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 +4035,14 @@ 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)) + dev_warn(ctrl->device, + "failed to create generic handle for nsid:%d\n", + nsid); + kfree(id); return; @@ -4733,23 +4844,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 +4891,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..1e52f7da82de 100644 --- a/drivers/nvme/host/nvme.h +++ b/drivers/nvme/host/nvme.h @@ -439,6 +439,10 @@ struct nvme_ns { struct kref kref; struct nvme_ns_head *head; + struct device cdev_device; /* char device */ + struct cdev cdev; + int minor; + int lba_shift; u16 ms; u16 sgs; @@ -818,6 +822,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 CADFCC4361B for ; Wed, 16 Dec 2020 18:18:46 +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 598E124AEF for ; Wed, 16 Dec 2020 18:18:46 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 598E124AEF 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=Mioxh3/Ye/P4JPn8uGZ3tKz4B7PIXq0eL/NLnUiYx7g=; b=bz3AuIsVSjUZ+N406+HevFXlU0 aP9nrgg43GDZ2EAhesfYb5xHCVVO72A4TfIVZJBnnhXHAVqACDrGuP9Z41B7uMFn2MRILlfTXVQly cuP0afkQM4Y2BnD4uiaHJ+suzv4sI+sav70fV0FxE7Ls7PGlAWi0MHfi1bPjlskjUkDBA6Uog9h13 BR9UwCOrIxZ32NiC9DOlVouHsGvEJLfzTBf0IpPxSdvGpBx1jZIkn5mkb/9t9TYSg2hGn/bqik6b0 jE7BAxrLl7ArEngDBuCM78s+XnOgEjTnVf97GpA+QbnnNKz1DPKOZGwvxHZBaFMVkdP9jvBr85MbN MQmiJcPA==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1kpbNn-0008Gc-Ne; Wed, 16 Dec 2020 18:18:39 +0000 Received: from mail-ej1-x62b.google.com ([2a00:1450:4864:20::62b]) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1kpbNk-0008GG-Vq for linux-nvme@lists.infradead.org; Wed, 16 Dec 2020 18:18:38 +0000 Received: by mail-ej1-x62b.google.com with SMTP id g20so34160666ejb.1 for ; Wed, 16 Dec 2020 10:18:34 -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=SX4WelKyM2LV1FT7S52XDF7hvQFsLxridjGFW3RI2lU=; b=vSUNcXWMTfyoHP2nzczHokA2n/lyzQ+CWFJPKZft5FF7qFySc1xTVJXPG6ZsPq5xJ8 wqgUdgUccD7jpFsh2TEZ9rg1+aOe7Fq3kCF/AboLA1gp6B1lLXDjYrwlFUlApLh+ee7H aRb4/bNtpBgbpfzpYQoCc5/Eme0mwRJ3Ax/esQNNfoswTLIZN65NzC2UkkkEI9WgQEaP u4gjDHsgiq4zIS15jWqmDYiAYTc0kHsDrKib/VIu9q6MLjBQlD8l6zMHpxbNVHNwzQHk OCO6jJcQTfPX/YwusAJAMauR4WBn9KeOKd2IosXf3AXra1t+DqkjXrZO9wDWy0WEr1g4 q+Tw== 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=SX4WelKyM2LV1FT7S52XDF7hvQFsLxridjGFW3RI2lU=; b=ZvtmSN0x8QrphHuFU3TKqkirKpco7EazgzAExp01n507Xiq/42Pw+2kCRGGeBfJz4X Wg/Jo+cGytTwV1OpFAx5/TDIjQtnQubLh9NuwShpW7ayJ4NntJM4tKIZTqPRqvbzOFkO 2wS7UgnOBFgvoVRdR/mvhkUa5AvUq4SLIXrqIb0vpTuRstzl0IdIDG8TXkh9GD9yyZzs iAxW3jwUm331ZX8CCWITmJSxD6quG458LPl0XUk2z1lfoJjVu94gOrKBxNRdAZn/S1lb mU0rISw1zl66fXGRRlyxjvvjlUlCUih8eI9g3aW5ikm1RlqN7UjtUefmg/xXVOa10f4G KJuA== X-Gm-Message-State: AOAM531FTmTsv4WtV92VBf6/5afoe1We8BC+i00+KMc/PNx0iYv2VwwP T+/WrgSReQ3DS7Y4k947owG1pl05fSudbO4x5yg= X-Google-Smtp-Source: ABdhPJzOlKMu10aiozk9lIAYsQknU0+AkKB2jgOsAXrfn23PeE4qEQ0UWoTTJ+OV7ivX6NhmAU+Kmg== X-Received: by 2002:a17:906:cecd:: with SMTP id si13mr11946308ejb.441.1608142712797; Wed, 16 Dec 2020 10:18:32 -0800 (PST) Received: from ch-wrk-javier.localdomain (5.186.124.214.cgn.fibianet.dk. [5.186.124.214]) by smtp.gmail.com with ESMTPSA id k23sm1948451ejs.100.2020.12.16.10.18.31 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Dec 2020 10:18:32 -0800 (PST) From: javier@javigon.com X-Google-Original-From: javier.gonz@samsung.com To: linux-nvme@lists.infradead.org Subject: [PATCH V4] nvme: enable char device per namespace Date: Wed, 16 Dec 2020 19:18:28 +0100 Message-Id: <20201216181828.21040-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-20201216_131837_069536_A9D60A96 X-CRM114-Status: GOOD ( 29.12 ) 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 LCBzaG91bGQgdGhlIGdlbmVyaWMgaGFuZGxlIHNob3cgdXAgaW4KcGxhY2Ugc3VjaCBhcyAnbnZt ZSBsaXN0Jz8gSWYgc28sIEkgY2FuIHNlbmQgYSBwYXRjaCBmb3IgdGhlIGZpbHRlcnMuCgpDaGFu Z2VzIHNpbmNlIFYzIChtZXJnZWQgcGF0Y2ggZnJvbSBrZWl0aCkKICAtIFVzZSBhIGRlZGljYXRl ZCBpZGEgZm9yIHRoZSBnZW5lcmljIGhhbmRsZQogIC0gRG8gbm90IGFib3J0IG5hbWVzcGFjZSBn cmVhdGlvbiBpZiB0aGUgZ2VuZXJpYyBoYW5kbGUgZmFpbHMKCkNoYW5nZXMgc2luY2UgVjI6CiAg LSBBcHBseSBhIG51bWJlciBvZiBuYW1pbmcgYW5kIGNvZGUgc3RydWN0dXJlIGltcHJvdmVtZW50 cyAoZnJvbQogICAgQ2hyaXN0b3BoKQogIC0gVXNlIGlfY2RldiB0byBwdWxsIHN0cnVjdCBudm1l X25zIGluIHRoZSBpb2N0bCBwYXRoIGluc3RlYWQgb2YKICAgIHBvcHVsYXRpbmcgZmlsZS0+cHJp dmF0ZV9kYXRhIChmcm9tIENocmlzdG9waCkKICAtIENoYW5nZSBjaGFyIGRldmljZSBhbmQgc3lz ZnMgZW50cmllcyB0byAvZGV2L2dlbmVyaWMtbnZtZVhjWW5aIHRvCiAgICBmb2xsb3cgdGhlIGhp ZGRlbiBkZXZpY2UgbmFtaW5nIHNjaGVtZSAoZnJvbSBDaHJpc3RvcGggYW5kIEtlaXRoKQoKQ2hh bmdlcyBzaW5jZSBWMToKICAtIFJlbW92ZSBwYXRjaGVzIDEtMyB3aGljaCBhcmUgYWxyZWFkeSBw aWNrZWQgdXAgYnkgQ2hyaXN0b3BoCiAgLSBDaGFuZ2UgdGhlIGNoYXIgZGV2aWNlIGFuZCBzeXNm cyBlbnRyaWVzIHRvIG52bWVYblljIC8gYyBzaWduYWxzCiAgICBjaGFyIGRldmljZQogIC0gQWRk cmVzcyBNaW53b28ncyBjb21tZW50cyBvbiBpbmxpbmUgZnVuY3Rpb25zIGFuZCBzdHlsZQoKU2ln bmVkLW9mZi1ieTogSmF2aWVyIEdvbnrDoWxleiA8amF2aWVyLmdvbnpAc2Ftc3VuZy5jb20+Ci0t LQogZHJpdmVycy9udm1lL2hvc3QvY29yZS5jIHwgMTU5ICsrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrLS0tLQogZHJpdmVycy9udm1lL2hvc3QvbnZtZS5oIHwgICA5ICsrKwogMiBm aWxlcyBjaGFuZ2VkLCAxNTIgaW5zZXJ0aW9ucygrKSwgMTYgZGVsZXRpb25zKC0pCgpkaWZmIC0t Z2l0IGEvZHJpdmVycy9udm1lL2hvc3QvY29yZS5jIGIvZHJpdmVycy9udm1lL2hvc3QvY29yZS5j CmluZGV4IDk5ZjkxZWZlMzgyNC4uZDFlZTQ2MmY0MWZhIDEwMDY0NAotLS0gYS9kcml2ZXJzL252 bWUvaG9zdC9jb3JlLmMKKysrIGIvZHJpdmVycy9udm1lL2hvc3QvY29yZS5jCkBAIC04Niw3ICs4 NiwxMSBAQCBzdGF0aWMgREVGSU5FX01VVEVYKG52bWVfc3Vic3lzdGVtc19sb2NrKTsKIAogc3Rh dGljIERFRklORV9JREEobnZtZV9pbnN0YW5jZV9pZGEpOwogc3RhdGljIGRldl90IG52bWVfY3Ry bF9iYXNlX2Nocl9kZXZ0OworCitzdGF0aWMgREVGSU5FX0lEQShudm1lX2dlbl9taW5vcl9pZGEp Oworc3RhdGljIGRldl90IG52bWVfbnNfYmFzZV9jaHJfZGV2dDsKIHN0YXRpYyBzdHJ1Y3QgY2xh c3MgKm52bWVfY2xhc3M7CitzdGF0aWMgc3RydWN0IGNsYXNzICpudm1lX25zX2NsYXNzOwogc3Rh dGljIHN0cnVjdCBjbGFzcyAqbnZtZV9zdWJzeXNfY2xhc3M7CiAKIHN0YXRpYyB2b2lkIG52bWVf cHV0X3N1YnN5c3RlbShzdHJ1Y3QgbnZtZV9zdWJzeXN0ZW0gKnN1YnN5cyk7CkBAIC01MzcsNyAr NTQxLDEwIEBAIHN0YXRpYyB2b2lkIG52bWVfZnJlZV9ucyhzdHJ1Y3Qga3JlZiAqa3JlZikKIAog CWlmIChucy0+bmRldikKIAkJbnZtZV9udm1fdW5yZWdpc3Rlcihucyk7CisJaWYgKG5zLT5taW5v cikKKwkJaWRhX3NpbXBsZV9yZW1vdmUoJm52bWVfZ2VuX21pbm9yX2lkYSwgbnMtPm1pbm9yIC0g MSk7CiAKKwljZGV2X2RldmljZV9kZWwoJm5zLT5jZGV2LCAmbnMtPmNkZXZfZGV2aWNlKTsKIAlw dXRfZGlzayhucy0+ZGlzayk7CiAJbnZtZV9wdXRfbnNfaGVhZChucy0+aGVhZCk7CiAJbnZtZV9w dXRfY3RybChucy0+Y3RybCk7CkBAIC0xNzM4LDE1ICsxNzQ1LDE1IEBAIHN0YXRpYyBpbnQgbnZt ZV9oYW5kbGVfY3RybF9pb2N0bChzdHJ1Y3QgbnZtZV9ucyAqbnMsIHVuc2lnbmVkIGludCBjbWQs CiAJcmV0dXJuIHJldDsKIH0KIAotc3RhdGljIGludCBudm1lX2lvY3RsKHN0cnVjdCBibG9ja19k ZXZpY2UgKmJkZXYsIGZtb2RlX3QgbW9kZSwKLQkJdW5zaWduZWQgaW50IGNtZCwgdW5zaWduZWQg bG9uZyBhcmcpCitzdGF0aWMgaW50IG52bWVfZGlza19pb2N0bChzdHJ1Y3QgZ2VuZGlzayAqZGlz aywgdW5zaWduZWQgaW50IGNtZCwKKwkJCSAgIHVuc2lnbmVkIGxvbmcgYXJnKQogewogCXN0cnVj dCBudm1lX25zX2hlYWQgKmhlYWQgPSBOVUxMOwogCXZvaWQgX191c2VyICphcmdwID0gKHZvaWQg X191c2VyICopYXJnOwogCXN0cnVjdCBudm1lX25zICpuczsKIAlpbnQgc3JjdV9pZHgsIHJldDsK IAotCW5zID0gbnZtZV9nZXRfbnNfZnJvbV9kaXNrKGJkZXYtPmJkX2Rpc2ssICZoZWFkLCAmc3Jj dV9pZHgpOworCW5zID0gbnZtZV9nZXRfbnNfZnJvbV9kaXNrKGRpc2ssICZoZWFkLCAmc3JjdV9p ZHgpOwogCWlmICh1bmxpa2VseSghbnMpKQogCQlyZXR1cm4gLUVXT1VMREJMT0NLOwogCkBAIC0x NzgzLDYgKzE3OTAsMTIgQEAgc3RhdGljIGludCBudm1lX2lvY3RsKHN0cnVjdCBibG9ja19kZXZp Y2UgKmJkZXYsIGZtb2RlX3QgbW9kZSwKIAlyZXR1cm4gcmV0OwogfQogCitzdGF0aWMgaW50IG52 bWVfaW9jdGwoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwgZm1vZGVfdCBtb2RlLAorCQkgICAg ICB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKK3sKKwlyZXR1cm4gbnZtZV9k aXNrX2lvY3RsKGJkZXYtPmJkX2Rpc2ssIGNtZCwgYXJnKTsKK30KKwogI2lmZGVmIENPTkZJR19D T01QQVQKIHN0cnVjdCBudm1lX3VzZXJfaW8zMiB7CiAJX191OAlvcGNvZGU7CkBAIC0xODI0LDEw ICsxODM3LDggQEAgc3RhdGljIGludCBudm1lX2NvbXBhdF9pb2N0bChzdHJ1Y3QgYmxvY2tfZGV2 aWNlICpiZGV2LCBmbW9kZV90IG1vZGUsCiAjZGVmaW5lIG52bWVfY29tcGF0X2lvY3RsCU5VTEwK ICNlbmRpZiAvKiBDT05GSUdfQ09NUEFUICovCiAKLXN0YXRpYyBpbnQgbnZtZV9vcGVuKHN0cnVj dCBibG9ja19kZXZpY2UgKmJkZXYsIGZtb2RlX3QgbW9kZSkKK3N0YXRpYyBpbnQgbnZtZV9uc19v cGVuKHN0cnVjdCBudm1lX25zICpucykKIHsKLQlzdHJ1Y3QgbnZtZV9ucyAqbnMgPSBiZGV2LT5i ZF9kaXNrLT5wcml2YXRlX2RhdGE7Ci0KICNpZmRlZiBDT05GSUdfTlZNRV9NVUxUSVBBVEgKIAkv KiBzaG91bGQgbmV2ZXIgYmUgY2FsbGVkIGR1ZSB0byBHRU5IRF9GTF9ISURERU4gKi8KIAlpZiAo V0FSTl9PTl9PTkNFKG5zLT5oZWFkLT5kaXNrKSkKQEAgLTE4NDYsMTQgKzE4NTcsMjIgQEAgc3Rh dGljIGludCBudm1lX29wZW4oc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwgZm1vZGVfdCBtb2Rl KQogCXJldHVybiAtRU5YSU87CiB9CiAKLXN0YXRpYyB2b2lkIG52bWVfcmVsZWFzZShzdHJ1Y3Qg Z2VuZGlzayAqZGlzaywgZm1vZGVfdCBtb2RlKQorc3RhdGljIHZvaWQgbnZtZV9uc19yZWxlYXNl KHN0cnVjdCBudm1lX25zICpucykKIHsKLQlzdHJ1Y3QgbnZtZV9ucyAqbnMgPSBkaXNrLT5wcml2 YXRlX2RhdGE7Ci0KIAltb2R1bGVfcHV0KG5zLT5jdHJsLT5vcHMtPm1vZHVsZSk7CiAJbnZtZV9w dXRfbnMobnMpOwogfQogCitzdGF0aWMgaW50IG52bWVfb3BlbihzdHJ1Y3QgYmxvY2tfZGV2aWNl ICpiZGV2LCBmbW9kZV90IG1vZGUpCit7CisJcmV0dXJuIG52bWVfbnNfb3BlbihiZGV2LT5iZF9k aXNrLT5wcml2YXRlX2RhdGEpOworfQorCitzdGF0aWMgdm9pZCBudm1lX3JlbGVhc2Uoc3RydWN0 IGdlbmRpc2sgKmRpc2ssIGZtb2RlX3QgbW9kZSkKK3sKKwludm1lX25zX3JlbGVhc2UoZGlzay0+ cHJpdmF0ZV9kYXRhKTsKK30KKwogc3RhdGljIGludCBudm1lX2dldGdlbyhzdHJ1Y3QgYmxvY2tf ZGV2aWNlICpiZGV2LCBzdHJ1Y3QgaGRfZ2VvbWV0cnkgKmdlbykKIHsKIAkvKiBzb21lIHN0YW5k YXJkIHZhbHVlcyAqLwpAQCAtMjIwOSw2ICsyMjI4LDEzIEBAIHN0YXRpYyBpbnQgbnZtZV91cGRh dGVfbnNfaW5mbyhzdHJ1Y3QgbnZtZV9ucyAqbnMsIHN0cnVjdCBudm1lX2lkX25zICppZCkKIAly ZXR1cm4gMDsKIAogb3V0X3VuZnJlZXplOgorCS8qCisJICogV2hlbiB0aGUgZGV2aWNlIGRvZXMg bm90IHN1cHBvcnQgYW55IG9mIHRoZSBmZWF0dXJlcyByZXF1aXJlZCBieSB0aGUKKwkgKiBrZXJu ZWwgKG9yIHZpY2V2ZXJzYSksIGhpZGUgdGhlIGJsb2NrIGRldmljZS4gV2UgY2FuIHN0aWxsIHJl bHkgb24KKwkgKiB0aGUgbmFtZXNwYWNlIGNoYXIgZGV2aWNlIGZvciBzdWJtaXR0aW5nIElPQ1RM cworCSAqLworCW5zLT5kaXNrLT5mbGFncyB8PSBHRU5IRF9GTF9ISURERU47CisKIAlibGtfbXFf dW5mcmVlemVfcXVldWUobnMtPmRpc2stPnF1ZXVlKTsKIAlyZXR1cm4gcmV0OwogfQpAQCAtMjM0 Niw2ICsyMzcyLDM4IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgYmxvY2tfZGV2aWNlX29wZXJhdGlv bnMgbnZtZV9iZGV2X29wcyA9IHsKIAkucHJfb3BzCQk9ICZudm1lX3ByX29wcywKIH07CiAKK3N0 YXRpYyBpbnQgbnZtZV9jZGV2X29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUg KmZpbGUpCit7CisJc3RydWN0IG52bWVfbnMgKm5zID0gY29udGFpbmVyX29mKGlub2RlLT5pX2Nk ZXYsIHN0cnVjdCBudm1lX25zLCBjZGV2KTsKKworCXJldHVybiBudm1lX25zX29wZW4obnMpOwor fQorCitzdGF0aWMgaW50IG52bWVfY2Rldl9yZWxlYXNlKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0 cnVjdCBmaWxlICpmaWxlKQoreworCXN0cnVjdCBudm1lX25zICpucyA9IGNvbnRhaW5lcl9vZihp bm9kZS0+aV9jZGV2LCBzdHJ1Y3QgbnZtZV9ucywgY2Rldik7CisKKwludm1lX25zX3JlbGVhc2Uo bnMpOworCXJldHVybiAwOworfQorCitzdGF0aWMgbG9uZyBudm1lX2NkZXZfaW9jdGwoc3RydWN0 IGZpbGUgKmZpbGUsIHVuc2lnbmVkIGludCBjbWQsCisJCQkgICAgdW5zaWduZWQgbG9uZyBhcmcp Cit7CisJc3RydWN0IG52bWVfbnMgKm5zID0gY29udGFpbmVyX29mKGZpbGUtPmZfaW5vZGUtPmlf Y2RldiwKKwkJCQlzdHJ1Y3QgbnZtZV9ucywgY2Rldik7CisKKwlyZXR1cm4gbnZtZV9kaXNrX2lv Y3RsKG5zLT5kaXNrLCBjbWQsIGFyZyk7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZmlsZV9v cGVyYXRpb25zIG52bWVfY2Rldl9mb3BzID0geworCS5vd25lcgkJPSBUSElTX01PRFVMRSwKKwku b3BlbgkJPSBudm1lX2NkZXZfb3BlbiwKKwkucmVsZWFzZQk9IG52bWVfY2Rldl9yZWxlYXNlLAor CS51bmxvY2tlZF9pb2N0bAk9IG52bWVfY2Rldl9pb2N0bCwKKwkuY29tcGF0X2lvY3RsCT0gY29t cGF0X3B0cl9pb2N0bCwKK307CisKICNpZmRlZiBDT05GSUdfTlZNRV9NVUxUSVBBVEgKIHN0YXRp YyBpbnQgbnZtZV9uc19oZWFkX29wZW4oc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwgZm1vZGVf dCBtb2RlKQogewpAQCAtMzM0Myw2ICszNDAxLDkgQEAgc3RhdGljIGlubGluZSBzdHJ1Y3QgbnZt ZV9uc19oZWFkICpkZXZfdG9fbnNfaGVhZChzdHJ1Y3QgZGV2aWNlICpkZXYpCiB7CiAJc3RydWN0 IGdlbmRpc2sgKmRpc2sgPSBkZXZfdG9fZGlzayhkZXYpOwogCisJaWYgKGRldi0+Y2xhc3MgPT0g bnZtZV9uc19jbGFzcykKKwkJcmV0dXJuIG52bWVfZ2V0X25zX2Zyb21fY2RldihkZXYpLT5oZWFk OworCiAJaWYgKGRpc2stPmZvcHMgPT0gJm52bWVfYmRldl9vcHMpCiAJCXJldHVybiBudm1lX2dl dF9uc19mcm9tX2RldihkZXYpLT5oZWFkOwogCWVsc2UKQEAgLTM0NzQsNiArMzUzNSwxMSBAQCBj b25zdCBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwICpudm1lX25zX2lkX2F0dHJfZ3JvdXBzW10gPSB7 CiAJTlVMTCwKIH07CiAKK2NvbnN0IHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgKm52bWVfbnNfY2hh cl9pZF9hdHRyX2dyb3Vwc1tdID0geworCSZudm1lX25zX2lkX2F0dHJfZ3JvdXAsCisJTlVMTCwK K307CisKICNkZWZpbmUgbnZtZV9zaG93X3N0cl9mdW5jdGlvbihmaWVsZCkJCQkJCQlcCiBzdGF0 aWMgc3NpemVfdCAgZmllbGQjI19zaG93KHN0cnVjdCBkZXZpY2UgKmRldiwJCQkJXAogCQkJICAg IHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpCQlcCkBAIC0zODY2LDYg KzM5MzIsNDcgQEAgc3RydWN0IG52bWVfbnMgKm52bWVfZmluZF9nZXRfbnMoc3RydWN0IG52bWVf Y3RybCAqY3RybCwgdW5zaWduZWQgbnNpZCkKIH0KIEVYUE9SVF9TWU1CT0xfTlNfR1BMKG52bWVf ZmluZF9nZXRfbnMsIE5WTUVfVEFSR0VUX1BBU1NUSFJVKTsKIAorc3RhdGljIGludCBudm1lX2Fs bG9jX2NoYXJkZXZfbnMoc3RydWN0IG52bWVfY3RybCAqY3RybCwgc3RydWN0IG52bWVfbnMgKm5z KQoreworCWNoYXIgY2Rpc2tfbmFtZVtESVNLX05BTUVfTEVOXTsKKwlpbnQgcmV0OworCisJcmV0 ID0gaWRhX3NpbXBsZV9nZXQoJm52bWVfZ2VuX21pbm9yX2lkYSwgMCwgMCwgR0ZQX0tFUk5FTCk7 CisJaWYgKHJldCA8IDApCisJCXJldHVybiByZXQ7CisKKwlucy0+bWlub3IgPSByZXQgKyAxOwor CWRldmljZV9pbml0aWFsaXplKCZucy0+Y2Rldl9kZXZpY2UpOworCW5zLT5jZGV2X2RldmljZS5k ZXZ0ID0gTUtERVYoTUFKT1IobnZtZV9uc19iYXNlX2Nocl9kZXZ0KSwgcmV0KTsKKwlucy0+Y2Rl dl9kZXZpY2UuY2xhc3MgPSBudm1lX25zX2NsYXNzOworCW5zLT5jZGV2X2RldmljZS5wYXJlbnQg PSBjdHJsLT5kZXZpY2U7CisJbnMtPmNkZXZfZGV2aWNlLmdyb3VwcyA9IG52bWVfbnNfY2hhcl9p ZF9hdHRyX2dyb3VwczsKKwlkZXZfc2V0X2RydmRhdGEoJm5zLT5jZGV2X2RldmljZSwgbnMpOwor CisJc3ByaW50ZihjZGlza19uYW1lLCAibnZtZS1nZW5lcmljLSVkYyVkbiVkIiwgY3RybC0+c3Vi c3lzLT5pbnN0YW5jZSwKKwkJY3RybC0+aW5zdGFuY2UsIG5zLT5oZWFkLT5pbnN0YW5jZSk7CisK KwlyZXQgPSBkZXZfc2V0X25hbWUoJm5zLT5jZGV2X2RldmljZSwgIiVzIiwgY2Rpc2tfbmFtZSk7 CisJaWYgKHJldCkKKwkJZ290byBwdXRfaWRhOworCisJY2Rldl9pbml0KCZucy0+Y2RldiwgJm52 bWVfY2Rldl9mb3BzKTsKKwlucy0+Y2Rldi5vd25lciA9IGN0cmwtPm9wcy0+bW9kdWxlOworCisJ cmV0ID0gY2Rldl9kZXZpY2VfYWRkKCZucy0+Y2RldiwgJm5zLT5jZGV2X2RldmljZSk7CisJaWYg KHJldCkKKwkJZ290byBmcmVlX2tvYmo7CisKKwlyZXR1cm4gcmV0OworCitmcmVlX2tvYmo6CisJ a2ZyZWVfY29uc3QobnMtPmNkZXZfZGV2aWNlLmtvYmoubmFtZSk7CitwdXRfaWRhOgorCWlkYV9z aW1wbGVfcmVtb3ZlKCZudm1lX2dlbl9taW5vcl9pZGEsIG5zLT5taW5vciAtIDEpOworCW5zLT5t aW5vciA9IDA7CisJcmV0dXJuIHJldDsKK30KKwogc3RhdGljIHZvaWQgbnZtZV9hbGxvY19ucyhz dHJ1Y3QgbnZtZV9jdHJsICpjdHJsLCB1bnNpZ25lZCBuc2lkLAogCQlzdHJ1Y3QgbnZtZV9uc19p ZHMgKmlkcykKIHsKQEAgLTM5MTIsOCArNDAxOSw3IEBAIHN0YXRpYyB2b2lkIG52bWVfYWxsb2Nf bnMoc3RydWN0IG52bWVfY3RybCAqY3RybCwgdW5zaWduZWQgbnNpZCwKIAltZW1jcHkoZGlzay0+ ZGlza19uYW1lLCBkaXNrX25hbWUsIERJU0tfTkFNRV9MRU4pOwogCW5zLT5kaXNrID0gZGlzazsK IAotCWlmIChudm1lX3VwZGF0ZV9uc19pbmZvKG5zLCBpZCkpCi0JCWdvdG8gb3V0X3B1dF9kaXNr OworCW52bWVfdXBkYXRlX25zX2luZm8obnMsIGlkKTsKIAogCWlmICgoY3RybC0+cXVpcmtzICYg TlZNRV9RVUlSS19MSUdIVE5WTSkgJiYgaWQtPnZzWzBdID09IDB4MSkgewogCQlpZiAobnZtZV9u dm1fcmVnaXN0ZXIobnMsIGRpc2tfbmFtZSwgbm9kZSkpIHsKQEAgLTM5MjksOSArNDAzNSwxNCBA QCBzdGF0aWMgdm9pZCBudm1lX2FsbG9jX25zKHN0cnVjdCBudm1lX2N0cmwgKmN0cmwsIHVuc2ln bmVkIG5zaWQsCiAJbnZtZV9nZXRfY3RybChjdHJsKTsKIAogCWRldmljZV9hZGRfZGlzayhjdHJs LT5kZXZpY2UsIG5zLT5kaXNrLCBudm1lX25zX2lkX2F0dHJfZ3JvdXBzKTsKLQogCW52bWVfbXBh dGhfYWRkX2Rpc2sobnMsIGlkKTsKIAludm1lX2ZhdWx0X2luamVjdF9pbml0KCZucy0+ZmF1bHRf aW5qZWN0LCBucy0+ZGlzay0+ZGlza19uYW1lKTsKKworCWlmIChudm1lX2FsbG9jX2NoYXJkZXZf bnMoY3RybCwgbnMpKQorCQlkZXZfd2FybihjdHJsLT5kZXZpY2UsCisJCQkiZmFpbGVkIHRvIGNy ZWF0ZSBnZW5lcmljIGhhbmRsZSBmb3IgbnNpZDolZFxuIiwKKwkJCW5zaWQpOworCiAJa2ZyZWUo aWQpOwogCiAJcmV0dXJuOwpAQCAtNDczMywyMyArNDg0NCwzOCBAQCBzdGF0aWMgaW50IF9faW5p dCBudm1lX2NvcmVfaW5pdCh2b2lkKQogCWlmIChyZXN1bHQgPCAwKQogCQlnb3RvIGRlc3Ryb3lf ZGVsZXRlX3dxOwogCisJcmVzdWx0ID0gYWxsb2NfY2hyZGV2X3JlZ2lvbigmbnZtZV9uc19iYXNl X2Nocl9kZXZ0LCAwLAorCQkJTlZNRV9NSU5PUlMsICJudm1lYyIpOworCWlmIChyZXN1bHQgPCAw KQorCQlnb3RvIHVucmVnaXN0ZXJfZGV2X2NocmRldjsKKwogCW52bWVfY2xhc3MgPSBjbGFzc19j cmVhdGUoVEhJU19NT0RVTEUsICJudm1lIik7CiAJaWYgKElTX0VSUihudm1lX2NsYXNzKSkgewog CQlyZXN1bHQgPSBQVFJfRVJSKG52bWVfY2xhc3MpOwotCQlnb3RvIHVucmVnaXN0ZXJfY2hyZGV2 OworCQlnb3RvIHVucmVnaXN0ZXJfbnNfY2hyZGV2OwogCX0KIAludm1lX2NsYXNzLT5kZXZfdWV2 ZW50ID0gbnZtZV9jbGFzc191ZXZlbnQ7CiAKKwludm1lX25zX2NsYXNzID0gY2xhc3NfY3JlYXRl KFRISVNfTU9EVUxFLCAibnZtZS1ucyIpOworCWlmIChJU19FUlIobnZtZV9uc19jbGFzcykpIHsK KwkJcmVzdWx0ID0gUFRSX0VSUihudm1lX25zX2NsYXNzKTsKKwkJZ290byBkZXN0cm95X2Rldl9j bGFzczsKKwl9CisKIAludm1lX3N1YnN5c19jbGFzcyA9IGNsYXNzX2NyZWF0ZShUSElTX01PRFVM RSwgIm52bWUtc3Vic3lzdGVtIik7CiAJaWYgKElTX0VSUihudm1lX3N1YnN5c19jbGFzcykpIHsK IAkJcmVzdWx0ID0gUFRSX0VSUihudm1lX3N1YnN5c19jbGFzcyk7Ci0JCWdvdG8gZGVzdHJveV9j bGFzczsKKwkJZ290byBkZXN0cm95X25zX2NsYXNzOwogCX0KIAlyZXR1cm4gMDsKIAotZGVzdHJv eV9jbGFzczoKK2Rlc3Ryb3lfbnNfY2xhc3M6CisJY2xhc3NfZGVzdHJveShudm1lX25zX2NsYXNz KTsKK2Rlc3Ryb3lfZGV2X2NsYXNzOgogCWNsYXNzX2Rlc3Ryb3kobnZtZV9jbGFzcyk7Ci11bnJl Z2lzdGVyX2NocmRldjoKK3VucmVnaXN0ZXJfbnNfY2hyZGV2OgorCXVucmVnaXN0ZXJfY2hyZGV2 X3JlZ2lvbihudm1lX25zX2Jhc2VfY2hyX2RldnQsIE5WTUVfTUlOT1JTKTsKK3VucmVnaXN0ZXJf ZGV2X2NocmRldjoKIAl1bnJlZ2lzdGVyX2NocmRldl9yZWdpb24obnZtZV9jdHJsX2Jhc2VfY2hy X2RldnQsIE5WTUVfTUlOT1JTKTsKIGRlc3Ryb3lfZGVsZXRlX3dxOgogCWRlc3Ryb3lfd29ya3F1 ZXVlKG52bWVfZGVsZXRlX3dxKTsKQEAgLTQ3NjUsNiArNDg5MSw3IEBAIHN0YXRpYyB2b2lkIF9f ZXhpdCBudm1lX2NvcmVfZXhpdCh2b2lkKQogewogCWNsYXNzX2Rlc3Ryb3kobnZtZV9zdWJzeXNf Y2xhc3MpOwogCWNsYXNzX2Rlc3Ryb3kobnZtZV9jbGFzcyk7CisJdW5yZWdpc3Rlcl9jaHJkZXZf cmVnaW9uKG52bWVfbnNfYmFzZV9jaHJfZGV2dCwgTlZNRV9NSU5PUlMpOwogCXVucmVnaXN0ZXJf Y2hyZGV2X3JlZ2lvbihudm1lX2N0cmxfYmFzZV9jaHJfZGV2dCwgTlZNRV9NSU5PUlMpOwogCWRl c3Ryb3lfd29ya3F1ZXVlKG52bWVfZGVsZXRlX3dxKTsKIAlkZXN0cm95X3dvcmtxdWV1ZShudm1l X3Jlc2V0X3dxKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbnZtZS9ob3N0L252bWUuaCBiL2RyaXZl cnMvbnZtZS9ob3N0L252bWUuaAppbmRleCBiZmNlZGZhNGIwNTcuLjFlNTJmN2RhODJkZSAxMDA2 NDQKLS0tIGEvZHJpdmVycy9udm1lL2hvc3QvbnZtZS5oCisrKyBiL2RyaXZlcnMvbnZtZS9ob3N0 L252bWUuaApAQCAtNDM5LDYgKzQzOSwxMCBAQCBzdHJ1Y3QgbnZtZV9ucyB7CiAJc3RydWN0IGty ZWYga3JlZjsKIAlzdHJ1Y3QgbnZtZV9uc19oZWFkICpoZWFkOwogCisJc3RydWN0IGRldmljZSBj ZGV2X2RldmljZTsJLyogY2hhciBkZXZpY2UgKi8KKwlzdHJ1Y3QgY2RldiBjZGV2OworCWludCBt aW5vcjsKKwogCWludCBsYmFfc2hpZnQ7CiAJdTE2IG1zOwogCXUxNiBzZ3M7CkBAIC04MTgsNiAr ODIyLDExIEBAIHN0YXRpYyBpbmxpbmUgc3RydWN0IG52bWVfbnMgKm52bWVfZ2V0X25zX2Zyb21f ZGV2KHN0cnVjdCBkZXZpY2UgKmRldikKIAlyZXR1cm4gZGV2X3RvX2Rpc2soZGV2KS0+cHJpdmF0 ZV9kYXRhOwogfQogCitzdGF0aWMgaW5saW5lIHN0cnVjdCBudm1lX25zICpudm1lX2dldF9uc19m cm9tX2NkZXYoc3RydWN0IGRldmljZSAqZGV2KQoreworCXJldHVybiBkZXZfZ2V0X2RydmRhdGEo ZGV2KTsKK30KKwogI2lmZGVmIENPTkZJR19OVk1FX0hXTU9OCiBpbnQgbnZtZV9od21vbl9pbml0 KHN0cnVjdCBudm1lX2N0cmwgKmN0cmwpOwogI2Vsc2UKLS0gCjIuMTcuMQoKCl9fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkxpbnV4LW52bWUgbWFpbGluZyBs aXN0CkxpbnV4LW52bWVAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFk Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LW52bWUK