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 63E2EC433E0 for ; Mon, 1 Mar 2021 19:30:55 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 0B8CA60231 for ; Mon, 1 Mar 2021 19:30:55 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S241930AbhCAT3s (ORCPT ); Mon, 1 Mar 2021 14:29:48 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:46436 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241485AbhCATZj (ORCPT ); Mon, 1 Mar 2021 14:25:39 -0500 Received: from mail-ed1-x532.google.com (mail-ed1-x532.google.com [IPv6:2a00:1450:4864:20::532]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 7CDE0C061756 for ; Mon, 1 Mar 2021 11:24:58 -0800 (PST) Received: by mail-ed1-x532.google.com with SMTP id b7so8761251edz.8 for ; Mon, 01 Mar 2021 11:24:58 -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:in-reply-to:references :mime-version:content-transfer-encoding; bh=Rv9lq3bFIO3avoEjZ4+xtnNVp+V9BnImfk4aUWZxpa8=; b=zviIuxJHCxr8o52lvIOxhHmYPZEfQH/1xT/a3TDzpERqOt2IuR4pQ2g6m0KEmhCmjn YWQJzJGRZuVJsAnmOTi2R8/vRw3hcybsBEZ+AuT50NZDIRTodxIiyPifh0bolSbcK5GN zzi1fkqVcw94qsxXJ2uBbc/WHtGY1gs75xNcg02qr/jP23xDWiNKFB1Q5d0+7ghdYX+1 7rxlJfG9yG71p9/ZUxdJVuB5fSKoi7cwanDRPXkGJjFGADbB8Jg7h9BRopKOJKmlExry 9nZ8k9mZAWYb8hL7xgdSwFZEQz/VC3u55gPp32VyY1OTq4IfxT44N0Mwt2k7mrHDwAqT wkPg== 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:in-reply-to :references:mime-version:content-transfer-encoding; bh=Rv9lq3bFIO3avoEjZ4+xtnNVp+V9BnImfk4aUWZxpa8=; b=UruIwkaD93ngwn/j0ZFehIp7lgzHOxGYm4IP+v2AExJg3gmUQzL84nnQci9WK26Qta 8/mGdrSQXXhvqjo8WxkShcXiRrU0tDunPsKDWcmOOdy9KBAFWMF+MpDvsu0wh7TTVFcA 3EvhwAW0rEE4vwjxiqI6W/yS88+Kt+Jsj5JIQtGSGyq5kAw1pvAnZY308EJqIJ2/cbnB bblPKyvi2/InnFS2zVpuabC9hnIR6f9IUeyCDZUh+9SXObhGhpNdNkXKcZrvxTY/Yx53 wdOSErkIDVJuz1scSmmY6D0jyog9gsd/4t9A8ImiUq9jqM5etsWxXfvIlwnbC6GEvlrT KAmw== X-Gm-Message-State: AOAM533KneCmW9RDuMyHB92ydE4psj1mwT4WQyARSsyYdeIkncQ9V+2v jo0EvtPa7rp2cvTesURi51nAww== X-Google-Smtp-Source: ABdhPJzHD5Th3rJGrAUIOntEwL3hlECfLagMEUPt7iOHni3nM3Z+no28zhgrUFGhFv/ELdOarVCqQw== X-Received: by 2002:a50:8466:: with SMTP id 93mr17765170edp.55.1614626697182; Mon, 01 Mar 2021 11:24:57 -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 i4sm14107110eje.90.2021.03.01.11.24.56 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 01 Mar 2021 11:24:56 -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 V6 1/2] nvme: enable char device per namespace Date: Mon, 1 Mar 2021 20:24:51 +0100 Message-Id: <20210301192452.16770-2-javier.gonz@samsung.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20210301192452.16770-1-javier.gonz@samsung.com> References: <20210301192452.16770-1-javier.gonz@samsung.com> 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/nvme-generic-XcYnZ. This naming scheme follows the convention of the hidden device (nvmeXcYnZ). Support for multipath will follow. Signed-off-by: Javier González Signed-off-by: Minwoo Im --- drivers/nvme/host/core.c | 185 +++++++++++++++++++++++++++++++++++---- drivers/nvme/host/nvme.h | 5 ++ 2 files changed, 174 insertions(+), 16 deletions(-) diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c index d77f3f26d8d3..b94609bc92f4 100644 --- a/drivers/nvme/host/core.c +++ b/drivers/nvme/host/core.c @@ -86,13 +86,31 @@ 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); static void nvme_remove_invalid_namespaces(struct nvme_ctrl *ctrl, unsigned nsid); +/* + * These two helpers check whether the given instance is per-namespace + * character device (generic device) or not. + */ +static inline bool nvme_dev_is_generic(struct device *dev) +{ + return dev->class == nvme_ns_class; +} + +static inline bool nvme_ns_is_generic(struct nvme_ns *ns) +{ + return !!ns->minor; +} + /* * Prepare a queue for teardown. * @@ -559,7 +577,10 @@ static void nvme_free_ns(struct kref *kref) if (ns->ndev) nvme_nvm_unregister(ns); + if (nvme_ns_is_generic(ns)) + 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); @@ -1772,15 +1793,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; @@ -1817,6 +1838,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; @@ -1858,10 +1885,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)) @@ -1880,14 +1905,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 */ @@ -2205,6 +2238,8 @@ static int nvme_update_ns_info(struct nvme_ns *ns, struct nvme_id_ns *id) unsigned lbaf = id->flbas & NVME_NS_FLBAS_LBA_MASK; int ret; + ns->features |= NVME_NS_CHAR_SUPPORTED; + blk_mq_freeze_queue(ns->disk->queue); ns->lba_shift = id->lbaf[lbaf].ds; nvme_set_queue_limits(ns->ctrl, ns->queue); @@ -2378,6 +2413,44 @@ static const struct block_device_operations nvme_bdev_ops = { .pr_ops = &nvme_pr_ops, }; +static inline struct nvme_ns *dev_to_ns(struct device *dev) +{ + return container_of(dev, struct nvme_ns, cdev_device); +} + +static inline struct nvme_ns *cdev_to_ns(struct cdev *cdev) +{ + return container_of(cdev, struct nvme_ns, cdev); +} + +static int nvme_cdev_open(struct inode *inode, struct file *file) +{ + return nvme_ns_open(cdev_to_ns(inode->i_cdev)); +} + +static int nvme_cdev_release(struct inode *inode, struct file *file) +{ + nvme_ns_release(cdev_to_ns(inode->i_cdev)); + + return 0; +} + +static long nvme_cdev_ioctl(struct file *file, unsigned int cmd, + unsigned long arg) +{ + struct nvme_ns *ns = cdev_to_ns(file->f_inode->i_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) { @@ -3379,6 +3452,9 @@ static inline struct nvme_ns_head *dev_to_ns_head(struct device *dev) { struct gendisk *disk = dev_to_disk(dev); + if (nvme_dev_is_generic(dev)) + return dev_to_ns(dev)->head; + if (disk->fops == &nvme_bdev_ops) return nvme_get_ns_from_dev(dev)->head; else @@ -3488,6 +3564,8 @@ static umode_t nvme_ns_id_attrs_are_visible(struct kobject *kobj, } #ifdef CONFIG_NVME_MULTIPATH if (a == &dev_attr_ana_grpid.attr || a == &dev_attr_ana_state.attr) { + if (nvme_dev_is_generic(dev)) + return 0; if (dev_to_disk(dev)->fops != &nvme_bdev_ops) /* per-path attr */ return 0; if (!nvme_ctrl_use_ana(nvme_get_ns_from_dev(dev)->ctrl)) @@ -3510,6 +3588,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) \ @@ -3902,6 +3985,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) { @@ -3948,8 +4072,16 @@ 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; + /* + * If the namespace update fails in a graceful manner, hide the block + * device, but still allow for the namespace char device to be created. + */ + if (nvme_update_ns_info(ns, id)) { + if (ns->features & NVME_NS_CHAR_SUPPORTED) + ns->disk->flags |= GENHD_FL_HIDDEN; + else + goto out_put_disk; + } if ((ctrl->quirks & NVME_QUIRK_LIGHTNVM) && id->vs[0] == 0x1) { if (nvme_nvm_register(ns, disk_name, node)) { @@ -3965,9 +4097,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; @@ -4780,23 +4917,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); @@ -4812,6 +4964,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 07b34175c6ce..a145eaa7f86f 100644 --- a/drivers/nvme/host/nvme.h +++ b/drivers/nvme/host/nvme.h @@ -425,6 +425,7 @@ struct nvme_ns_head { enum nvme_ns_features { NVME_NS_EXT_LBAS = 1 << 0, /* support extended LBA format */ NVME_NS_METADATA_SUPPORTED = 1 << 1, /* support getting generated md */ + NVME_NS_CHAR_SUPPORTED = 1 << 2, /* support for char device */ }; struct nvme_ns { @@ -442,6 +443,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; -- 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,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 5B142C433E0 for ; Mon, 1 Mar 2021 19:25:12 +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 D0FF4601FA for ; Mon, 1 Mar 2021 19:25:11 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D0FF4601FA 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:References:In-Reply-To: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:List-Owner; bh=egJ+58ytnEcrBHreu3eSJBhVD7qtYcX6uxZGiP4EVMM=; b=bUg+58C8uXYgyCjwXNKAZJOl8 t460i/Us1o8pXWtxbFkw7x0go1R55HGn02cKIVBNeDVSPJ66RbE0PYSSLaR4oimelCZ5A1t2GrTPw sjqnYcy0EyH9v1CYt7HIa1IEBlh1MavolxSG0GbzOgfMz+MOSvDz2A0s6oyISD90cFSR7Bimux9q0 4C2UcjguTW6e1ZmuZTKKG8J7JLvTHHzUVliz1o8JwR3lWIPJPwGfbR5S4GqkkZHvDYkHwYFvgBVzS 5ORpP50CxP1jwTzFSfDhpd0dVJvGebECNBk5L+umGJ6qNCU5fRiSpDAVWG8y7pK06Ga0MpoLcg7Oj 4aZnynexw==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1lGoAD-0004R7-3j; Mon, 01 Mar 2021 19:25:05 +0000 Received: from mail-ed1-x52a.google.com ([2a00:1450:4864:20::52a]) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1lGoA8-0004PQ-65 for linux-nvme@lists.infradead.org; Mon, 01 Mar 2021 19:25:01 +0000 Received: by mail-ed1-x52a.google.com with SMTP id f6so6518878edd.12 for ; Mon, 01 Mar 2021 11:24:58 -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:in-reply-to:references :mime-version:content-transfer-encoding; bh=Rv9lq3bFIO3avoEjZ4+xtnNVp+V9BnImfk4aUWZxpa8=; b=zviIuxJHCxr8o52lvIOxhHmYPZEfQH/1xT/a3TDzpERqOt2IuR4pQ2g6m0KEmhCmjn YWQJzJGRZuVJsAnmOTi2R8/vRw3hcybsBEZ+AuT50NZDIRTodxIiyPifh0bolSbcK5GN zzi1fkqVcw94qsxXJ2uBbc/WHtGY1gs75xNcg02qr/jP23xDWiNKFB1Q5d0+7ghdYX+1 7rxlJfG9yG71p9/ZUxdJVuB5fSKoi7cwanDRPXkGJjFGADbB8Jg7h9BRopKOJKmlExry 9nZ8k9mZAWYb8hL7xgdSwFZEQz/VC3u55gPp32VyY1OTq4IfxT44N0Mwt2k7mrHDwAqT wkPg== 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:in-reply-to :references:mime-version:content-transfer-encoding; bh=Rv9lq3bFIO3avoEjZ4+xtnNVp+V9BnImfk4aUWZxpa8=; b=I29VEDyIZxKbVWCIXN+SFUBKx8hfPA2q6GGgoO8m/RLFqosDLtzgyy58Po69msv8Ux DpM5C6W6+t5d5wRq+/heUFH8SI/uuoE4RoT/yDLIZofGdLT+xVaH4WAztoGc2n+hgPHJ 1VcTaA5QA6ll8wqHyxkiJ2p4Z5z80A9Gwzzi+h5wbiv809IG3yfO4dfAOixjz+MI6Q92 UZ5HvjxQKbv/KqL+Wh9+eyootzQ6ZFsgMqdj0rjlA/5JzUl9agHPKJRhqnw4sFAHKCiA U+E9JCSscm8ONJyUqucM4S7l2fXXi1Z8wHatF2i8jbFp6vRTdh7wU7LVNI6QnBobtkLQ xh1Q== X-Gm-Message-State: AOAM532WqqbFg3OzdguIdpzJTGypIyHanCArmLRaiGfGbltnxPw6dM60 Ah8QBF3h0wqbBm675jo1EixuLdMe2EL3UHM/Xro= X-Google-Smtp-Source: ABdhPJzHD5Th3rJGrAUIOntEwL3hlECfLagMEUPt7iOHni3nM3Z+no28zhgrUFGhFv/ELdOarVCqQw== X-Received: by 2002:a50:8466:: with SMTP id 93mr17765170edp.55.1614626697182; Mon, 01 Mar 2021 11:24:57 -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 i4sm14107110eje.90.2021.03.01.11.24.56 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 01 Mar 2021 11:24:56 -0800 (PST) From: javier@javigon.com X-Google-Original-From: javier.gonz@samsung.com To: linux-nvme@lists.infradead.org Subject: [PATCH V6 1/2] nvme: enable char device per namespace Date: Mon, 1 Mar 2021 20:24:51 +0100 Message-Id: <20210301192452.16770-2-javier.gonz@samsung.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20210301192452.16770-1-javier.gonz@samsung.com> References: <20210301192452.16770-1-javier.gonz@samsung.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210301_142500_353193_53F392DC X-CRM114-Status: GOOD ( 27.50 ) 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 cyAvZGV2L252bWUtZ2VuZXJpYy1YY1luWi4gVGhpcyBuYW1pbmcKc2NoZW1lIGZvbGxvd3MgdGhl IGNvbnZlbnRpb24gb2YgdGhlIGhpZGRlbiBkZXZpY2UgKG52bWVYY1luWikuIFN1cHBvcnQKZm9y IG11bHRpcGF0aCB3aWxsIGZvbGxvdy4KClNpZ25lZC1vZmYtYnk6IEphdmllciBHb256w6FsZXog PGphdmllci5nb256QHNhbXN1bmcuY29tPgpTaWduZWQtb2ZmLWJ5OiBNaW53b28gSW0gPG1pbndv by5pbS5kZXZAZ21haWwuY29tPgotLS0KIGRyaXZlcnMvbnZtZS9ob3N0L2NvcmUuYyB8IDE4NSAr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0KIGRyaXZlcnMvbnZtZS9ob3N0 L252bWUuaCB8ICAgNSArKwogMiBmaWxlcyBjaGFuZ2VkLCAxNzQgaW5zZXJ0aW9ucygrKSwgMTYg ZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9udm1lL2hvc3QvY29yZS5jIGIvZHJp dmVycy9udm1lL2hvc3QvY29yZS5jCmluZGV4IGQ3N2YzZjI2ZDhkMy4uYjk0NjA5YmM5MmY0IDEw MDY0NAotLS0gYS9kcml2ZXJzL252bWUvaG9zdC9jb3JlLmMKKysrIGIvZHJpdmVycy9udm1lL2hv c3QvY29yZS5jCkBAIC04NiwxMyArODYsMzEgQEAgc3RhdGljIERFRklORV9NVVRFWChudm1lX3N1 YnN5c3RlbXNfbG9jayk7CiAKIHN0YXRpYyBERUZJTkVfSURBKG52bWVfaW5zdGFuY2VfaWRhKTsK IHN0YXRpYyBkZXZfdCBudm1lX2N0cmxfYmFzZV9jaHJfZGV2dDsKKworc3RhdGljIERFRklORV9J REEobnZtZV9nZW5fbWlub3JfaWRhKTsKK3N0YXRpYyBkZXZfdCBudm1lX25zX2Jhc2VfY2hyX2Rl dnQ7CiBzdGF0aWMgc3RydWN0IGNsYXNzICpudm1lX2NsYXNzOworc3RhdGljIHN0cnVjdCBjbGFz cyAqbnZtZV9uc19jbGFzczsKIHN0YXRpYyBzdHJ1Y3QgY2xhc3MgKm52bWVfc3Vic3lzX2NsYXNz OwogCiBzdGF0aWMgdm9pZCBudm1lX3B1dF9zdWJzeXN0ZW0oc3RydWN0IG52bWVfc3Vic3lzdGVt ICpzdWJzeXMpOwogc3RhdGljIHZvaWQgbnZtZV9yZW1vdmVfaW52YWxpZF9uYW1lc3BhY2VzKHN0 cnVjdCBudm1lX2N0cmwgKmN0cmwsCiAJCQkJCSAgIHVuc2lnbmVkIG5zaWQpOwogCisvKgorICog VGhlc2UgdHdvIGhlbHBlcnMgY2hlY2sgd2hldGhlciB0aGUgZ2l2ZW4gaW5zdGFuY2UgaXMgcGVy LW5hbWVzcGFjZQorICogY2hhcmFjdGVyIGRldmljZSAoZ2VuZXJpYyBkZXZpY2UpIG9yIG5vdC4K KyAqLworc3RhdGljIGlubGluZSBib29sIG52bWVfZGV2X2lzX2dlbmVyaWMoc3RydWN0IGRldmlj ZSAqZGV2KQoreworCXJldHVybiBkZXYtPmNsYXNzID09IG52bWVfbnNfY2xhc3M7Cit9CisKK3N0 YXRpYyBpbmxpbmUgYm9vbCBudm1lX25zX2lzX2dlbmVyaWMoc3RydWN0IG52bWVfbnMgKm5zKQor eworCXJldHVybiAhIW5zLT5taW5vcjsKK30KKwogLyoKICAqIFByZXBhcmUgYSBxdWV1ZSBmb3Ig dGVhcmRvd24uCiAgKgpAQCAtNTU5LDcgKzU3NywxMCBAQCBzdGF0aWMgdm9pZCBudm1lX2ZyZWVf bnMoc3RydWN0IGtyZWYgKmtyZWYpCiAKIAlpZiAobnMtPm5kZXYpCiAJCW52bWVfbnZtX3VucmVn aXN0ZXIobnMpOworCWlmIChudm1lX25zX2lzX2dlbmVyaWMobnMpKQorCQlpZGFfc2ltcGxlX3Jl bW92ZSgmbnZtZV9nZW5fbWlub3JfaWRhLCBucy0+bWlub3IgLSAxKTsKIAorCWNkZXZfZGV2aWNl X2RlbCgmbnMtPmNkZXYsICZucy0+Y2Rldl9kZXZpY2UpOwogCXB1dF9kaXNrKG5zLT5kaXNrKTsK IAludm1lX3B1dF9uc19oZWFkKG5zLT5oZWFkKTsKIAludm1lX3B1dF9jdHJsKG5zLT5jdHJsKTsK QEAgLTE3NzIsMTUgKzE3OTMsMTUgQEAgc3RhdGljIGludCBudm1lX2hhbmRsZV9jdHJsX2lvY3Rs KHN0cnVjdCBudm1lX25zICpucywgdW5zaWduZWQgaW50IGNtZCwKIAlyZXR1cm4gcmV0OwogfQog Ci1zdGF0aWMgaW50IG52bWVfaW9jdGwoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwgZm1vZGVf dCBtb2RlLAotCQl1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKK3N0YXRpYyBp bnQgbnZtZV9kaXNrX2lvY3RsKHN0cnVjdCBnZW5kaXNrICpkaXNrLCB1bnNpZ25lZCBpbnQgY21k LAorCQkJICAgdW5zaWduZWQgbG9uZyBhcmcpCiB7CiAJc3RydWN0IG52bWVfbnNfaGVhZCAqaGVh ZCA9IE5VTEw7CiAJdm9pZCBfX3VzZXIgKmFyZ3AgPSAodm9pZCBfX3VzZXIgKilhcmc7CiAJc3Ry dWN0IG52bWVfbnMgKm5zOwogCWludCBzcmN1X2lkeCwgcmV0OwogCi0JbnMgPSBudm1lX2dldF9u c19mcm9tX2Rpc2soYmRldi0+YmRfZGlzaywgJmhlYWQsICZzcmN1X2lkeCk7CisJbnMgPSBudm1l X2dldF9uc19mcm9tX2Rpc2soZGlzaywgJmhlYWQsICZzcmN1X2lkeCk7CiAJaWYgKHVubGlrZWx5 KCFucykpCiAJCXJldHVybiAtRVdPVUxEQkxPQ0s7CiAKQEAgLTE4MTcsNiArMTgzOCwxMiBAQCBz dGF0aWMgaW50IG52bWVfaW9jdGwoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwgZm1vZGVfdCBt b2RlLAogCXJldHVybiByZXQ7CiB9CiAKK3N0YXRpYyBpbnQgbnZtZV9pb2N0bChzdHJ1Y3QgYmxv Y2tfZGV2aWNlICpiZGV2LCBmbW9kZV90IG1vZGUsCisJCSAgICAgIHVuc2lnbmVkIGludCBjbWQs IHVuc2lnbmVkIGxvbmcgYXJnKQoreworCXJldHVybiBudm1lX2Rpc2tfaW9jdGwoYmRldi0+YmRf ZGlzaywgY21kLCBhcmcpOworfQorCiAjaWZkZWYgQ09ORklHX0NPTVBBVAogc3RydWN0IG52bWVf dXNlcl9pbzMyIHsKIAlfX3U4CW9wY29kZTsKQEAgLTE4NTgsMTAgKzE4ODUsOCBAQCBzdGF0aWMg aW50IG52bWVfY29tcGF0X2lvY3RsKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYsIGZtb2RlX3Qg bW9kZSwKICNkZWZpbmUgbnZtZV9jb21wYXRfaW9jdGwJTlVMTAogI2VuZGlmIC8qIENPTkZJR19D T01QQVQgKi8KIAotc3RhdGljIGludCBudm1lX29wZW4oc3RydWN0IGJsb2NrX2RldmljZSAqYmRl diwgZm1vZGVfdCBtb2RlKQorc3RhdGljIGludCBudm1lX25zX29wZW4oc3RydWN0IG52bWVfbnMg Km5zKQogewotCXN0cnVjdCBudm1lX25zICpucyA9IGJkZXYtPmJkX2Rpc2stPnByaXZhdGVfZGF0 YTsKLQogI2lmZGVmIENPTkZJR19OVk1FX01VTFRJUEFUSAogCS8qIHNob3VsZCBuZXZlciBiZSBj YWxsZWQgZHVlIHRvIEdFTkhEX0ZMX0hJRERFTiAqLwogCWlmIChXQVJOX09OX09OQ0UobnMtPmhl YWQtPmRpc2spKQpAQCAtMTg4MCwxNCArMTkwNSwyMiBAQCBzdGF0aWMgaW50IG52bWVfb3Blbihz dHJ1Y3QgYmxvY2tfZGV2aWNlICpiZGV2LCBmbW9kZV90IG1vZGUpCiAJcmV0dXJuIC1FTlhJTzsK IH0KIAotc3RhdGljIHZvaWQgbnZtZV9yZWxlYXNlKHN0cnVjdCBnZW5kaXNrICpkaXNrLCBmbW9k ZV90IG1vZGUpCitzdGF0aWMgdm9pZCBudm1lX25zX3JlbGVhc2Uoc3RydWN0IG52bWVfbnMgKm5z KQogewotCXN0cnVjdCBudm1lX25zICpucyA9IGRpc2stPnByaXZhdGVfZGF0YTsKLQogCW1vZHVs ZV9wdXQobnMtPmN0cmwtPm9wcy0+bW9kdWxlKTsKIAludm1lX3B1dF9ucyhucyk7CiB9CiAKK3N0 YXRpYyBpbnQgbnZtZV9vcGVuKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYsIGZtb2RlX3QgbW9k ZSkKK3sKKwlyZXR1cm4gbnZtZV9uc19vcGVuKGJkZXYtPmJkX2Rpc2stPnByaXZhdGVfZGF0YSk7 Cit9CisKK3N0YXRpYyB2b2lkIG52bWVfcmVsZWFzZShzdHJ1Y3QgZ2VuZGlzayAqZGlzaywgZm1v ZGVfdCBtb2RlKQoreworCW52bWVfbnNfcmVsZWFzZShkaXNrLT5wcml2YXRlX2RhdGEpOworfQor CiBzdGF0aWMgaW50IG52bWVfZ2V0Z2VvKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYsIHN0cnVj dCBoZF9nZW9tZXRyeSAqZ2VvKQogewogCS8qIHNvbWUgc3RhbmRhcmQgdmFsdWVzICovCkBAIC0y MjA1LDYgKzIyMzgsOCBAQCBzdGF0aWMgaW50IG52bWVfdXBkYXRlX25zX2luZm8oc3RydWN0IG52 bWVfbnMgKm5zLCBzdHJ1Y3QgbnZtZV9pZF9ucyAqaWQpCiAJdW5zaWduZWQgbGJhZiA9IGlkLT5m bGJhcyAmIE5WTUVfTlNfRkxCQVNfTEJBX01BU0s7CiAJaW50IHJldDsKIAorCW5zLT5mZWF0dXJl cyB8PSBOVk1FX05TX0NIQVJfU1VQUE9SVEVEOworCiAJYmxrX21xX2ZyZWV6ZV9xdWV1ZShucy0+ ZGlzay0+cXVldWUpOwogCW5zLT5sYmFfc2hpZnQgPSBpZC0+bGJhZltsYmFmXS5kczsKIAludm1l X3NldF9xdWV1ZV9saW1pdHMobnMtPmN0cmwsIG5zLT5xdWV1ZSk7CkBAIC0yMzc4LDYgKzI0MTMs NDQgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBibG9ja19kZXZpY2Vfb3BlcmF0aW9ucyBudm1lX2Jk ZXZfb3BzID0gewogCS5wcl9vcHMJCT0gJm52bWVfcHJfb3BzLAogfTsKIAorc3RhdGljIGlubGlu ZSBzdHJ1Y3QgbnZtZV9ucyAqZGV2X3RvX25zKHN0cnVjdCBkZXZpY2UgKmRldikKK3sKKwlyZXR1 cm4gY29udGFpbmVyX29mKGRldiwgc3RydWN0IG52bWVfbnMsIGNkZXZfZGV2aWNlKTsKK30KKwor c3RhdGljIGlubGluZSBzdHJ1Y3QgbnZtZV9ucyAqY2Rldl90b19ucyhzdHJ1Y3QgY2RldiAqY2Rl dikKK3sKKwlyZXR1cm4gY29udGFpbmVyX29mKGNkZXYsIHN0cnVjdCBudm1lX25zLCBjZGV2KTsK K30KKworc3RhdGljIGludCBudm1lX2NkZXZfb3BlbihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1 Y3QgZmlsZSAqZmlsZSkKK3sKKwlyZXR1cm4gbnZtZV9uc19vcGVuKGNkZXZfdG9fbnMoaW5vZGUt PmlfY2RldikpOworfQorCitzdGF0aWMgaW50IG52bWVfY2Rldl9yZWxlYXNlKHN0cnVjdCBpbm9k ZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQoreworCW52bWVfbnNfcmVsZWFzZShjZGV2X3Rv X25zKGlub2RlLT5pX2NkZXYpKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgbG9uZyBudm1l X2NkZXZfaW9jdGwoc3RydWN0IGZpbGUgKmZpbGUsIHVuc2lnbmVkIGludCBjbWQsCisJCQkgICAg dW5zaWduZWQgbG9uZyBhcmcpCit7CisJc3RydWN0IG52bWVfbnMgKm5zID0gY2Rldl90b19ucyhm aWxlLT5mX2lub2RlLT5pX2NkZXYpOworCisJcmV0dXJuIG52bWVfZGlza19pb2N0bChucy0+ZGlz aywgY21kLCBhcmcpOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBu dm1lX2NkZXZfZm9wcyA9IHsKKwkub3duZXIJCT0gVEhJU19NT0RVTEUsCisJLm9wZW4JCT0gbnZt ZV9jZGV2X29wZW4sCisJLnJlbGVhc2UJPSBudm1lX2NkZXZfcmVsZWFzZSwKKwkudW5sb2NrZWRf aW9jdGwJPSBudm1lX2NkZXZfaW9jdGwsCisJLmNvbXBhdF9pb2N0bAk9IGNvbXBhdF9wdHJfaW9j dGwsCit9OworCiAjaWZkZWYgQ09ORklHX05WTUVfTVVMVElQQVRICiBzdGF0aWMgaW50IG52bWVf bnNfaGVhZF9vcGVuKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYsIGZtb2RlX3QgbW9kZSkKIHsK QEAgLTMzNzksNiArMzQ1Miw5IEBAIHN0YXRpYyBpbmxpbmUgc3RydWN0IG52bWVfbnNfaGVhZCAq ZGV2X3RvX25zX2hlYWQoc3RydWN0IGRldmljZSAqZGV2KQogewogCXN0cnVjdCBnZW5kaXNrICpk aXNrID0gZGV2X3RvX2Rpc2soZGV2KTsKIAorCWlmIChudm1lX2Rldl9pc19nZW5lcmljKGRldikp CisJCXJldHVybiBkZXZfdG9fbnMoZGV2KS0+aGVhZDsKKwogCWlmIChkaXNrLT5mb3BzID09ICZu dm1lX2JkZXZfb3BzKQogCQlyZXR1cm4gbnZtZV9nZXRfbnNfZnJvbV9kZXYoZGV2KS0+aGVhZDsK IAllbHNlCkBAIC0zNDg4LDYgKzM1NjQsOCBAQCBzdGF0aWMgdW1vZGVfdCBudm1lX25zX2lkX2F0 dHJzX2FyZV92aXNpYmxlKHN0cnVjdCBrb2JqZWN0ICprb2JqLAogCX0KICNpZmRlZiBDT05GSUdf TlZNRV9NVUxUSVBBVEgKIAlpZiAoYSA9PSAmZGV2X2F0dHJfYW5hX2dycGlkLmF0dHIgfHwgYSA9 PSAmZGV2X2F0dHJfYW5hX3N0YXRlLmF0dHIpIHsKKwkJaWYgKG52bWVfZGV2X2lzX2dlbmVyaWMo ZGV2KSkKKwkJCXJldHVybiAwOwogCQlpZiAoZGV2X3RvX2Rpc2soZGV2KS0+Zm9wcyAhPSAmbnZt ZV9iZGV2X29wcykgLyogcGVyLXBhdGggYXR0ciAqLwogCQkJcmV0dXJuIDA7CiAJCWlmICghbnZt ZV9jdHJsX3VzZV9hbmEobnZtZV9nZXRfbnNfZnJvbV9kZXYoZGV2KS0+Y3RybCkpCkBAIC0zNTEw LDYgKzM1ODgsMTEgQEAgY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCAqbnZtZV9uc19pZF9h dHRyX2dyb3Vwc1tdID0gewogCU5VTEwsCiB9OwogCitjb25zdCBzdHJ1Y3QgYXR0cmlidXRlX2dy b3VwICpudm1lX25zX2NoYXJfaWRfYXR0cl9ncm91cHNbXSA9IHsKKwkmbnZtZV9uc19pZF9hdHRy X2dyb3VwLAorCU5VTEwsCit9OworCiAjZGVmaW5lIG52bWVfc2hvd19zdHJfZnVuY3Rpb24oZmll bGQpCQkJCQkJXAogc3RhdGljIHNzaXplX3QgIGZpZWxkIyNfc2hvdyhzdHJ1Y3QgZGV2aWNlICpk ZXYsCQkJCVwKIAkJCSAgICBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVm KQkJXApAQCAtMzkwMiw2ICszOTg1LDQ3IEBAIHN0cnVjdCBudm1lX25zICpudm1lX2ZpbmRfZ2V0 X25zKHN0cnVjdCBudm1lX2N0cmwgKmN0cmwsIHVuc2lnbmVkIG5zaWQpCiB9CiBFWFBPUlRfU1lN Qk9MX05TX0dQTChudm1lX2ZpbmRfZ2V0X25zLCBOVk1FX1RBUkdFVF9QQVNTVEhSVSk7CiAKK3N0 YXRpYyBpbnQgbnZtZV9hbGxvY19jaGFyZGV2X25zKHN0cnVjdCBudm1lX2N0cmwgKmN0cmwsIHN0 cnVjdCBudm1lX25zICpucykKK3sKKwljaGFyIGNkaXNrX25hbWVbRElTS19OQU1FX0xFTl07CisJ aW50IHJldDsKKworCXJldCA9IGlkYV9zaW1wbGVfZ2V0KCZudm1lX2dlbl9taW5vcl9pZGEsIDAs IDAsIEdGUF9LRVJORUwpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0OworCisJbnMtPm1p bm9yID0gcmV0ICsgMTsKKwlkZXZpY2VfaW5pdGlhbGl6ZSgmbnMtPmNkZXZfZGV2aWNlKTsKKwlu cy0+Y2Rldl9kZXZpY2UuZGV2dCA9IE1LREVWKE1BSk9SKG52bWVfbnNfYmFzZV9jaHJfZGV2dCks IHJldCk7CisJbnMtPmNkZXZfZGV2aWNlLmNsYXNzID0gbnZtZV9uc19jbGFzczsKKwlucy0+Y2Rl dl9kZXZpY2UucGFyZW50ID0gY3RybC0+ZGV2aWNlOworCW5zLT5jZGV2X2RldmljZS5ncm91cHMg PSBudm1lX25zX2NoYXJfaWRfYXR0cl9ncm91cHM7CisJZGV2X3NldF9kcnZkYXRhKCZucy0+Y2Rl dl9kZXZpY2UsIG5zKTsKKworCXNwcmludGYoY2Rpc2tfbmFtZSwgIm52bWUtZ2VuZXJpYy0lZGMl ZG4lZCIsIGN0cmwtPnN1YnN5cy0+aW5zdGFuY2UsCisJCWN0cmwtPmluc3RhbmNlLCBucy0+aGVh ZC0+aW5zdGFuY2UpOworCisJcmV0ID0gZGV2X3NldF9uYW1lKCZucy0+Y2Rldl9kZXZpY2UsICIl cyIsIGNkaXNrX25hbWUpOworCWlmIChyZXQpCisJCWdvdG8gcHV0X2lkYTsKKworCWNkZXZfaW5p dCgmbnMtPmNkZXYsICZudm1lX2NkZXZfZm9wcyk7CisJbnMtPmNkZXYub3duZXIgPSBjdHJsLT5v cHMtPm1vZHVsZTsKKworCXJldCA9IGNkZXZfZGV2aWNlX2FkZCgmbnMtPmNkZXYsICZucy0+Y2Rl dl9kZXZpY2UpOworCWlmIChyZXQpCisJCWdvdG8gZnJlZV9rb2JqOworCisJcmV0dXJuIHJldDsK KworZnJlZV9rb2JqOgorCWtmcmVlX2NvbnN0KG5zLT5jZGV2X2RldmljZS5rb2JqLm5hbWUpOwor cHV0X2lkYToKKwlpZGFfc2ltcGxlX3JlbW92ZSgmbnZtZV9nZW5fbWlub3JfaWRhLCBucy0+bWlu b3IgLSAxKTsKKwlucy0+bWlub3IgPSAwOworCXJldHVybiByZXQ7Cit9CisKIHN0YXRpYyB2b2lk IG52bWVfYWxsb2NfbnMoc3RydWN0IG52bWVfY3RybCAqY3RybCwgdW5zaWduZWQgbnNpZCwKIAkJ c3RydWN0IG52bWVfbnNfaWRzICppZHMpCiB7CkBAIC0zOTQ4LDggKzQwNzIsMTYgQEAgc3RhdGlj IHZvaWQgbnZtZV9hbGxvY19ucyhzdHJ1Y3QgbnZtZV9jdHJsICpjdHJsLCB1bnNpZ25lZCBuc2lk LAogCW1lbWNweShkaXNrLT5kaXNrX25hbWUsIGRpc2tfbmFtZSwgRElTS19OQU1FX0xFTik7CiAJ bnMtPmRpc2sgPSBkaXNrOwogCi0JaWYgKG52bWVfdXBkYXRlX25zX2luZm8obnMsIGlkKSkKLQkJ Z290byBvdXRfcHV0X2Rpc2s7CisJLyoKKwkgKiBJZiB0aGUgbmFtZXNwYWNlIHVwZGF0ZSBmYWls cyBpbiBhIGdyYWNlZnVsIG1hbm5lciwgaGlkZSB0aGUgYmxvY2sKKwkgKiBkZXZpY2UsIGJ1dCBz dGlsbCBhbGxvdyBmb3IgdGhlIG5hbWVzcGFjZSBjaGFyIGRldmljZSB0byBiZSBjcmVhdGVkLgor CSAqLworCWlmIChudm1lX3VwZGF0ZV9uc19pbmZvKG5zLCBpZCkpIHsKKwkJaWYgKG5zLT5mZWF0 dXJlcyAmIE5WTUVfTlNfQ0hBUl9TVVBQT1JURUQpCisJCQlucy0+ZGlzay0+ZmxhZ3MgfD0gR0VO SERfRkxfSElEREVOOworCQllbHNlCisJCQlnb3RvIG91dF9wdXRfZGlzazsKKwl9CiAKIAlpZiAo KGN0cmwtPnF1aXJrcyAmIE5WTUVfUVVJUktfTElHSFROVk0pICYmIGlkLT52c1swXSA9PSAweDEp IHsKIAkJaWYgKG52bWVfbnZtX3JlZ2lzdGVyKG5zLCBkaXNrX25hbWUsIG5vZGUpKSB7CkBAIC0z OTY1LDkgKzQwOTcsMTQgQEAgc3RhdGljIHZvaWQgbnZtZV9hbGxvY19ucyhzdHJ1Y3QgbnZtZV9j dHJsICpjdHJsLCB1bnNpZ25lZCBuc2lkLAogCW52bWVfZ2V0X2N0cmwoY3RybCk7CiAKIAlkZXZp Y2VfYWRkX2Rpc2soY3RybC0+ZGV2aWNlLCBucy0+ZGlzaywgbnZtZV9uc19pZF9hdHRyX2dyb3Vw cyk7Ci0KIAludm1lX21wYXRoX2FkZF9kaXNrKG5zLCBpZCk7CiAJbnZtZV9mYXVsdF9pbmplY3Rf aW5pdCgmbnMtPmZhdWx0X2luamVjdCwgbnMtPmRpc2stPmRpc2tfbmFtZSk7CisKKwlpZiAobnZt ZV9hbGxvY19jaGFyZGV2X25zKGN0cmwsIG5zKSkKKwkJZGV2X3dhcm4oY3RybC0+ZGV2aWNlLAor CQkJImZhaWxlZCB0byBjcmVhdGUgZ2VuZXJpYyBoYW5kbGUgZm9yIG5zaWQ6JWRcbiIsCisJCQlu c2lkKTsKKwogCWtmcmVlKGlkKTsKIAogCXJldHVybjsKQEAgLTQ3ODAsMjMgKzQ5MTcsMzggQEAg c3RhdGljIGludCBfX2luaXQgbnZtZV9jb3JlX2luaXQodm9pZCkKIAlpZiAocmVzdWx0IDwgMCkK IAkJZ290byBkZXN0cm95X2RlbGV0ZV93cTsKIAorCXJlc3VsdCA9IGFsbG9jX2NocmRldl9yZWdp b24oJm52bWVfbnNfYmFzZV9jaHJfZGV2dCwgMCwKKwkJCU5WTUVfTUlOT1JTLCAibnZtZWMiKTsK KwlpZiAocmVzdWx0IDwgMCkKKwkJZ290byB1bnJlZ2lzdGVyX2Rldl9jaHJkZXY7CisKIAludm1l X2NsYXNzID0gY2xhc3NfY3JlYXRlKFRISVNfTU9EVUxFLCAibnZtZSIpOwogCWlmIChJU19FUlIo bnZtZV9jbGFzcykpIHsKIAkJcmVzdWx0ID0gUFRSX0VSUihudm1lX2NsYXNzKTsKLQkJZ290byB1 bnJlZ2lzdGVyX2NocmRldjsKKwkJZ290byB1bnJlZ2lzdGVyX25zX2NocmRldjsKIAl9CiAJbnZt ZV9jbGFzcy0+ZGV2X3VldmVudCA9IG52bWVfY2xhc3NfdWV2ZW50OwogCisJbnZtZV9uc19jbGFz cyA9IGNsYXNzX2NyZWF0ZShUSElTX01PRFVMRSwgIm52bWUtbnMiKTsKKwlpZiAoSVNfRVJSKG52 bWVfbnNfY2xhc3MpKSB7CisJCXJlc3VsdCA9IFBUUl9FUlIobnZtZV9uc19jbGFzcyk7CisJCWdv dG8gZGVzdHJveV9kZXZfY2xhc3M7CisJfQorCiAJbnZtZV9zdWJzeXNfY2xhc3MgPSBjbGFzc19j cmVhdGUoVEhJU19NT0RVTEUsICJudm1lLXN1YnN5c3RlbSIpOwogCWlmIChJU19FUlIobnZtZV9z dWJzeXNfY2xhc3MpKSB7CiAJCXJlc3VsdCA9IFBUUl9FUlIobnZtZV9zdWJzeXNfY2xhc3MpOwot CQlnb3RvIGRlc3Ryb3lfY2xhc3M7CisJCWdvdG8gZGVzdHJveV9uc19jbGFzczsKIAl9CiAJcmV0 dXJuIDA7CiAKLWRlc3Ryb3lfY2xhc3M6CitkZXN0cm95X25zX2NsYXNzOgorCWNsYXNzX2Rlc3Ry b3kobnZtZV9uc19jbGFzcyk7CitkZXN0cm95X2Rldl9jbGFzczoKIAljbGFzc19kZXN0cm95KG52 bWVfY2xhc3MpOwotdW5yZWdpc3Rlcl9jaHJkZXY6Cit1bnJlZ2lzdGVyX25zX2NocmRldjoKKwl1 bnJlZ2lzdGVyX2NocmRldl9yZWdpb24obnZtZV9uc19iYXNlX2Nocl9kZXZ0LCBOVk1FX01JTk9S Uyk7Cit1bnJlZ2lzdGVyX2Rldl9jaHJkZXY6CiAJdW5yZWdpc3Rlcl9jaHJkZXZfcmVnaW9uKG52 bWVfY3RybF9iYXNlX2Nocl9kZXZ0LCBOVk1FX01JTk9SUyk7CiBkZXN0cm95X2RlbGV0ZV93cToK IAlkZXN0cm95X3dvcmtxdWV1ZShudm1lX2RlbGV0ZV93cSk7CkBAIC00ODEyLDYgKzQ5NjQsNyBA QCBzdGF0aWMgdm9pZCBfX2V4aXQgbnZtZV9jb3JlX2V4aXQodm9pZCkKIHsKIAljbGFzc19kZXN0 cm95KG52bWVfc3Vic3lzX2NsYXNzKTsKIAljbGFzc19kZXN0cm95KG52bWVfY2xhc3MpOworCXVu cmVnaXN0ZXJfY2hyZGV2X3JlZ2lvbihudm1lX25zX2Jhc2VfY2hyX2RldnQsIE5WTUVfTUlOT1JT KTsKIAl1bnJlZ2lzdGVyX2NocmRldl9yZWdpb24obnZtZV9jdHJsX2Jhc2VfY2hyX2RldnQsIE5W TUVfTUlOT1JTKTsKIAlkZXN0cm95X3dvcmtxdWV1ZShudm1lX2RlbGV0ZV93cSk7CiAJZGVzdHJv eV93b3JrcXVldWUobnZtZV9yZXNldF93cSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL252bWUvaG9z dC9udm1lLmggYi9kcml2ZXJzL252bWUvaG9zdC9udm1lLmgKaW5kZXggMDdiMzQxNzVjNmNlLi5h MTQ1ZWFhN2Y4NmYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbnZtZS9ob3N0L252bWUuaAorKysgYi9k cml2ZXJzL252bWUvaG9zdC9udm1lLmgKQEAgLTQyNSw2ICs0MjUsNyBAQCBzdHJ1Y3QgbnZtZV9u c19oZWFkIHsKIGVudW0gbnZtZV9uc19mZWF0dXJlcyB7CiAJTlZNRV9OU19FWFRfTEJBUyA9IDEg PDwgMCwgLyogc3VwcG9ydCBleHRlbmRlZCBMQkEgZm9ybWF0ICovCiAJTlZNRV9OU19NRVRBREFU QV9TVVBQT1JURUQgPSAxIDw8IDEsIC8qIHN1cHBvcnQgZ2V0dGluZyBnZW5lcmF0ZWQgbWQgKi8K KwlOVk1FX05TX0NIQVJfU1VQUE9SVEVEID0gMSA8PCAyLCAvKiBzdXBwb3J0IGZvciBjaGFyIGRl dmljZSAqLwogfTsKIAogc3RydWN0IG52bWVfbnMgewpAQCAtNDQyLDYgKzQ0MywxMCBAQCBzdHJ1 Y3QgbnZtZV9ucyB7CiAJc3RydWN0IGtyZWYga3JlZjsKIAlzdHJ1Y3QgbnZtZV9uc19oZWFkICpo ZWFkOwogCisJc3RydWN0IGRldmljZSBjZGV2X2RldmljZTsJLyogY2hhciBkZXZpY2UgKi8KKwlz dHJ1Y3QgY2RldiBjZGV2OworCWludCBtaW5vcjsKKwogCWludCBsYmFfc2hpZnQ7CiAJdTE2IG1z OwogCXUxNiBzZ3M7Ci0tIAoyLjE3LjEKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXwpMaW51eC1udm1lIG1haWxpbmcgbGlzdApMaW51eC1udm1lQGxpc3Rz LmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5m by9saW51eC1udm1lCg==