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=-17.6 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER,INCLUDES_PATCH,MAILING_LIST_MULTI,NICE_REPLY_A, SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1 autolearn=unavailable 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 46024C49361 for ; Mon, 21 Jun 2021 09:14:19 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 201146109E for ; Mon, 21 Jun 2021 09:14:19 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230346AbhFUJQa (ORCPT ); Mon, 21 Jun 2021 05:16:30 -0400 Received: from us-smtp-delivery-124.mimecast.com ([216.205.24.124]:22438 "EHLO us-smtp-delivery-124.mimecast.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230137AbhFUJQZ (ORCPT ); Mon, 21 Jun 2021 05:16:25 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1624266851; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=Tt7yo2RvlMhoUkpaMWxyjOZFsanqqyuVLb80GWGQKSo=; b=dXlphZEUByJglmzr2fvD/56wLNoC98l38KCjOuHmkC8ubLpKFyxwqj0eMUdv7wQ6pXWvE6 KhBSTNECDJCOas6rJENrHL02Wwafhofa+RhirJAfAn6/g60MvP0EsHTWs4VpOIWFg6qw6i 1sGBW3LcP1YmRJw2xnTEa+9KlClJXig= Received: from mail-pj1-f72.google.com (mail-pj1-f72.google.com [209.85.216.72]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-183-_ocHIfdBMLCmzGpM3NMcNw-1; Mon, 21 Jun 2021 05:14:09 -0400 X-MC-Unique: _ocHIfdBMLCmzGpM3NMcNw-1 Received: by mail-pj1-f72.google.com with SMTP id j18-20020a17090a5892b029016e79c56ccbso9287589pji.8 for ; Mon, 21 Jun 2021 02:14:09 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-transfer-encoding :content-language; bh=Tt7yo2RvlMhoUkpaMWxyjOZFsanqqyuVLb80GWGQKSo=; b=rEk0nN89xaRyVkhZbi3bsJ4zwVC/ijVId41+jORSxhyAdjEfdEePbNHm/bsIT7vLji yyAaG7hV8PODp65mei2iX7zp04C99Cs+LxVG6kqE9eX7uqmSMZMye4wBHsUZ4Qb7Fr5E +gFhp0215jnKpc7pFUJgVre5x039Z2xpriqPhdVuU+apPegXT2nrL+15/mEIU2HM63OX 4GhdMkNJ78Po/rahSwX0XQDVQMNfJcYHO2YZEe/YyIYTpR1u9vXvNGpB7TTrqbuNGIyH 80u+IjUouuJxrAvJjvMN5mVvgdRSHt/P/g4ormt6OooPlIrY5S0xQcatXngi44VUj3Gn SMBg== X-Gm-Message-State: AOAM532bpDJlihpSKf+74E9x1b1k23isFwZgbP3VvZLqHar9Hkx4v+cW sBM7sLqqJ4BfP5Llz5UTz4bbUmTJeTALEfn/fyJIIrGQY+bQkd1cbJiHzC7j9oZmvT+35HKj9kc whWMCRnlbZB48d3V0grH5S1rUJ8aQDlccLReDoqm1C00qxzwra1ZrNTjh6X5VW/9qzU1Cos/9Wz JC X-Received: by 2002:a17:90a:e606:: with SMTP id j6mr20491657pjy.230.1624266848359; Mon, 21 Jun 2021 02:14:08 -0700 (PDT) X-Google-Smtp-Source: ABdhPJx760A/hTM9EzlHk6g1tGJ/qdpSIJzoPD2qafIY56u0RfGUdMjcnsBf7nOS0VHd+bGYuxc98w== X-Received: by 2002:a17:90a:e606:: with SMTP id j6mr20491630pjy.230.1624266847951; Mon, 21 Jun 2021 02:14:07 -0700 (PDT) Received: from wangxiaodeMacBook-Air.local ([209.132.188.80]) by smtp.gmail.com with ESMTPSA id n12sm5354590pfu.5.2021.06.21.02.14.00 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 21 Jun 2021 02:14:07 -0700 (PDT) Subject: Re: [PATCH v8 09/10] vduse: Introduce VDUSE - vDPA Device in Userspace To: Xie Yongji , mst@redhat.com, stefanha@redhat.com, sgarzare@redhat.com, parav@nvidia.com, hch@infradead.org, christian.brauner@canonical.com, rdunlap@infradead.org, willy@infradead.org, viro@zeniv.linux.org.uk, axboe@kernel.dk, bcrl@kvack.org, corbet@lwn.net, mika.penttila@nextfour.com, dan.carpenter@oracle.com, joro@8bytes.org, gregkh@linuxfoundation.org Cc: songmuchun@bytedance.com, virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, kvm@vger.kernel.org, linux-fsdevel@vger.kernel.org, iommu@lists.linux-foundation.org, linux-kernel@vger.kernel.org References: <20210615141331.407-1-xieyongji@bytedance.com> <20210615141331.407-10-xieyongji@bytedance.com> From: Jason Wang Message-ID: Date: Mon, 21 Jun 2021 17:13:55 +0800 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0) Gecko/20100101 Thunderbird/78.11.0 MIME-Version: 1.0 In-Reply-To: <20210615141331.407-10-xieyongji@bytedance.com> Content-Type: text/plain; charset=gbk; format=flowed Content-Transfer-Encoding: 8bit Content-Language: en-US Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org ÔÚ 2021/6/15 ÏÂÎç10:13, Xie Yongji дµÀ: > This VDUSE driver enables implementing vDPA devices in userspace. > The vDPA device's control path is handled in kernel and the data > path is handled in userspace. > > A message mechnism is used by VDUSE driver to forward some control > messages such as starting/stopping datapath to userspace. Userspace > can use read()/write() to receive/reply those control messages. > > And some ioctls are introduced to help userspace to implement the > data path. VDUSE_IOTLB_GET_FD ioctl can be used to get the file > descriptors referring to vDPA device's iova regions. Then userspace > can use mmap() to access those iova regions. VDUSE_DEV_GET_FEATURES > and VDUSE_VQ_GET_INFO ioctls are used to get the negotiated features > and metadata of virtqueues. VDUSE_INJECT_VQ_IRQ and VDUSE_VQ_SETUP_KICKFD > ioctls can be used to inject interrupt and setup the kickfd for > virtqueues. VDUSE_DEV_UPDATE_CONFIG ioctl is used to update the > configuration space and inject a config interrupt. > > Signed-off-by: Xie Yongji > --- > Documentation/userspace-api/ioctl/ioctl-number.rst | 1 + > drivers/vdpa/Kconfig | 10 + > drivers/vdpa/Makefile | 1 + > drivers/vdpa/vdpa_user/Makefile | 5 + > drivers/vdpa/vdpa_user/vduse_dev.c | 1453 ++++++++++++++++++++ > include/uapi/linux/vduse.h | 143 ++ > 6 files changed, 1613 insertions(+) > create mode 100644 drivers/vdpa/vdpa_user/Makefile > create mode 100644 drivers/vdpa/vdpa_user/vduse_dev.c > create mode 100644 include/uapi/linux/vduse.h > > diff --git a/Documentation/userspace-api/ioctl/ioctl-number.rst b/Documentation/userspace-api/ioctl/ioctl-number.rst > index 9bfc2b510c64..acd95e9dcfe7 100644 > --- a/Documentation/userspace-api/ioctl/ioctl-number.rst > +++ b/Documentation/userspace-api/ioctl/ioctl-number.rst > @@ -300,6 +300,7 @@ Code Seq# Include File Comments > 'z' 10-4F drivers/s390/crypto/zcrypt_api.h conflict! > '|' 00-7F linux/media.h > 0x80 00-1F linux/fb.h > +0x81 00-1F linux/vduse.h > 0x89 00-06 arch/x86/include/asm/sockios.h > 0x89 0B-DF linux/sockios.h > 0x89 E0-EF linux/sockios.h SIOCPROTOPRIVATE range > diff --git a/drivers/vdpa/Kconfig b/drivers/vdpa/Kconfig > index a503c1b2bfd9..6e23bce6433a 100644 > --- a/drivers/vdpa/Kconfig > +++ b/drivers/vdpa/Kconfig > @@ -33,6 +33,16 @@ config VDPA_SIM_BLOCK > vDPA block device simulator which terminates IO request in a > memory buffer. > > +config VDPA_USER > + tristate "VDUSE (vDPA Device in Userspace) support" > + depends on EVENTFD && MMU && HAS_DMA > + select DMA_OPS > + select VHOST_IOTLB > + select IOMMU_IOVA > + help > + With VDUSE it is possible to emulate a vDPA Device > + in a userspace program. > + > config IFCVF > tristate "Intel IFC VF vDPA driver" > depends on PCI_MSI > diff --git a/drivers/vdpa/Makefile b/drivers/vdpa/Makefile > index 67fe7f3d6943..f02ebed33f19 100644 > --- a/drivers/vdpa/Makefile > +++ b/drivers/vdpa/Makefile > @@ -1,6 +1,7 @@ > # SPDX-License-Identifier: GPL-2.0 > obj-$(CONFIG_VDPA) += vdpa.o > obj-$(CONFIG_VDPA_SIM) += vdpa_sim/ > +obj-$(CONFIG_VDPA_USER) += vdpa_user/ > obj-$(CONFIG_IFCVF) += ifcvf/ > obj-$(CONFIG_MLX5_VDPA) += mlx5/ > obj-$(CONFIG_VP_VDPA) += virtio_pci/ > diff --git a/drivers/vdpa/vdpa_user/Makefile b/drivers/vdpa/vdpa_user/Makefile > new file mode 100644 > index 000000000000..260e0b26af99 > --- /dev/null > +++ b/drivers/vdpa/vdpa_user/Makefile > @@ -0,0 +1,5 @@ > +# SPDX-License-Identifier: GPL-2.0 > + > +vduse-y := vduse_dev.o iova_domain.o > + > +obj-$(CONFIG_VDPA_USER) += vduse.o > diff --git a/drivers/vdpa/vdpa_user/vduse_dev.c b/drivers/vdpa/vdpa_user/vduse_dev.c > new file mode 100644 > index 000000000000..5271cbd15e28 > --- /dev/null > +++ b/drivers/vdpa/vdpa_user/vduse_dev.c > @@ -0,0 +1,1453 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * VDUSE: vDPA Device in Userspace > + * > + * Copyright (C) 2020-2021 Bytedance Inc. and/or its affiliates. All rights reserved. > + * > + * Author: Xie Yongji > + * > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include "iova_domain.h" > + > +#define DRV_AUTHOR "Yongji Xie " > +#define DRV_DESC "vDPA Device in Userspace" > +#define DRV_LICENSE "GPL v2" > + > +#define VDUSE_DEV_MAX (1U << MINORBITS) > +#define VDUSE_MAX_BOUNCE_SIZE (64 * 1024 * 1024) > +#define VDUSE_IOVA_SIZE (128 * 1024 * 1024) > +#define VDUSE_REQUEST_TIMEOUT 30 > + > +struct vduse_virtqueue { > + u16 index; > + u32 num; > + u32 avail_idx; > + u64 desc_addr; > + u64 driver_addr; > + u64 device_addr; > + bool ready; > + bool kicked; > + spinlock_t kick_lock; > + spinlock_t irq_lock; > + struct eventfd_ctx *kickfd; > + struct vdpa_callback cb; > + struct work_struct inject; > +}; > + > +struct vduse_dev; > + > +struct vduse_vdpa { > + struct vdpa_device vdpa; > + struct vduse_dev *dev; > +}; > + > +struct vduse_dev { > + struct vduse_vdpa *vdev; > + struct device *dev; > + struct vduse_virtqueue *vqs; > + struct vduse_iova_domain *domain; > + char *name; > + struct mutex lock; > + spinlock_t msg_lock; > + u64 msg_unique; > + wait_queue_head_t waitq; > + struct list_head send_list; > + struct list_head recv_list; > + struct vdpa_callback config_cb; > + struct work_struct inject; > + spinlock_t irq_lock; > + int minor; > + bool connected; > + bool started; > + u64 api_version; > + u64 user_features; Let's use device_features. > + u64 features; And driver features. > + u32 device_id; > + u32 vendor_id; > + u32 generation; > + u32 config_size; > + void *config; > + u8 status; > + u16 vq_size_max; > + u32 vq_num; > + u32 vq_align; > +}; > + > +struct vduse_dev_msg { > + struct vduse_dev_request req; > + struct vduse_dev_response resp; > + struct list_head list; > + wait_queue_head_t waitq; > + bool completed; > +}; > + > +struct vduse_control { > + u64 api_version; > +}; > + > +static DEFINE_MUTEX(vduse_lock); > +static DEFINE_IDR(vduse_idr); > + > +static dev_t vduse_major; > +static struct class *vduse_class; > +static struct cdev vduse_ctrl_cdev; > +static struct cdev vduse_cdev; > +static struct workqueue_struct *vduse_irq_wq; > + > +static u32 allowed_device_id[] = { > + VIRTIO_ID_BLOCK, > +}; > + > +static inline struct vduse_dev *vdpa_to_vduse(struct vdpa_device *vdpa) > +{ > + struct vduse_vdpa *vdev = container_of(vdpa, struct vduse_vdpa, vdpa); > + > + return vdev->dev; > +} > + > +static inline struct vduse_dev *dev_to_vduse(struct device *dev) > +{ > + struct vdpa_device *vdpa = dev_to_vdpa(dev); > + > + return vdpa_to_vduse(vdpa); > +} > + > +static struct vduse_dev_msg *vduse_find_msg(struct list_head *head, > + uint32_t request_id) > +{ > + struct vduse_dev_msg *msg; > + > + list_for_each_entry(msg, head, list) { > + if (msg->req.request_id == request_id) { > + list_del(&msg->list); > + return msg; > + } > + } > + > + return NULL; > +} > + > +static struct vduse_dev_msg *vduse_dequeue_msg(struct list_head *head) > +{ > + struct vduse_dev_msg *msg = NULL; > + > + if (!list_empty(head)) { > + msg = list_first_entry(head, struct vduse_dev_msg, list); > + list_del(&msg->list); > + } > + > + return msg; > +} > + > +static void vduse_enqueue_msg(struct list_head *head, > + struct vduse_dev_msg *msg) > +{ > + list_add_tail(&msg->list, head); > +} > + > +static int vduse_dev_msg_send(struct vduse_dev *dev, > + struct vduse_dev_msg *msg, bool no_reply) > +{ It looks to me the only user for no_reply=true is the dataplane start. I wonder no_reply is really needed consider we have switched to use wait_event_killable_timeout(). In another way, no_reply is false for vq state synchronization and IOTLB updating. I wonder if we can simply use no_reply = true for them. > + init_waitqueue_head(&msg->waitq); > + spin_lock(&dev->msg_lock); > + msg->req.request_id = dev->msg_unique++; > + vduse_enqueue_msg(&dev->send_list, msg); > + wake_up(&dev->waitq); > + spin_unlock(&dev->msg_lock); > + if (no_reply) > + return 0; > + > + wait_event_killable_timeout(msg->waitq, msg->completed, > + VDUSE_REQUEST_TIMEOUT * HZ); > + spin_lock(&dev->msg_lock); > + if (!msg->completed) { > + list_del(&msg->list); > + msg->resp.result = VDUSE_REQ_RESULT_FAILED; > + } > + spin_unlock(&dev->msg_lock); > + > + return (msg->resp.result == VDUSE_REQ_RESULT_OK) ? 0 : -EIO; Do we need to serialize the check by protecting it with the spinlock above? > +} > + > +static void vduse_dev_msg_cleanup(struct vduse_dev *dev) > +{ > + struct vduse_dev_msg *msg; > + > + spin_lock(&dev->msg_lock); > + while ((msg = vduse_dequeue_msg(&dev->send_list))) { > + if (msg->req.flags & VDUSE_REQ_FLAGS_NO_REPLY) > + kfree(msg); > + else > + vduse_enqueue_msg(&dev->recv_list, msg); > + } > + while ((msg = vduse_dequeue_msg(&dev->recv_list))) { > + msg->resp.result = VDUSE_REQ_RESULT_FAILED; > + msg->completed = 1; > + wake_up(&msg->waitq); > + } > + spin_unlock(&dev->msg_lock); > +} > + > +static void vduse_dev_start_dataplane(struct vduse_dev *dev) > +{ > + struct vduse_dev_msg *msg = kzalloc(sizeof(*msg), > + GFP_KERNEL | __GFP_NOFAIL); > + > + msg->req.type = VDUSE_START_DATAPLANE; > + msg->req.flags |= VDUSE_REQ_FLAGS_NO_REPLY; > + vduse_dev_msg_send(dev, msg, true); > +} > + > +static void vduse_dev_stop_dataplane(struct vduse_dev *dev) > +{ > + struct vduse_dev_msg *msg = kzalloc(sizeof(*msg), > + GFP_KERNEL | __GFP_NOFAIL); > + > + msg->req.type = VDUSE_STOP_DATAPLANE; > + msg->req.flags |= VDUSE_REQ_FLAGS_NO_REPLY; Can we simply use this flag instead of introducing a new parameter (no_reply) in vduse_dev_msg_send()? > + vduse_dev_msg_send(dev, msg, true); > +} > + > +static int vduse_dev_get_vq_state(struct vduse_dev *dev, > + struct vduse_virtqueue *vq, > + struct vdpa_vq_state *state) > +{ > + struct vduse_dev_msg msg = { 0 }; > + int ret; Note that I post a series that implement the packed virtqueue support: https://lists.linuxfoundation.org/pipermail/virtualization/2021-June/054501.html So this patch needs to be updated as well. > + > + msg.req.type = VDUSE_GET_VQ_STATE; > + msg.req.vq_state.index = vq->index; > + > + ret = vduse_dev_msg_send(dev, &msg, false); > + if (ret) > + return ret; > + > + state->avail_index = msg.resp.vq_state.avail_idx; > + return 0; > +} > + > +static int vduse_dev_update_iotlb(struct vduse_dev *dev, > + u64 start, u64 last) > +{ > + struct vduse_dev_msg msg = { 0 }; > + > + if (last < start) > + return -EINVAL; > + > + msg.req.type = VDUSE_UPDATE_IOTLB; > + msg.req.iova.start = start; > + msg.req.iova.last = last; > + > + return vduse_dev_msg_send(dev, &msg, false); > +} > + > +static ssize_t vduse_dev_read_iter(struct kiocb *iocb, struct iov_iter *to) > +{ > + struct file *file = iocb->ki_filp; > + struct vduse_dev *dev = file->private_data; > + struct vduse_dev_msg *msg; > + int size = sizeof(struct vduse_dev_request); > + ssize_t ret; > + > + if (iov_iter_count(to) < size) > + return -EINVAL; > + > + spin_lock(&dev->msg_lock); > + while (1) { > + msg = vduse_dequeue_msg(&dev->send_list); > + if (msg) > + break; > + > + ret = -EAGAIN; > + if (file->f_flags & O_NONBLOCK) > + goto unlock; > + > + spin_unlock(&dev->msg_lock); > + ret = wait_event_interruptible_exclusive(dev->waitq, > + !list_empty(&dev->send_list)); > + if (ret) > + return ret; > + > + spin_lock(&dev->msg_lock); > + } > + spin_unlock(&dev->msg_lock); > + ret = copy_to_iter(&msg->req, size, to); > + spin_lock(&dev->msg_lock); > + if (ret != size) { > + ret = -EFAULT; > + vduse_enqueue_msg(&dev->send_list, msg); > + goto unlock; > + } > + if (msg->req.flags & VDUSE_REQ_FLAGS_NO_REPLY) > + kfree(msg); > + else > + vduse_enqueue_msg(&dev->recv_list, msg); > +unlock: > + spin_unlock(&dev->msg_lock); > + > + return ret; > +} > + > +static ssize_t vduse_dev_write_iter(struct kiocb *iocb, struct iov_iter *from) > +{ > + struct file *file = iocb->ki_filp; > + struct vduse_dev *dev = file->private_data; > + struct vduse_dev_response resp; > + struct vduse_dev_msg *msg; > + size_t ret; > + > + ret = copy_from_iter(&resp, sizeof(resp), from); > + if (ret != sizeof(resp)) > + return -EINVAL; > + > + spin_lock(&dev->msg_lock); > + msg = vduse_find_msg(&dev->recv_list, resp.request_id); > + if (!msg) { > + ret = -ENOENT; > + goto unlock; > + } > + > + memcpy(&msg->resp, &resp, sizeof(resp)); > + msg->completed = 1; > + wake_up(&msg->waitq); > +unlock: > + spin_unlock(&dev->msg_lock); > + > + return ret; > +} > + > +static __poll_t vduse_dev_poll(struct file *file, poll_table *wait) > +{ > + struct vduse_dev *dev = file->private_data; > + __poll_t mask = 0; > + > + poll_wait(file, &dev->waitq, wait); > + > + if (!list_empty(&dev->send_list)) > + mask |= EPOLLIN | EPOLLRDNORM; > + if (!list_empty(&dev->recv_list)) > + mask |= EPOLLOUT | EPOLLWRNORM; > + > + return mask; > +} > + > +static void vduse_dev_reset(struct vduse_dev *dev) > +{ > + int i; > + struct vduse_iova_domain *domain = dev->domain; > + > + /* The coherent mappings are handled in vduse_dev_free_coherent() */ > + if (domain->bounce_map) > + vduse_domain_reset_bounce_map(domain); > + > + dev->features = 0; > + dev->generation++; > + spin_lock(&dev->irq_lock); > + dev->config_cb.callback = NULL; > + dev->config_cb.private = NULL; > + spin_unlock(&dev->irq_lock); > + > + for (i = 0; i < dev->vq_num; i++) { > + struct vduse_virtqueue *vq = &dev->vqs[i]; > + > + vq->ready = false; > + vq->desc_addr = 0; > + vq->driver_addr = 0; > + vq->device_addr = 0; > + vq->avail_idx = 0; > + vq->num = 0; > + > + spin_lock(&vq->kick_lock); > + vq->kicked = false; > + if (vq->kickfd) > + eventfd_ctx_put(vq->kickfd); > + vq->kickfd = NULL; > + spin_unlock(&vq->kick_lock); > + > + spin_lock(&vq->irq_lock); > + vq->cb.callback = NULL; > + vq->cb.private = NULL; > + spin_unlock(&vq->irq_lock); > + } > +} > + > +static int vduse_vdpa_set_vq_address(struct vdpa_device *vdpa, u16 idx, > + u64 desc_area, u64 driver_area, > + u64 device_area) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + struct vduse_virtqueue *vq = &dev->vqs[idx]; > + > + vq->desc_addr = desc_area; > + vq->driver_addr = driver_area; > + vq->device_addr = device_area; > + > + return 0; > +} > + > +static void vduse_vdpa_kick_vq(struct vdpa_device *vdpa, u16 idx) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + struct vduse_virtqueue *vq = &dev->vqs[idx]; > + > + spin_lock(&vq->kick_lock); > + if (!vq->ready) > + goto unlock; > + > + if (vq->kickfd) > + eventfd_signal(vq->kickfd, 1); > + else > + vq->kicked = true; > +unlock: > + spin_unlock(&vq->kick_lock); > +} > + > +static void vduse_vdpa_set_vq_cb(struct vdpa_device *vdpa, u16 idx, > + struct vdpa_callback *cb) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + struct vduse_virtqueue *vq = &dev->vqs[idx]; > + > + spin_lock(&vq->irq_lock); > + vq->cb.callback = cb->callback; > + vq->cb.private = cb->private; > + spin_unlock(&vq->irq_lock); > +} > + > +static void vduse_vdpa_set_vq_num(struct vdpa_device *vdpa, u16 idx, u32 num) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + struct vduse_virtqueue *vq = &dev->vqs[idx]; > + > + vq->num = num; > +} > + > +static void vduse_vdpa_set_vq_ready(struct vdpa_device *vdpa, > + u16 idx, bool ready) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + struct vduse_virtqueue *vq = &dev->vqs[idx]; > + > + vq->ready = ready; > +} > + > +static bool vduse_vdpa_get_vq_ready(struct vdpa_device *vdpa, u16 idx) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + struct vduse_virtqueue *vq = &dev->vqs[idx]; > + > + return vq->ready; > +} > + > +static int vduse_vdpa_set_vq_state(struct vdpa_device *vdpa, u16 idx, > + const struct vdpa_vq_state *state) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + struct vduse_virtqueue *vq = &dev->vqs[idx]; > + > + vq->avail_idx = state->avail_index; > + return 0; > +} > + > +static int vduse_vdpa_get_vq_state(struct vdpa_device *vdpa, u16 idx, > + struct vdpa_vq_state *state) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + struct vduse_virtqueue *vq = &dev->vqs[idx]; > + > + return vduse_dev_get_vq_state(dev, vq, state); > +} > + > +static u32 vduse_vdpa_get_vq_align(struct vdpa_device *vdpa) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + > + return dev->vq_align; > +} > + > +static u64 vduse_vdpa_get_features(struct vdpa_device *vdpa) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + > + return dev->user_features; > +} > + > +static int vduse_vdpa_set_features(struct vdpa_device *vdpa, u64 features) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + > + dev->features = features; > + return 0; > +} > + > +static void vduse_vdpa_set_config_cb(struct vdpa_device *vdpa, > + struct vdpa_callback *cb) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + > + spin_lock(&dev->irq_lock); > + dev->config_cb.callback = cb->callback; > + dev->config_cb.private = cb->private; > + spin_unlock(&dev->irq_lock); > +} > + > +static u16 vduse_vdpa_get_vq_num_max(struct vdpa_device *vdpa) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + > + return dev->vq_size_max; > +} > + > +static u32 vduse_vdpa_get_device_id(struct vdpa_device *vdpa) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + > + return dev->device_id; > +} > + > +static u32 vduse_vdpa_get_vendor_id(struct vdpa_device *vdpa) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + > + return dev->vendor_id; > +} > + > +static u8 vduse_vdpa_get_status(struct vdpa_device *vdpa) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + > + return dev->status; > +} > + > +static void vduse_vdpa_set_status(struct vdpa_device *vdpa, u8 status) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + bool started = !!(status & VIRTIO_CONFIG_S_DRIVER_OK); > + > + dev->status = status; > + > + if (dev->started == started) > + return; If we check dev->status == status, (or only check the DRIVER_OK bit) then there's no need to introduce an extra dev->started. > + > + dev->started = started; > + if (dev->started) { > + vduse_dev_start_dataplane(dev); > + } else { > + vduse_dev_reset(dev); > + vduse_dev_stop_dataplane(dev); I wonder if no_reply work for the case of vhost-vdpa. For virtio-vDPA, we have bouncing buffers so it's harmless if usersapce dataplane keeps performing read/write. For vhost-vDPA we don't have such stuffs. > + } > +} > + > +static size_t vduse_vdpa_get_config_size(struct vdpa_device *vdpa) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + > + return dev->config_size; > +} > + > +static void vduse_vdpa_get_config(struct vdpa_device *vdpa, unsigned int offset, > + void *buf, unsigned int len) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + > + memcpy(buf, dev->config + offset, len); > +} > + > +static void vduse_vdpa_set_config(struct vdpa_device *vdpa, unsigned int offset, > + const void *buf, unsigned int len) > +{ > + /* Now we only support read-only configuration space */ > +} > + > +static u32 vduse_vdpa_get_generation(struct vdpa_device *vdpa) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + > + return dev->generation; > +} > + > +static int vduse_vdpa_set_map(struct vdpa_device *vdpa, > + struct vhost_iotlb *iotlb) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + int ret; > + > + ret = vduse_domain_set_map(dev->domain, iotlb); > + if (ret) > + return ret; > + > + ret = vduse_dev_update_iotlb(dev, 0ULL, ULLONG_MAX); > + if (ret) { > + vduse_domain_clear_map(dev->domain, iotlb); > + return ret; > + } > + > + return 0; > +} > + > +static void vduse_vdpa_free(struct vdpa_device *vdpa) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + > + dev->vdev = NULL; > +} > + > +static const struct vdpa_config_ops vduse_vdpa_config_ops = { > + .set_vq_address = vduse_vdpa_set_vq_address, > + .kick_vq = vduse_vdpa_kick_vq, > + .set_vq_cb = vduse_vdpa_set_vq_cb, > + .set_vq_num = vduse_vdpa_set_vq_num, > + .set_vq_ready = vduse_vdpa_set_vq_ready, > + .get_vq_ready = vduse_vdpa_get_vq_ready, > + .set_vq_state = vduse_vdpa_set_vq_state, > + .get_vq_state = vduse_vdpa_get_vq_state, > + .get_vq_align = vduse_vdpa_get_vq_align, > + .get_features = vduse_vdpa_get_features, > + .set_features = vduse_vdpa_set_features, > + .set_config_cb = vduse_vdpa_set_config_cb, > + .get_vq_num_max = vduse_vdpa_get_vq_num_max, > + .get_device_id = vduse_vdpa_get_device_id, > + .get_vendor_id = vduse_vdpa_get_vendor_id, > + .get_status = vduse_vdpa_get_status, > + .set_status = vduse_vdpa_set_status, > + .get_config_size = vduse_vdpa_get_config_size, > + .get_config = vduse_vdpa_get_config, > + .set_config = vduse_vdpa_set_config, > + .get_generation = vduse_vdpa_get_generation, > + .set_map = vduse_vdpa_set_map, > + .free = vduse_vdpa_free, > +}; > + > +static dma_addr_t vduse_dev_map_page(struct device *dev, struct page *page, > + unsigned long offset, size_t size, > + enum dma_data_direction dir, > + unsigned long attrs) > +{ > + struct vduse_dev *vdev = dev_to_vduse(dev); > + struct vduse_iova_domain *domain = vdev->domain; > + > + return vduse_domain_map_page(domain, page, offset, size, dir, attrs); > +} > + > +static void vduse_dev_unmap_page(struct device *dev, dma_addr_t dma_addr, > + size_t size, enum dma_data_direction dir, > + unsigned long attrs) > +{ > + struct vduse_dev *vdev = dev_to_vduse(dev); > + struct vduse_iova_domain *domain = vdev->domain; > + > + return vduse_domain_unmap_page(domain, dma_addr, size, dir, attrs); > +} > + > +static void *vduse_dev_alloc_coherent(struct device *dev, size_t size, > + dma_addr_t *dma_addr, gfp_t flag, > + unsigned long attrs) > +{ > + struct vduse_dev *vdev = dev_to_vduse(dev); > + struct vduse_iova_domain *domain = vdev->domain; > + unsigned long iova; > + void *addr; > + > + *dma_addr = DMA_MAPPING_ERROR; > + addr = vduse_domain_alloc_coherent(domain, size, > + (dma_addr_t *)&iova, flag, attrs); > + if (!addr) > + return NULL; > + > + *dma_addr = (dma_addr_t)iova; > + > + return addr; > +} > + > +static void vduse_dev_free_coherent(struct device *dev, size_t size, > + void *vaddr, dma_addr_t dma_addr, > + unsigned long attrs) > +{ > + struct vduse_dev *vdev = dev_to_vduse(dev); > + struct vduse_iova_domain *domain = vdev->domain; > + > + vduse_domain_free_coherent(domain, size, vaddr, dma_addr, attrs); > +} > + > +static size_t vduse_dev_max_mapping_size(struct device *dev) > +{ > + struct vduse_dev *vdev = dev_to_vduse(dev); > + struct vduse_iova_domain *domain = vdev->domain; > + > + return domain->bounce_size; > +} > + > +static const struct dma_map_ops vduse_dev_dma_ops = { > + .map_page = vduse_dev_map_page, > + .unmap_page = vduse_dev_unmap_page, > + .alloc = vduse_dev_alloc_coherent, > + .free = vduse_dev_free_coherent, > + .max_mapping_size = vduse_dev_max_mapping_size, > +}; > + > +static unsigned int perm_to_file_flags(u8 perm) > +{ > + unsigned int flags = 0; > + > + switch (perm) { > + case VDUSE_ACCESS_WO: > + flags |= O_WRONLY; > + break; > + case VDUSE_ACCESS_RO: > + flags |= O_RDONLY; > + break; > + case VDUSE_ACCESS_RW: > + flags |= O_RDWR; > + break; > + default: > + WARN(1, "invalidate vhost IOTLB permission\n"); > + break; > + } > + > + return flags; > +} > + > +static int vduse_kickfd_setup(struct vduse_dev *dev, > + struct vduse_vq_eventfd *eventfd) > +{ > + struct eventfd_ctx *ctx = NULL; > + struct vduse_virtqueue *vq; > + u32 index; > + > + if (eventfd->index >= dev->vq_num) > + return -EINVAL; > + > + index = array_index_nospec(eventfd->index, dev->vq_num); > + vq = &dev->vqs[index]; > + if (eventfd->fd >= 0) { > + ctx = eventfd_ctx_fdget(eventfd->fd); > + if (IS_ERR(ctx)) > + return PTR_ERR(ctx); > + } else if (eventfd->fd != VDUSE_EVENTFD_DEASSIGN) > + return 0; > + > + spin_lock(&vq->kick_lock); > + if (vq->kickfd) > + eventfd_ctx_put(vq->kickfd); > + vq->kickfd = ctx; > + if (vq->ready && vq->kicked && vq->kickfd) { > + eventfd_signal(vq->kickfd, 1); > + vq->kicked = false; > + } > + spin_unlock(&vq->kick_lock); > + > + return 0; > +} > + > +static void vduse_dev_irq_inject(struct work_struct *work) > +{ > + struct vduse_dev *dev = container_of(work, struct vduse_dev, inject); > + > + spin_lock_irq(&dev->irq_lock); > + if (dev->config_cb.callback) > + dev->config_cb.callback(dev->config_cb.private); > + spin_unlock_irq(&dev->irq_lock); > +} > + > +static void vduse_vq_irq_inject(struct work_struct *work) > +{ > + struct vduse_virtqueue *vq = container_of(work, > + struct vduse_virtqueue, inject); > + > + spin_lock_irq(&vq->irq_lock); > + if (vq->ready && vq->cb.callback) > + vq->cb.callback(vq->cb.private); > + spin_unlock_irq(&vq->irq_lock); > +} > + > +static long vduse_dev_ioctl(struct file *file, unsigned int cmd, > + unsigned long arg) > +{ > + struct vduse_dev *dev = file->private_data; > + void __user *argp = (void __user *)arg; > + int ret; > + > + switch (cmd) { > + case VDUSE_IOTLB_GET_FD: { > + struct vduse_iotlb_entry entry; > + struct vhost_iotlb_map *map; > + struct vdpa_map_file *map_file; > + struct vduse_iova_domain *domain = dev->domain; > + struct file *f = NULL; > + > + ret = -EFAULT; > + if (copy_from_user(&entry, argp, sizeof(entry))) > + break; > + > + ret = -EINVAL; > + if (entry.start > entry.last) > + break; > + > + spin_lock(&domain->iotlb_lock); > + map = vhost_iotlb_itree_first(domain->iotlb, > + entry.start, entry.last); > + if (map) { > + map_file = (struct vdpa_map_file *)map->opaque; > + f = get_file(map_file->file); > + entry.offset = map_file->offset; > + entry.start = map->start; > + entry.last = map->last; > + entry.perm = map->perm; > + } > + spin_unlock(&domain->iotlb_lock); > + ret = -EINVAL; > + if (!f) > + break; > + > + ret = -EFAULT; > + if (copy_to_user(argp, &entry, sizeof(entry))) { > + fput(f); > + break; > + } > + ret = receive_fd(f, perm_to_file_flags(entry.perm)); > + fput(f); > + break; > + } > + case VDUSE_DEV_GET_FEATURES: > + ret = put_user(dev->features, (u64 __user *)argp); > + break; > + case VDUSE_DEV_UPDATE_CONFIG: { > + struct vduse_config_update config; > + unsigned long size = offsetof(struct vduse_config_update, > + buffer); > + > + ret = -EFAULT; > + if (copy_from_user(&config, argp, size)) > + break; > + > + ret = -EINVAL; > + if (config.length == 0 || > + config.length > dev->config_size - config.offset) > + break; > + > + ret = -EFAULT; > + if (copy_from_user(dev->config + config.offset, argp + size, > + config.length)) > + break; > + > + ret = 0; > + queue_work(vduse_irq_wq, &dev->inject); I wonder if it's better to separate config interrupt out of config update or we need document this. > + break; > + } > + case VDUSE_VQ_GET_INFO: { Do we need to limit this only when DRIVER_OK is set? > + struct vduse_vq_info vq_info; > + u32 vq_index; > + > + ret = -EFAULT; > + if (copy_from_user(&vq_info, argp, sizeof(vq_info))) > + break; > + > + ret = -EINVAL; > + if (vq_info.index >= dev->vq_num) > + break; > + > + vq_index = array_index_nospec(vq_info.index, dev->vq_num); > + vq_info.desc_addr = dev->vqs[vq_index].desc_addr; > + vq_info.driver_addr = dev->vqs[vq_index].driver_addr; > + vq_info.device_addr = dev->vqs[vq_index].device_addr; > + vq_info.num = dev->vqs[vq_index].num; > + vq_info.avail_idx = dev->vqs[vq_index].avail_idx; > + vq_info.ready = dev->vqs[vq_index].ready; > + > + ret = -EFAULT; > + if (copy_to_user(argp, &vq_info, sizeof(vq_info))) > + break; > + > + ret = 0; > + break; > + } > + case VDUSE_VQ_SETUP_KICKFD: { > + struct vduse_vq_eventfd eventfd; > + > + ret = -EFAULT; > + if (copy_from_user(&eventfd, argp, sizeof(eventfd))) > + break; > + > + ret = vduse_kickfd_setup(dev, &eventfd); > + break; > + } > + case VDUSE_VQ_INJECT_IRQ: { > + u32 vq_index; > + > + ret = -EFAULT; > + if (get_user(vq_index, (u32 __user *)argp)) > + break; > + > + ret = -EINVAL; > + if (vq_index >= dev->vq_num) > + break; > + > + ret = 0; > + vq_index = array_index_nospec(vq_index, dev->vq_num); > + queue_work(vduse_irq_wq, &dev->vqs[vq_index].inject); > + break; > + } > + default: > + ret = -ENOIOCTLCMD; > + break; > + } > + > + return ret; > +} > + > +static int vduse_dev_release(struct inode *inode, struct file *file) > +{ > + struct vduse_dev *dev = file->private_data; > + > + spin_lock(&dev->msg_lock); > + /* Make sure the inflight messages can processed after reconncection */ > + list_splice_init(&dev->recv_list, &dev->send_list); > + spin_unlock(&dev->msg_lock); > + dev->connected = false; > + > + return 0; > +} > + > +static struct vduse_dev *vduse_dev_get_from_minor(int minor) > +{ > + struct vduse_dev *dev; > + > + mutex_lock(&vduse_lock); > + dev = idr_find(&vduse_idr, minor); > + mutex_unlock(&vduse_lock); > + > + return dev; > +} > + > +static int vduse_dev_open(struct inode *inode, struct file *file) > +{ > + int ret; > + struct vduse_dev *dev = vduse_dev_get_from_minor(iminor(inode)); > + > + if (!dev) > + return -ENODEV; > + > + ret = -EBUSY; > + mutex_lock(&dev->lock); > + if (dev->connected) > + goto unlock; > + > + ret = 0; > + dev->connected = true; > + file->private_data = dev; > +unlock: > + mutex_unlock(&dev->lock); > + > + return ret; > +} > + > +static const struct file_operations vduse_dev_fops = { > + .owner = THIS_MODULE, > + .open = vduse_dev_open, > + .release = vduse_dev_release, > + .read_iter = vduse_dev_read_iter, > + .write_iter = vduse_dev_write_iter, > + .poll = vduse_dev_poll, > + .unlocked_ioctl = vduse_dev_ioctl, > + .compat_ioctl = compat_ptr_ioctl, > + .llseek = noop_llseek, > +}; > + > +static struct vduse_dev *vduse_dev_create(void) > +{ > + struct vduse_dev *dev = kzalloc(sizeof(*dev), GFP_KERNEL); > + > + if (!dev) > + return NULL; > + > + mutex_init(&dev->lock); > + spin_lock_init(&dev->msg_lock); > + INIT_LIST_HEAD(&dev->send_list); > + INIT_LIST_HEAD(&dev->recv_list); > + spin_lock_init(&dev->irq_lock); > + > + INIT_WORK(&dev->inject, vduse_dev_irq_inject); > + init_waitqueue_head(&dev->waitq); > + > + return dev; > +} > + > +static void vduse_dev_destroy(struct vduse_dev *dev) > +{ > + kfree(dev); > +} > + > +static struct vduse_dev *vduse_find_dev(const char *name) > +{ > + struct vduse_dev *dev; > + int id; > + > + idr_for_each_entry(&vduse_idr, dev, id) > + if (!strcmp(dev->name, name)) > + return dev; > + > + return NULL; > +} > + > +static int vduse_destroy_dev(char *name) > +{ > + struct vduse_dev *dev = vduse_find_dev(name); > + > + if (!dev) > + return -EINVAL; > + > + mutex_lock(&dev->lock); > + if (dev->vdev || dev->connected) { > + mutex_unlock(&dev->lock); > + return -EBUSY; > + } > + dev->connected = true; > + mutex_unlock(&dev->lock); > + > + vduse_dev_msg_cleanup(dev); > + device_destroy(vduse_class, MKDEV(MAJOR(vduse_major), dev->minor)); > + idr_remove(&vduse_idr, dev->minor); > + kvfree(dev->config); > + kfree(dev->vqs); > + vduse_domain_destroy(dev->domain); > + kfree(dev->name); > + vduse_dev_destroy(dev); > + module_put(THIS_MODULE); > + > + return 0; > +} > + > +static bool device_is_allowed(u32 device_id) > +{ > + int i; > + > + for (i = 0; i < ARRAY_SIZE(allowed_device_id); i++) > + if (allowed_device_id[i] == device_id) > + return true; > + > + return false; > +} > + > +static bool features_is_valid(u64 features) > +{ > + if (!(features & (1ULL << VIRTIO_F_ACCESS_PLATFORM))) > + return false; > + > + /* Now we only support read-only configuration space */ > + if (features & (1ULL << VIRTIO_BLK_F_CONFIG_WCE)) > + return false; > + > + return true; > +} > + > +static bool vduse_validate_config(struct vduse_dev_config *config) > +{ > + if (config->bounce_size > VDUSE_MAX_BOUNCE_SIZE) > + return false; > + > + if (config->vq_align > PAGE_SIZE) > + return false; > + > + if (config->config_size > PAGE_SIZE) > + return false; > + > + if (!device_is_allowed(config->device_id)) > + return false; > + > + if (!features_is_valid(config->features)) > + return false; Do we need to validate whether or not config_size is too small otherwise we may have OOB access in get_config()? > + > + return true; > +} > + > +static int vduse_create_dev(struct vduse_dev_config *config, > + void *config_buf, u64 api_version) > +{ > + int i, ret; > + struct vduse_dev *dev; > + > + ret = -EEXIST; > + if (vduse_find_dev(config->name)) > + goto err; > + > + ret = -ENOMEM; > + dev = vduse_dev_create(); > + if (!dev) > + goto err; > + > + dev->api_version = api_version; > + dev->user_features = config->features; > + dev->device_id = config->device_id; > + dev->vendor_id = config->vendor_id; > + dev->name = kstrdup(config->name, GFP_KERNEL); > + if (!dev->name) > + goto err_str; > + > + dev->domain = vduse_domain_create(VDUSE_IOVA_SIZE - 1, > + config->bounce_size); > + if (!dev->domain) > + goto err_domain; > + > + dev->config = config_buf; > + dev->config_size = config->config_size; > + dev->vq_align = config->vq_align; > + dev->vq_size_max = config->vq_size_max; > + dev->vq_num = config->vq_num; > + dev->vqs = kcalloc(dev->vq_num, sizeof(*dev->vqs), GFP_KERNEL); > + if (!dev->vqs) > + goto err_vqs; > + > + for (i = 0; i < dev->vq_num; i++) { > + dev->vqs[i].index = i; > + INIT_WORK(&dev->vqs[i].inject, vduse_vq_irq_inject); > + spin_lock_init(&dev->vqs[i].kick_lock); > + spin_lock_init(&dev->vqs[i].irq_lock); > + } > + > + ret = idr_alloc(&vduse_idr, dev, 1, VDUSE_DEV_MAX, GFP_KERNEL); > + if (ret < 0) > + goto err_idr; > + > + dev->minor = ret; > + dev->dev = device_create(vduse_class, NULL, > + MKDEV(MAJOR(vduse_major), dev->minor), > + NULL, "%s", config->name); > + if (IS_ERR(dev->dev)) { > + ret = PTR_ERR(dev->dev); > + goto err_dev; > + } > + __module_get(THIS_MODULE); > + > + return 0; > +err_dev: > + idr_remove(&vduse_idr, dev->minor); > +err_idr: > + kfree(dev->vqs); > +err_vqs: > + vduse_domain_destroy(dev->domain); > +err_domain: > + kfree(dev->name); > +err_str: > + vduse_dev_destroy(dev); > +err: > + kvfree(config_buf); > + return ret; > +} > + > +static long vduse_ioctl(struct file *file, unsigned int cmd, > + unsigned long arg) > +{ > + int ret; > + void __user *argp = (void __user *)arg; > + struct vduse_control *control = file->private_data; > + > + mutex_lock(&vduse_lock); > + switch (cmd) { > + case VDUSE_GET_API_VERSION: > + ret = put_user(control->api_version, (u64 __user *)argp); > + break; > + case VDUSE_SET_API_VERSION: { > + u64 api_version; > + > + ret = -EFAULT; > + if (get_user(api_version, (u64 __user *)argp)) > + break; > + > + ret = -EINVAL; > + if (api_version > VDUSE_API_VERSION) > + break; > + > + ret = 0; > + control->api_version = api_version; > + break; > + } > + case VDUSE_CREATE_DEV: { > + struct vduse_dev_config config; > + unsigned long size = offsetof(struct vduse_dev_config, config); > + void *buf; > + > + ret = -EFAULT; > + if (copy_from_user(&config, argp, size)) > + break; > + > + ret = -EINVAL; > + if (vduse_validate_config(&config) == false) > + break; > + > + buf = vmemdup_user(argp + size, config.config_size); > + if (IS_ERR(buf)) { > + ret = PTR_ERR(buf); > + break; > + } > + ret = vduse_create_dev(&config, buf, control->api_version); > + break; > + } > + case VDUSE_DESTROY_DEV: { > + char name[VDUSE_NAME_MAX]; > + > + ret = -EFAULT; > + if (copy_from_user(name, argp, VDUSE_NAME_MAX)) > + break; > + > + ret = vduse_destroy_dev(name); > + break; > + } > + default: > + ret = -EINVAL; > + break; > + } > + mutex_unlock(&vduse_lock); > + > + return ret; > +} > + > +static int vduse_release(struct inode *inode, struct file *file) > +{ > + struct vduse_control *control = file->private_data; > + > + kfree(control); > + return 0; > +} > + > +static int vduse_open(struct inode *inode, struct file *file) > +{ > + struct vduse_control *control; > + > + control = kmalloc(sizeof(struct vduse_control), GFP_KERNEL); > + if (!control) > + return -ENOMEM; > + > + control->api_version = VDUSE_API_VERSION; > + file->private_data = control; > + > + return 0; > +} > + > +static const struct file_operations vduse_ctrl_fops = { > + .owner = THIS_MODULE, > + .open = vduse_open, > + .release = vduse_release, > + .unlocked_ioctl = vduse_ioctl, > + .compat_ioctl = compat_ptr_ioctl, > + .llseek = noop_llseek, > +}; > + > +static char *vduse_devnode(struct device *dev, umode_t *mode) > +{ > + return kasprintf(GFP_KERNEL, "vduse/%s", dev_name(dev)); > +} > + > +static void vduse_mgmtdev_release(struct device *dev) > +{ > +} > + > +static struct device vduse_mgmtdev = { > + .init_name = "vduse", > + .release = vduse_mgmtdev_release, > +}; > + > +static struct vdpa_mgmt_dev mgmt_dev; > + > +static int vduse_dev_init_vdpa(struct vduse_dev *dev, const char *name) > +{ > + struct vduse_vdpa *vdev; > + int ret; > + > + if (dev->vdev) > + return -EEXIST; > + > + vdev = vdpa_alloc_device(struct vduse_vdpa, vdpa, dev->dev, > + &vduse_vdpa_config_ops, name, true); > + if (!vdev) > + return -ENOMEM; > + > + dev->vdev = vdev; > + vdev->dev = dev; > + vdev->vdpa.dev.dma_mask = &vdev->vdpa.dev.coherent_dma_mask; > + ret = dma_set_mask_and_coherent(&vdev->vdpa.dev, DMA_BIT_MASK(64)); > + if (ret) { > + put_device(&vdev->vdpa.dev); > + return ret; > + } > + set_dma_ops(&vdev->vdpa.dev, &vduse_dev_dma_ops); > + vdev->vdpa.dma_dev = &vdev->vdpa.dev; > + vdev->vdpa.mdev = &mgmt_dev; > + > + return 0; > +} > + > +static int vdpa_dev_add(struct vdpa_mgmt_dev *mdev, const char *name) > +{ > + struct vduse_dev *dev; > + int ret; > + > + mutex_lock(&vduse_lock); > + dev = vduse_find_dev(name); > + if (!dev) { > + mutex_unlock(&vduse_lock); > + return -EINVAL; > + } > + ret = vduse_dev_init_vdpa(dev, name); > + mutex_unlock(&vduse_lock); > + if (ret) > + return ret; > + > + ret = _vdpa_register_device(&dev->vdev->vdpa, dev->vq_num); > + if (ret) { > + put_device(&dev->vdev->vdpa.dev); > + return ret; > + } > + > + return 0; > +} > + > +static void vdpa_dev_del(struct vdpa_mgmt_dev *mdev, struct vdpa_device *dev) > +{ > + _vdpa_unregister_device(dev); > +} > + > +static const struct vdpa_mgmtdev_ops vdpa_dev_mgmtdev_ops = { > + .dev_add = vdpa_dev_add, > + .dev_del = vdpa_dev_del, > +}; > + > +static struct virtio_device_id id_table[] = { > + { VIRTIO_ID_BLOCK, VIRTIO_DEV_ANY_ID }, > + { 0 }, > +}; > + > +static struct vdpa_mgmt_dev mgmt_dev = { > + .device = &vduse_mgmtdev, > + .id_table = id_table, > + .ops = &vdpa_dev_mgmtdev_ops, > +}; > + > +static int vduse_mgmtdev_init(void) > +{ > + int ret; > + > + ret = device_register(&vduse_mgmtdev); > + if (ret) > + return ret; > + > + ret = vdpa_mgmtdev_register(&mgmt_dev); > + if (ret) > + goto err; > + > + return 0; > +err: > + device_unregister(&vduse_mgmtdev); > + return ret; > +} > + > +static void vduse_mgmtdev_exit(void) > +{ > + vdpa_mgmtdev_unregister(&mgmt_dev); > + device_unregister(&vduse_mgmtdev); > +} > + > +static int vduse_init(void) > +{ > + int ret; > + struct device *dev; > + > + vduse_class = class_create(THIS_MODULE, "vduse"); > + if (IS_ERR(vduse_class)) > + return PTR_ERR(vduse_class); > + > + vduse_class->devnode = vduse_devnode; > + > + ret = alloc_chrdev_region(&vduse_major, 0, VDUSE_DEV_MAX, "vduse"); > + if (ret) > + goto err_chardev_region; > + > + /* /dev/vduse/control */ > + cdev_init(&vduse_ctrl_cdev, &vduse_ctrl_fops); > + vduse_ctrl_cdev.owner = THIS_MODULE; > + ret = cdev_add(&vduse_ctrl_cdev, vduse_major, 1); > + if (ret) > + goto err_ctrl_cdev; > + > + dev = device_create(vduse_class, NULL, vduse_major, NULL, "control"); > + if (IS_ERR(dev)) { > + ret = PTR_ERR(dev); > + goto err_device; > + } > + > + /* /dev/vduse/$DEVICE */ > + cdev_init(&vduse_cdev, &vduse_dev_fops); > + vduse_cdev.owner = THIS_MODULE; > + ret = cdev_add(&vduse_cdev, MKDEV(MAJOR(vduse_major), 1), > + VDUSE_DEV_MAX - 1); > + if (ret) > + goto err_cdev; > + > + vduse_irq_wq = alloc_workqueue("vduse-irq", > + WQ_HIGHPRI | WQ_SYSFS | WQ_UNBOUND, 0); > + if (!vduse_irq_wq) > + goto err_wq; > + > + ret = vduse_domain_init(); > + if (ret) > + goto err_domain; > + > + ret = vduse_mgmtdev_init(); > + if (ret) > + goto err_mgmtdev; > + > + return 0; > +err_mgmtdev: > + vduse_domain_exit(); > +err_domain: > + destroy_workqueue(vduse_irq_wq); > +err_wq: > + cdev_del(&vduse_cdev); > +err_cdev: > + device_destroy(vduse_class, vduse_major); > +err_device: > + cdev_del(&vduse_ctrl_cdev); > +err_ctrl_cdev: > + unregister_chrdev_region(vduse_major, VDUSE_DEV_MAX); > +err_chardev_region: > + class_destroy(vduse_class); > + return ret; > +} > +module_init(vduse_init); > + > +static void vduse_exit(void) > +{ > + vduse_mgmtdev_exit(); > + vduse_domain_exit(); > + destroy_workqueue(vduse_irq_wq); > + cdev_del(&vduse_cdev); > + device_destroy(vduse_class, vduse_major); > + cdev_del(&vduse_ctrl_cdev); > + unregister_chrdev_region(vduse_major, VDUSE_DEV_MAX); > + class_destroy(vduse_class); > +} > +module_exit(vduse_exit); > + > +MODULE_LICENSE(DRV_LICENSE); > +MODULE_AUTHOR(DRV_AUTHOR); > +MODULE_DESCRIPTION(DRV_DESC); > diff --git a/include/uapi/linux/vduse.h b/include/uapi/linux/vduse.h > new file mode 100644 > index 000000000000..f21b2e51b5c8 > --- /dev/null > +++ b/include/uapi/linux/vduse.h > @@ -0,0 +1,143 @@ > +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ > +#ifndef _UAPI_VDUSE_H_ > +#define _UAPI_VDUSE_H_ > + > +#include > + > +#define VDUSE_API_VERSION 0 > + > +#define VDUSE_NAME_MAX 256 > + > +/* the control messages definition for read/write */ > + > +enum vduse_req_type { > + /* Get the state for virtqueue from userspace */ > + VDUSE_GET_VQ_STATE, > + /* Notify userspace to start the dataplane, no reply */ > + VDUSE_START_DATAPLANE, > + /* Notify userspace to stop the dataplane, no reply */ > + VDUSE_STOP_DATAPLANE, > + /* Notify userspace to update the memory mapping in device IOTLB */ > + VDUSE_UPDATE_IOTLB, > +}; > + > +struct vduse_vq_state { > + __u32 index; /* virtqueue index */ > + __u32 avail_idx; /* virtqueue state (last_avail_idx) */ > +}; This needs some tweaks to support packed virtqueue. > + > +struct vduse_iova_range { > + __u64 start; /* start of the IOVA range */ > + __u64 last; /* end of the IOVA range */ > +}; > + > +struct vduse_dev_request { > + __u32 type; /* request type */ > + __u32 request_id; /* request id */ > +#define VDUSE_REQ_FLAGS_NO_REPLY (1 << 0) /* No need to reply */ > + __u32 flags; /* request flags */ > + __u32 reserved; /* for future use */ > + union { > + struct vduse_vq_state vq_state; /* virtqueue state */ > + struct vduse_iova_range iova; /* iova range for updating */ > + __u32 padding[16]; /* padding */ > + }; > +}; > + > +struct vduse_dev_response { > + __u32 request_id; /* corresponding request id */ > +#define VDUSE_REQ_RESULT_OK 0x00 > +#define VDUSE_REQ_RESULT_FAILED 0x01 > + __u32 result; /* the result of request */ > + __u32 reserved[2]; /* for future use */ > + union { > + struct vduse_vq_state vq_state; /* virtqueue state */ > + __u32 padding[16]; /* padding */ > + }; > +}; > + > +/* ioctls */ > + > +struct vduse_dev_config { > + char name[VDUSE_NAME_MAX]; /* vduse device name */ > + __u32 vendor_id; /* virtio vendor id */ > + __u32 device_id; /* virtio device id */ > + __u64 features; /* device features */ > + __u64 bounce_size; /* bounce buffer size for iommu */ > + __u16 vq_size_max; /* the max size of virtqueue */ > + __u16 padding; /* padding */ > + __u32 vq_num; /* the number of virtqueues */ > + __u32 vq_align; /* the allocation alignment of virtqueue's metadata */ > + __u32 config_size; /* the size of the configuration space */ > + __u32 reserved[15]; /* for future use */ > + __u8 config[0]; /* the buffer of the configuration space */ > +}; > + > +struct vduse_iotlb_entry { > + __u64 offset; /* the mmap offset on fd */ > + __u64 start; /* start of the IOVA range */ > + __u64 last; /* last of the IOVA range */ > +#define VDUSE_ACCESS_RO 0x1 > +#define VDUSE_ACCESS_WO 0x2 > +#define VDUSE_ACCESS_RW 0x3 > + __u8 perm; /* access permission of this range */ > +}; > + > +struct vduse_config_update { > + __u32 offset; /* offset from the beginning of configuration space */ > + __u32 length; /* the length to write to configuration space */ > + __u8 buffer[0]; /* buffer used to write from */ > +}; > + > +struct vduse_vq_info { > + __u32 index; /* virtqueue index */ > + __u32 avail_idx; /* virtqueue state (last_avail_idx) */ > + __u64 desc_addr; /* address of desc area */ > + __u64 driver_addr; /* address of driver area */ > + __u64 device_addr; /* address of device area */ > + __u32 num; /* the size of virtqueue */ > + __u8 ready; /* ready status of virtqueue */ > +}; > + > +struct vduse_vq_eventfd { > + __u32 index; /* virtqueue index */ > +#define VDUSE_EVENTFD_DEASSIGN -1 > + int fd; /* eventfd, -1 means de-assigning the eventfd */ > +}; > + > +#define VDUSE_BASE 0x81 > + > +/* Get the version of VDUSE API. This is used for future extension */ > +#define VDUSE_GET_API_VERSION _IOR(VDUSE_BASE, 0x00, __u64) > + > +/* Set the version of VDUSE API. */ > +#define VDUSE_SET_API_VERSION _IOW(VDUSE_BASE, 0x01, __u64) > + > +/* Create a vduse device which is represented by a char device (/dev/vduse/) */ > +#define VDUSE_CREATE_DEV _IOW(VDUSE_BASE, 0x02, struct vduse_dev_config) > + > +/* Destroy a vduse device. Make sure there are no references to the char device */ > +#define VDUSE_DESTROY_DEV _IOW(VDUSE_BASE, 0x03, char[VDUSE_NAME_MAX]) > + > +/* > + * Get a file descriptor for the first overlapped iova region, > + * -EINVAL means the iova region doesn't exist. > + */ > +#define VDUSE_IOTLB_GET_FD _IOWR(VDUSE_BASE, 0x04, struct vduse_iotlb_entry) > + > +/* Get the negotiated features */ > +#define VDUSE_DEV_GET_FEATURES _IOR(VDUSE_BASE, 0x05, __u64) > + > +/* Update the configuration space */ > +#define VDUSE_DEV_UPDATE_CONFIG _IOW(VDUSE_BASE, 0x06, struct vduse_config_update) > + > +/* Get the specified virtqueue's information */ > +#define VDUSE_VQ_GET_INFO _IOWR(VDUSE_BASE, 0x07, struct vduse_vq_info) > + > +/* Setup an eventfd to receive kick for virtqueue */ > +#define VDUSE_VQ_SETUP_KICKFD _IOW(VDUSE_BASE, 0x08, struct vduse_vq_eventfd) > + > +/* Inject an interrupt for specific virtqueue */ > +#define VDUSE_VQ_INJECT_IRQ _IOW(VDUSE_BASE, 0x09, __u32) > + > +#endif /* _UAPI_VDUSE_H_ */ 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=-15.1 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS,URIBL_RED, USER_AGENT_SANE_1 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 BCC57C48BE5 for ; Mon, 21 Jun 2021 09:14:20 +0000 (UTC) Received: from smtp2.osuosl.org (smtp2.osuosl.org [140.211.166.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 5CC166109E for ; Mon, 21 Jun 2021 09:14:20 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 5CC166109E Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=iommu-bounces@lists.linux-foundation.org Received: from localhost (localhost [127.0.0.1]) by smtp2.osuosl.org (Postfix) with ESMTP id 1FCE3400A9; Mon, 21 Jun 2021 09:14:20 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp2.osuosl.org ([127.0.0.1]) by localhost (smtp2.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id PjAjUqyIt3Up; Mon, 21 Jun 2021 09:14:18 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by smtp2.osuosl.org (Postfix) with ESMTPS id 9938840022; Mon, 21 Jun 2021 09:14:17 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 53222C0010; Mon, 21 Jun 2021 09:14:17 +0000 (UTC) Received: from smtp1.osuosl.org (smtp1.osuosl.org [IPv6:2605:bc80:3010::138]) by lists.linuxfoundation.org (Postfix) with ESMTP id 71E93C000C for ; Mon, 21 Jun 2021 09:14:16 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp1.osuosl.org (Postfix) with ESMTP id 47DF183026 for ; Mon, 21 Jun 2021 09:14:16 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Authentication-Results: smtp1.osuosl.org (amavisd-new); dkim=pass (1024-bit key) header.d=redhat.com Received: from smtp1.osuosl.org ([127.0.0.1]) by localhost (smtp1.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id CEVdhqzr8n0x for ; Mon, 21 Jun 2021 09:14:13 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.8.0 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by smtp1.osuosl.org (Postfix) with ESMTPS id 715CD8301F for ; Mon, 21 Jun 2021 09:14:13 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1624266851; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=Tt7yo2RvlMhoUkpaMWxyjOZFsanqqyuVLb80GWGQKSo=; b=dXlphZEUByJglmzr2fvD/56wLNoC98l38KCjOuHmkC8ubLpKFyxwqj0eMUdv7wQ6pXWvE6 KhBSTNECDJCOas6rJENrHL02Wwafhofa+RhirJAfAn6/g60MvP0EsHTWs4VpOIWFg6qw6i 1sGBW3LcP1YmRJw2xnTEa+9KlClJXig= Received: from mail-pj1-f72.google.com (mail-pj1-f72.google.com [209.85.216.72]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-226-Q8qVIC05NnG_-B6e4iAIeg-1; Mon, 21 Jun 2021 05:14:09 -0400 X-MC-Unique: Q8qVIC05NnG_-B6e4iAIeg-1 Received: by mail-pj1-f72.google.com with SMTP id 15-20020a17090a0f0fb029016ad0f32fd0so3201443pjy.6 for ; Mon, 21 Jun 2021 02:14:09 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-transfer-encoding :content-language; bh=Tt7yo2RvlMhoUkpaMWxyjOZFsanqqyuVLb80GWGQKSo=; b=KyfJQ6JvKce990AfhEV3tl+1nwfGQecbkzmfs0ezTaypdDECpsRWhAbssyhHqAsJrj KLs3V/TIBEWmX3pc3nwnUev3rKxkSayGZpK16OEBDTffM5ibuqc4obg5K7QyPQKHLVTv ERLrNwuwwXV/aKb3KvZNycw1NWHuAz4G0w/lYIJW+p++kYWcbMk9l6SwkVA8SOOkzciF 9ZVB8ajublpkGHZRFa7HdSAkCI762EQG0QKrknKW5eTGp/cpfEMJ93fzBzahkk7uNs4B cjotQYstc4ugALYkQ9ay8+L5MqFhYMKstzc0VN56hcHrlb9tmC+E8jYPFdd2plV9zW4p Fdzw== X-Gm-Message-State: AOAM532lbT1qYSjYJZTlpY/e4fN4KeVhiqmlU0gvP9A+RYPSl4euTsJm FZw1R9Leh6nhlWMfzEcGd4u12pe09Q56KqXRy7E4cgGetjQ/9YBmgUsoFFnuXvoGV4jpyNLaaYY w7BdgYIG2q9rx5tmVojD3idmiYEGkFg== X-Received: by 2002:a17:90a:e606:: with SMTP id j6mr20491679pjy.230.1624266848491; Mon, 21 Jun 2021 02:14:08 -0700 (PDT) X-Google-Smtp-Source: ABdhPJx760A/hTM9EzlHk6g1tGJ/qdpSIJzoPD2qafIY56u0RfGUdMjcnsBf7nOS0VHd+bGYuxc98w== X-Received: by 2002:a17:90a:e606:: with SMTP id j6mr20491630pjy.230.1624266847951; Mon, 21 Jun 2021 02:14:07 -0700 (PDT) Received: from wangxiaodeMacBook-Air.local ([209.132.188.80]) by smtp.gmail.com with ESMTPSA id n12sm5354590pfu.5.2021.06.21.02.14.00 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 21 Jun 2021 02:14:07 -0700 (PDT) Subject: Re: [PATCH v8 09/10] vduse: Introduce VDUSE - vDPA Device in Userspace To: Xie Yongji , mst@redhat.com, stefanha@redhat.com, sgarzare@redhat.com, parav@nvidia.com, hch@infradead.org, christian.brauner@canonical.com, rdunlap@infradead.org, willy@infradead.org, viro@zeniv.linux.org.uk, axboe@kernel.dk, bcrl@kvack.org, corbet@lwn.net, mika.penttila@nextfour.com, dan.carpenter@oracle.com, joro@8bytes.org, gregkh@linuxfoundation.org References: <20210615141331.407-1-xieyongji@bytedance.com> <20210615141331.407-10-xieyongji@bytedance.com> From: Jason Wang Message-ID: Date: Mon, 21 Jun 2021 17:13:55 +0800 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0) Gecko/20100101 Thunderbird/78.11.0 MIME-Version: 1.0 In-Reply-To: <20210615141331.407-10-xieyongji@bytedance.com> Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=jasowang@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Language: en-US Cc: kvm@vger.kernel.org, netdev@vger.kernel.org, linux-kernel@vger.kernel.org, virtualization@lists.linux-foundation.org, iommu@lists.linux-foundation.org, songmuchun@bytedance.com, linux-fsdevel@vger.kernel.org X-BeenThere: iommu@lists.linux-foundation.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Development issues for Linux IOMMU support List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="gbk"; Format="flowed" Errors-To: iommu-bounces@lists.linux-foundation.org Sender: "iommu" CtTaIDIwMjEvNi8xNSDPws7nMTA6MTMsIFhpZSBZb25namkg0LS1wDoKPiBUaGlzIFZEVVNFIGRy aXZlciBlbmFibGVzIGltcGxlbWVudGluZyB2RFBBIGRldmljZXMgaW4gdXNlcnNwYWNlLgo+IFRo ZSB2RFBBIGRldmljZSdzIGNvbnRyb2wgcGF0aCBpcyBoYW5kbGVkIGluIGtlcm5lbCBhbmQgdGhl IGRhdGEKPiBwYXRoIGlzIGhhbmRsZWQgaW4gdXNlcnNwYWNlLgo+Cj4gQSBtZXNzYWdlIG1lY2hu aXNtIGlzIHVzZWQgYnkgVkRVU0UgZHJpdmVyIHRvIGZvcndhcmQgc29tZSBjb250cm9sCj4gbWVz c2FnZXMgc3VjaCBhcyBzdGFydGluZy9zdG9wcGluZyBkYXRhcGF0aCB0byB1c2Vyc3BhY2UuIFVz ZXJzcGFjZQo+IGNhbiB1c2UgcmVhZCgpL3dyaXRlKCkgdG8gcmVjZWl2ZS9yZXBseSB0aG9zZSBj b250cm9sIG1lc3NhZ2VzLgo+Cj4gQW5kIHNvbWUgaW9jdGxzIGFyZSBpbnRyb2R1Y2VkIHRvIGhl bHAgdXNlcnNwYWNlIHRvIGltcGxlbWVudCB0aGUKPiBkYXRhIHBhdGguIFZEVVNFX0lPVExCX0dF VF9GRCBpb2N0bCBjYW4gYmUgdXNlZCB0byBnZXQgdGhlIGZpbGUKPiBkZXNjcmlwdG9ycyByZWZl cnJpbmcgdG8gdkRQQSBkZXZpY2UncyBpb3ZhIHJlZ2lvbnMuIFRoZW4gdXNlcnNwYWNlCj4gY2Fu IHVzZSBtbWFwKCkgdG8gYWNjZXNzIHRob3NlIGlvdmEgcmVnaW9ucy4gVkRVU0VfREVWX0dFVF9G RUFUVVJFUwo+IGFuZCBWRFVTRV9WUV9HRVRfSU5GTyBpb2N0bHMgYXJlIHVzZWQgdG8gZ2V0IHRo ZSBuZWdvdGlhdGVkIGZlYXR1cmVzCj4gYW5kIG1ldGFkYXRhIG9mIHZpcnRxdWV1ZXMuIFZEVVNF X0lOSkVDVF9WUV9JUlEgYW5kIFZEVVNFX1ZRX1NFVFVQX0tJQ0tGRAo+IGlvY3RscyBjYW4gYmUg dXNlZCB0byBpbmplY3QgaW50ZXJydXB0IGFuZCBzZXR1cCB0aGUga2lja2ZkIGZvcgo+IHZpcnRx dWV1ZXMuIFZEVVNFX0RFVl9VUERBVEVfQ09ORklHIGlvY3RsIGlzIHVzZWQgdG8gdXBkYXRlIHRo ZQo+IGNvbmZpZ3VyYXRpb24gc3BhY2UgYW5kIGluamVjdCBhIGNvbmZpZyBpbnRlcnJ1cHQuCj4K PiBTaWduZWQtb2ZmLWJ5OiBYaWUgWW9uZ2ppIDx4aWV5b25namlAYnl0ZWRhbmNlLmNvbT4KPiAt LS0KPiAgIERvY3VtZW50YXRpb24vdXNlcnNwYWNlLWFwaS9pb2N0bC9pb2N0bC1udW1iZXIucnN0 IHwgICAgMSArCj4gICBkcml2ZXJzL3ZkcGEvS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB8ICAgMTAgKwo+ICAgZHJpdmVycy92ZHBhL01ha2VmaWxlICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgfCAgICAxICsKPiAgIGRyaXZlcnMvdmRwYS92ZHBhX3VzZXIvTWFrZWZp bGUgICAgICAgICAgICAgICAgICAgIHwgICAgNSArCj4gICBkcml2ZXJzL3ZkcGEvdmRwYV91c2Vy L3ZkdXNlX2Rldi5jICAgICAgICAgICAgICAgICB8IDE0NTMgKysrKysrKysrKysrKysrKysrKysK PiAgIGluY2x1ZGUvdWFwaS9saW51eC92ZHVzZS5oICAgICAgICAgICAgICAgICAgICAgICAgIHwg IDE0MyArKwo+ICAgNiBmaWxlcyBjaGFuZ2VkLCAxNjEzIGluc2VydGlvbnMoKykKPiAgIGNyZWF0 ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3ZkcGEvdmRwYV91c2VyL01ha2VmaWxlCj4gICBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy92ZHBhL3ZkcGFfdXNlci92ZHVzZV9kZXYuYwo+ICAgY3JlYXRl IG1vZGUgMTAwNjQ0IGluY2x1ZGUvdWFwaS9saW51eC92ZHVzZS5oCj4KPiBkaWZmIC0tZ2l0IGEv RG9jdW1lbnRhdGlvbi91c2Vyc3BhY2UtYXBpL2lvY3RsL2lvY3RsLW51bWJlci5yc3QgYi9Eb2N1 bWVudGF0aW9uL3VzZXJzcGFjZS1hcGkvaW9jdGwvaW9jdGwtbnVtYmVyLnJzdAo+IGluZGV4IDli ZmMyYjUxMGM2NC4uYWNkOTVlOWRjZmU3IDEwMDY0NAo+IC0tLSBhL0RvY3VtZW50YXRpb24vdXNl cnNwYWNlLWFwaS9pb2N0bC9pb2N0bC1udW1iZXIucnN0Cj4gKysrIGIvRG9jdW1lbnRhdGlvbi91 c2Vyc3BhY2UtYXBpL2lvY3RsL2lvY3RsLW51bWJlci5yc3QKPiBAQCAtMzAwLDYgKzMwMCw3IEBA IENvZGUgIFNlcSMgICAgSW5jbHVkZSBGaWxlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIENvbW1lbnRzCj4gICAneicgICAxMC00RiAgZHJpdmVycy9zMzkwL2NyeXB0 by96Y3J5cHRfYXBpLmggICAgICAgICAgICAgICAgICAgICAgICBjb25mbGljdCEKPiAgICd8JyAg IDAwLTdGICBsaW51eC9tZWRpYS5oCj4gICAweDgwICAwMC0xRiAgbGludXgvZmIuaAo+ICsweDgx ICAwMC0xRiAgbGludXgvdmR1c2UuaAo+ICAgMHg4OSAgMDAtMDYgIGFyY2gveDg2L2luY2x1ZGUv YXNtL3NvY2tpb3MuaAo+ICAgMHg4OSAgMEItREYgIGxpbnV4L3NvY2tpb3MuaAo+ICAgMHg4OSAg RTAtRUYgIGxpbnV4L3NvY2tpb3MuaCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgU0lPQ1BST1RPUFJJVkFURSByYW5nZQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3ZkcGEv S2NvbmZpZyBiL2RyaXZlcnMvdmRwYS9LY29uZmlnCj4gaW5kZXggYTUwM2MxYjJiZmQ5Li42ZTIz YmNlNjQzM2EgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy92ZHBhL0tjb25maWcKPiArKysgYi9kcml2 ZXJzL3ZkcGEvS2NvbmZpZwo+IEBAIC0zMyw2ICszMywxNiBAQCBjb25maWcgVkRQQV9TSU1fQkxP Q0sKPiAgIAkgIHZEUEEgYmxvY2sgZGV2aWNlIHNpbXVsYXRvciB3aGljaCB0ZXJtaW5hdGVzIElP IHJlcXVlc3QgaW4gYQo+ICAgCSAgbWVtb3J5IGJ1ZmZlci4KPiAgIAo+ICtjb25maWcgVkRQQV9V U0VSCj4gKwl0cmlzdGF0ZSAiVkRVU0UgKHZEUEEgRGV2aWNlIGluIFVzZXJzcGFjZSkgc3VwcG9y dCIKPiArCWRlcGVuZHMgb24gRVZFTlRGRCAmJiBNTVUgJiYgSEFTX0RNQQo+ICsJc2VsZWN0IERN QV9PUFMKPiArCXNlbGVjdCBWSE9TVF9JT1RMQgo+ICsJc2VsZWN0IElPTU1VX0lPVkEKPiArCWhl bHAKPiArCSAgV2l0aCBWRFVTRSBpdCBpcyBwb3NzaWJsZSB0byBlbXVsYXRlIGEgdkRQQSBEZXZp Y2UKPiArCSAgaW4gYSB1c2Vyc3BhY2UgcHJvZ3JhbS4KPiArCj4gICBjb25maWcgSUZDVkYKPiAg IAl0cmlzdGF0ZSAiSW50ZWwgSUZDIFZGIHZEUEEgZHJpdmVyIgo+ICAgCWRlcGVuZHMgb24gUENJ X01TSQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3ZkcGEvTWFrZWZpbGUgYi9kcml2ZXJzL3ZkcGEv TWFrZWZpbGUKPiBpbmRleCA2N2ZlN2YzZDY5NDMuLmYwMmViZWQzM2YxOSAxMDA2NDQKPiAtLS0g YS9kcml2ZXJzL3ZkcGEvTWFrZWZpbGUKPiArKysgYi9kcml2ZXJzL3ZkcGEvTWFrZWZpbGUKPiBA QCAtMSw2ICsxLDcgQEAKPiAgICMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKPiAg IG9iai0kKENPTkZJR19WRFBBKSArPSB2ZHBhLm8KPiAgIG9iai0kKENPTkZJR19WRFBBX1NJTSkg Kz0gdmRwYV9zaW0vCj4gK29iai0kKENPTkZJR19WRFBBX1VTRVIpICs9IHZkcGFfdXNlci8KPiAg IG9iai0kKENPTkZJR19JRkNWRikgICAgKz0gaWZjdmYvCj4gICBvYmotJChDT05GSUdfTUxYNV9W RFBBKSArPSBtbHg1Lwo+ICAgb2JqLSQoQ09ORklHX1ZQX1ZEUEEpICAgICs9IHZpcnRpb19wY2kv Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmRwYS92ZHBhX3VzZXIvTWFrZWZpbGUgYi9kcml2ZXJz L3ZkcGEvdmRwYV91c2VyL01ha2VmaWxlCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAw MDAwMDAwMDAwMDAuLjI2MGUwYjI2YWY5OQo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJz L3ZkcGEvdmRwYV91c2VyL01ha2VmaWxlCj4gQEAgLTAsMCArMSw1IEBACj4gKyMgU1BEWC1MaWNl bnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKPiArCj4gK3ZkdXNlLXkgOj0gdmR1c2VfZGV2Lm8gaW92 YV9kb21haW4ubwo+ICsKPiArb2JqLSQoQ09ORklHX1ZEUEFfVVNFUikgKz0gdmR1c2Uubwo+IGRp ZmYgLS1naXQgYS9kcml2ZXJzL3ZkcGEvdmRwYV91c2VyL3ZkdXNlX2Rldi5jIGIvZHJpdmVycy92 ZHBhL3ZkcGFfdXNlci92ZHVzZV9kZXYuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXgg MDAwMDAwMDAwMDAwLi41MjcxY2JkMTVlMjgKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJpdmVy cy92ZHBhL3ZkcGFfdXNlci92ZHVzZV9kZXYuYwo+IEBAIC0wLDAgKzEsMTQ1MyBAQAo+ICsvLyBT UERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5Cj4gKy8qCj4gKyAqIFZEVVNFOiB2 RFBBIERldmljZSBpbiBVc2Vyc3BhY2UKPiArICoKPiArICogQ29weXJpZ2h0IChDKSAyMDIwLTIw MjEgQnl0ZWRhbmNlIEluYy4gYW5kL29yIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2Vy dmVkLgo+ICsgKgo+ICsgKiBBdXRob3I6IFhpZSBZb25namkgPHhpZXlvbmdqaUBieXRlZGFuY2Uu Y29tPgo+ICsgKgo+ICsgKi8KPiArCj4gKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+Cj4gKyNpbmNs dWRlIDxsaW51eC9tb2R1bGUuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2NkZXYuaD4KPiArI2luY2x1 ZGUgPGxpbnV4L2RldmljZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvZXZlbnRmZC5oPgo+ICsjaW5j bHVkZSA8bGludXgvc2xhYi5oPgo+ICsjaW5jbHVkZSA8bGludXgvd2FpdC5oPgo+ICsjaW5jbHVk ZSA8bGludXgvZG1hLW1hcC1vcHMuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3BvbGwuaD4KPiArI2lu Y2x1ZGUgPGxpbnV4L2ZpbGUuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3Vpby5oPgo+ICsjaW5jbHVk ZSA8bGludXgvdmRwYS5oPgo+ICsjaW5jbHVkZSA8bGludXgvbm9zcGVjLmg+Cj4gKyNpbmNsdWRl IDx1YXBpL2xpbnV4L3ZkdXNlLmg+Cj4gKyNpbmNsdWRlIDx1YXBpL2xpbnV4L3ZkcGEuaD4KPiAr I2luY2x1ZGUgPHVhcGkvbGludXgvdmlydGlvX2NvbmZpZy5oPgo+ICsjaW5jbHVkZSA8dWFwaS9s aW51eC92aXJ0aW9faWRzLmg+Cj4gKyNpbmNsdWRlIDx1YXBpL2xpbnV4L3ZpcnRpb19ibGsuaD4K PiArI2luY2x1ZGUgPGxpbnV4L21vZF9kZXZpY2V0YWJsZS5oPgo+ICsKPiArI2luY2x1ZGUgImlv dmFfZG9tYWluLmgiCj4gKwo+ICsjZGVmaW5lIERSVl9BVVRIT1IgICAiWW9uZ2ppIFhpZSA8eGll eW9uZ2ppQGJ5dGVkYW5jZS5jb20+Igo+ICsjZGVmaW5lIERSVl9ERVNDICAgICAidkRQQSBEZXZp Y2UgaW4gVXNlcnNwYWNlIgo+ICsjZGVmaW5lIERSVl9MSUNFTlNFICAiR1BMIHYyIgo+ICsKPiAr I2RlZmluZSBWRFVTRV9ERVZfTUFYICgxVSA8PCBNSU5PUkJJVFMpCj4gKyNkZWZpbmUgVkRVU0Vf TUFYX0JPVU5DRV9TSVpFICg2NCAqIDEwMjQgKiAxMDI0KQo+ICsjZGVmaW5lIFZEVVNFX0lPVkFf U0laRSAoMTI4ICogMTAyNCAqIDEwMjQpCj4gKyNkZWZpbmUgVkRVU0VfUkVRVUVTVF9USU1FT1VU IDMwCj4gKwo+ICtzdHJ1Y3QgdmR1c2VfdmlydHF1ZXVlIHsKPiArCXUxNiBpbmRleDsKPiArCXUz MiBudW07Cj4gKwl1MzIgYXZhaWxfaWR4Owo+ICsJdTY0IGRlc2NfYWRkcjsKPiArCXU2NCBkcml2 ZXJfYWRkcjsKPiArCXU2NCBkZXZpY2VfYWRkcjsKPiArCWJvb2wgcmVhZHk7Cj4gKwlib29sIGtp Y2tlZDsKPiArCXNwaW5sb2NrX3Qga2lja19sb2NrOwo+ICsJc3BpbmxvY2tfdCBpcnFfbG9jazsK PiArCXN0cnVjdCBldmVudGZkX2N0eCAqa2lja2ZkOwo+ICsJc3RydWN0IHZkcGFfY2FsbGJhY2sg Y2I7Cj4gKwlzdHJ1Y3Qgd29ya19zdHJ1Y3QgaW5qZWN0Owo+ICt9Owo+ICsKPiArc3RydWN0IHZk dXNlX2RldjsKPiArCj4gK3N0cnVjdCB2ZHVzZV92ZHBhIHsKPiArCXN0cnVjdCB2ZHBhX2Rldmlj ZSB2ZHBhOwo+ICsJc3RydWN0IHZkdXNlX2RldiAqZGV2Owo+ICt9Owo+ICsKPiArc3RydWN0IHZk dXNlX2RldiB7Cj4gKwlzdHJ1Y3QgdmR1c2VfdmRwYSAqdmRldjsKPiArCXN0cnVjdCBkZXZpY2Ug KmRldjsKPiArCXN0cnVjdCB2ZHVzZV92aXJ0cXVldWUgKnZxczsKPiArCXN0cnVjdCB2ZHVzZV9p b3ZhX2RvbWFpbiAqZG9tYWluOwo+ICsJY2hhciAqbmFtZTsKPiArCXN0cnVjdCBtdXRleCBsb2Nr Owo+ICsJc3BpbmxvY2tfdCBtc2dfbG9jazsKPiArCXU2NCBtc2dfdW5pcXVlOwo+ICsJd2FpdF9x dWV1ZV9oZWFkX3Qgd2FpdHE7Cj4gKwlzdHJ1Y3QgbGlzdF9oZWFkIHNlbmRfbGlzdDsKPiArCXN0 cnVjdCBsaXN0X2hlYWQgcmVjdl9saXN0Owo+ICsJc3RydWN0IHZkcGFfY2FsbGJhY2sgY29uZmln X2NiOwo+ICsJc3RydWN0IHdvcmtfc3RydWN0IGluamVjdDsKPiArCXNwaW5sb2NrX3QgaXJxX2xv Y2s7Cj4gKwlpbnQgbWlub3I7Cj4gKwlib29sIGNvbm5lY3RlZDsKPiArCWJvb2wgc3RhcnRlZDsK PiArCXU2NCBhcGlfdmVyc2lvbjsKPiArCXU2NCB1c2VyX2ZlYXR1cmVzOwoKCkxldCdzIHVzZSBk ZXZpY2VfZmVhdHVyZXMuCgoKPiArCXU2NCBmZWF0dXJlczsKCgpBbmQgZHJpdmVyIGZlYXR1cmVz LgoKCj4gKwl1MzIgZGV2aWNlX2lkOwo+ICsJdTMyIHZlbmRvcl9pZDsKPiArCXUzMiBnZW5lcmF0 aW9uOwo+ICsJdTMyIGNvbmZpZ19zaXplOwo+ICsJdm9pZCAqY29uZmlnOwo+ICsJdTggc3RhdHVz Owo+ICsJdTE2IHZxX3NpemVfbWF4Owo+ICsJdTMyIHZxX251bTsKPiArCXUzMiB2cV9hbGlnbjsK PiArfTsKPiArCj4gK3N0cnVjdCB2ZHVzZV9kZXZfbXNnIHsKPiArCXN0cnVjdCB2ZHVzZV9kZXZf cmVxdWVzdCByZXE7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2X3Jlc3BvbnNlIHJlc3A7Cj4gKwlzdHJ1 Y3QgbGlzdF9oZWFkIGxpc3Q7Cj4gKwl3YWl0X3F1ZXVlX2hlYWRfdCB3YWl0cTsKPiArCWJvb2wg Y29tcGxldGVkOwo+ICt9Owo+ICsKPiArc3RydWN0IHZkdXNlX2NvbnRyb2wgewo+ICsJdTY0IGFw aV92ZXJzaW9uOwo+ICt9Owo+ICsKPiArc3RhdGljIERFRklORV9NVVRFWCh2ZHVzZV9sb2NrKTsK PiArc3RhdGljIERFRklORV9JRFIodmR1c2VfaWRyKTsKPiArCj4gK3N0YXRpYyBkZXZfdCB2ZHVz ZV9tYWpvcjsKPiArc3RhdGljIHN0cnVjdCBjbGFzcyAqdmR1c2VfY2xhc3M7Cj4gK3N0YXRpYyBz dHJ1Y3QgY2RldiB2ZHVzZV9jdHJsX2NkZXY7Cj4gK3N0YXRpYyBzdHJ1Y3QgY2RldiB2ZHVzZV9j ZGV2Owo+ICtzdGF0aWMgc3RydWN0IHdvcmtxdWV1ZV9zdHJ1Y3QgKnZkdXNlX2lycV93cTsKPiAr Cj4gK3N0YXRpYyB1MzIgYWxsb3dlZF9kZXZpY2VfaWRbXSA9IHsKPiArCVZJUlRJT19JRF9CTE9D SywKPiArfTsKPiArCj4gK3N0YXRpYyBpbmxpbmUgc3RydWN0IHZkdXNlX2RldiAqdmRwYV90b192 ZHVzZShzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV92ZHBh ICp2ZGV2ID0gY29udGFpbmVyX29mKHZkcGEsIHN0cnVjdCB2ZHVzZV92ZHBhLCB2ZHBhKTsKPiAr Cj4gKwlyZXR1cm4gdmRldi0+ZGV2Owo+ICt9Cj4gKwo+ICtzdGF0aWMgaW5saW5lIHN0cnVjdCB2 ZHVzZV9kZXYgKmRldl90b192ZHVzZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gK3sKPiArCXN0cnVj dCB2ZHBhX2RldmljZSAqdmRwYSA9IGRldl90b192ZHBhKGRldik7Cj4gKwo+ICsJcmV0dXJuIHZk cGFfdG9fdmR1c2UodmRwYSk7Cj4gK30KPiArCj4gK3N0YXRpYyBzdHJ1Y3QgdmR1c2VfZGV2X21z ZyAqdmR1c2VfZmluZF9tc2coc3RydWN0IGxpc3RfaGVhZCAqaGVhZCwKPiArCQkJCQkgICAgdWlu dDMyX3QgcmVxdWVzdF9pZCkKPiArewo+ICsJc3RydWN0IHZkdXNlX2Rldl9tc2cgKm1zZzsKPiAr Cj4gKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KG1zZywgaGVhZCwgbGlzdCkgewo+ICsJCWlmIChtc2ct PnJlcS5yZXF1ZXN0X2lkID09IHJlcXVlc3RfaWQpIHsKPiArCQkJbGlzdF9kZWwoJm1zZy0+bGlz dCk7Cj4gKwkJCXJldHVybiBtc2c7Cj4gKwkJfQo+ICsJfQo+ICsKPiArCXJldHVybiBOVUxMOwo+ ICt9Cj4gKwo+ICtzdGF0aWMgc3RydWN0IHZkdXNlX2Rldl9tc2cgKnZkdXNlX2RlcXVldWVfbXNn KHN0cnVjdCBsaXN0X2hlYWQgKmhlYWQpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXZfbXNnICpt c2cgPSBOVUxMOwo+ICsKPiArCWlmICghbGlzdF9lbXB0eShoZWFkKSkgewo+ICsJCW1zZyA9IGxp c3RfZmlyc3RfZW50cnkoaGVhZCwgc3RydWN0IHZkdXNlX2Rldl9tc2csIGxpc3QpOwo+ICsJCWxp c3RfZGVsKCZtc2ctPmxpc3QpOwo+ICsJfQo+ICsKPiArCXJldHVybiBtc2c7Cj4gK30KPiArCj4g K3N0YXRpYyB2b2lkIHZkdXNlX2VucXVldWVfbXNnKHN0cnVjdCBsaXN0X2hlYWQgKmhlYWQsCj4g KwkJCSAgICAgIHN0cnVjdCB2ZHVzZV9kZXZfbXNnICptc2cpCj4gK3sKPiArCWxpc3RfYWRkX3Rh aWwoJm1zZy0+bGlzdCwgaGVhZCk7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgdmR1c2VfZGV2X21z Z19zZW5kKHN0cnVjdCB2ZHVzZV9kZXYgKmRldiwKPiArCQkJICAgICAgc3RydWN0IHZkdXNlX2Rl dl9tc2cgKm1zZywgYm9vbCBub19yZXBseSkKPiArewoKCkl0IGxvb2tzIHRvIG1lIHRoZSBvbmx5 IHVzZXIgZm9yIG5vX3JlcGx5PXRydWUgaXMgdGhlIGRhdGFwbGFuZSBzdGFydC4gSSAKd29uZGVy IG5vX3JlcGx5IGlzIHJlYWxseSBuZWVkZWQgY29uc2lkZXIgd2UgaGF2ZSBzd2l0Y2hlZCB0byB1 c2UgCndhaXRfZXZlbnRfa2lsbGFibGVfdGltZW91dCgpLgoKSW4gYW5vdGhlciB3YXksIG5vX3Jl cGx5IGlzIGZhbHNlIGZvciB2cSBzdGF0ZSBzeW5jaHJvbml6YXRpb24gYW5kIElPVExCIAp1cGRh dGluZy4gSSB3b25kZXIgaWYgd2UgY2FuIHNpbXBseSB1c2Ugbm9fcmVwbHkgPSB0cnVlIGZvciB0 aGVtLgoKCj4gKwlpbml0X3dhaXRxdWV1ZV9oZWFkKCZtc2ctPndhaXRxKTsKPiArCXNwaW5fbG9j aygmZGV2LT5tc2dfbG9jayk7Cj4gKwltc2ctPnJlcS5yZXF1ZXN0X2lkID0gZGV2LT5tc2dfdW5p cXVlKys7Cj4gKwl2ZHVzZV9lbnF1ZXVlX21zZygmZGV2LT5zZW5kX2xpc3QsIG1zZyk7Cj4gKwl3 YWtlX3VwKCZkZXYtPndhaXRxKTsKPiArCXNwaW5fdW5sb2NrKCZkZXYtPm1zZ19sb2NrKTsKPiAr CWlmIChub19yZXBseSkKPiArCQlyZXR1cm4gMDsKPiArCj4gKwl3YWl0X2V2ZW50X2tpbGxhYmxl X3RpbWVvdXQobXNnLT53YWl0cSwgbXNnLT5jb21wbGV0ZWQsCj4gKwkJCQkgICAgVkRVU0VfUkVR VUVTVF9USU1FT1VUICogSFopOwo+ICsJc3Bpbl9sb2NrKCZkZXYtPm1zZ19sb2NrKTsKPiArCWlm ICghbXNnLT5jb21wbGV0ZWQpIHsKPiArCQlsaXN0X2RlbCgmbXNnLT5saXN0KTsKPiArCQltc2ct PnJlc3AucmVzdWx0ID0gVkRVU0VfUkVRX1JFU1VMVF9GQUlMRUQ7Cj4gKwl9Cj4gKwlzcGluX3Vu bG9jaygmZGV2LT5tc2dfbG9jayk7Cj4gKwo+ICsJcmV0dXJuIChtc2ctPnJlc3AucmVzdWx0ID09 IFZEVVNFX1JFUV9SRVNVTFRfT0spID8gMCA6IC1FSU87CgoKRG8gd2UgbmVlZCB0byBzZXJpYWxp emUgdGhlIGNoZWNrIGJ5IHByb3RlY3RpbmcgaXQgd2l0aCB0aGUgc3BpbmxvY2sgYWJvdmU/CgoK PiArfQo+ICsKPiArc3RhdGljIHZvaWQgdmR1c2VfZGV2X21zZ19jbGVhbnVwKHN0cnVjdCB2ZHVz ZV9kZXYgKmRldikKPiArewo+ICsJc3RydWN0IHZkdXNlX2Rldl9tc2cgKm1zZzsKPiArCj4gKwlz cGluX2xvY2soJmRldi0+bXNnX2xvY2spOwo+ICsJd2hpbGUgKChtc2cgPSB2ZHVzZV9kZXF1ZXVl X21zZygmZGV2LT5zZW5kX2xpc3QpKSkgewo+ICsJCWlmIChtc2ctPnJlcS5mbGFncyAmIFZEVVNF X1JFUV9GTEFHU19OT19SRVBMWSkKPiArCQkJa2ZyZWUobXNnKTsKPiArCQllbHNlCj4gKwkJCXZk dXNlX2VucXVldWVfbXNnKCZkZXYtPnJlY3ZfbGlzdCwgbXNnKTsKPiArCX0KPiArCXdoaWxlICgo bXNnID0gdmR1c2VfZGVxdWV1ZV9tc2coJmRldi0+cmVjdl9saXN0KSkpIHsKPiArCQltc2ctPnJl c3AucmVzdWx0ID0gVkRVU0VfUkVRX1JFU1VMVF9GQUlMRUQ7Cj4gKwkJbXNnLT5jb21wbGV0ZWQg PSAxOwo+ICsJCXdha2VfdXAoJm1zZy0+d2FpdHEpOwo+ICsJfQo+ICsJc3Bpbl91bmxvY2soJmRl di0+bXNnX2xvY2spOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCB2ZHVzZV9kZXZfc3RhcnRfZGF0 YXBsYW5lKHN0cnVjdCB2ZHVzZV9kZXYgKmRldikKPiArewo+ICsJc3RydWN0IHZkdXNlX2Rldl9t c2cgKm1zZyA9IGt6YWxsb2Moc2l6ZW9mKCptc2cpLAo+ICsJCQkJCSAgICBHRlBfS0VSTkVMIHwg X19HRlBfTk9GQUlMKTsKPiArCj4gKwltc2ctPnJlcS50eXBlID0gVkRVU0VfU1RBUlRfREFUQVBM QU5FOwo+ICsJbXNnLT5yZXEuZmxhZ3MgfD0gVkRVU0VfUkVRX0ZMQUdTX05PX1JFUExZOwo+ICsJ dmR1c2VfZGV2X21zZ19zZW5kKGRldiwgbXNnLCB0cnVlKTsKPiArfQo+ICsKPiArc3RhdGljIHZv aWQgdmR1c2VfZGV2X3N0b3BfZGF0YXBsYW5lKHN0cnVjdCB2ZHVzZV9kZXYgKmRldikKPiArewo+ ICsJc3RydWN0IHZkdXNlX2Rldl9tc2cgKm1zZyA9IGt6YWxsb2Moc2l6ZW9mKCptc2cpLAo+ICsJ CQkJCSAgICBHRlBfS0VSTkVMIHwgX19HRlBfTk9GQUlMKTsKPiArCj4gKwltc2ctPnJlcS50eXBl ID0gVkRVU0VfU1RPUF9EQVRBUExBTkU7Cj4gKwltc2ctPnJlcS5mbGFncyB8PSBWRFVTRV9SRVFf RkxBR1NfTk9fUkVQTFk7CgoKQ2FuIHdlIHNpbXBseSB1c2UgdGhpcyBmbGFnIGluc3RlYWQgb2Yg aW50cm9kdWNpbmcgYSBuZXcgcGFyYW1ldGVyIAoobm9fcmVwbHkpIGluIHZkdXNlX2Rldl9tc2df c2VuZCgpPwoKCj4gKwl2ZHVzZV9kZXZfbXNnX3NlbmQoZGV2LCBtc2csIHRydWUpOwo+ICt9Cj4g Kwo+ICtzdGF0aWMgaW50IHZkdXNlX2Rldl9nZXRfdnFfc3RhdGUoc3RydWN0IHZkdXNlX2RldiAq ZGV2LAo+ICsJCQkJICBzdHJ1Y3QgdmR1c2VfdmlydHF1ZXVlICp2cSwKPiArCQkJCSAgc3RydWN0 IHZkcGFfdnFfc3RhdGUgKnN0YXRlKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2X21zZyBtc2cg PSB7IDAgfTsKPiArCWludCByZXQ7CgoKTm90ZSB0aGF0IEkgcG9zdCBhIHNlcmllcyB0aGF0IGlt cGxlbWVudCB0aGUgcGFja2VkIHZpcnRxdWV1ZSBzdXBwb3J0OgoKaHR0cHM6Ly9saXN0cy5saW51 eGZvdW5kYXRpb24ub3JnL3BpcGVybWFpbC92aXJ0dWFsaXphdGlvbi8yMDIxLUp1bmUvMDU0NTAx Lmh0bWwKClNvIHRoaXMgcGF0Y2ggbmVlZHMgdG8gYmUgdXBkYXRlZCBhcyB3ZWxsLgoKCj4gKwo+ ICsJbXNnLnJlcS50eXBlID0gVkRVU0VfR0VUX1ZRX1NUQVRFOwo+ICsJbXNnLnJlcS52cV9zdGF0 ZS5pbmRleCA9IHZxLT5pbmRleDsKPiArCj4gKwlyZXQgPSB2ZHVzZV9kZXZfbXNnX3NlbmQoZGV2 LCAmbXNnLCBmYWxzZSk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJc3Rh dGUtPmF2YWlsX2luZGV4ID0gbXNnLnJlc3AudnFfc3RhdGUuYXZhaWxfaWR4Owo+ICsJcmV0dXJu IDA7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgdmR1c2VfZGV2X3VwZGF0ZV9pb3RsYihzdHJ1Y3Qg dmR1c2VfZGV2ICpkZXYsCj4gKwkJCQl1NjQgc3RhcnQsIHU2NCBsYXN0KQo+ICt7Cj4gKwlzdHJ1 Y3QgdmR1c2VfZGV2X21zZyBtc2cgPSB7IDAgfTsKPiArCj4gKwlpZiAobGFzdCA8IHN0YXJ0KQo+ ICsJCXJldHVybiAtRUlOVkFMOwo+ICsKPiArCW1zZy5yZXEudHlwZSA9IFZEVVNFX1VQREFURV9J T1RMQjsKPiArCW1zZy5yZXEuaW92YS5zdGFydCA9IHN0YXJ0Owo+ICsJbXNnLnJlcS5pb3ZhLmxh c3QgPSBsYXN0Owo+ICsKPiArCXJldHVybiB2ZHVzZV9kZXZfbXNnX3NlbmQoZGV2LCAmbXNnLCBm YWxzZSk7Cj4gK30KPiArCj4gK3N0YXRpYyBzc2l6ZV90IHZkdXNlX2Rldl9yZWFkX2l0ZXIoc3Ry dWN0IGtpb2NiICppb2NiLCBzdHJ1Y3QgaW92X2l0ZXIgKnRvKQo+ICt7Cj4gKwlzdHJ1Y3QgZmls ZSAqZmlsZSA9IGlvY2ItPmtpX2ZpbHA7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSBmaWxl LT5wcml2YXRlX2RhdGE7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2X21zZyAqbXNnOwo+ICsJaW50IHNp emUgPSBzaXplb2Yoc3RydWN0IHZkdXNlX2Rldl9yZXF1ZXN0KTsKPiArCXNzaXplX3QgcmV0Owo+ ICsKPiArCWlmIChpb3ZfaXRlcl9jb3VudCh0bykgPCBzaXplKQo+ICsJCXJldHVybiAtRUlOVkFM Owo+ICsKPiArCXNwaW5fbG9jaygmZGV2LT5tc2dfbG9jayk7Cj4gKwl3aGlsZSAoMSkgewo+ICsJ CW1zZyA9IHZkdXNlX2RlcXVldWVfbXNnKCZkZXYtPnNlbmRfbGlzdCk7Cj4gKwkJaWYgKG1zZykK PiArCQkJYnJlYWs7Cj4gKwo+ICsJCXJldCA9IC1FQUdBSU47Cj4gKwkJaWYgKGZpbGUtPmZfZmxh Z3MgJiBPX05PTkJMT0NLKQo+ICsJCQlnb3RvIHVubG9jazsKPiArCj4gKwkJc3Bpbl91bmxvY2so JmRldi0+bXNnX2xvY2spOwo+ICsJCXJldCA9IHdhaXRfZXZlbnRfaW50ZXJydXB0aWJsZV9leGNs dXNpdmUoZGV2LT53YWl0cSwKPiArCQkJCQkhbGlzdF9lbXB0eSgmZGV2LT5zZW5kX2xpc3QpKTsK PiArCQlpZiAocmV0KQo+ICsJCQlyZXR1cm4gcmV0Owo+ICsKPiArCQlzcGluX2xvY2soJmRldi0+ bXNnX2xvY2spOwo+ICsJfQo+ICsJc3Bpbl91bmxvY2soJmRldi0+bXNnX2xvY2spOwo+ICsJcmV0 ID0gY29weV90b19pdGVyKCZtc2ctPnJlcSwgc2l6ZSwgdG8pOwo+ICsJc3Bpbl9sb2NrKCZkZXYt Pm1zZ19sb2NrKTsKPiArCWlmIChyZXQgIT0gc2l6ZSkgewo+ICsJCXJldCA9IC1FRkFVTFQ7Cj4g KwkJdmR1c2VfZW5xdWV1ZV9tc2coJmRldi0+c2VuZF9saXN0LCBtc2cpOwo+ICsJCWdvdG8gdW5s b2NrOwo+ICsJfQo+ICsJaWYgKG1zZy0+cmVxLmZsYWdzICYgVkRVU0VfUkVRX0ZMQUdTX05PX1JF UExZKQo+ICsJCWtmcmVlKG1zZyk7Cj4gKwllbHNlCj4gKwkJdmR1c2VfZW5xdWV1ZV9tc2coJmRl di0+cmVjdl9saXN0LCBtc2cpOwo+ICt1bmxvY2s6Cj4gKwlzcGluX3VubG9jaygmZGV2LT5tc2df bG9jayk7Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGljIHNzaXplX3QgdmR1 c2VfZGV2X3dyaXRlX2l0ZXIoc3RydWN0IGtpb2NiICppb2NiLCBzdHJ1Y3QgaW92X2l0ZXIgKmZy b20pCj4gK3sKPiArCXN0cnVjdCBmaWxlICpmaWxlID0gaW9jYi0+a2lfZmlscDsKPiArCXN0cnVj dCB2ZHVzZV9kZXYgKmRldiA9IGZpbGUtPnByaXZhdGVfZGF0YTsKPiArCXN0cnVjdCB2ZHVzZV9k ZXZfcmVzcG9uc2UgcmVzcDsKPiArCXN0cnVjdCB2ZHVzZV9kZXZfbXNnICptc2c7Cj4gKwlzaXpl X3QgcmV0Owo+ICsKPiArCXJldCA9IGNvcHlfZnJvbV9pdGVyKCZyZXNwLCBzaXplb2YocmVzcCks IGZyb20pOwo+ICsJaWYgKHJldCAhPSBzaXplb2YocmVzcCkpCj4gKwkJcmV0dXJuIC1FSU5WQUw7 Cj4gKwo+ICsJc3Bpbl9sb2NrKCZkZXYtPm1zZ19sb2NrKTsKPiArCW1zZyA9IHZkdXNlX2ZpbmRf bXNnKCZkZXYtPnJlY3ZfbGlzdCwgcmVzcC5yZXF1ZXN0X2lkKTsKPiArCWlmICghbXNnKSB7Cj4g KwkJcmV0ID0gLUVOT0VOVDsKPiArCQlnb3RvIHVubG9jazsKPiArCX0KPiArCj4gKwltZW1jcHko Jm1zZy0+cmVzcCwgJnJlc3AsIHNpemVvZihyZXNwKSk7Cj4gKwltc2ctPmNvbXBsZXRlZCA9IDE7 Cj4gKwl3YWtlX3VwKCZtc2ctPndhaXRxKTsKPiArdW5sb2NrOgo+ICsJc3Bpbl91bmxvY2soJmRl di0+bXNnX2xvY2spOwo+ICsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4gK3N0YXRpYyBfX3Bv bGxfdCB2ZHVzZV9kZXZfcG9sbChzdHJ1Y3QgZmlsZSAqZmlsZSwgcG9sbF90YWJsZSAqd2FpdCkK PiArewo+ICsJc3RydWN0IHZkdXNlX2RldiAqZGV2ID0gZmlsZS0+cHJpdmF0ZV9kYXRhOwo+ICsJ X19wb2xsX3QgbWFzayA9IDA7Cj4gKwo+ICsJcG9sbF93YWl0KGZpbGUsICZkZXYtPndhaXRxLCB3 YWl0KTsKPiArCj4gKwlpZiAoIWxpc3RfZW1wdHkoJmRldi0+c2VuZF9saXN0KSkKPiArCQltYXNr IHw9IEVQT0xMSU4gfCBFUE9MTFJETk9STTsKPiArCWlmICghbGlzdF9lbXB0eSgmZGV2LT5yZWN2 X2xpc3QpKQo+ICsJCW1hc2sgfD0gRVBPTExPVVQgfCBFUE9MTFdSTk9STTsKPiArCj4gKwlyZXR1 cm4gbWFzazsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdmR1c2VfZGV2X3Jlc2V0KHN0cnVjdCB2 ZHVzZV9kZXYgKmRldikKPiArewo+ICsJaW50IGk7Cj4gKwlzdHJ1Y3QgdmR1c2VfaW92YV9kb21h aW4gKmRvbWFpbiA9IGRldi0+ZG9tYWluOwo+ICsKPiArCS8qIFRoZSBjb2hlcmVudCBtYXBwaW5n cyBhcmUgaGFuZGxlZCBpbiB2ZHVzZV9kZXZfZnJlZV9jb2hlcmVudCgpICovCj4gKwlpZiAoZG9t YWluLT5ib3VuY2VfbWFwKQo+ICsJCXZkdXNlX2RvbWFpbl9yZXNldF9ib3VuY2VfbWFwKGRvbWFp bik7Cj4gKwo+ICsJZGV2LT5mZWF0dXJlcyA9IDA7Cj4gKwlkZXYtPmdlbmVyYXRpb24rKzsKPiAr CXNwaW5fbG9jaygmZGV2LT5pcnFfbG9jayk7Cj4gKwlkZXYtPmNvbmZpZ19jYi5jYWxsYmFjayA9 IE5VTEw7Cj4gKwlkZXYtPmNvbmZpZ19jYi5wcml2YXRlID0gTlVMTDsKPiArCXNwaW5fdW5sb2Nr KCZkZXYtPmlycV9sb2NrKTsKPiArCj4gKwlmb3IgKGkgPSAwOyBpIDwgZGV2LT52cV9udW07IGkr Kykgewo+ICsJCXN0cnVjdCB2ZHVzZV92aXJ0cXVldWUgKnZxID0gJmRldi0+dnFzW2ldOwo+ICsK PiArCQl2cS0+cmVhZHkgPSBmYWxzZTsKPiArCQl2cS0+ZGVzY19hZGRyID0gMDsKPiArCQl2cS0+ ZHJpdmVyX2FkZHIgPSAwOwo+ICsJCXZxLT5kZXZpY2VfYWRkciA9IDA7Cj4gKwkJdnEtPmF2YWls X2lkeCA9IDA7Cj4gKwkJdnEtPm51bSA9IDA7Cj4gKwo+ICsJCXNwaW5fbG9jaygmdnEtPmtpY2tf bG9jayk7Cj4gKwkJdnEtPmtpY2tlZCA9IGZhbHNlOwo+ICsJCWlmICh2cS0+a2lja2ZkKQo+ICsJ CQlldmVudGZkX2N0eF9wdXQodnEtPmtpY2tmZCk7Cj4gKwkJdnEtPmtpY2tmZCA9IE5VTEw7Cj4g KwkJc3Bpbl91bmxvY2soJnZxLT5raWNrX2xvY2spOwo+ICsKPiArCQlzcGluX2xvY2soJnZxLT5p cnFfbG9jayk7Cj4gKwkJdnEtPmNiLmNhbGxiYWNrID0gTlVMTDsKPiArCQl2cS0+Y2IucHJpdmF0 ZSA9IE5VTEw7Cj4gKwkJc3Bpbl91bmxvY2soJnZxLT5pcnFfbG9jayk7Cj4gKwl9Cj4gK30KPiAr Cj4gK3N0YXRpYyBpbnQgdmR1c2VfdmRwYV9zZXRfdnFfYWRkcmVzcyhzdHJ1Y3QgdmRwYV9kZXZp Y2UgKnZkcGEsIHUxNiBpZHgsCj4gKwkJCQl1NjQgZGVzY19hcmVhLCB1NjQgZHJpdmVyX2FyZWEs Cj4gKwkJCQl1NjQgZGV2aWNlX2FyZWEpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9 IHZkcGFfdG9fdmR1c2UodmRwYSk7Cj4gKwlzdHJ1Y3QgdmR1c2VfdmlydHF1ZXVlICp2cSA9ICZk ZXYtPnZxc1tpZHhdOwo+ICsKPiArCXZxLT5kZXNjX2FkZHIgPSBkZXNjX2FyZWE7Cj4gKwl2cS0+ ZHJpdmVyX2FkZHIgPSBkcml2ZXJfYXJlYTsKPiArCXZxLT5kZXZpY2VfYWRkciA9IGRldmljZV9h cmVhOwo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCB2ZHVzZV92ZHBh X2tpY2tfdnEoc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhLCB1MTYgaWR4KQo+ICt7Cj4gKwlzdHJ1 Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBhX3RvX3ZkdXNlKHZkcGEpOwo+ICsJc3RydWN0IHZkdXNl X3ZpcnRxdWV1ZSAqdnEgPSAmZGV2LT52cXNbaWR4XTsKPiArCj4gKwlzcGluX2xvY2soJnZxLT5r aWNrX2xvY2spOwo+ICsJaWYgKCF2cS0+cmVhZHkpCj4gKwkJZ290byB1bmxvY2s7Cj4gKwo+ICsJ aWYgKHZxLT5raWNrZmQpCj4gKwkJZXZlbnRmZF9zaWduYWwodnEtPmtpY2tmZCwgMSk7Cj4gKwll bHNlCj4gKwkJdnEtPmtpY2tlZCA9IHRydWU7Cj4gK3VubG9jazoKPiArCXNwaW5fdW5sb2NrKCZ2 cS0+a2lja19sb2NrKTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdmR1c2VfdmRwYV9zZXRfdnFf Y2Ioc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhLCB1MTYgaWR4LAo+ICsJCQkgICAgICBzdHJ1Y3Qg dmRwYV9jYWxsYmFjayAqY2IpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IHZkcGFf dG9fdmR1c2UodmRwYSk7Cj4gKwlzdHJ1Y3QgdmR1c2VfdmlydHF1ZXVlICp2cSA9ICZkZXYtPnZx c1tpZHhdOwo+ICsKPiArCXNwaW5fbG9jaygmdnEtPmlycV9sb2NrKTsKPiArCXZxLT5jYi5jYWxs YmFjayA9IGNiLT5jYWxsYmFjazsKPiArCXZxLT5jYi5wcml2YXRlID0gY2ItPnByaXZhdGU7Cj4g KwlzcGluX3VubG9jaygmdnEtPmlycV9sb2NrKTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdmR1 c2VfdmRwYV9zZXRfdnFfbnVtKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYSwgdTE2IGlkeCwgdTMy IG51bSkKPiArewo+ICsJc3RydWN0IHZkdXNlX2RldiAqZGV2ID0gdmRwYV90b192ZHVzZSh2ZHBh KTsKPiArCXN0cnVjdCB2ZHVzZV92aXJ0cXVldWUgKnZxID0gJmRldi0+dnFzW2lkeF07Cj4gKwo+ ICsJdnEtPm51bSA9IG51bTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdmR1c2VfdmRwYV9zZXRf dnFfcmVhZHkoc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhLAo+ICsJCQkJCXUxNiBpZHgsIGJvb2wg cmVhZHkpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IHZkcGFfdG9fdmR1c2UodmRw YSk7Cj4gKwlzdHJ1Y3QgdmR1c2VfdmlydHF1ZXVlICp2cSA9ICZkZXYtPnZxc1tpZHhdOwo+ICsK PiArCXZxLT5yZWFkeSA9IHJlYWR5Owo+ICt9Cj4gKwo+ICtzdGF0aWMgYm9vbCB2ZHVzZV92ZHBh X2dldF92cV9yZWFkeShzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEsIHUxNiBpZHgpCj4gK3sKPiAr CXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IHZkcGFfdG9fdmR1c2UodmRwYSk7Cj4gKwlzdHJ1Y3Qg dmR1c2VfdmlydHF1ZXVlICp2cSA9ICZkZXYtPnZxc1tpZHhdOwo+ICsKPiArCXJldHVybiB2cS0+ cmVhZHk7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgdmR1c2VfdmRwYV9zZXRfdnFfc3RhdGUoc3Ry dWN0IHZkcGFfZGV2aWNlICp2ZHBhLCB1MTYgaWR4LAo+ICsJCQkJY29uc3Qgc3RydWN0IHZkcGFf dnFfc3RhdGUgKnN0YXRlKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBhX3Rv X3ZkdXNlKHZkcGEpOwo+ICsJc3RydWN0IHZkdXNlX3ZpcnRxdWV1ZSAqdnEgPSAmZGV2LT52cXNb aWR4XTsKPiArCj4gKwl2cS0+YXZhaWxfaWR4ID0gc3RhdGUtPmF2YWlsX2luZGV4Owo+ICsJcmV0 dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgdmR1c2VfdmRwYV9nZXRfdnFfc3RhdGUoc3Ry dWN0IHZkcGFfZGV2aWNlICp2ZHBhLCB1MTYgaWR4LAo+ICsJCQkJc3RydWN0IHZkcGFfdnFfc3Rh dGUgKnN0YXRlKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBhX3RvX3ZkdXNl KHZkcGEpOwo+ICsJc3RydWN0IHZkdXNlX3ZpcnRxdWV1ZSAqdnEgPSAmZGV2LT52cXNbaWR4XTsK PiArCj4gKwlyZXR1cm4gdmR1c2VfZGV2X2dldF92cV9zdGF0ZShkZXYsIHZxLCBzdGF0ZSk7Cj4g K30KPiArCj4gK3N0YXRpYyB1MzIgdmR1c2VfdmRwYV9nZXRfdnFfYWxpZ24oc3RydWN0IHZkcGFf ZGV2aWNlICp2ZHBhKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBhX3RvX3Zk dXNlKHZkcGEpOwo+ICsKPiArCXJldHVybiBkZXYtPnZxX2FsaWduOwo+ICt9Cj4gKwo+ICtzdGF0 aWMgdTY0IHZkdXNlX3ZkcGFfZ2V0X2ZlYXR1cmVzKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYSkK PiArewo+ICsJc3RydWN0IHZkdXNlX2RldiAqZGV2ID0gdmRwYV90b192ZHVzZSh2ZHBhKTsKPiAr Cj4gKwlyZXR1cm4gZGV2LT51c2VyX2ZlYXR1cmVzOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHZk dXNlX3ZkcGFfc2V0X2ZlYXR1cmVzKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYSwgdTY0IGZlYXR1 cmVzKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBhX3RvX3ZkdXNlKHZkcGEp Owo+ICsKPiArCWRldi0+ZmVhdHVyZXMgPSBmZWF0dXJlczsKPiArCXJldHVybiAwOwo+ICt9Cj4g Kwo+ICtzdGF0aWMgdm9pZCB2ZHVzZV92ZHBhX3NldF9jb25maWdfY2Ioc3RydWN0IHZkcGFfZGV2 aWNlICp2ZHBhLAo+ICsJCQkJICBzdHJ1Y3QgdmRwYV9jYWxsYmFjayAqY2IpCj4gK3sKPiArCXN0 cnVjdCB2ZHVzZV9kZXYgKmRldiA9IHZkcGFfdG9fdmR1c2UodmRwYSk7Cj4gKwo+ICsJc3Bpbl9s b2NrKCZkZXYtPmlycV9sb2NrKTsKPiArCWRldi0+Y29uZmlnX2NiLmNhbGxiYWNrID0gY2ItPmNh bGxiYWNrOwo+ICsJZGV2LT5jb25maWdfY2IucHJpdmF0ZSA9IGNiLT5wcml2YXRlOwo+ICsJc3Bp bl91bmxvY2soJmRldi0+aXJxX2xvY2spOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdTE2IHZkdXNlX3Zk cGFfZ2V0X3ZxX251bV9tYXgoc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhKQo+ICt7Cj4gKwlzdHJ1 Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBhX3RvX3ZkdXNlKHZkcGEpOwo+ICsKPiArCXJldHVybiBk ZXYtPnZxX3NpemVfbWF4Owo+ICt9Cj4gKwo+ICtzdGF0aWMgdTMyIHZkdXNlX3ZkcGFfZ2V0X2Rl dmljZV9pZChzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9k ZXYgKmRldiA9IHZkcGFfdG9fdmR1c2UodmRwYSk7Cj4gKwo+ICsJcmV0dXJuIGRldi0+ZGV2aWNl X2lkOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdTMyIHZkdXNlX3ZkcGFfZ2V0X3ZlbmRvcl9pZChzdHJ1 Y3QgdmRwYV9kZXZpY2UgKnZkcGEpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IHZk cGFfdG9fdmR1c2UodmRwYSk7Cj4gKwo+ICsJcmV0dXJuIGRldi0+dmVuZG9yX2lkOwo+ICt9Cj4g Kwo+ICtzdGF0aWMgdTggdmR1c2VfdmRwYV9nZXRfc3RhdHVzKHN0cnVjdCB2ZHBhX2RldmljZSAq dmRwYSkKPiArewo+ICsJc3RydWN0IHZkdXNlX2RldiAqZGV2ID0gdmRwYV90b192ZHVzZSh2ZHBh KTsKPiArCj4gKwlyZXR1cm4gZGV2LT5zdGF0dXM7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHZk dXNlX3ZkcGFfc2V0X3N0YXR1cyhzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEsIHU4IHN0YXR1cykK PiArewo+ICsJc3RydWN0IHZkdXNlX2RldiAqZGV2ID0gdmRwYV90b192ZHVzZSh2ZHBhKTsKPiAr CWJvb2wgc3RhcnRlZCA9ICEhKHN0YXR1cyAmIFZJUlRJT19DT05GSUdfU19EUklWRVJfT0spOwo+ ICsKPiArCWRldi0+c3RhdHVzID0gc3RhdHVzOwo+ICsKPiArCWlmIChkZXYtPnN0YXJ0ZWQgPT0g c3RhcnRlZCkKPiArCQlyZXR1cm47CgoKSWYgd2UgY2hlY2sgZGV2LT5zdGF0dXMgPT0gc3RhdHVz LCAob3Igb25seSBjaGVjayB0aGUgRFJJVkVSX09LIGJpdCkgCnRoZW4gdGhlcmUncyBubyBuZWVk IHRvIGludHJvZHVjZSBhbiBleHRyYSBkZXYtPnN0YXJ0ZWQuCgoKPiArCj4gKwlkZXYtPnN0YXJ0 ZWQgPSBzdGFydGVkOwo+ICsJaWYgKGRldi0+c3RhcnRlZCkgewo+ICsJCXZkdXNlX2Rldl9zdGFy dF9kYXRhcGxhbmUoZGV2KTsKPiArCX0gZWxzZSB7Cj4gKwkJdmR1c2VfZGV2X3Jlc2V0KGRldik7 Cj4gKwkJdmR1c2VfZGV2X3N0b3BfZGF0YXBsYW5lKGRldik7CgoKSSB3b25kZXIgaWYgbm9fcmVw bHkgd29yayBmb3IgdGhlIGNhc2Ugb2Ygdmhvc3QtdmRwYS4gRm9yIHZpcnRpby12RFBBLCAKd2Ug aGF2ZSBib3VuY2luZyBidWZmZXJzIHNvIGl0J3MgaGFybWxlc3MgaWYgdXNlcnNhcGNlIGRhdGFw bGFuZSBrZWVwcyAKcGVyZm9ybWluZyByZWFkL3dyaXRlLiBGb3Igdmhvc3QtdkRQQSB3ZSBkb24n dCBoYXZlIHN1Y2ggc3R1ZmZzLgoKCj4gKwl9Cj4gK30KPiArCj4gK3N0YXRpYyBzaXplX3QgdmR1 c2VfdmRwYV9nZXRfY29uZmlnX3NpemUoc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhKQo+ICt7Cj4g KwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBhX3RvX3ZkdXNlKHZkcGEpOwo+ICsKPiArCXJl dHVybiBkZXYtPmNvbmZpZ19zaXplOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCB2ZHVzZV92ZHBh X2dldF9jb25maWcoc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhLCB1bnNpZ25lZCBpbnQgb2Zmc2V0 LAo+ICsJCQkJICB2b2lkICpidWYsIHVuc2lnbmVkIGludCBsZW4pCj4gK3sKPiArCXN0cnVjdCB2 ZHVzZV9kZXYgKmRldiA9IHZkcGFfdG9fdmR1c2UodmRwYSk7Cj4gKwo+ICsJbWVtY3B5KGJ1Ziwg ZGV2LT5jb25maWcgKyBvZmZzZXQsIGxlbik7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHZkdXNl X3ZkcGFfc2V0X2NvbmZpZyhzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEsIHVuc2lnbmVkIGludCBv ZmZzZXQsCj4gKwkJCWNvbnN0IHZvaWQgKmJ1ZiwgdW5zaWduZWQgaW50IGxlbikKPiArewo+ICsJ LyogTm93IHdlIG9ubHkgc3VwcG9ydCByZWFkLW9ubHkgY29uZmlndXJhdGlvbiBzcGFjZSAqLwo+ ICt9Cj4gKwo+ICtzdGF0aWMgdTMyIHZkdXNlX3ZkcGFfZ2V0X2dlbmVyYXRpb24oc3RydWN0IHZk cGFfZGV2aWNlICp2ZHBhKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBhX3Rv X3ZkdXNlKHZkcGEpOwo+ICsKPiArCXJldHVybiBkZXYtPmdlbmVyYXRpb247Cj4gK30KPiArCj4g K3N0YXRpYyBpbnQgdmR1c2VfdmRwYV9zZXRfbWFwKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYSwK PiArCQkJCXN0cnVjdCB2aG9zdF9pb3RsYiAqaW90bGIpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9k ZXYgKmRldiA9IHZkcGFfdG9fdmR1c2UodmRwYSk7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXJldCA9 IHZkdXNlX2RvbWFpbl9zZXRfbWFwKGRldi0+ZG9tYWluLCBpb3RsYik7Cj4gKwlpZiAocmV0KQo+ ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJcmV0ID0gdmR1c2VfZGV2X3VwZGF0ZV9pb3RsYihkZXYs IDBVTEwsIFVMTE9OR19NQVgpOwo+ICsJaWYgKHJldCkgewo+ICsJCXZkdXNlX2RvbWFpbl9jbGVh cl9tYXAoZGV2LT5kb21haW4sIGlvdGxiKTsKPiArCQlyZXR1cm4gcmV0Owo+ICsJfQo+ICsKPiAr CXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCB2ZHVzZV92ZHBhX2ZyZWUoc3RydWN0 IHZkcGFfZGV2aWNlICp2ZHBhKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBh X3RvX3ZkdXNlKHZkcGEpOwo+ICsKPiArCWRldi0+dmRldiA9IE5VTEw7Cj4gK30KPiArCj4gK3N0 YXRpYyBjb25zdCBzdHJ1Y3QgdmRwYV9jb25maWdfb3BzIHZkdXNlX3ZkcGFfY29uZmlnX29wcyA9 IHsKPiArCS5zZXRfdnFfYWRkcmVzcwkJPSB2ZHVzZV92ZHBhX3NldF92cV9hZGRyZXNzLAo+ICsJ LmtpY2tfdnEJCT0gdmR1c2VfdmRwYV9raWNrX3ZxLAo+ICsJLnNldF92cV9jYgkJPSB2ZHVzZV92 ZHBhX3NldF92cV9jYiwKPiArCS5zZXRfdnFfbnVtICAgICAgICAgICAgID0gdmR1c2VfdmRwYV9z ZXRfdnFfbnVtLAo+ICsJLnNldF92cV9yZWFkeQkJPSB2ZHVzZV92ZHBhX3NldF92cV9yZWFkeSwK PiArCS5nZXRfdnFfcmVhZHkJCT0gdmR1c2VfdmRwYV9nZXRfdnFfcmVhZHksCj4gKwkuc2V0X3Zx X3N0YXRlCQk9IHZkdXNlX3ZkcGFfc2V0X3ZxX3N0YXRlLAo+ICsJLmdldF92cV9zdGF0ZQkJPSB2 ZHVzZV92ZHBhX2dldF92cV9zdGF0ZSwKPiArCS5nZXRfdnFfYWxpZ24JCT0gdmR1c2VfdmRwYV9n ZXRfdnFfYWxpZ24sCj4gKwkuZ2V0X2ZlYXR1cmVzCQk9IHZkdXNlX3ZkcGFfZ2V0X2ZlYXR1cmVz LAo+ICsJLnNldF9mZWF0dXJlcwkJPSB2ZHVzZV92ZHBhX3NldF9mZWF0dXJlcywKPiArCS5zZXRf Y29uZmlnX2NiCQk9IHZkdXNlX3ZkcGFfc2V0X2NvbmZpZ19jYiwKPiArCS5nZXRfdnFfbnVtX21h eAkJPSB2ZHVzZV92ZHBhX2dldF92cV9udW1fbWF4LAo+ICsJLmdldF9kZXZpY2VfaWQJCT0gdmR1 c2VfdmRwYV9nZXRfZGV2aWNlX2lkLAo+ICsJLmdldF92ZW5kb3JfaWQJCT0gdmR1c2VfdmRwYV9n ZXRfdmVuZG9yX2lkLAo+ICsJLmdldF9zdGF0dXMJCT0gdmR1c2VfdmRwYV9nZXRfc3RhdHVzLAo+ ICsJLnNldF9zdGF0dXMJCT0gdmR1c2VfdmRwYV9zZXRfc3RhdHVzLAo+ICsJLmdldF9jb25maWdf c2l6ZQk9IHZkdXNlX3ZkcGFfZ2V0X2NvbmZpZ19zaXplLAo+ICsJLmdldF9jb25maWcJCT0gdmR1 c2VfdmRwYV9nZXRfY29uZmlnLAo+ICsJLnNldF9jb25maWcJCT0gdmR1c2VfdmRwYV9zZXRfY29u ZmlnLAo+ICsJLmdldF9nZW5lcmF0aW9uCQk9IHZkdXNlX3ZkcGFfZ2V0X2dlbmVyYXRpb24sCj4g Kwkuc2V0X21hcAkJPSB2ZHVzZV92ZHBhX3NldF9tYXAsCj4gKwkuZnJlZQkJCT0gdmR1c2VfdmRw YV9mcmVlLAo+ICt9Owo+ICsKPiArc3RhdGljIGRtYV9hZGRyX3QgdmR1c2VfZGV2X21hcF9wYWdl KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHBhZ2UgKnBhZ2UsCj4gKwkJCQkgICAgIHVuc2ln bmVkIGxvbmcgb2Zmc2V0LCBzaXplX3Qgc2l6ZSwKPiArCQkJCSAgICAgZW51bSBkbWFfZGF0YV9k aXJlY3Rpb24gZGlyLAo+ICsJCQkJICAgICB1bnNpZ25lZCBsb25nIGF0dHJzKQo+ICt7Cj4gKwlz dHJ1Y3QgdmR1c2VfZGV2ICp2ZGV2ID0gZGV2X3RvX3ZkdXNlKGRldik7Cj4gKwlzdHJ1Y3QgdmR1 c2VfaW92YV9kb21haW4gKmRvbWFpbiA9IHZkZXYtPmRvbWFpbjsKPiArCj4gKwlyZXR1cm4gdmR1 c2VfZG9tYWluX21hcF9wYWdlKGRvbWFpbiwgcGFnZSwgb2Zmc2V0LCBzaXplLCBkaXIsIGF0dHJz KTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdmR1c2VfZGV2X3VubWFwX3BhZ2Uoc3RydWN0IGRl dmljZSAqZGV2LCBkbWFfYWRkcl90IGRtYV9hZGRyLAo+ICsJCQkJc2l6ZV90IHNpemUsIGVudW0g ZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwKPiArCQkJCXVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gK3sK PiArCXN0cnVjdCB2ZHVzZV9kZXYgKnZkZXYgPSBkZXZfdG9fdmR1c2UoZGV2KTsKPiArCXN0cnVj dCB2ZHVzZV9pb3ZhX2RvbWFpbiAqZG9tYWluID0gdmRldi0+ZG9tYWluOwo+ICsKPiArCXJldHVy biB2ZHVzZV9kb21haW5fdW5tYXBfcGFnZShkb21haW4sIGRtYV9hZGRyLCBzaXplLCBkaXIsIGF0 dHJzKTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgKnZkdXNlX2Rldl9hbGxvY19jb2hlcmVudChz dHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBzaXplLAo+ICsJCQkJCWRtYV9hZGRyX3QgKmRtYV9h ZGRyLCBnZnBfdCBmbGFnLAo+ICsJCQkJCXVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gK3sKPiArCXN0 cnVjdCB2ZHVzZV9kZXYgKnZkZXYgPSBkZXZfdG9fdmR1c2UoZGV2KTsKPiArCXN0cnVjdCB2ZHVz ZV9pb3ZhX2RvbWFpbiAqZG9tYWluID0gdmRldi0+ZG9tYWluOwo+ICsJdW5zaWduZWQgbG9uZyBp b3ZhOwo+ICsJdm9pZCAqYWRkcjsKPiArCj4gKwkqZG1hX2FkZHIgPSBETUFfTUFQUElOR19FUlJP UjsKPiArCWFkZHIgPSB2ZHVzZV9kb21haW5fYWxsb2NfY29oZXJlbnQoZG9tYWluLCBzaXplLAo+ ICsJCQkJKGRtYV9hZGRyX3QgKikmaW92YSwgZmxhZywgYXR0cnMpOwo+ICsJaWYgKCFhZGRyKQo+ ICsJCXJldHVybiBOVUxMOwo+ICsKPiArCSpkbWFfYWRkciA9IChkbWFfYWRkcl90KWlvdmE7Cj4g Kwo+ICsJcmV0dXJuIGFkZHI7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHZkdXNlX2Rldl9mcmVl X2NvaGVyZW50KHN0cnVjdCBkZXZpY2UgKmRldiwgc2l6ZV90IHNpemUsCj4gKwkJCQkJdm9pZCAq dmFkZHIsIGRtYV9hZGRyX3QgZG1hX2FkZHIsCj4gKwkJCQkJdW5zaWduZWQgbG9uZyBhdHRycykK PiArewo+ICsJc3RydWN0IHZkdXNlX2RldiAqdmRldiA9IGRldl90b192ZHVzZShkZXYpOwo+ICsJ c3RydWN0IHZkdXNlX2lvdmFfZG9tYWluICpkb21haW4gPSB2ZGV2LT5kb21haW47Cj4gKwo+ICsJ dmR1c2VfZG9tYWluX2ZyZWVfY29oZXJlbnQoZG9tYWluLCBzaXplLCB2YWRkciwgZG1hX2FkZHIs IGF0dHJzKTsKPiArfQo+ICsKPiArc3RhdGljIHNpemVfdCB2ZHVzZV9kZXZfbWF4X21hcHBpbmdf c2l6ZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKnZkZXYg PSBkZXZfdG9fdmR1c2UoZGV2KTsKPiArCXN0cnVjdCB2ZHVzZV9pb3ZhX2RvbWFpbiAqZG9tYWlu ID0gdmRldi0+ZG9tYWluOwo+ICsKPiArCXJldHVybiBkb21haW4tPmJvdW5jZV9zaXplOwo+ICt9 Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGRtYV9tYXBfb3BzIHZkdXNlX2Rldl9kbWFfb3Bz ID0gewo+ICsJLm1hcF9wYWdlID0gdmR1c2VfZGV2X21hcF9wYWdlLAo+ICsJLnVubWFwX3BhZ2Ug PSB2ZHVzZV9kZXZfdW5tYXBfcGFnZSwKPiArCS5hbGxvYyA9IHZkdXNlX2Rldl9hbGxvY19jb2hl cmVudCwKPiArCS5mcmVlID0gdmR1c2VfZGV2X2ZyZWVfY29oZXJlbnQsCj4gKwkubWF4X21hcHBp bmdfc2l6ZSA9IHZkdXNlX2Rldl9tYXhfbWFwcGluZ19zaXplLAo+ICt9Owo+ICsKPiArc3RhdGlj IHVuc2lnbmVkIGludCBwZXJtX3RvX2ZpbGVfZmxhZ3ModTggcGVybSkKPiArewo+ICsJdW5zaWdu ZWQgaW50IGZsYWdzID0gMDsKPiArCj4gKwlzd2l0Y2ggKHBlcm0pIHsKPiArCWNhc2UgVkRVU0Vf QUNDRVNTX1dPOgo+ICsJCWZsYWdzIHw9IE9fV1JPTkxZOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSBW RFVTRV9BQ0NFU1NfUk86Cj4gKwkJZmxhZ3MgfD0gT19SRE9OTFk7Cj4gKwkJYnJlYWs7Cj4gKwlj YXNlIFZEVVNFX0FDQ0VTU19SVzoKPiArCQlmbGFncyB8PSBPX1JEV1I7Cj4gKwkJYnJlYWs7Cj4g KwlkZWZhdWx0Ogo+ICsJCVdBUk4oMSwgImludmFsaWRhdGUgdmhvc3QgSU9UTEIgcGVybWlzc2lv blxuIik7Cj4gKwkJYnJlYWs7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIGZsYWdzOwo+ICt9Cj4gKwo+ ICtzdGF0aWMgaW50IHZkdXNlX2tpY2tmZF9zZXR1cChzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYsCj4g KwkJCXN0cnVjdCB2ZHVzZV92cV9ldmVudGZkICpldmVudGZkKQo+ICt7Cj4gKwlzdHJ1Y3QgZXZl bnRmZF9jdHggKmN0eCA9IE5VTEw7Cj4gKwlzdHJ1Y3QgdmR1c2VfdmlydHF1ZXVlICp2cTsKPiAr CXUzMiBpbmRleDsKPiArCj4gKwlpZiAoZXZlbnRmZC0+aW5kZXggPj0gZGV2LT52cV9udW0pCj4g KwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJaW5kZXggPSBhcnJheV9pbmRleF9ub3NwZWMoZXZl bnRmZC0+aW5kZXgsIGRldi0+dnFfbnVtKTsKPiArCXZxID0gJmRldi0+dnFzW2luZGV4XTsKPiAr CWlmIChldmVudGZkLT5mZCA+PSAwKSB7Cj4gKwkJY3R4ID0gZXZlbnRmZF9jdHhfZmRnZXQoZXZl bnRmZC0+ZmQpOwo+ICsJCWlmIChJU19FUlIoY3R4KSkKPiArCQkJcmV0dXJuIFBUUl9FUlIoY3R4 KTsKPiArCX0gZWxzZSBpZiAoZXZlbnRmZC0+ZmQgIT0gVkRVU0VfRVZFTlRGRF9ERUFTU0lHTikK PiArCQlyZXR1cm4gMDsKPiArCj4gKwlzcGluX2xvY2soJnZxLT5raWNrX2xvY2spOwo+ICsJaWYg KHZxLT5raWNrZmQpCj4gKwkJZXZlbnRmZF9jdHhfcHV0KHZxLT5raWNrZmQpOwo+ICsJdnEtPmtp Y2tmZCA9IGN0eDsKPiArCWlmICh2cS0+cmVhZHkgJiYgdnEtPmtpY2tlZCAmJiB2cS0+a2lja2Zk KSB7Cj4gKwkJZXZlbnRmZF9zaWduYWwodnEtPmtpY2tmZCwgMSk7Cj4gKwkJdnEtPmtpY2tlZCA9 IGZhbHNlOwo+ICsJfQo+ICsJc3Bpbl91bmxvY2soJnZxLT5raWNrX2xvY2spOwo+ICsKPiArCXJl dHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCB2ZHVzZV9kZXZfaXJxX2luamVjdChzdHJ1 Y3Qgd29ya19zdHJ1Y3QgKndvcmspCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IGNv bnRhaW5lcl9vZih3b3JrLCBzdHJ1Y3QgdmR1c2VfZGV2LCBpbmplY3QpOwo+ICsKPiArCXNwaW5f bG9ja19pcnEoJmRldi0+aXJxX2xvY2spOwo+ICsJaWYgKGRldi0+Y29uZmlnX2NiLmNhbGxiYWNr KQo+ICsJCWRldi0+Y29uZmlnX2NiLmNhbGxiYWNrKGRldi0+Y29uZmlnX2NiLnByaXZhdGUpOwo+ ICsJc3Bpbl91bmxvY2tfaXJxKCZkZXYtPmlycV9sb2NrKTsKPiArfQo+ICsKPiArc3RhdGljIHZv aWQgdmR1c2VfdnFfaXJxX2luamVjdChzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCj4gK3sKPiAr CXN0cnVjdCB2ZHVzZV92aXJ0cXVldWUgKnZxID0gY29udGFpbmVyX29mKHdvcmssCj4gKwkJCQkJ c3RydWN0IHZkdXNlX3ZpcnRxdWV1ZSwgaW5qZWN0KTsKPiArCj4gKwlzcGluX2xvY2tfaXJxKCZ2 cS0+aXJxX2xvY2spOwo+ICsJaWYgKHZxLT5yZWFkeSAmJiB2cS0+Y2IuY2FsbGJhY2spCj4gKwkJ dnEtPmNiLmNhbGxiYWNrKHZxLT5jYi5wcml2YXRlKTsKPiArCXNwaW5fdW5sb2NrX2lycSgmdnEt PmlycV9sb2NrKTsKPiArfQo+ICsKPiArc3RhdGljIGxvbmcgdmR1c2VfZGV2X2lvY3RsKHN0cnVj dCBmaWxlICpmaWxlLCB1bnNpZ25lZCBpbnQgY21kLAo+ICsJCQkgICAgdW5zaWduZWQgbG9uZyBh cmcpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IGZpbGUtPnByaXZhdGVfZGF0YTsK PiArCXZvaWQgX191c2VyICphcmdwID0gKHZvaWQgX191c2VyICopYXJnOwo+ICsJaW50IHJldDsK PiArCj4gKwlzd2l0Y2ggKGNtZCkgewo+ICsJY2FzZSBWRFVTRV9JT1RMQl9HRVRfRkQ6IHsKPiAr CQlzdHJ1Y3QgdmR1c2VfaW90bGJfZW50cnkgZW50cnk7Cj4gKwkJc3RydWN0IHZob3N0X2lvdGxi X21hcCAqbWFwOwo+ICsJCXN0cnVjdCB2ZHBhX21hcF9maWxlICptYXBfZmlsZTsKPiArCQlzdHJ1 Y3QgdmR1c2VfaW92YV9kb21haW4gKmRvbWFpbiA9IGRldi0+ZG9tYWluOwo+ICsJCXN0cnVjdCBm aWxlICpmID0gTlVMTDsKPiArCj4gKwkJcmV0ID0gLUVGQVVMVDsKPiArCQlpZiAoY29weV9mcm9t X3VzZXIoJmVudHJ5LCBhcmdwLCBzaXplb2YoZW50cnkpKSkKPiArCQkJYnJlYWs7Cj4gKwo+ICsJ CXJldCA9IC1FSU5WQUw7Cj4gKwkJaWYgKGVudHJ5LnN0YXJ0ID4gZW50cnkubGFzdCkKPiArCQkJ YnJlYWs7Cj4gKwo+ICsJCXNwaW5fbG9jaygmZG9tYWluLT5pb3RsYl9sb2NrKTsKPiArCQltYXAg PSB2aG9zdF9pb3RsYl9pdHJlZV9maXJzdChkb21haW4tPmlvdGxiLAo+ICsJCQkJCSAgICAgIGVu dHJ5LnN0YXJ0LCBlbnRyeS5sYXN0KTsKPiArCQlpZiAobWFwKSB7Cj4gKwkJCW1hcF9maWxlID0g KHN0cnVjdCB2ZHBhX21hcF9maWxlICopbWFwLT5vcGFxdWU7Cj4gKwkJCWYgPSBnZXRfZmlsZSht YXBfZmlsZS0+ZmlsZSk7Cj4gKwkJCWVudHJ5Lm9mZnNldCA9IG1hcF9maWxlLT5vZmZzZXQ7Cj4g KwkJCWVudHJ5LnN0YXJ0ID0gbWFwLT5zdGFydDsKPiArCQkJZW50cnkubGFzdCA9IG1hcC0+bGFz dDsKPiArCQkJZW50cnkucGVybSA9IG1hcC0+cGVybTsKPiArCQl9Cj4gKwkJc3Bpbl91bmxvY2so JmRvbWFpbi0+aW90bGJfbG9jayk7Cj4gKwkJcmV0ID0gLUVJTlZBTDsKPiArCQlpZiAoIWYpCj4g KwkJCWJyZWFrOwo+ICsKPiArCQlyZXQgPSAtRUZBVUxUOwo+ICsJCWlmIChjb3B5X3RvX3VzZXIo YXJncCwgJmVudHJ5LCBzaXplb2YoZW50cnkpKSkgewo+ICsJCQlmcHV0KGYpOwo+ICsJCQlicmVh azsKPiArCQl9Cj4gKwkJcmV0ID0gcmVjZWl2ZV9mZChmLCBwZXJtX3RvX2ZpbGVfZmxhZ3MoZW50 cnkucGVybSkpOwo+ICsJCWZwdXQoZik7Cj4gKwkJYnJlYWs7Cj4gKwl9Cj4gKwljYXNlIFZEVVNF X0RFVl9HRVRfRkVBVFVSRVM6Cj4gKwkJcmV0ID0gcHV0X3VzZXIoZGV2LT5mZWF0dXJlcywgKHU2 NCBfX3VzZXIgKilhcmdwKTsKPiArCQlicmVhazsKPiArCWNhc2UgVkRVU0VfREVWX1VQREFURV9D T05GSUc6IHsKPiArCQlzdHJ1Y3QgdmR1c2VfY29uZmlnX3VwZGF0ZSBjb25maWc7Cj4gKwkJdW5z aWduZWQgbG9uZyBzaXplID0gb2Zmc2V0b2Yoc3RydWN0IHZkdXNlX2NvbmZpZ191cGRhdGUsCj4g KwkJCQkJICAgICAgYnVmZmVyKTsKPiArCj4gKwkJcmV0ID0gLUVGQVVMVDsKPiArCQlpZiAoY29w eV9mcm9tX3VzZXIoJmNvbmZpZywgYXJncCwgc2l6ZSkpCj4gKwkJCWJyZWFrOwo+ICsKPiArCQly ZXQgPSAtRUlOVkFMOwo+ICsJCWlmIChjb25maWcubGVuZ3RoID09IDAgfHwKPiArCQkgICAgY29u ZmlnLmxlbmd0aCA+IGRldi0+Y29uZmlnX3NpemUgLSBjb25maWcub2Zmc2V0KQo+ICsJCQlicmVh azsKPiArCj4gKwkJcmV0ID0gLUVGQVVMVDsKPiArCQlpZiAoY29weV9mcm9tX3VzZXIoZGV2LT5j b25maWcgKyBjb25maWcub2Zmc2V0LCBhcmdwICsgc2l6ZSwKPiArCQkJCSAgIGNvbmZpZy5sZW5n dGgpKQo+ICsJCQlicmVhazsKPiArCj4gKwkJcmV0ID0gMDsKPiArCQlxdWV1ZV93b3JrKHZkdXNl X2lycV93cSwgJmRldi0+aW5qZWN0KTsKCgpJIHdvbmRlciBpZiBpdCdzIGJldHRlciB0byBzZXBh cmF0ZSBjb25maWcgaW50ZXJydXB0IG91dCBvZiBjb25maWcgCnVwZGF0ZSBvciB3ZSBuZWVkIGRv Y3VtZW50IHRoaXMuCgoKPiArCQlicmVhazsKPiArCX0KPiArCWNhc2UgVkRVU0VfVlFfR0VUX0lO Rk86IHsKCgpEbyB3ZSBuZWVkIHRvIGxpbWl0IHRoaXMgb25seSB3aGVuIERSSVZFUl9PSyBpcyBz ZXQ/CgoKPiArCQlzdHJ1Y3QgdmR1c2VfdnFfaW5mbyB2cV9pbmZvOwo+ICsJCXUzMiB2cV9pbmRl eDsKPiArCj4gKwkJcmV0ID0gLUVGQVVMVDsKPiArCQlpZiAoY29weV9mcm9tX3VzZXIoJnZxX2lu Zm8sIGFyZ3AsIHNpemVvZih2cV9pbmZvKSkpCj4gKwkJCWJyZWFrOwo+ICsKPiArCQlyZXQgPSAt RUlOVkFMOwo+ICsJCWlmICh2cV9pbmZvLmluZGV4ID49IGRldi0+dnFfbnVtKQo+ICsJCQlicmVh azsKPiArCj4gKwkJdnFfaW5kZXggPSBhcnJheV9pbmRleF9ub3NwZWModnFfaW5mby5pbmRleCwg ZGV2LT52cV9udW0pOwo+ICsJCXZxX2luZm8uZGVzY19hZGRyID0gZGV2LT52cXNbdnFfaW5kZXhd LmRlc2NfYWRkcjsKPiArCQl2cV9pbmZvLmRyaXZlcl9hZGRyID0gZGV2LT52cXNbdnFfaW5kZXhd LmRyaXZlcl9hZGRyOwo+ICsJCXZxX2luZm8uZGV2aWNlX2FkZHIgPSBkZXYtPnZxc1t2cV9pbmRl eF0uZGV2aWNlX2FkZHI7Cj4gKwkJdnFfaW5mby5udW0gPSBkZXYtPnZxc1t2cV9pbmRleF0ubnVt Owo+ICsJCXZxX2luZm8uYXZhaWxfaWR4ID0gZGV2LT52cXNbdnFfaW5kZXhdLmF2YWlsX2lkeDsK PiArCQl2cV9pbmZvLnJlYWR5ID0gZGV2LT52cXNbdnFfaW5kZXhdLnJlYWR5Owo+ICsKPiArCQly ZXQgPSAtRUZBVUxUOwo+ICsJCWlmIChjb3B5X3RvX3VzZXIoYXJncCwgJnZxX2luZm8sIHNpemVv Zih2cV9pbmZvKSkpCj4gKwkJCWJyZWFrOwo+ICsKPiArCQlyZXQgPSAwOwo+ICsJCWJyZWFrOwo+ ICsJfQo+ICsJY2FzZSBWRFVTRV9WUV9TRVRVUF9LSUNLRkQ6IHsKPiArCQlzdHJ1Y3QgdmR1c2Vf dnFfZXZlbnRmZCBldmVudGZkOwo+ICsKPiArCQlyZXQgPSAtRUZBVUxUOwo+ICsJCWlmIChjb3B5 X2Zyb21fdXNlcigmZXZlbnRmZCwgYXJncCwgc2l6ZW9mKGV2ZW50ZmQpKSkKPiArCQkJYnJlYWs7 Cj4gKwo+ICsJCXJldCA9IHZkdXNlX2tpY2tmZF9zZXR1cChkZXYsICZldmVudGZkKTsKPiArCQli cmVhazsKPiArCX0KPiArCWNhc2UgVkRVU0VfVlFfSU5KRUNUX0lSUTogewo+ICsJCXUzMiB2cV9p bmRleDsKPiArCj4gKwkJcmV0ID0gLUVGQVVMVDsKPiArCQlpZiAoZ2V0X3VzZXIodnFfaW5kZXgs ICh1MzIgX191c2VyICopYXJncCkpCj4gKwkJCWJyZWFrOwo+ICsKPiArCQlyZXQgPSAtRUlOVkFM Owo+ICsJCWlmICh2cV9pbmRleCA+PSBkZXYtPnZxX251bSkKPiArCQkJYnJlYWs7Cj4gKwo+ICsJ CXJldCA9IDA7Cj4gKwkJdnFfaW5kZXggPSBhcnJheV9pbmRleF9ub3NwZWModnFfaW5kZXgsIGRl di0+dnFfbnVtKTsKPiArCQlxdWV1ZV93b3JrKHZkdXNlX2lycV93cSwgJmRldi0+dnFzW3ZxX2lu ZGV4XS5pbmplY3QpOwo+ICsJCWJyZWFrOwo+ICsJfQo+ICsJZGVmYXVsdDoKPiArCQlyZXQgPSAt RU5PSU9DVExDTUQ7Cj4gKwkJYnJlYWs7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ ICsKPiArc3RhdGljIGludCB2ZHVzZV9kZXZfcmVsZWFzZShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBz dHJ1Y3QgZmlsZSAqZmlsZSkKPiArewo+ICsJc3RydWN0IHZkdXNlX2RldiAqZGV2ID0gZmlsZS0+ cHJpdmF0ZV9kYXRhOwo+ICsKPiArCXNwaW5fbG9jaygmZGV2LT5tc2dfbG9jayk7Cj4gKwkvKiBN YWtlIHN1cmUgdGhlIGluZmxpZ2h0IG1lc3NhZ2VzIGNhbiBwcm9jZXNzZWQgYWZ0ZXIgcmVjb25u Y2VjdGlvbiAqLwo+ICsJbGlzdF9zcGxpY2VfaW5pdCgmZGV2LT5yZWN2X2xpc3QsICZkZXYtPnNl bmRfbGlzdCk7Cj4gKwlzcGluX3VubG9jaygmZGV2LT5tc2dfbG9jayk7Cj4gKwlkZXYtPmNvbm5l Y3RlZCA9IGZhbHNlOwo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgc3RydWN0 IHZkdXNlX2RldiAqdmR1c2VfZGV2X2dldF9mcm9tX21pbm9yKGludCBtaW5vcikKPiArewo+ICsJ c3RydWN0IHZkdXNlX2RldiAqZGV2Owo+ICsKPiArCW11dGV4X2xvY2soJnZkdXNlX2xvY2spOwo+ ICsJZGV2ID0gaWRyX2ZpbmQoJnZkdXNlX2lkciwgbWlub3IpOwo+ICsJbXV0ZXhfdW5sb2NrKCZ2 ZHVzZV9sb2NrKTsKPiArCj4gKwlyZXR1cm4gZGV2Owo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHZk dXNlX2Rldl9vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQo+ICt7 Cj4gKwlpbnQgcmV0Owo+ICsJc3RydWN0IHZkdXNlX2RldiAqZGV2ID0gdmR1c2VfZGV2X2dldF9m cm9tX21pbm9yKGltaW5vcihpbm9kZSkpOwo+ICsKPiArCWlmICghZGV2KQo+ICsJCXJldHVybiAt RU5PREVWOwo+ICsKPiArCXJldCA9IC1FQlVTWTsKPiArCW11dGV4X2xvY2soJmRldi0+bG9jayk7 Cj4gKwlpZiAoZGV2LT5jb25uZWN0ZWQpCj4gKwkJZ290byB1bmxvY2s7Cj4gKwo+ICsJcmV0ID0g MDsKPiArCWRldi0+Y29ubmVjdGVkID0gdHJ1ZTsKPiArCWZpbGUtPnByaXZhdGVfZGF0YSA9IGRl djsKPiArdW5sb2NrOgo+ICsJbXV0ZXhfdW5sb2NrKCZkZXYtPmxvY2spOwo+ICsKPiArCXJldHVy biByZXQ7Cj4gK30KPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIHZk dXNlX2Rldl9mb3BzID0gewo+ICsJLm93bmVyCQk9IFRISVNfTU9EVUxFLAo+ICsJLm9wZW4JCT0g dmR1c2VfZGV2X29wZW4sCj4gKwkucmVsZWFzZQk9IHZkdXNlX2Rldl9yZWxlYXNlLAo+ICsJLnJl YWRfaXRlcgk9IHZkdXNlX2Rldl9yZWFkX2l0ZXIsCj4gKwkud3JpdGVfaXRlcgk9IHZkdXNlX2Rl dl93cml0ZV9pdGVyLAo+ICsJLnBvbGwJCT0gdmR1c2VfZGV2X3BvbGwsCj4gKwkudW5sb2NrZWRf aW9jdGwJPSB2ZHVzZV9kZXZfaW9jdGwsCj4gKwkuY29tcGF0X2lvY3RsCT0gY29tcGF0X3B0cl9p b2N0bCwKPiArCS5sbHNlZWsJCT0gbm9vcF9sbHNlZWssCj4gK307Cj4gKwo+ICtzdGF0aWMgc3Ry dWN0IHZkdXNlX2RldiAqdmR1c2VfZGV2X2NyZWF0ZSh2b2lkKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1 c2VfZGV2ICpkZXYgPSBremFsbG9jKHNpemVvZigqZGV2KSwgR0ZQX0tFUk5FTCk7Cj4gKwo+ICsJ aWYgKCFkZXYpCj4gKwkJcmV0dXJuIE5VTEw7Cj4gKwo+ICsJbXV0ZXhfaW5pdCgmZGV2LT5sb2Nr KTsKPiArCXNwaW5fbG9ja19pbml0KCZkZXYtPm1zZ19sb2NrKTsKPiArCUlOSVRfTElTVF9IRUFE KCZkZXYtPnNlbmRfbGlzdCk7Cj4gKwlJTklUX0xJU1RfSEVBRCgmZGV2LT5yZWN2X2xpc3QpOwo+ ICsJc3Bpbl9sb2NrX2luaXQoJmRldi0+aXJxX2xvY2spOwo+ICsKPiArCUlOSVRfV09SSygmZGV2 LT5pbmplY3QsIHZkdXNlX2Rldl9pcnFfaW5qZWN0KTsKPiArCWluaXRfd2FpdHF1ZXVlX2hlYWQo JmRldi0+d2FpdHEpOwo+ICsKPiArCXJldHVybiBkZXY7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lk IHZkdXNlX2Rldl9kZXN0cm95KHN0cnVjdCB2ZHVzZV9kZXYgKmRldikKPiArewo+ICsJa2ZyZWUo ZGV2KTsKPiArfQo+ICsKPiArc3RhdGljIHN0cnVjdCB2ZHVzZV9kZXYgKnZkdXNlX2ZpbmRfZGV2 KGNvbnN0IGNoYXIgKm5hbWUpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldjsKPiArCWlu dCBpZDsKPiArCj4gKwlpZHJfZm9yX2VhY2hfZW50cnkoJnZkdXNlX2lkciwgZGV2LCBpZCkKPiAr CQlpZiAoIXN0cmNtcChkZXYtPm5hbWUsIG5hbWUpKQo+ICsJCQlyZXR1cm4gZGV2Owo+ICsKPiAr CXJldHVybiBOVUxMOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHZkdXNlX2Rlc3Ryb3lfZGV2KGNo YXIgKm5hbWUpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IHZkdXNlX2ZpbmRfZGV2 KG5hbWUpOwo+ICsKPiArCWlmICghZGV2KQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsKPiArCW11 dGV4X2xvY2soJmRldi0+bG9jayk7Cj4gKwlpZiAoZGV2LT52ZGV2IHx8IGRldi0+Y29ubmVjdGVk KSB7Cj4gKwkJbXV0ZXhfdW5sb2NrKCZkZXYtPmxvY2spOwo+ICsJCXJldHVybiAtRUJVU1k7Cj4g Kwl9Cj4gKwlkZXYtPmNvbm5lY3RlZCA9IHRydWU7Cj4gKwltdXRleF91bmxvY2soJmRldi0+bG9j ayk7Cj4gKwo+ICsJdmR1c2VfZGV2X21zZ19jbGVhbnVwKGRldik7Cj4gKwlkZXZpY2VfZGVzdHJv eSh2ZHVzZV9jbGFzcywgTUtERVYoTUFKT1IodmR1c2VfbWFqb3IpLCBkZXYtPm1pbm9yKSk7Cj4g KwlpZHJfcmVtb3ZlKCZ2ZHVzZV9pZHIsIGRldi0+bWlub3IpOwo+ICsJa3ZmcmVlKGRldi0+Y29u ZmlnKTsKPiArCWtmcmVlKGRldi0+dnFzKTsKPiArCXZkdXNlX2RvbWFpbl9kZXN0cm95KGRldi0+ ZG9tYWluKTsKPiArCWtmcmVlKGRldi0+bmFtZSk7Cj4gKwl2ZHVzZV9kZXZfZGVzdHJveShkZXYp Owo+ICsJbW9kdWxlX3B1dChUSElTX01PRFVMRSk7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiAr Cj4gK3N0YXRpYyBib29sIGRldmljZV9pc19hbGxvd2VkKHUzMiBkZXZpY2VfaWQpCj4gK3sKPiAr CWludCBpOwo+ICsKPiArCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKGFsbG93ZWRfZGV2aWNl X2lkKTsgaSsrKQo+ICsJCWlmIChhbGxvd2VkX2RldmljZV9pZFtpXSA9PSBkZXZpY2VfaWQpCj4g KwkJCXJldHVybiB0cnVlOwo+ICsKPiArCXJldHVybiBmYWxzZTsKPiArfQo+ICsKPiArc3RhdGlj IGJvb2wgZmVhdHVyZXNfaXNfdmFsaWQodTY0IGZlYXR1cmVzKQo+ICt7Cj4gKwlpZiAoIShmZWF0 dXJlcyAmICgxVUxMIDw8IFZJUlRJT19GX0FDQ0VTU19QTEFURk9STSkpKQo+ICsJCXJldHVybiBm YWxzZTsKPiArCj4gKwkvKiBOb3cgd2Ugb25seSBzdXBwb3J0IHJlYWQtb25seSBjb25maWd1cmF0 aW9uIHNwYWNlICovCj4gKwlpZiAoZmVhdHVyZXMgJiAoMVVMTCA8PCBWSVJUSU9fQkxLX0ZfQ09O RklHX1dDRSkpCj4gKwkJcmV0dXJuIGZhbHNlOwo+ICsKPiArCXJldHVybiB0cnVlOwo+ICt9Cj4g Kwo+ICtzdGF0aWMgYm9vbCB2ZHVzZV92YWxpZGF0ZV9jb25maWcoc3RydWN0IHZkdXNlX2Rldl9j b25maWcgKmNvbmZpZykKPiArewo+ICsJaWYgKGNvbmZpZy0+Ym91bmNlX3NpemUgPiBWRFVTRV9N QVhfQk9VTkNFX1NJWkUpCj4gKwkJcmV0dXJuIGZhbHNlOwo+ICsKPiArCWlmIChjb25maWctPnZx X2FsaWduID4gUEFHRV9TSVpFKQo+ICsJCXJldHVybiBmYWxzZTsKPiArCj4gKwlpZiAoY29uZmln LT5jb25maWdfc2l6ZSA+IFBBR0VfU0laRSkKPiArCQlyZXR1cm4gZmFsc2U7Cj4gKwo+ICsJaWYg KCFkZXZpY2VfaXNfYWxsb3dlZChjb25maWctPmRldmljZV9pZCkpCj4gKwkJcmV0dXJuIGZhbHNl Owo+ICsKPiArCWlmICghZmVhdHVyZXNfaXNfdmFsaWQoY29uZmlnLT5mZWF0dXJlcykpCj4gKwkJ cmV0dXJuIGZhbHNlOwoKCkRvIHdlIG5lZWQgdG8gdmFsaWRhdGUgd2hldGhlciBvciBub3QgY29u ZmlnX3NpemUgaXMgdG9vIHNtYWxsIG90aGVyd2lzZSAKd2UgbWF5IGhhdmUgT09CIGFjY2VzcyBp biBnZXRfY29uZmlnKCk/CgoKPiArCj4gKwlyZXR1cm4gdHJ1ZTsKPiArfQo+ICsKPiArc3RhdGlj IGludCB2ZHVzZV9jcmVhdGVfZGV2KHN0cnVjdCB2ZHVzZV9kZXZfY29uZmlnICpjb25maWcsCj4g KwkJCSAgICB2b2lkICpjb25maWdfYnVmLCB1NjQgYXBpX3ZlcnNpb24pCj4gK3sKPiArCWludCBp LCByZXQ7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXY7Cj4gKwo+ICsJcmV0ID0gLUVFWElTVDsK PiArCWlmICh2ZHVzZV9maW5kX2Rldihjb25maWctPm5hbWUpKQo+ICsJCWdvdG8gZXJyOwo+ICsK PiArCXJldCA9IC1FTk9NRU07Cj4gKwlkZXYgPSB2ZHVzZV9kZXZfY3JlYXRlKCk7Cj4gKwlpZiAo IWRldikKPiArCQlnb3RvIGVycjsKPiArCj4gKwlkZXYtPmFwaV92ZXJzaW9uID0gYXBpX3ZlcnNp b247Cj4gKwlkZXYtPnVzZXJfZmVhdHVyZXMgPSBjb25maWctPmZlYXR1cmVzOwo+ICsJZGV2LT5k ZXZpY2VfaWQgPSBjb25maWctPmRldmljZV9pZDsKPiArCWRldi0+dmVuZG9yX2lkID0gY29uZmln LT52ZW5kb3JfaWQ7Cj4gKwlkZXYtPm5hbWUgPSBrc3RyZHVwKGNvbmZpZy0+bmFtZSwgR0ZQX0tF Uk5FTCk7Cj4gKwlpZiAoIWRldi0+bmFtZSkKPiArCQlnb3RvIGVycl9zdHI7Cj4gKwo+ICsJZGV2 LT5kb21haW4gPSB2ZHVzZV9kb21haW5fY3JlYXRlKFZEVVNFX0lPVkFfU0laRSAtIDEsCj4gKwkJ CQkJICBjb25maWctPmJvdW5jZV9zaXplKTsKPiArCWlmICghZGV2LT5kb21haW4pCj4gKwkJZ290 byBlcnJfZG9tYWluOwo+ICsKPiArCWRldi0+Y29uZmlnID0gY29uZmlnX2J1ZjsKPiArCWRldi0+ Y29uZmlnX3NpemUgPSBjb25maWctPmNvbmZpZ19zaXplOwo+ICsJZGV2LT52cV9hbGlnbiA9IGNv bmZpZy0+dnFfYWxpZ247Cj4gKwlkZXYtPnZxX3NpemVfbWF4ID0gY29uZmlnLT52cV9zaXplX21h eDsKPiArCWRldi0+dnFfbnVtID0gY29uZmlnLT52cV9udW07Cj4gKwlkZXYtPnZxcyA9IGtjYWxs b2MoZGV2LT52cV9udW0sIHNpemVvZigqZGV2LT52cXMpLCBHRlBfS0VSTkVMKTsKPiArCWlmICgh ZGV2LT52cXMpCj4gKwkJZ290byBlcnJfdnFzOwo+ICsKPiArCWZvciAoaSA9IDA7IGkgPCBkZXYt PnZxX251bTsgaSsrKSB7Cj4gKwkJZGV2LT52cXNbaV0uaW5kZXggPSBpOwo+ICsJCUlOSVRfV09S SygmZGV2LT52cXNbaV0uaW5qZWN0LCB2ZHVzZV92cV9pcnFfaW5qZWN0KTsKPiArCQlzcGluX2xv Y2tfaW5pdCgmZGV2LT52cXNbaV0ua2lja19sb2NrKTsKPiArCQlzcGluX2xvY2tfaW5pdCgmZGV2 LT52cXNbaV0uaXJxX2xvY2spOwo+ICsJfQo+ICsKPiArCXJldCA9IGlkcl9hbGxvYygmdmR1c2Vf aWRyLCBkZXYsIDEsIFZEVVNFX0RFVl9NQVgsIEdGUF9LRVJORUwpOwo+ICsJaWYgKHJldCA8IDAp Cj4gKwkJZ290byBlcnJfaWRyOwo+ICsKPiArCWRldi0+bWlub3IgPSByZXQ7Cj4gKwlkZXYtPmRl diA9IGRldmljZV9jcmVhdGUodmR1c2VfY2xhc3MsIE5VTEwsCj4gKwkJCQkgTUtERVYoTUFKT1Io dmR1c2VfbWFqb3IpLCBkZXYtPm1pbm9yKSwKPiArCQkJCSBOVUxMLCAiJXMiLCBjb25maWctPm5h bWUpOwo+ICsJaWYgKElTX0VSUihkZXYtPmRldikpIHsKPiArCQlyZXQgPSBQVFJfRVJSKGRldi0+ ZGV2KTsKPiArCQlnb3RvIGVycl9kZXY7Cj4gKwl9Cj4gKwlfX21vZHVsZV9nZXQoVEhJU19NT0RV TEUpOwo+ICsKPiArCXJldHVybiAwOwo+ICtlcnJfZGV2Ogo+ICsJaWRyX3JlbW92ZSgmdmR1c2Vf aWRyLCBkZXYtPm1pbm9yKTsKPiArZXJyX2lkcjoKPiArCWtmcmVlKGRldi0+dnFzKTsKPiArZXJy X3ZxczoKPiArCXZkdXNlX2RvbWFpbl9kZXN0cm95KGRldi0+ZG9tYWluKTsKPiArZXJyX2RvbWFp bjoKPiArCWtmcmVlKGRldi0+bmFtZSk7Cj4gK2Vycl9zdHI6Cj4gKwl2ZHVzZV9kZXZfZGVzdHJv eShkZXYpOwo+ICtlcnI6Cj4gKwlrdmZyZWUoY29uZmlnX2J1Zik7Cj4gKwlyZXR1cm4gcmV0Owo+ ICt9Cj4gKwo+ICtzdGF0aWMgbG9uZyB2ZHVzZV9pb2N0bChzdHJ1Y3QgZmlsZSAqZmlsZSwgdW5z aWduZWQgaW50IGNtZCwKPiArCQkJdW5zaWduZWQgbG9uZyBhcmcpCj4gK3sKPiArCWludCByZXQ7 Cj4gKwl2b2lkIF9fdXNlciAqYXJncCA9ICh2b2lkIF9fdXNlciAqKWFyZzsKPiArCXN0cnVjdCB2 ZHVzZV9jb250cm9sICpjb250cm9sID0gZmlsZS0+cHJpdmF0ZV9kYXRhOwo+ICsKPiArCW11dGV4 X2xvY2soJnZkdXNlX2xvY2spOwo+ICsJc3dpdGNoIChjbWQpIHsKPiArCWNhc2UgVkRVU0VfR0VU X0FQSV9WRVJTSU9OOgo+ICsJCXJldCA9IHB1dF91c2VyKGNvbnRyb2wtPmFwaV92ZXJzaW9uLCAo dTY0IF9fdXNlciAqKWFyZ3ApOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSBWRFVTRV9TRVRfQVBJX1ZF UlNJT046IHsKPiArCQl1NjQgYXBpX3ZlcnNpb247Cj4gKwo+ICsJCXJldCA9IC1FRkFVTFQ7Cj4g KwkJaWYgKGdldF91c2VyKGFwaV92ZXJzaW9uLCAodTY0IF9fdXNlciAqKWFyZ3ApKQo+ICsJCQli cmVhazsKPiArCj4gKwkJcmV0ID0gLUVJTlZBTDsKPiArCQlpZiAoYXBpX3ZlcnNpb24gPiBWRFVT RV9BUElfVkVSU0lPTikKPiArCQkJYnJlYWs7Cj4gKwo+ICsJCXJldCA9IDA7Cj4gKwkJY29udHJv bC0+YXBpX3ZlcnNpb24gPSBhcGlfdmVyc2lvbjsKPiArCQlicmVhazsKPiArCX0KPiArCWNhc2Ug VkRVU0VfQ1JFQVRFX0RFVjogewo+ICsJCXN0cnVjdCB2ZHVzZV9kZXZfY29uZmlnIGNvbmZpZzsK PiArCQl1bnNpZ25lZCBsb25nIHNpemUgPSBvZmZzZXRvZihzdHJ1Y3QgdmR1c2VfZGV2X2NvbmZp ZywgY29uZmlnKTsKPiArCQl2b2lkICpidWY7Cj4gKwo+ICsJCXJldCA9IC1FRkFVTFQ7Cj4gKwkJ aWYgKGNvcHlfZnJvbV91c2VyKCZjb25maWcsIGFyZ3AsIHNpemUpKQo+ICsJCQlicmVhazsKPiAr Cj4gKwkJcmV0ID0gLUVJTlZBTDsKPiArCQlpZiAodmR1c2VfdmFsaWRhdGVfY29uZmlnKCZjb25m aWcpID09IGZhbHNlKQo+ICsJCQlicmVhazsKPiArCj4gKwkJYnVmID0gdm1lbWR1cF91c2VyKGFy Z3AgKyBzaXplLCBjb25maWcuY29uZmlnX3NpemUpOwo+ICsJCWlmIChJU19FUlIoYnVmKSkgewo+ ICsJCQlyZXQgPSBQVFJfRVJSKGJ1Zik7Cj4gKwkJCWJyZWFrOwo+ICsJCX0KPiArCQlyZXQgPSB2 ZHVzZV9jcmVhdGVfZGV2KCZjb25maWcsIGJ1ZiwgY29udHJvbC0+YXBpX3ZlcnNpb24pOwo+ICsJ CWJyZWFrOwo+ICsJfQo+ICsJY2FzZSBWRFVTRV9ERVNUUk9ZX0RFVjogewo+ICsJCWNoYXIgbmFt ZVtWRFVTRV9OQU1FX01BWF07Cj4gKwo+ICsJCXJldCA9IC1FRkFVTFQ7Cj4gKwkJaWYgKGNvcHlf ZnJvbV91c2VyKG5hbWUsIGFyZ3AsIFZEVVNFX05BTUVfTUFYKSkKPiArCQkJYnJlYWs7Cj4gKwo+ ICsJCXJldCA9IHZkdXNlX2Rlc3Ryb3lfZGV2KG5hbWUpOwo+ICsJCWJyZWFrOwo+ICsJfQo+ICsJ ZGVmYXVsdDoKPiArCQlyZXQgPSAtRUlOVkFMOwo+ICsJCWJyZWFrOwo+ICsJfQo+ICsJbXV0ZXhf dW5sb2NrKCZ2ZHVzZV9sb2NrKTsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0 aWMgaW50IHZkdXNlX3JlbGVhc2Uoc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZp bGUpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9jb250cm9sICpjb250cm9sID0gZmlsZS0+cHJpdmF0 ZV9kYXRhOwo+ICsKPiArCWtmcmVlKGNvbnRyb2wpOwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4g K3N0YXRpYyBpbnQgdmR1c2Vfb3BlbihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAq ZmlsZSkKPiArewo+ICsJc3RydWN0IHZkdXNlX2NvbnRyb2wgKmNvbnRyb2w7Cj4gKwo+ICsJY29u dHJvbCA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCB2ZHVzZV9jb250cm9sKSwgR0ZQX0tFUk5FTCk7 Cj4gKwlpZiAoIWNvbnRyb2wpCj4gKwkJcmV0dXJuIC1FTk9NRU07Cj4gKwo+ICsJY29udHJvbC0+ YXBpX3ZlcnNpb24gPSBWRFVTRV9BUElfVkVSU0lPTjsKPiArCWZpbGUtPnByaXZhdGVfZGF0YSA9 IGNvbnRyb2w7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1 Y3QgZmlsZV9vcGVyYXRpb25zIHZkdXNlX2N0cmxfZm9wcyA9IHsKPiArCS5vd25lcgkJPSBUSElT X01PRFVMRSwKPiArCS5vcGVuCQk9IHZkdXNlX29wZW4sCj4gKwkucmVsZWFzZQk9IHZkdXNlX3Jl bGVhc2UsCj4gKwkudW5sb2NrZWRfaW9jdGwJPSB2ZHVzZV9pb2N0bCwKPiArCS5jb21wYXRfaW9j dGwJPSBjb21wYXRfcHRyX2lvY3RsLAo+ICsJLmxsc2VlawkJPSBub29wX2xsc2VlaywKPiArfTsK PiArCj4gK3N0YXRpYyBjaGFyICp2ZHVzZV9kZXZub2RlKHN0cnVjdCBkZXZpY2UgKmRldiwgdW1v ZGVfdCAqbW9kZSkKPiArewo+ICsJcmV0dXJuIGthc3ByaW50ZihHRlBfS0VSTkVMLCAidmR1c2Uv JXMiLCBkZXZfbmFtZShkZXYpKTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdmR1c2VfbWdtdGRl dl9yZWxlYXNlKHN0cnVjdCBkZXZpY2UgKmRldikKPiArewo+ICt9Cj4gKwo+ICtzdGF0aWMgc3Ry dWN0IGRldmljZSB2ZHVzZV9tZ210ZGV2ID0gewo+ICsJLmluaXRfbmFtZSA9ICJ2ZHVzZSIsCj4g KwkucmVsZWFzZSA9IHZkdXNlX21nbXRkZXZfcmVsZWFzZSwKPiArfTsKPiArCj4gK3N0YXRpYyBz dHJ1Y3QgdmRwYV9tZ210X2RldiBtZ210X2RldjsKPiArCj4gK3N0YXRpYyBpbnQgdmR1c2VfZGV2 X2luaXRfdmRwYShzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYsIGNvbnN0IGNoYXIgKm5hbWUpCj4gK3sK PiArCXN0cnVjdCB2ZHVzZV92ZHBhICp2ZGV2Owo+ICsJaW50IHJldDsKPiArCj4gKwlpZiAoZGV2 LT52ZGV2KQo+ICsJCXJldHVybiAtRUVYSVNUOwo+ICsKPiArCXZkZXYgPSB2ZHBhX2FsbG9jX2Rl dmljZShzdHJ1Y3QgdmR1c2VfdmRwYSwgdmRwYSwgZGV2LT5kZXYsCj4gKwkJCQkgJnZkdXNlX3Zk cGFfY29uZmlnX29wcywgbmFtZSwgdHJ1ZSk7Cj4gKwlpZiAoIXZkZXYpCj4gKwkJcmV0dXJuIC1F Tk9NRU07Cj4gKwo+ICsJZGV2LT52ZGV2ID0gdmRldjsKPiArCXZkZXYtPmRldiA9IGRldjsKPiAr CXZkZXYtPnZkcGEuZGV2LmRtYV9tYXNrID0gJnZkZXYtPnZkcGEuZGV2LmNvaGVyZW50X2RtYV9t YXNrOwo+ICsJcmV0ID0gZG1hX3NldF9tYXNrX2FuZF9jb2hlcmVudCgmdmRldi0+dmRwYS5kZXYs IERNQV9CSVRfTUFTSyg2NCkpOwo+ICsJaWYgKHJldCkgewo+ICsJCXB1dF9kZXZpY2UoJnZkZXYt PnZkcGEuZGV2KTsKPiArCQlyZXR1cm4gcmV0Owo+ICsJfQo+ICsJc2V0X2RtYV9vcHMoJnZkZXYt PnZkcGEuZGV2LCAmdmR1c2VfZGV2X2RtYV9vcHMpOwo+ICsJdmRldi0+dmRwYS5kbWFfZGV2ID0g JnZkZXYtPnZkcGEuZGV2Owo+ICsJdmRldi0+dmRwYS5tZGV2ID0gJm1nbXRfZGV2Owo+ICsKPiAr CXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHZkcGFfZGV2X2FkZChzdHJ1Y3QgdmRw YV9tZ210X2RldiAqbWRldiwgY29uc3QgY2hhciAqbmFtZSkKPiArewo+ICsJc3RydWN0IHZkdXNl X2RldiAqZGV2Owo+ICsJaW50IHJldDsKPiArCj4gKwltdXRleF9sb2NrKCZ2ZHVzZV9sb2NrKTsK PiArCWRldiA9IHZkdXNlX2ZpbmRfZGV2KG5hbWUpOwo+ICsJaWYgKCFkZXYpIHsKPiArCQltdXRl eF91bmxvY2soJnZkdXNlX2xvY2spOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsJfQo+ICsJcmV0 ID0gdmR1c2VfZGV2X2luaXRfdmRwYShkZXYsIG5hbWUpOwo+ICsJbXV0ZXhfdW5sb2NrKCZ2ZHVz ZV9sb2NrKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiArCj4gKwlyZXQgPSBfdmRw YV9yZWdpc3Rlcl9kZXZpY2UoJmRldi0+dmRldi0+dmRwYSwgZGV2LT52cV9udW0pOwo+ICsJaWYg KHJldCkgewo+ICsJCXB1dF9kZXZpY2UoJmRldi0+dmRldi0+dmRwYS5kZXYpOwo+ICsJCXJldHVy biByZXQ7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHZk cGFfZGV2X2RlbChzdHJ1Y3QgdmRwYV9tZ210X2RldiAqbWRldiwgc3RydWN0IHZkcGFfZGV2aWNl ICpkZXYpCj4gK3sKPiArCV92ZHBhX3VucmVnaXN0ZXJfZGV2aWNlKGRldik7Cj4gK30KPiArCj4g K3N0YXRpYyBjb25zdCBzdHJ1Y3QgdmRwYV9tZ210ZGV2X29wcyB2ZHBhX2Rldl9tZ210ZGV2X29w cyA9IHsKPiArCS5kZXZfYWRkID0gdmRwYV9kZXZfYWRkLAo+ICsJLmRldl9kZWwgPSB2ZHBhX2Rl dl9kZWwsCj4gK307Cj4gKwo+ICtzdGF0aWMgc3RydWN0IHZpcnRpb19kZXZpY2VfaWQgaWRfdGFi bGVbXSA9IHsKPiArCXsgVklSVElPX0lEX0JMT0NLLCBWSVJUSU9fREVWX0FOWV9JRCB9LAo+ICsJ eyAwIH0sCj4gK307Cj4gKwo+ICtzdGF0aWMgc3RydWN0IHZkcGFfbWdtdF9kZXYgbWdtdF9kZXYg PSB7Cj4gKwkuZGV2aWNlID0gJnZkdXNlX21nbXRkZXYsCj4gKwkuaWRfdGFibGUgPSBpZF90YWJs ZSwKPiArCS5vcHMgPSAmdmRwYV9kZXZfbWdtdGRldl9vcHMsCj4gK307Cj4gKwo+ICtzdGF0aWMg aW50IHZkdXNlX21nbXRkZXZfaW5pdCh2b2lkKQo+ICt7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXJl dCA9IGRldmljZV9yZWdpc3RlcigmdmR1c2VfbWdtdGRldik7Cj4gKwlpZiAocmV0KQo+ICsJCXJl dHVybiByZXQ7Cj4gKwo+ICsJcmV0ID0gdmRwYV9tZ210ZGV2X3JlZ2lzdGVyKCZtZ210X2Rldik7 Cj4gKwlpZiAocmV0KQo+ICsJCWdvdG8gZXJyOwo+ICsKPiArCXJldHVybiAwOwo+ICtlcnI6Cj4g KwlkZXZpY2VfdW5yZWdpc3RlcigmdmR1c2VfbWdtdGRldik7Cj4gKwlyZXR1cm4gcmV0Owo+ICt9 Cj4gKwo+ICtzdGF0aWMgdm9pZCB2ZHVzZV9tZ210ZGV2X2V4aXQodm9pZCkKPiArewo+ICsJdmRw YV9tZ210ZGV2X3VucmVnaXN0ZXIoJm1nbXRfZGV2KTsKPiArCWRldmljZV91bnJlZ2lzdGVyKCZ2 ZHVzZV9tZ210ZGV2KTsKPiArfQo+ICsKPiArc3RhdGljIGludCB2ZHVzZV9pbml0KHZvaWQpCj4g K3sKPiArCWludCByZXQ7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpkZXY7Cj4gKwo+ICsJdmR1c2VfY2xh c3MgPSBjbGFzc19jcmVhdGUoVEhJU19NT0RVTEUsICJ2ZHVzZSIpOwo+ICsJaWYgKElTX0VSUih2 ZHVzZV9jbGFzcykpCj4gKwkJcmV0dXJuIFBUUl9FUlIodmR1c2VfY2xhc3MpOwo+ICsKPiArCXZk dXNlX2NsYXNzLT5kZXZub2RlID0gdmR1c2VfZGV2bm9kZTsKPiArCj4gKwlyZXQgPSBhbGxvY19j aHJkZXZfcmVnaW9uKCZ2ZHVzZV9tYWpvciwgMCwgVkRVU0VfREVWX01BWCwgInZkdXNlIik7Cj4g KwlpZiAocmV0KQo+ICsJCWdvdG8gZXJyX2NoYXJkZXZfcmVnaW9uOwo+ICsKPiArCS8qIC9kZXYv dmR1c2UvY29udHJvbCAqLwo+ICsJY2Rldl9pbml0KCZ2ZHVzZV9jdHJsX2NkZXYsICZ2ZHVzZV9j dHJsX2ZvcHMpOwo+ICsJdmR1c2VfY3RybF9jZGV2Lm93bmVyID0gVEhJU19NT0RVTEU7Cj4gKwly ZXQgPSBjZGV2X2FkZCgmdmR1c2VfY3RybF9jZGV2LCB2ZHVzZV9tYWpvciwgMSk7Cj4gKwlpZiAo cmV0KQo+ICsJCWdvdG8gZXJyX2N0cmxfY2RldjsKPiArCj4gKwlkZXYgPSBkZXZpY2VfY3JlYXRl KHZkdXNlX2NsYXNzLCBOVUxMLCB2ZHVzZV9tYWpvciwgTlVMTCwgImNvbnRyb2wiKTsKPiArCWlm IChJU19FUlIoZGV2KSkgewo+ICsJCXJldCA9IFBUUl9FUlIoZGV2KTsKPiArCQlnb3RvIGVycl9k ZXZpY2U7Cj4gKwl9Cj4gKwo+ICsJLyogL2Rldi92ZHVzZS8kREVWSUNFICovCj4gKwljZGV2X2lu aXQoJnZkdXNlX2NkZXYsICZ2ZHVzZV9kZXZfZm9wcyk7Cj4gKwl2ZHVzZV9jZGV2Lm93bmVyID0g VEhJU19NT0RVTEU7Cj4gKwlyZXQgPSBjZGV2X2FkZCgmdmR1c2VfY2RldiwgTUtERVYoTUFKT1Io dmR1c2VfbWFqb3IpLCAxKSwKPiArCQkgICAgICAgVkRVU0VfREVWX01BWCAtIDEpOwo+ICsJaWYg KHJldCkKPiArCQlnb3RvIGVycl9jZGV2Owo+ICsKPiArCXZkdXNlX2lycV93cSA9IGFsbG9jX3dv cmtxdWV1ZSgidmR1c2UtaXJxIiwKPiArCQkJCVdRX0hJR0hQUkkgfCBXUV9TWVNGUyB8IFdRX1VO Qk9VTkQsIDApOwo+ICsJaWYgKCF2ZHVzZV9pcnFfd3EpCj4gKwkJZ290byBlcnJfd3E7Cj4gKwo+ ICsJcmV0ID0gdmR1c2VfZG9tYWluX2luaXQoKTsKPiArCWlmIChyZXQpCj4gKwkJZ290byBlcnJf ZG9tYWluOwo+ICsKPiArCXJldCA9IHZkdXNlX21nbXRkZXZfaW5pdCgpOwo+ICsJaWYgKHJldCkK PiArCQlnb3RvIGVycl9tZ210ZGV2Owo+ICsKPiArCXJldHVybiAwOwo+ICtlcnJfbWdtdGRldjoK PiArCXZkdXNlX2RvbWFpbl9leGl0KCk7Cj4gK2Vycl9kb21haW46Cj4gKwlkZXN0cm95X3dvcmtx dWV1ZSh2ZHVzZV9pcnFfd3EpOwo+ICtlcnJfd3E6Cj4gKwljZGV2X2RlbCgmdmR1c2VfY2Rldik7 Cj4gK2Vycl9jZGV2Ogo+ICsJZGV2aWNlX2Rlc3Ryb3kodmR1c2VfY2xhc3MsIHZkdXNlX21ham9y KTsKPiArZXJyX2RldmljZToKPiArCWNkZXZfZGVsKCZ2ZHVzZV9jdHJsX2NkZXYpOwo+ICtlcnJf Y3RybF9jZGV2Ogo+ICsJdW5yZWdpc3Rlcl9jaHJkZXZfcmVnaW9uKHZkdXNlX21ham9yLCBWRFVT RV9ERVZfTUFYKTsKPiArZXJyX2NoYXJkZXZfcmVnaW9uOgo+ICsJY2xhc3NfZGVzdHJveSh2ZHVz ZV9jbGFzcyk7Cj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gK21vZHVsZV9pbml0KHZkdXNlX2luaXQp Owo+ICsKPiArc3RhdGljIHZvaWQgdmR1c2VfZXhpdCh2b2lkKQo+ICt7Cj4gKwl2ZHVzZV9tZ210 ZGV2X2V4aXQoKTsKPiArCXZkdXNlX2RvbWFpbl9leGl0KCk7Cj4gKwlkZXN0cm95X3dvcmtxdWV1 ZSh2ZHVzZV9pcnFfd3EpOwo+ICsJY2Rldl9kZWwoJnZkdXNlX2NkZXYpOwo+ICsJZGV2aWNlX2Rl c3Ryb3kodmR1c2VfY2xhc3MsIHZkdXNlX21ham9yKTsKPiArCWNkZXZfZGVsKCZ2ZHVzZV9jdHJs X2NkZXYpOwo+ICsJdW5yZWdpc3Rlcl9jaHJkZXZfcmVnaW9uKHZkdXNlX21ham9yLCBWRFVTRV9E RVZfTUFYKTsKPiArCWNsYXNzX2Rlc3Ryb3kodmR1c2VfY2xhc3MpOwo+ICt9Cj4gK21vZHVsZV9l eGl0KHZkdXNlX2V4aXQpOwo+ICsKPiArTU9EVUxFX0xJQ0VOU0UoRFJWX0xJQ0VOU0UpOwo+ICtN T0RVTEVfQVVUSE9SKERSVl9BVVRIT1IpOwo+ICtNT0RVTEVfREVTQ1JJUFRJT04oRFJWX0RFU0Mp Owo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL3VhcGkvbGludXgvdmR1c2UuaCBiL2luY2x1ZGUvdWFw aS9saW51eC92ZHVzZS5oCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAw MDAuLmYyMWIyZTUxYjVjOAo+IC0tLSAvZGV2L251bGwKPiArKysgYi9pbmNsdWRlL3VhcGkvbGlu dXgvdmR1c2UuaAo+IEBAIC0wLDAgKzEsMTQzIEBACj4gKy8qIFNQRFgtTGljZW5zZS1JZGVudGlm aWVyOiBHUEwtMi4wIFdJVEggTGludXgtc3lzY2FsbC1ub3RlICovCj4gKyNpZm5kZWYgX1VBUElf VkRVU0VfSF8KPiArI2RlZmluZSBfVUFQSV9WRFVTRV9IXwo+ICsKPiArI2luY2x1ZGUgPGxpbnV4 L3R5cGVzLmg+Cj4gKwo+ICsjZGVmaW5lIFZEVVNFX0FQSV9WRVJTSU9OCTAKPiArCj4gKyNkZWZp bmUgVkRVU0VfTkFNRV9NQVgJMjU2Cj4gKwo+ICsvKiB0aGUgY29udHJvbCBtZXNzYWdlcyBkZWZp bml0aW9uIGZvciByZWFkL3dyaXRlICovCj4gKwo+ICtlbnVtIHZkdXNlX3JlcV90eXBlIHsKPiAr CS8qIEdldCB0aGUgc3RhdGUgZm9yIHZpcnRxdWV1ZSBmcm9tIHVzZXJzcGFjZSAqLwo+ICsJVkRV U0VfR0VUX1ZRX1NUQVRFLAo+ICsJLyogTm90aWZ5IHVzZXJzcGFjZSB0byBzdGFydCB0aGUgZGF0 YXBsYW5lLCBubyByZXBseSAqLwo+ICsJVkRVU0VfU1RBUlRfREFUQVBMQU5FLAo+ICsJLyogTm90 aWZ5IHVzZXJzcGFjZSB0byBzdG9wIHRoZSBkYXRhcGxhbmUsIG5vIHJlcGx5ICovCj4gKwlWRFVT RV9TVE9QX0RBVEFQTEFORSwKPiArCS8qIE5vdGlmeSB1c2Vyc3BhY2UgdG8gdXBkYXRlIHRoZSBt ZW1vcnkgbWFwcGluZyBpbiBkZXZpY2UgSU9UTEIgKi8KPiArCVZEVVNFX1VQREFURV9JT1RMQiwK PiArfTsKPiArCj4gK3N0cnVjdCB2ZHVzZV92cV9zdGF0ZSB7Cj4gKwlfX3UzMiBpbmRleDsgLyog dmlydHF1ZXVlIGluZGV4ICovCj4gKwlfX3UzMiBhdmFpbF9pZHg7IC8qIHZpcnRxdWV1ZSBzdGF0 ZSAobGFzdF9hdmFpbF9pZHgpICovCj4gK307CgoKVGhpcyBuZWVkcyBzb21lIHR3ZWFrcyB0byBz dXBwb3J0IHBhY2tlZCB2aXJ0cXVldWUuCgoKPiArCj4gK3N0cnVjdCB2ZHVzZV9pb3ZhX3Jhbmdl IHsKPiArCV9fdTY0IHN0YXJ0OyAvKiBzdGFydCBvZiB0aGUgSU9WQSByYW5nZSAqLwo+ICsJX191 NjQgbGFzdDsgLyogZW5kIG9mIHRoZSBJT1ZBIHJhbmdlICovCj4gK307Cj4gKwo+ICtzdHJ1Y3Qg dmR1c2VfZGV2X3JlcXVlc3Qgewo+ICsJX191MzIgdHlwZTsgLyogcmVxdWVzdCB0eXBlICovCj4g KwlfX3UzMiByZXF1ZXN0X2lkOyAvKiByZXF1ZXN0IGlkICovCj4gKyNkZWZpbmUgVkRVU0VfUkVR X0ZMQUdTX05PX1JFUExZCSgxIDw8IDApIC8qIE5vIG5lZWQgdG8gcmVwbHkgKi8KPiArCV9fdTMy IGZsYWdzOyAvKiByZXF1ZXN0IGZsYWdzICovCj4gKwlfX3UzMiByZXNlcnZlZDsgLyogZm9yIGZ1 dHVyZSB1c2UgKi8KPiArCXVuaW9uIHsKPiArCQlzdHJ1Y3QgdmR1c2VfdnFfc3RhdGUgdnFfc3Rh dGU7IC8qIHZpcnRxdWV1ZSBzdGF0ZSAqLwo+ICsJCXN0cnVjdCB2ZHVzZV9pb3ZhX3JhbmdlIGlv dmE7IC8qIGlvdmEgcmFuZ2UgZm9yIHVwZGF0aW5nICovCj4gKwkJX191MzIgcGFkZGluZ1sxNl07 IC8qIHBhZGRpbmcgKi8KPiArCX07Cj4gK307Cj4gKwo+ICtzdHJ1Y3QgdmR1c2VfZGV2X3Jlc3Bv bnNlIHsKPiArCV9fdTMyIHJlcXVlc3RfaWQ7IC8qIGNvcnJlc3BvbmRpbmcgcmVxdWVzdCBpZCAq Lwo+ICsjZGVmaW5lIFZEVVNFX1JFUV9SRVNVTFRfT0sJMHgwMAo+ICsjZGVmaW5lIFZEVVNFX1JF UV9SRVNVTFRfRkFJTEVECTB4MDEKPiArCV9fdTMyIHJlc3VsdDsgLyogdGhlIHJlc3VsdCBvZiBy ZXF1ZXN0ICovCj4gKwlfX3UzMiByZXNlcnZlZFsyXTsgLyogZm9yIGZ1dHVyZSB1c2UgKi8KPiAr CXVuaW9uIHsKPiArCQlzdHJ1Y3QgdmR1c2VfdnFfc3RhdGUgdnFfc3RhdGU7IC8qIHZpcnRxdWV1 ZSBzdGF0ZSAqLwo+ICsJCV9fdTMyIHBhZGRpbmdbMTZdOyAvKiBwYWRkaW5nICovCj4gKwl9Owo+ ICt9Owo+ICsKPiArLyogaW9jdGxzICovCj4gKwo+ICtzdHJ1Y3QgdmR1c2VfZGV2X2NvbmZpZyB7 Cj4gKwljaGFyIG5hbWVbVkRVU0VfTkFNRV9NQVhdOyAvKiB2ZHVzZSBkZXZpY2UgbmFtZSAqLwo+ ICsJX191MzIgdmVuZG9yX2lkOyAvKiB2aXJ0aW8gdmVuZG9yIGlkICovCj4gKwlfX3UzMiBkZXZp Y2VfaWQ7IC8qIHZpcnRpbyBkZXZpY2UgaWQgKi8KPiArCV9fdTY0IGZlYXR1cmVzOyAvKiBkZXZp Y2UgZmVhdHVyZXMgKi8KPiArCV9fdTY0IGJvdW5jZV9zaXplOyAvKiBib3VuY2UgYnVmZmVyIHNp emUgZm9yIGlvbW11ICovCj4gKwlfX3UxNiB2cV9zaXplX21heDsgLyogdGhlIG1heCBzaXplIG9m IHZpcnRxdWV1ZSAqLwo+ICsJX191MTYgcGFkZGluZzsgLyogcGFkZGluZyAqLwo+ICsJX191MzIg dnFfbnVtOyAvKiB0aGUgbnVtYmVyIG9mIHZpcnRxdWV1ZXMgKi8KPiArCV9fdTMyIHZxX2FsaWdu OyAvKiB0aGUgYWxsb2NhdGlvbiBhbGlnbm1lbnQgb2YgdmlydHF1ZXVlJ3MgbWV0YWRhdGEgKi8K PiArCV9fdTMyIGNvbmZpZ19zaXplOyAvKiB0aGUgc2l6ZSBvZiB0aGUgY29uZmlndXJhdGlvbiBz cGFjZSAqLwo+ICsJX191MzIgcmVzZXJ2ZWRbMTVdOyAvKiBmb3IgZnV0dXJlIHVzZSAqLwo+ICsJ X191OCBjb25maWdbMF07IC8qIHRoZSBidWZmZXIgb2YgdGhlIGNvbmZpZ3VyYXRpb24gc3BhY2Ug Ki8KPiArfTsKPiArCj4gK3N0cnVjdCB2ZHVzZV9pb3RsYl9lbnRyeSB7Cj4gKwlfX3U2NCBvZmZz ZXQ7IC8qIHRoZSBtbWFwIG9mZnNldCBvbiBmZCAqLwo+ICsJX191NjQgc3RhcnQ7IC8qIHN0YXJ0 IG9mIHRoZSBJT1ZBIHJhbmdlICovCj4gKwlfX3U2NCBsYXN0OyAvKiBsYXN0IG9mIHRoZSBJT1ZB IHJhbmdlICovCj4gKyNkZWZpbmUgVkRVU0VfQUNDRVNTX1JPIDB4MQo+ICsjZGVmaW5lIFZEVVNF X0FDQ0VTU19XTyAweDIKPiArI2RlZmluZSBWRFVTRV9BQ0NFU1NfUlcgMHgzCj4gKwlfX3U4IHBl cm07IC8qIGFjY2VzcyBwZXJtaXNzaW9uIG9mIHRoaXMgcmFuZ2UgKi8KPiArfTsKPiArCj4gK3N0 cnVjdCB2ZHVzZV9jb25maWdfdXBkYXRlIHsKPiArCV9fdTMyIG9mZnNldDsgLyogb2Zmc2V0IGZy b20gdGhlIGJlZ2lubmluZyBvZiBjb25maWd1cmF0aW9uIHNwYWNlICovCj4gKwlfX3UzMiBsZW5n dGg7IC8qIHRoZSBsZW5ndGggdG8gd3JpdGUgdG8gY29uZmlndXJhdGlvbiBzcGFjZSAqLwo+ICsJ X191OCBidWZmZXJbMF07IC8qIGJ1ZmZlciB1c2VkIHRvIHdyaXRlIGZyb20gKi8KPiArfTsKPiAr Cj4gK3N0cnVjdCB2ZHVzZV92cV9pbmZvIHsKPiArCV9fdTMyIGluZGV4OyAvKiB2aXJ0cXVldWUg aW5kZXggKi8KPiArCV9fdTMyIGF2YWlsX2lkeDsgLyogdmlydHF1ZXVlIHN0YXRlIChsYXN0X2F2 YWlsX2lkeCkgKi8KPiArCV9fdTY0IGRlc2NfYWRkcjsgLyogYWRkcmVzcyBvZiBkZXNjIGFyZWEg Ki8KPiArCV9fdTY0IGRyaXZlcl9hZGRyOyAvKiBhZGRyZXNzIG9mIGRyaXZlciBhcmVhICovCj4g KwlfX3U2NCBkZXZpY2VfYWRkcjsgLyogYWRkcmVzcyBvZiBkZXZpY2UgYXJlYSAqLwo+ICsJX191 MzIgbnVtOyAvKiB0aGUgc2l6ZSBvZiB2aXJ0cXVldWUgKi8KPiArCV9fdTggcmVhZHk7IC8qIHJl YWR5IHN0YXR1cyBvZiB2aXJ0cXVldWUgKi8KPiArfTsKPiArCj4gK3N0cnVjdCB2ZHVzZV92cV9l dmVudGZkIHsKPiArCV9fdTMyIGluZGV4OyAvKiB2aXJ0cXVldWUgaW5kZXggKi8KPiArI2RlZmlu ZSBWRFVTRV9FVkVOVEZEX0RFQVNTSUdOIC0xCj4gKwlpbnQgZmQ7IC8qIGV2ZW50ZmQsIC0xIG1l YW5zIGRlLWFzc2lnbmluZyB0aGUgZXZlbnRmZCAqLwo+ICt9Owo+ICsKPiArI2RlZmluZSBWRFVT RV9CQVNFCTB4ODEKPiArCj4gKy8qIEdldCB0aGUgdmVyc2lvbiBvZiBWRFVTRSBBUEkuIFRoaXMg aXMgdXNlZCBmb3IgZnV0dXJlIGV4dGVuc2lvbiAqLwo+ICsjZGVmaW5lIFZEVVNFX0dFVF9BUElf VkVSU0lPTglfSU9SKFZEVVNFX0JBU0UsIDB4MDAsIF9fdTY0KQo+ICsKPiArLyogU2V0IHRoZSB2 ZXJzaW9uIG9mIFZEVVNFIEFQSS4gKi8KPiArI2RlZmluZSBWRFVTRV9TRVRfQVBJX1ZFUlNJT04J X0lPVyhWRFVTRV9CQVNFLCAweDAxLCBfX3U2NCkKPiArCj4gKy8qIENyZWF0ZSBhIHZkdXNlIGRl dmljZSB3aGljaCBpcyByZXByZXNlbnRlZCBieSBhIGNoYXIgZGV2aWNlICgvZGV2L3ZkdXNlLzxu YW1lPikgKi8KPiArI2RlZmluZSBWRFVTRV9DUkVBVEVfREVWCV9JT1coVkRVU0VfQkFTRSwgMHgw Miwgc3RydWN0IHZkdXNlX2Rldl9jb25maWcpCj4gKwo+ICsvKiBEZXN0cm95IGEgdmR1c2UgZGV2 aWNlLiBNYWtlIHN1cmUgdGhlcmUgYXJlIG5vIHJlZmVyZW5jZXMgdG8gdGhlIGNoYXIgZGV2aWNl ICovCj4gKyNkZWZpbmUgVkRVU0VfREVTVFJPWV9ERVYJX0lPVyhWRFVTRV9CQVNFLCAweDAzLCBj aGFyW1ZEVVNFX05BTUVfTUFYXSkKPiArCj4gKy8qCj4gKyAqIEdldCBhIGZpbGUgZGVzY3JpcHRv ciBmb3IgdGhlIGZpcnN0IG92ZXJsYXBwZWQgaW92YSByZWdpb24sCj4gKyAqIC1FSU5WQUwgbWVh bnMgdGhlIGlvdmEgcmVnaW9uIGRvZXNuJ3QgZXhpc3QuCj4gKyAqLwo+ICsjZGVmaW5lIFZEVVNF X0lPVExCX0dFVF9GRAlfSU9XUihWRFVTRV9CQVNFLCAweDA0LCBzdHJ1Y3QgdmR1c2VfaW90bGJf ZW50cnkpCj4gKwo+ICsvKiBHZXQgdGhlIG5lZ290aWF0ZWQgZmVhdHVyZXMgKi8KPiArI2RlZmlu ZSBWRFVTRV9ERVZfR0VUX0ZFQVRVUkVTCV9JT1IoVkRVU0VfQkFTRSwgMHgwNSwgX191NjQpCj4g Kwo+ICsvKiBVcGRhdGUgdGhlIGNvbmZpZ3VyYXRpb24gc3BhY2UgKi8KPiArI2RlZmluZSBWRFVT RV9ERVZfVVBEQVRFX0NPTkZJRwlfSU9XKFZEVVNFX0JBU0UsIDB4MDYsIHN0cnVjdCB2ZHVzZV9j b25maWdfdXBkYXRlKQo+ICsKPiArLyogR2V0IHRoZSBzcGVjaWZpZWQgdmlydHF1ZXVlJ3MgaW5m b3JtYXRpb24gKi8KPiArI2RlZmluZSBWRFVTRV9WUV9HRVRfSU5GTwlfSU9XUihWRFVTRV9CQVNF LCAweDA3LCBzdHJ1Y3QgdmR1c2VfdnFfaW5mbykKPiArCj4gKy8qIFNldHVwIGFuIGV2ZW50ZmQg dG8gcmVjZWl2ZSBraWNrIGZvciB2aXJ0cXVldWUgKi8KPiArI2RlZmluZSBWRFVTRV9WUV9TRVRV UF9LSUNLRkQJX0lPVyhWRFVTRV9CQVNFLCAweDA4LCBzdHJ1Y3QgdmR1c2VfdnFfZXZlbnRmZCkK PiArCj4gKy8qIEluamVjdCBhbiBpbnRlcnJ1cHQgZm9yIHNwZWNpZmljIHZpcnRxdWV1ZSAqLwo+ ICsjZGVmaW5lIFZEVVNFX1ZRX0lOSkVDVF9JUlEJX0lPVyhWRFVTRV9CQVNFLCAweDA5LCBfX3Uz MikKPiArCj4gKyNlbmRpZiAvKiBfVUFQSV9WRFVTRV9IXyAqLwoKCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmlvbW11IG1haWxpbmcgbGlzdAppb21tdUBs aXN0cy5saW51eC1mb3VuZGF0aW9uLm9yZwpodHRwczovL2xpc3RzLmxpbnV4Zm91bmRhdGlvbi5v cmcvbWFpbG1hbi9saXN0aW5mby9pb21tdQ== 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=-15.1 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS,URIBL_RED, USER_AGENT_SANE_1 autolearn=unavailable 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 34E5AC48BE5 for ; Mon, 21 Jun 2021 09:14:51 +0000 (UTC) Received: from smtp4.osuosl.org (smtp4.osuosl.org [140.211.166.137]) (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 D3EF561002 for ; Mon, 21 Jun 2021 09:14:50 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D3EF561002 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=virtualization-bounces@lists.linux-foundation.org Received: from localhost (localhost [127.0.0.1]) by smtp4.osuosl.org (Postfix) with ESMTP id 94C6B4013C; Mon, 21 Jun 2021 09:14:50 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp4.osuosl.org ([127.0.0.1]) by localhost (smtp4.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id LeBZM87JDFRT; Mon, 21 Jun 2021 09:14:47 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [IPv6:2605:bc80:3010:104::8cd3:938]) by smtp4.osuosl.org (Postfix) with ESMTPS id CFFCE402BD; Mon, 21 Jun 2021 09:14:46 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id A5138C0010; Mon, 21 Jun 2021 09:14:46 +0000 (UTC) Received: from smtp2.osuosl.org (smtp2.osuosl.org [140.211.166.133]) by lists.linuxfoundation.org (Postfix) with ESMTP id 7284CC000C for ; Mon, 21 Jun 2021 09:14:45 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp2.osuosl.org (Postfix) with ESMTP id 52B5D400A9 for ; Mon, 21 Jun 2021 09:14:45 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Authentication-Results: smtp2.osuosl.org (amavisd-new); dkim=pass (1024-bit key) header.d=redhat.com Received: from smtp2.osuosl.org ([127.0.0.1]) by localhost (smtp2.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 5UvbyTnWN0P0 for ; Mon, 21 Jun 2021 09:14:43 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.8.0 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by smtp2.osuosl.org (Postfix) with ESMTPS id CB42040022 for ; Mon, 21 Jun 2021 09:14:42 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1624266881; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=Tt7yo2RvlMhoUkpaMWxyjOZFsanqqyuVLb80GWGQKSo=; b=JZi+ORnfbO1W2/T3nW7w4U88Ty0S+eccMEfsgfDl0ov3Y2ctn1Zmbakt4ouCSUPtFqCO0P MeAFWmdDweD5kbWyQx6FK1Cu1ffTuSxQx74K2x0ONNveb1SYlmwr6ss3T54of4uTvUa0k8 vsd98PbBTyA7ytcFXuv6+tYsYGFNtWY= Received: from mail-pj1-f70.google.com (mail-pj1-f70.google.com [209.85.216.70]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-122-sGhHUyrMNDS7AzsS-YsPag-1; Mon, 21 Jun 2021 05:14:09 -0400 X-MC-Unique: sGhHUyrMNDS7AzsS-YsPag-1 Received: by mail-pj1-f70.google.com with SMTP id om12-20020a17090b3a8cb029016a4ee7d56fso9304884pjb.7 for ; Mon, 21 Jun 2021 02:14:09 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-transfer-encoding :content-language; bh=Tt7yo2RvlMhoUkpaMWxyjOZFsanqqyuVLb80GWGQKSo=; b=P1CADd4LZ/ke+0audoGi0twcc50LHjh+L5oFppzbIv2+V3lqTQ29XkvzevnN952KkB wS+Jp1OR+aDF/3FxLP/u+MXOrypNYLWevKUQA+XUA6CVuXk64PaiDe2+Oao0iRbAp17y o8gu7ML85GTK+3liDvD5Z8nyTLrFkU7iWb6ndhwlncgIppYvC580xNDYeDM75eIsYl1N G4JB+As2jw5vkMtKsJ72iy4fKavZrgMljS1AbbkIAPvEXUj9mpXWEA2a812aqQ/jymCF a3HibYvotoAGwhMulCbMrDCKDUEt+CZdYLduFjCEemlDpw+8YEaqIUqLfoyq0UjgUKEM p2zA== X-Gm-Message-State: AOAM531GLv1Pc2xNJlssWFeQwnjqAkzxd7/SCV5sAVPaiJF9jRUp8XHd m1whP1om0nNAuHjzXgxS//LZ6ezxSHG9I1s2ghCTP0roJDwOIwEuYyge36A6AlGxr6561CZVVRA bC8BS7O+yTHB/NZndBLfR5+7CNQdyhfJosLN1yqTJMw== X-Received: by 2002:a17:90a:e606:: with SMTP id j6mr20491676pjy.230.1624266848484; Mon, 21 Jun 2021 02:14:08 -0700 (PDT) X-Google-Smtp-Source: ABdhPJx760A/hTM9EzlHk6g1tGJ/qdpSIJzoPD2qafIY56u0RfGUdMjcnsBf7nOS0VHd+bGYuxc98w== X-Received: by 2002:a17:90a:e606:: with SMTP id j6mr20491630pjy.230.1624266847951; Mon, 21 Jun 2021 02:14:07 -0700 (PDT) Received: from wangxiaodeMacBook-Air.local ([209.132.188.80]) by smtp.gmail.com with ESMTPSA id n12sm5354590pfu.5.2021.06.21.02.14.00 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 21 Jun 2021 02:14:07 -0700 (PDT) Subject: Re: [PATCH v8 09/10] vduse: Introduce VDUSE - vDPA Device in Userspace To: Xie Yongji , mst@redhat.com, stefanha@redhat.com, sgarzare@redhat.com, parav@nvidia.com, hch@infradead.org, christian.brauner@canonical.com, rdunlap@infradead.org, willy@infradead.org, viro@zeniv.linux.org.uk, axboe@kernel.dk, bcrl@kvack.org, corbet@lwn.net, mika.penttila@nextfour.com, dan.carpenter@oracle.com, joro@8bytes.org, gregkh@linuxfoundation.org References: <20210615141331.407-1-xieyongji@bytedance.com> <20210615141331.407-10-xieyongji@bytedance.com> From: Jason Wang Message-ID: Date: Mon, 21 Jun 2021 17:13:55 +0800 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0) Gecko/20100101 Thunderbird/78.11.0 MIME-Version: 1.0 In-Reply-To: <20210615141331.407-10-xieyongji@bytedance.com> Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=jasowang@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Language: en-US Cc: kvm@vger.kernel.org, netdev@vger.kernel.org, linux-kernel@vger.kernel.org, virtualization@lists.linux-foundation.org, iommu@lists.linux-foundation.org, songmuchun@bytedance.com, linux-fsdevel@vger.kernel.org X-BeenThere: virtualization@lists.linux-foundation.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Linux virtualization List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="gbk"; Format="flowed" Errors-To: virtualization-bounces@lists.linux-foundation.org Sender: "Virtualization" CtTaIDIwMjEvNi8xNSDPws7nMTA6MTMsIFhpZSBZb25namkg0LS1wDoKPiBUaGlzIFZEVVNFIGRy aXZlciBlbmFibGVzIGltcGxlbWVudGluZyB2RFBBIGRldmljZXMgaW4gdXNlcnNwYWNlLgo+IFRo ZSB2RFBBIGRldmljZSdzIGNvbnRyb2wgcGF0aCBpcyBoYW5kbGVkIGluIGtlcm5lbCBhbmQgdGhl IGRhdGEKPiBwYXRoIGlzIGhhbmRsZWQgaW4gdXNlcnNwYWNlLgo+Cj4gQSBtZXNzYWdlIG1lY2hu aXNtIGlzIHVzZWQgYnkgVkRVU0UgZHJpdmVyIHRvIGZvcndhcmQgc29tZSBjb250cm9sCj4gbWVz c2FnZXMgc3VjaCBhcyBzdGFydGluZy9zdG9wcGluZyBkYXRhcGF0aCB0byB1c2Vyc3BhY2UuIFVz ZXJzcGFjZQo+IGNhbiB1c2UgcmVhZCgpL3dyaXRlKCkgdG8gcmVjZWl2ZS9yZXBseSB0aG9zZSBj b250cm9sIG1lc3NhZ2VzLgo+Cj4gQW5kIHNvbWUgaW9jdGxzIGFyZSBpbnRyb2R1Y2VkIHRvIGhl bHAgdXNlcnNwYWNlIHRvIGltcGxlbWVudCB0aGUKPiBkYXRhIHBhdGguIFZEVVNFX0lPVExCX0dF VF9GRCBpb2N0bCBjYW4gYmUgdXNlZCB0byBnZXQgdGhlIGZpbGUKPiBkZXNjcmlwdG9ycyByZWZl cnJpbmcgdG8gdkRQQSBkZXZpY2UncyBpb3ZhIHJlZ2lvbnMuIFRoZW4gdXNlcnNwYWNlCj4gY2Fu IHVzZSBtbWFwKCkgdG8gYWNjZXNzIHRob3NlIGlvdmEgcmVnaW9ucy4gVkRVU0VfREVWX0dFVF9G RUFUVVJFUwo+IGFuZCBWRFVTRV9WUV9HRVRfSU5GTyBpb2N0bHMgYXJlIHVzZWQgdG8gZ2V0IHRo ZSBuZWdvdGlhdGVkIGZlYXR1cmVzCj4gYW5kIG1ldGFkYXRhIG9mIHZpcnRxdWV1ZXMuIFZEVVNF X0lOSkVDVF9WUV9JUlEgYW5kIFZEVVNFX1ZRX1NFVFVQX0tJQ0tGRAo+IGlvY3RscyBjYW4gYmUg dXNlZCB0byBpbmplY3QgaW50ZXJydXB0IGFuZCBzZXR1cCB0aGUga2lja2ZkIGZvcgo+IHZpcnRx dWV1ZXMuIFZEVVNFX0RFVl9VUERBVEVfQ09ORklHIGlvY3RsIGlzIHVzZWQgdG8gdXBkYXRlIHRo ZQo+IGNvbmZpZ3VyYXRpb24gc3BhY2UgYW5kIGluamVjdCBhIGNvbmZpZyBpbnRlcnJ1cHQuCj4K PiBTaWduZWQtb2ZmLWJ5OiBYaWUgWW9uZ2ppIDx4aWV5b25namlAYnl0ZWRhbmNlLmNvbT4KPiAt LS0KPiAgIERvY3VtZW50YXRpb24vdXNlcnNwYWNlLWFwaS9pb2N0bC9pb2N0bC1udW1iZXIucnN0 IHwgICAgMSArCj4gICBkcml2ZXJzL3ZkcGEvS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB8ICAgMTAgKwo+ICAgZHJpdmVycy92ZHBhL01ha2VmaWxlICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgfCAgICAxICsKPiAgIGRyaXZlcnMvdmRwYS92ZHBhX3VzZXIvTWFrZWZp bGUgICAgICAgICAgICAgICAgICAgIHwgICAgNSArCj4gICBkcml2ZXJzL3ZkcGEvdmRwYV91c2Vy L3ZkdXNlX2Rldi5jICAgICAgICAgICAgICAgICB8IDE0NTMgKysrKysrKysrKysrKysrKysrKysK PiAgIGluY2x1ZGUvdWFwaS9saW51eC92ZHVzZS5oICAgICAgICAgICAgICAgICAgICAgICAgIHwg IDE0MyArKwo+ICAgNiBmaWxlcyBjaGFuZ2VkLCAxNjEzIGluc2VydGlvbnMoKykKPiAgIGNyZWF0 ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3ZkcGEvdmRwYV91c2VyL01ha2VmaWxlCj4gICBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy92ZHBhL3ZkcGFfdXNlci92ZHVzZV9kZXYuYwo+ICAgY3JlYXRl IG1vZGUgMTAwNjQ0IGluY2x1ZGUvdWFwaS9saW51eC92ZHVzZS5oCj4KPiBkaWZmIC0tZ2l0IGEv RG9jdW1lbnRhdGlvbi91c2Vyc3BhY2UtYXBpL2lvY3RsL2lvY3RsLW51bWJlci5yc3QgYi9Eb2N1 bWVudGF0aW9uL3VzZXJzcGFjZS1hcGkvaW9jdGwvaW9jdGwtbnVtYmVyLnJzdAo+IGluZGV4IDli ZmMyYjUxMGM2NC4uYWNkOTVlOWRjZmU3IDEwMDY0NAo+IC0tLSBhL0RvY3VtZW50YXRpb24vdXNl cnNwYWNlLWFwaS9pb2N0bC9pb2N0bC1udW1iZXIucnN0Cj4gKysrIGIvRG9jdW1lbnRhdGlvbi91 c2Vyc3BhY2UtYXBpL2lvY3RsL2lvY3RsLW51bWJlci5yc3QKPiBAQCAtMzAwLDYgKzMwMCw3IEBA IENvZGUgIFNlcSMgICAgSW5jbHVkZSBGaWxlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIENvbW1lbnRzCj4gICAneicgICAxMC00RiAgZHJpdmVycy9zMzkwL2NyeXB0 by96Y3J5cHRfYXBpLmggICAgICAgICAgICAgICAgICAgICAgICBjb25mbGljdCEKPiAgICd8JyAg IDAwLTdGICBsaW51eC9tZWRpYS5oCj4gICAweDgwICAwMC0xRiAgbGludXgvZmIuaAo+ICsweDgx ICAwMC0xRiAgbGludXgvdmR1c2UuaAo+ICAgMHg4OSAgMDAtMDYgIGFyY2gveDg2L2luY2x1ZGUv YXNtL3NvY2tpb3MuaAo+ICAgMHg4OSAgMEItREYgIGxpbnV4L3NvY2tpb3MuaAo+ICAgMHg4OSAg RTAtRUYgIGxpbnV4L3NvY2tpb3MuaCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgU0lPQ1BST1RPUFJJVkFURSByYW5nZQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3ZkcGEv S2NvbmZpZyBiL2RyaXZlcnMvdmRwYS9LY29uZmlnCj4gaW5kZXggYTUwM2MxYjJiZmQ5Li42ZTIz YmNlNjQzM2EgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy92ZHBhL0tjb25maWcKPiArKysgYi9kcml2 ZXJzL3ZkcGEvS2NvbmZpZwo+IEBAIC0zMyw2ICszMywxNiBAQCBjb25maWcgVkRQQV9TSU1fQkxP Q0sKPiAgIAkgIHZEUEEgYmxvY2sgZGV2aWNlIHNpbXVsYXRvciB3aGljaCB0ZXJtaW5hdGVzIElP IHJlcXVlc3QgaW4gYQo+ICAgCSAgbWVtb3J5IGJ1ZmZlci4KPiAgIAo+ICtjb25maWcgVkRQQV9V U0VSCj4gKwl0cmlzdGF0ZSAiVkRVU0UgKHZEUEEgRGV2aWNlIGluIFVzZXJzcGFjZSkgc3VwcG9y dCIKPiArCWRlcGVuZHMgb24gRVZFTlRGRCAmJiBNTVUgJiYgSEFTX0RNQQo+ICsJc2VsZWN0IERN QV9PUFMKPiArCXNlbGVjdCBWSE9TVF9JT1RMQgo+ICsJc2VsZWN0IElPTU1VX0lPVkEKPiArCWhl bHAKPiArCSAgV2l0aCBWRFVTRSBpdCBpcyBwb3NzaWJsZSB0byBlbXVsYXRlIGEgdkRQQSBEZXZp Y2UKPiArCSAgaW4gYSB1c2Vyc3BhY2UgcHJvZ3JhbS4KPiArCj4gICBjb25maWcgSUZDVkYKPiAg IAl0cmlzdGF0ZSAiSW50ZWwgSUZDIFZGIHZEUEEgZHJpdmVyIgo+ICAgCWRlcGVuZHMgb24gUENJ X01TSQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3ZkcGEvTWFrZWZpbGUgYi9kcml2ZXJzL3ZkcGEv TWFrZWZpbGUKPiBpbmRleCA2N2ZlN2YzZDY5NDMuLmYwMmViZWQzM2YxOSAxMDA2NDQKPiAtLS0g YS9kcml2ZXJzL3ZkcGEvTWFrZWZpbGUKPiArKysgYi9kcml2ZXJzL3ZkcGEvTWFrZWZpbGUKPiBA QCAtMSw2ICsxLDcgQEAKPiAgICMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKPiAg IG9iai0kKENPTkZJR19WRFBBKSArPSB2ZHBhLm8KPiAgIG9iai0kKENPTkZJR19WRFBBX1NJTSkg Kz0gdmRwYV9zaW0vCj4gK29iai0kKENPTkZJR19WRFBBX1VTRVIpICs9IHZkcGFfdXNlci8KPiAg IG9iai0kKENPTkZJR19JRkNWRikgICAgKz0gaWZjdmYvCj4gICBvYmotJChDT05GSUdfTUxYNV9W RFBBKSArPSBtbHg1Lwo+ICAgb2JqLSQoQ09ORklHX1ZQX1ZEUEEpICAgICs9IHZpcnRpb19wY2kv Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmRwYS92ZHBhX3VzZXIvTWFrZWZpbGUgYi9kcml2ZXJz L3ZkcGEvdmRwYV91c2VyL01ha2VmaWxlCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAw MDAwMDAwMDAwMDAuLjI2MGUwYjI2YWY5OQo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJz L3ZkcGEvdmRwYV91c2VyL01ha2VmaWxlCj4gQEAgLTAsMCArMSw1IEBACj4gKyMgU1BEWC1MaWNl bnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKPiArCj4gK3ZkdXNlLXkgOj0gdmR1c2VfZGV2Lm8gaW92 YV9kb21haW4ubwo+ICsKPiArb2JqLSQoQ09ORklHX1ZEUEFfVVNFUikgKz0gdmR1c2Uubwo+IGRp ZmYgLS1naXQgYS9kcml2ZXJzL3ZkcGEvdmRwYV91c2VyL3ZkdXNlX2Rldi5jIGIvZHJpdmVycy92 ZHBhL3ZkcGFfdXNlci92ZHVzZV9kZXYuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXgg MDAwMDAwMDAwMDAwLi41MjcxY2JkMTVlMjgKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJpdmVy cy92ZHBhL3ZkcGFfdXNlci92ZHVzZV9kZXYuYwo+IEBAIC0wLDAgKzEsMTQ1MyBAQAo+ICsvLyBT UERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5Cj4gKy8qCj4gKyAqIFZEVVNFOiB2 RFBBIERldmljZSBpbiBVc2Vyc3BhY2UKPiArICoKPiArICogQ29weXJpZ2h0IChDKSAyMDIwLTIw MjEgQnl0ZWRhbmNlIEluYy4gYW5kL29yIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2Vy dmVkLgo+ICsgKgo+ICsgKiBBdXRob3I6IFhpZSBZb25namkgPHhpZXlvbmdqaUBieXRlZGFuY2Uu Y29tPgo+ICsgKgo+ICsgKi8KPiArCj4gKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+Cj4gKyNpbmNs dWRlIDxsaW51eC9tb2R1bGUuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2NkZXYuaD4KPiArI2luY2x1 ZGUgPGxpbnV4L2RldmljZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvZXZlbnRmZC5oPgo+ICsjaW5j bHVkZSA8bGludXgvc2xhYi5oPgo+ICsjaW5jbHVkZSA8bGludXgvd2FpdC5oPgo+ICsjaW5jbHVk ZSA8bGludXgvZG1hLW1hcC1vcHMuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3BvbGwuaD4KPiArI2lu Y2x1ZGUgPGxpbnV4L2ZpbGUuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3Vpby5oPgo+ICsjaW5jbHVk ZSA8bGludXgvdmRwYS5oPgo+ICsjaW5jbHVkZSA8bGludXgvbm9zcGVjLmg+Cj4gKyNpbmNsdWRl IDx1YXBpL2xpbnV4L3ZkdXNlLmg+Cj4gKyNpbmNsdWRlIDx1YXBpL2xpbnV4L3ZkcGEuaD4KPiAr I2luY2x1ZGUgPHVhcGkvbGludXgvdmlydGlvX2NvbmZpZy5oPgo+ICsjaW5jbHVkZSA8dWFwaS9s aW51eC92aXJ0aW9faWRzLmg+Cj4gKyNpbmNsdWRlIDx1YXBpL2xpbnV4L3ZpcnRpb19ibGsuaD4K PiArI2luY2x1ZGUgPGxpbnV4L21vZF9kZXZpY2V0YWJsZS5oPgo+ICsKPiArI2luY2x1ZGUgImlv dmFfZG9tYWluLmgiCj4gKwo+ICsjZGVmaW5lIERSVl9BVVRIT1IgICAiWW9uZ2ppIFhpZSA8eGll eW9uZ2ppQGJ5dGVkYW5jZS5jb20+Igo+ICsjZGVmaW5lIERSVl9ERVNDICAgICAidkRQQSBEZXZp Y2UgaW4gVXNlcnNwYWNlIgo+ICsjZGVmaW5lIERSVl9MSUNFTlNFICAiR1BMIHYyIgo+ICsKPiAr I2RlZmluZSBWRFVTRV9ERVZfTUFYICgxVSA8PCBNSU5PUkJJVFMpCj4gKyNkZWZpbmUgVkRVU0Vf TUFYX0JPVU5DRV9TSVpFICg2NCAqIDEwMjQgKiAxMDI0KQo+ICsjZGVmaW5lIFZEVVNFX0lPVkFf U0laRSAoMTI4ICogMTAyNCAqIDEwMjQpCj4gKyNkZWZpbmUgVkRVU0VfUkVRVUVTVF9USU1FT1VU IDMwCj4gKwo+ICtzdHJ1Y3QgdmR1c2VfdmlydHF1ZXVlIHsKPiArCXUxNiBpbmRleDsKPiArCXUz MiBudW07Cj4gKwl1MzIgYXZhaWxfaWR4Owo+ICsJdTY0IGRlc2NfYWRkcjsKPiArCXU2NCBkcml2 ZXJfYWRkcjsKPiArCXU2NCBkZXZpY2VfYWRkcjsKPiArCWJvb2wgcmVhZHk7Cj4gKwlib29sIGtp Y2tlZDsKPiArCXNwaW5sb2NrX3Qga2lja19sb2NrOwo+ICsJc3BpbmxvY2tfdCBpcnFfbG9jazsK PiArCXN0cnVjdCBldmVudGZkX2N0eCAqa2lja2ZkOwo+ICsJc3RydWN0IHZkcGFfY2FsbGJhY2sg Y2I7Cj4gKwlzdHJ1Y3Qgd29ya19zdHJ1Y3QgaW5qZWN0Owo+ICt9Owo+ICsKPiArc3RydWN0IHZk dXNlX2RldjsKPiArCj4gK3N0cnVjdCB2ZHVzZV92ZHBhIHsKPiArCXN0cnVjdCB2ZHBhX2Rldmlj ZSB2ZHBhOwo+ICsJc3RydWN0IHZkdXNlX2RldiAqZGV2Owo+ICt9Owo+ICsKPiArc3RydWN0IHZk dXNlX2RldiB7Cj4gKwlzdHJ1Y3QgdmR1c2VfdmRwYSAqdmRldjsKPiArCXN0cnVjdCBkZXZpY2Ug KmRldjsKPiArCXN0cnVjdCB2ZHVzZV92aXJ0cXVldWUgKnZxczsKPiArCXN0cnVjdCB2ZHVzZV9p b3ZhX2RvbWFpbiAqZG9tYWluOwo+ICsJY2hhciAqbmFtZTsKPiArCXN0cnVjdCBtdXRleCBsb2Nr Owo+ICsJc3BpbmxvY2tfdCBtc2dfbG9jazsKPiArCXU2NCBtc2dfdW5pcXVlOwo+ICsJd2FpdF9x dWV1ZV9oZWFkX3Qgd2FpdHE7Cj4gKwlzdHJ1Y3QgbGlzdF9oZWFkIHNlbmRfbGlzdDsKPiArCXN0 cnVjdCBsaXN0X2hlYWQgcmVjdl9saXN0Owo+ICsJc3RydWN0IHZkcGFfY2FsbGJhY2sgY29uZmln X2NiOwo+ICsJc3RydWN0IHdvcmtfc3RydWN0IGluamVjdDsKPiArCXNwaW5sb2NrX3QgaXJxX2xv Y2s7Cj4gKwlpbnQgbWlub3I7Cj4gKwlib29sIGNvbm5lY3RlZDsKPiArCWJvb2wgc3RhcnRlZDsK PiArCXU2NCBhcGlfdmVyc2lvbjsKPiArCXU2NCB1c2VyX2ZlYXR1cmVzOwoKCkxldCdzIHVzZSBk ZXZpY2VfZmVhdHVyZXMuCgoKPiArCXU2NCBmZWF0dXJlczsKCgpBbmQgZHJpdmVyIGZlYXR1cmVz LgoKCj4gKwl1MzIgZGV2aWNlX2lkOwo+ICsJdTMyIHZlbmRvcl9pZDsKPiArCXUzMiBnZW5lcmF0 aW9uOwo+ICsJdTMyIGNvbmZpZ19zaXplOwo+ICsJdm9pZCAqY29uZmlnOwo+ICsJdTggc3RhdHVz Owo+ICsJdTE2IHZxX3NpemVfbWF4Owo+ICsJdTMyIHZxX251bTsKPiArCXUzMiB2cV9hbGlnbjsK PiArfTsKPiArCj4gK3N0cnVjdCB2ZHVzZV9kZXZfbXNnIHsKPiArCXN0cnVjdCB2ZHVzZV9kZXZf cmVxdWVzdCByZXE7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2X3Jlc3BvbnNlIHJlc3A7Cj4gKwlzdHJ1 Y3QgbGlzdF9oZWFkIGxpc3Q7Cj4gKwl3YWl0X3F1ZXVlX2hlYWRfdCB3YWl0cTsKPiArCWJvb2wg Y29tcGxldGVkOwo+ICt9Owo+ICsKPiArc3RydWN0IHZkdXNlX2NvbnRyb2wgewo+ICsJdTY0IGFw aV92ZXJzaW9uOwo+ICt9Owo+ICsKPiArc3RhdGljIERFRklORV9NVVRFWCh2ZHVzZV9sb2NrKTsK PiArc3RhdGljIERFRklORV9JRFIodmR1c2VfaWRyKTsKPiArCj4gK3N0YXRpYyBkZXZfdCB2ZHVz ZV9tYWpvcjsKPiArc3RhdGljIHN0cnVjdCBjbGFzcyAqdmR1c2VfY2xhc3M7Cj4gK3N0YXRpYyBz dHJ1Y3QgY2RldiB2ZHVzZV9jdHJsX2NkZXY7Cj4gK3N0YXRpYyBzdHJ1Y3QgY2RldiB2ZHVzZV9j ZGV2Owo+ICtzdGF0aWMgc3RydWN0IHdvcmtxdWV1ZV9zdHJ1Y3QgKnZkdXNlX2lycV93cTsKPiAr Cj4gK3N0YXRpYyB1MzIgYWxsb3dlZF9kZXZpY2VfaWRbXSA9IHsKPiArCVZJUlRJT19JRF9CTE9D SywKPiArfTsKPiArCj4gK3N0YXRpYyBpbmxpbmUgc3RydWN0IHZkdXNlX2RldiAqdmRwYV90b192 ZHVzZShzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV92ZHBh ICp2ZGV2ID0gY29udGFpbmVyX29mKHZkcGEsIHN0cnVjdCB2ZHVzZV92ZHBhLCB2ZHBhKTsKPiAr Cj4gKwlyZXR1cm4gdmRldi0+ZGV2Owo+ICt9Cj4gKwo+ICtzdGF0aWMgaW5saW5lIHN0cnVjdCB2 ZHVzZV9kZXYgKmRldl90b192ZHVzZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gK3sKPiArCXN0cnVj dCB2ZHBhX2RldmljZSAqdmRwYSA9IGRldl90b192ZHBhKGRldik7Cj4gKwo+ICsJcmV0dXJuIHZk cGFfdG9fdmR1c2UodmRwYSk7Cj4gK30KPiArCj4gK3N0YXRpYyBzdHJ1Y3QgdmR1c2VfZGV2X21z ZyAqdmR1c2VfZmluZF9tc2coc3RydWN0IGxpc3RfaGVhZCAqaGVhZCwKPiArCQkJCQkgICAgdWlu dDMyX3QgcmVxdWVzdF9pZCkKPiArewo+ICsJc3RydWN0IHZkdXNlX2Rldl9tc2cgKm1zZzsKPiAr Cj4gKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KG1zZywgaGVhZCwgbGlzdCkgewo+ICsJCWlmIChtc2ct PnJlcS5yZXF1ZXN0X2lkID09IHJlcXVlc3RfaWQpIHsKPiArCQkJbGlzdF9kZWwoJm1zZy0+bGlz dCk7Cj4gKwkJCXJldHVybiBtc2c7Cj4gKwkJfQo+ICsJfQo+ICsKPiArCXJldHVybiBOVUxMOwo+ ICt9Cj4gKwo+ICtzdGF0aWMgc3RydWN0IHZkdXNlX2Rldl9tc2cgKnZkdXNlX2RlcXVldWVfbXNn KHN0cnVjdCBsaXN0X2hlYWQgKmhlYWQpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXZfbXNnICpt c2cgPSBOVUxMOwo+ICsKPiArCWlmICghbGlzdF9lbXB0eShoZWFkKSkgewo+ICsJCW1zZyA9IGxp c3RfZmlyc3RfZW50cnkoaGVhZCwgc3RydWN0IHZkdXNlX2Rldl9tc2csIGxpc3QpOwo+ICsJCWxp c3RfZGVsKCZtc2ctPmxpc3QpOwo+ICsJfQo+ICsKPiArCXJldHVybiBtc2c7Cj4gK30KPiArCj4g K3N0YXRpYyB2b2lkIHZkdXNlX2VucXVldWVfbXNnKHN0cnVjdCBsaXN0X2hlYWQgKmhlYWQsCj4g KwkJCSAgICAgIHN0cnVjdCB2ZHVzZV9kZXZfbXNnICptc2cpCj4gK3sKPiArCWxpc3RfYWRkX3Rh aWwoJm1zZy0+bGlzdCwgaGVhZCk7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgdmR1c2VfZGV2X21z Z19zZW5kKHN0cnVjdCB2ZHVzZV9kZXYgKmRldiwKPiArCQkJICAgICAgc3RydWN0IHZkdXNlX2Rl dl9tc2cgKm1zZywgYm9vbCBub19yZXBseSkKPiArewoKCkl0IGxvb2tzIHRvIG1lIHRoZSBvbmx5 IHVzZXIgZm9yIG5vX3JlcGx5PXRydWUgaXMgdGhlIGRhdGFwbGFuZSBzdGFydC4gSSAKd29uZGVy IG5vX3JlcGx5IGlzIHJlYWxseSBuZWVkZWQgY29uc2lkZXIgd2UgaGF2ZSBzd2l0Y2hlZCB0byB1 c2UgCndhaXRfZXZlbnRfa2lsbGFibGVfdGltZW91dCgpLgoKSW4gYW5vdGhlciB3YXksIG5vX3Jl cGx5IGlzIGZhbHNlIGZvciB2cSBzdGF0ZSBzeW5jaHJvbml6YXRpb24gYW5kIElPVExCIAp1cGRh dGluZy4gSSB3b25kZXIgaWYgd2UgY2FuIHNpbXBseSB1c2Ugbm9fcmVwbHkgPSB0cnVlIGZvciB0 aGVtLgoKCj4gKwlpbml0X3dhaXRxdWV1ZV9oZWFkKCZtc2ctPndhaXRxKTsKPiArCXNwaW5fbG9j aygmZGV2LT5tc2dfbG9jayk7Cj4gKwltc2ctPnJlcS5yZXF1ZXN0X2lkID0gZGV2LT5tc2dfdW5p cXVlKys7Cj4gKwl2ZHVzZV9lbnF1ZXVlX21zZygmZGV2LT5zZW5kX2xpc3QsIG1zZyk7Cj4gKwl3 YWtlX3VwKCZkZXYtPndhaXRxKTsKPiArCXNwaW5fdW5sb2NrKCZkZXYtPm1zZ19sb2NrKTsKPiAr CWlmIChub19yZXBseSkKPiArCQlyZXR1cm4gMDsKPiArCj4gKwl3YWl0X2V2ZW50X2tpbGxhYmxl X3RpbWVvdXQobXNnLT53YWl0cSwgbXNnLT5jb21wbGV0ZWQsCj4gKwkJCQkgICAgVkRVU0VfUkVR VUVTVF9USU1FT1VUICogSFopOwo+ICsJc3Bpbl9sb2NrKCZkZXYtPm1zZ19sb2NrKTsKPiArCWlm ICghbXNnLT5jb21wbGV0ZWQpIHsKPiArCQlsaXN0X2RlbCgmbXNnLT5saXN0KTsKPiArCQltc2ct PnJlc3AucmVzdWx0ID0gVkRVU0VfUkVRX1JFU1VMVF9GQUlMRUQ7Cj4gKwl9Cj4gKwlzcGluX3Vu bG9jaygmZGV2LT5tc2dfbG9jayk7Cj4gKwo+ICsJcmV0dXJuIChtc2ctPnJlc3AucmVzdWx0ID09 IFZEVVNFX1JFUV9SRVNVTFRfT0spID8gMCA6IC1FSU87CgoKRG8gd2UgbmVlZCB0byBzZXJpYWxp emUgdGhlIGNoZWNrIGJ5IHByb3RlY3RpbmcgaXQgd2l0aCB0aGUgc3BpbmxvY2sgYWJvdmU/CgoK PiArfQo+ICsKPiArc3RhdGljIHZvaWQgdmR1c2VfZGV2X21zZ19jbGVhbnVwKHN0cnVjdCB2ZHVz ZV9kZXYgKmRldikKPiArewo+ICsJc3RydWN0IHZkdXNlX2Rldl9tc2cgKm1zZzsKPiArCj4gKwlz cGluX2xvY2soJmRldi0+bXNnX2xvY2spOwo+ICsJd2hpbGUgKChtc2cgPSB2ZHVzZV9kZXF1ZXVl X21zZygmZGV2LT5zZW5kX2xpc3QpKSkgewo+ICsJCWlmIChtc2ctPnJlcS5mbGFncyAmIFZEVVNF X1JFUV9GTEFHU19OT19SRVBMWSkKPiArCQkJa2ZyZWUobXNnKTsKPiArCQllbHNlCj4gKwkJCXZk dXNlX2VucXVldWVfbXNnKCZkZXYtPnJlY3ZfbGlzdCwgbXNnKTsKPiArCX0KPiArCXdoaWxlICgo bXNnID0gdmR1c2VfZGVxdWV1ZV9tc2coJmRldi0+cmVjdl9saXN0KSkpIHsKPiArCQltc2ctPnJl c3AucmVzdWx0ID0gVkRVU0VfUkVRX1JFU1VMVF9GQUlMRUQ7Cj4gKwkJbXNnLT5jb21wbGV0ZWQg PSAxOwo+ICsJCXdha2VfdXAoJm1zZy0+d2FpdHEpOwo+ICsJfQo+ICsJc3Bpbl91bmxvY2soJmRl di0+bXNnX2xvY2spOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCB2ZHVzZV9kZXZfc3RhcnRfZGF0 YXBsYW5lKHN0cnVjdCB2ZHVzZV9kZXYgKmRldikKPiArewo+ICsJc3RydWN0IHZkdXNlX2Rldl9t c2cgKm1zZyA9IGt6YWxsb2Moc2l6ZW9mKCptc2cpLAo+ICsJCQkJCSAgICBHRlBfS0VSTkVMIHwg X19HRlBfTk9GQUlMKTsKPiArCj4gKwltc2ctPnJlcS50eXBlID0gVkRVU0VfU1RBUlRfREFUQVBM QU5FOwo+ICsJbXNnLT5yZXEuZmxhZ3MgfD0gVkRVU0VfUkVRX0ZMQUdTX05PX1JFUExZOwo+ICsJ dmR1c2VfZGV2X21zZ19zZW5kKGRldiwgbXNnLCB0cnVlKTsKPiArfQo+ICsKPiArc3RhdGljIHZv aWQgdmR1c2VfZGV2X3N0b3BfZGF0YXBsYW5lKHN0cnVjdCB2ZHVzZV9kZXYgKmRldikKPiArewo+ ICsJc3RydWN0IHZkdXNlX2Rldl9tc2cgKm1zZyA9IGt6YWxsb2Moc2l6ZW9mKCptc2cpLAo+ICsJ CQkJCSAgICBHRlBfS0VSTkVMIHwgX19HRlBfTk9GQUlMKTsKPiArCj4gKwltc2ctPnJlcS50eXBl ID0gVkRVU0VfU1RPUF9EQVRBUExBTkU7Cj4gKwltc2ctPnJlcS5mbGFncyB8PSBWRFVTRV9SRVFf RkxBR1NfTk9fUkVQTFk7CgoKQ2FuIHdlIHNpbXBseSB1c2UgdGhpcyBmbGFnIGluc3RlYWQgb2Yg aW50cm9kdWNpbmcgYSBuZXcgcGFyYW1ldGVyIAoobm9fcmVwbHkpIGluIHZkdXNlX2Rldl9tc2df c2VuZCgpPwoKCj4gKwl2ZHVzZV9kZXZfbXNnX3NlbmQoZGV2LCBtc2csIHRydWUpOwo+ICt9Cj4g Kwo+ICtzdGF0aWMgaW50IHZkdXNlX2Rldl9nZXRfdnFfc3RhdGUoc3RydWN0IHZkdXNlX2RldiAq ZGV2LAo+ICsJCQkJICBzdHJ1Y3QgdmR1c2VfdmlydHF1ZXVlICp2cSwKPiArCQkJCSAgc3RydWN0 IHZkcGFfdnFfc3RhdGUgKnN0YXRlKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2X21zZyBtc2cg PSB7IDAgfTsKPiArCWludCByZXQ7CgoKTm90ZSB0aGF0IEkgcG9zdCBhIHNlcmllcyB0aGF0IGlt cGxlbWVudCB0aGUgcGFja2VkIHZpcnRxdWV1ZSBzdXBwb3J0OgoKaHR0cHM6Ly9saXN0cy5saW51 eGZvdW5kYXRpb24ub3JnL3BpcGVybWFpbC92aXJ0dWFsaXphdGlvbi8yMDIxLUp1bmUvMDU0NTAx Lmh0bWwKClNvIHRoaXMgcGF0Y2ggbmVlZHMgdG8gYmUgdXBkYXRlZCBhcyB3ZWxsLgoKCj4gKwo+ ICsJbXNnLnJlcS50eXBlID0gVkRVU0VfR0VUX1ZRX1NUQVRFOwo+ICsJbXNnLnJlcS52cV9zdGF0 ZS5pbmRleCA9IHZxLT5pbmRleDsKPiArCj4gKwlyZXQgPSB2ZHVzZV9kZXZfbXNnX3NlbmQoZGV2 LCAmbXNnLCBmYWxzZSk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJc3Rh dGUtPmF2YWlsX2luZGV4ID0gbXNnLnJlc3AudnFfc3RhdGUuYXZhaWxfaWR4Owo+ICsJcmV0dXJu IDA7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgdmR1c2VfZGV2X3VwZGF0ZV9pb3RsYihzdHJ1Y3Qg dmR1c2VfZGV2ICpkZXYsCj4gKwkJCQl1NjQgc3RhcnQsIHU2NCBsYXN0KQo+ICt7Cj4gKwlzdHJ1 Y3QgdmR1c2VfZGV2X21zZyBtc2cgPSB7IDAgfTsKPiArCj4gKwlpZiAobGFzdCA8IHN0YXJ0KQo+ ICsJCXJldHVybiAtRUlOVkFMOwo+ICsKPiArCW1zZy5yZXEudHlwZSA9IFZEVVNFX1VQREFURV9J T1RMQjsKPiArCW1zZy5yZXEuaW92YS5zdGFydCA9IHN0YXJ0Owo+ICsJbXNnLnJlcS5pb3ZhLmxh c3QgPSBsYXN0Owo+ICsKPiArCXJldHVybiB2ZHVzZV9kZXZfbXNnX3NlbmQoZGV2LCAmbXNnLCBm YWxzZSk7Cj4gK30KPiArCj4gK3N0YXRpYyBzc2l6ZV90IHZkdXNlX2Rldl9yZWFkX2l0ZXIoc3Ry dWN0IGtpb2NiICppb2NiLCBzdHJ1Y3QgaW92X2l0ZXIgKnRvKQo+ICt7Cj4gKwlzdHJ1Y3QgZmls ZSAqZmlsZSA9IGlvY2ItPmtpX2ZpbHA7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSBmaWxl LT5wcml2YXRlX2RhdGE7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2X21zZyAqbXNnOwo+ICsJaW50IHNp emUgPSBzaXplb2Yoc3RydWN0IHZkdXNlX2Rldl9yZXF1ZXN0KTsKPiArCXNzaXplX3QgcmV0Owo+ ICsKPiArCWlmIChpb3ZfaXRlcl9jb3VudCh0bykgPCBzaXplKQo+ICsJCXJldHVybiAtRUlOVkFM Owo+ICsKPiArCXNwaW5fbG9jaygmZGV2LT5tc2dfbG9jayk7Cj4gKwl3aGlsZSAoMSkgewo+ICsJ CW1zZyA9IHZkdXNlX2RlcXVldWVfbXNnKCZkZXYtPnNlbmRfbGlzdCk7Cj4gKwkJaWYgKG1zZykK PiArCQkJYnJlYWs7Cj4gKwo+ICsJCXJldCA9IC1FQUdBSU47Cj4gKwkJaWYgKGZpbGUtPmZfZmxh Z3MgJiBPX05PTkJMT0NLKQo+ICsJCQlnb3RvIHVubG9jazsKPiArCj4gKwkJc3Bpbl91bmxvY2so JmRldi0+bXNnX2xvY2spOwo+ICsJCXJldCA9IHdhaXRfZXZlbnRfaW50ZXJydXB0aWJsZV9leGNs dXNpdmUoZGV2LT53YWl0cSwKPiArCQkJCQkhbGlzdF9lbXB0eSgmZGV2LT5zZW5kX2xpc3QpKTsK PiArCQlpZiAocmV0KQo+ICsJCQlyZXR1cm4gcmV0Owo+ICsKPiArCQlzcGluX2xvY2soJmRldi0+ bXNnX2xvY2spOwo+ICsJfQo+ICsJc3Bpbl91bmxvY2soJmRldi0+bXNnX2xvY2spOwo+ICsJcmV0 ID0gY29weV90b19pdGVyKCZtc2ctPnJlcSwgc2l6ZSwgdG8pOwo+ICsJc3Bpbl9sb2NrKCZkZXYt Pm1zZ19sb2NrKTsKPiArCWlmIChyZXQgIT0gc2l6ZSkgewo+ICsJCXJldCA9IC1FRkFVTFQ7Cj4g KwkJdmR1c2VfZW5xdWV1ZV9tc2coJmRldi0+c2VuZF9saXN0LCBtc2cpOwo+ICsJCWdvdG8gdW5s b2NrOwo+ICsJfQo+ICsJaWYgKG1zZy0+cmVxLmZsYWdzICYgVkRVU0VfUkVRX0ZMQUdTX05PX1JF UExZKQo+ICsJCWtmcmVlKG1zZyk7Cj4gKwllbHNlCj4gKwkJdmR1c2VfZW5xdWV1ZV9tc2coJmRl di0+cmVjdl9saXN0LCBtc2cpOwo+ICt1bmxvY2s6Cj4gKwlzcGluX3VubG9jaygmZGV2LT5tc2df bG9jayk7Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGljIHNzaXplX3QgdmR1 c2VfZGV2X3dyaXRlX2l0ZXIoc3RydWN0IGtpb2NiICppb2NiLCBzdHJ1Y3QgaW92X2l0ZXIgKmZy b20pCj4gK3sKPiArCXN0cnVjdCBmaWxlICpmaWxlID0gaW9jYi0+a2lfZmlscDsKPiArCXN0cnVj dCB2ZHVzZV9kZXYgKmRldiA9IGZpbGUtPnByaXZhdGVfZGF0YTsKPiArCXN0cnVjdCB2ZHVzZV9k ZXZfcmVzcG9uc2UgcmVzcDsKPiArCXN0cnVjdCB2ZHVzZV9kZXZfbXNnICptc2c7Cj4gKwlzaXpl X3QgcmV0Owo+ICsKPiArCXJldCA9IGNvcHlfZnJvbV9pdGVyKCZyZXNwLCBzaXplb2YocmVzcCks IGZyb20pOwo+ICsJaWYgKHJldCAhPSBzaXplb2YocmVzcCkpCj4gKwkJcmV0dXJuIC1FSU5WQUw7 Cj4gKwo+ICsJc3Bpbl9sb2NrKCZkZXYtPm1zZ19sb2NrKTsKPiArCW1zZyA9IHZkdXNlX2ZpbmRf bXNnKCZkZXYtPnJlY3ZfbGlzdCwgcmVzcC5yZXF1ZXN0X2lkKTsKPiArCWlmICghbXNnKSB7Cj4g KwkJcmV0ID0gLUVOT0VOVDsKPiArCQlnb3RvIHVubG9jazsKPiArCX0KPiArCj4gKwltZW1jcHko Jm1zZy0+cmVzcCwgJnJlc3AsIHNpemVvZihyZXNwKSk7Cj4gKwltc2ctPmNvbXBsZXRlZCA9IDE7 Cj4gKwl3YWtlX3VwKCZtc2ctPndhaXRxKTsKPiArdW5sb2NrOgo+ICsJc3Bpbl91bmxvY2soJmRl di0+bXNnX2xvY2spOwo+ICsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4gK3N0YXRpYyBfX3Bv bGxfdCB2ZHVzZV9kZXZfcG9sbChzdHJ1Y3QgZmlsZSAqZmlsZSwgcG9sbF90YWJsZSAqd2FpdCkK PiArewo+ICsJc3RydWN0IHZkdXNlX2RldiAqZGV2ID0gZmlsZS0+cHJpdmF0ZV9kYXRhOwo+ICsJ X19wb2xsX3QgbWFzayA9IDA7Cj4gKwo+ICsJcG9sbF93YWl0KGZpbGUsICZkZXYtPndhaXRxLCB3 YWl0KTsKPiArCj4gKwlpZiAoIWxpc3RfZW1wdHkoJmRldi0+c2VuZF9saXN0KSkKPiArCQltYXNr IHw9IEVQT0xMSU4gfCBFUE9MTFJETk9STTsKPiArCWlmICghbGlzdF9lbXB0eSgmZGV2LT5yZWN2 X2xpc3QpKQo+ICsJCW1hc2sgfD0gRVBPTExPVVQgfCBFUE9MTFdSTk9STTsKPiArCj4gKwlyZXR1 cm4gbWFzazsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdmR1c2VfZGV2X3Jlc2V0KHN0cnVjdCB2 ZHVzZV9kZXYgKmRldikKPiArewo+ICsJaW50IGk7Cj4gKwlzdHJ1Y3QgdmR1c2VfaW92YV9kb21h aW4gKmRvbWFpbiA9IGRldi0+ZG9tYWluOwo+ICsKPiArCS8qIFRoZSBjb2hlcmVudCBtYXBwaW5n cyBhcmUgaGFuZGxlZCBpbiB2ZHVzZV9kZXZfZnJlZV9jb2hlcmVudCgpICovCj4gKwlpZiAoZG9t YWluLT5ib3VuY2VfbWFwKQo+ICsJCXZkdXNlX2RvbWFpbl9yZXNldF9ib3VuY2VfbWFwKGRvbWFp bik7Cj4gKwo+ICsJZGV2LT5mZWF0dXJlcyA9IDA7Cj4gKwlkZXYtPmdlbmVyYXRpb24rKzsKPiAr CXNwaW5fbG9jaygmZGV2LT5pcnFfbG9jayk7Cj4gKwlkZXYtPmNvbmZpZ19jYi5jYWxsYmFjayA9 IE5VTEw7Cj4gKwlkZXYtPmNvbmZpZ19jYi5wcml2YXRlID0gTlVMTDsKPiArCXNwaW5fdW5sb2Nr KCZkZXYtPmlycV9sb2NrKTsKPiArCj4gKwlmb3IgKGkgPSAwOyBpIDwgZGV2LT52cV9udW07IGkr Kykgewo+ICsJCXN0cnVjdCB2ZHVzZV92aXJ0cXVldWUgKnZxID0gJmRldi0+dnFzW2ldOwo+ICsK PiArCQl2cS0+cmVhZHkgPSBmYWxzZTsKPiArCQl2cS0+ZGVzY19hZGRyID0gMDsKPiArCQl2cS0+ ZHJpdmVyX2FkZHIgPSAwOwo+ICsJCXZxLT5kZXZpY2VfYWRkciA9IDA7Cj4gKwkJdnEtPmF2YWls X2lkeCA9IDA7Cj4gKwkJdnEtPm51bSA9IDA7Cj4gKwo+ICsJCXNwaW5fbG9jaygmdnEtPmtpY2tf bG9jayk7Cj4gKwkJdnEtPmtpY2tlZCA9IGZhbHNlOwo+ICsJCWlmICh2cS0+a2lja2ZkKQo+ICsJ CQlldmVudGZkX2N0eF9wdXQodnEtPmtpY2tmZCk7Cj4gKwkJdnEtPmtpY2tmZCA9IE5VTEw7Cj4g KwkJc3Bpbl91bmxvY2soJnZxLT5raWNrX2xvY2spOwo+ICsKPiArCQlzcGluX2xvY2soJnZxLT5p cnFfbG9jayk7Cj4gKwkJdnEtPmNiLmNhbGxiYWNrID0gTlVMTDsKPiArCQl2cS0+Y2IucHJpdmF0 ZSA9IE5VTEw7Cj4gKwkJc3Bpbl91bmxvY2soJnZxLT5pcnFfbG9jayk7Cj4gKwl9Cj4gK30KPiAr Cj4gK3N0YXRpYyBpbnQgdmR1c2VfdmRwYV9zZXRfdnFfYWRkcmVzcyhzdHJ1Y3QgdmRwYV9kZXZp Y2UgKnZkcGEsIHUxNiBpZHgsCj4gKwkJCQl1NjQgZGVzY19hcmVhLCB1NjQgZHJpdmVyX2FyZWEs Cj4gKwkJCQl1NjQgZGV2aWNlX2FyZWEpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9 IHZkcGFfdG9fdmR1c2UodmRwYSk7Cj4gKwlzdHJ1Y3QgdmR1c2VfdmlydHF1ZXVlICp2cSA9ICZk ZXYtPnZxc1tpZHhdOwo+ICsKPiArCXZxLT5kZXNjX2FkZHIgPSBkZXNjX2FyZWE7Cj4gKwl2cS0+ ZHJpdmVyX2FkZHIgPSBkcml2ZXJfYXJlYTsKPiArCXZxLT5kZXZpY2VfYWRkciA9IGRldmljZV9h cmVhOwo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCB2ZHVzZV92ZHBh X2tpY2tfdnEoc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhLCB1MTYgaWR4KQo+ICt7Cj4gKwlzdHJ1 Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBhX3RvX3ZkdXNlKHZkcGEpOwo+ICsJc3RydWN0IHZkdXNl X3ZpcnRxdWV1ZSAqdnEgPSAmZGV2LT52cXNbaWR4XTsKPiArCj4gKwlzcGluX2xvY2soJnZxLT5r aWNrX2xvY2spOwo+ICsJaWYgKCF2cS0+cmVhZHkpCj4gKwkJZ290byB1bmxvY2s7Cj4gKwo+ICsJ aWYgKHZxLT5raWNrZmQpCj4gKwkJZXZlbnRmZF9zaWduYWwodnEtPmtpY2tmZCwgMSk7Cj4gKwll bHNlCj4gKwkJdnEtPmtpY2tlZCA9IHRydWU7Cj4gK3VubG9jazoKPiArCXNwaW5fdW5sb2NrKCZ2 cS0+a2lja19sb2NrKTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdmR1c2VfdmRwYV9zZXRfdnFf Y2Ioc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhLCB1MTYgaWR4LAo+ICsJCQkgICAgICBzdHJ1Y3Qg dmRwYV9jYWxsYmFjayAqY2IpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IHZkcGFf dG9fdmR1c2UodmRwYSk7Cj4gKwlzdHJ1Y3QgdmR1c2VfdmlydHF1ZXVlICp2cSA9ICZkZXYtPnZx c1tpZHhdOwo+ICsKPiArCXNwaW5fbG9jaygmdnEtPmlycV9sb2NrKTsKPiArCXZxLT5jYi5jYWxs YmFjayA9IGNiLT5jYWxsYmFjazsKPiArCXZxLT5jYi5wcml2YXRlID0gY2ItPnByaXZhdGU7Cj4g KwlzcGluX3VubG9jaygmdnEtPmlycV9sb2NrKTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdmR1 c2VfdmRwYV9zZXRfdnFfbnVtKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYSwgdTE2IGlkeCwgdTMy IG51bSkKPiArewo+ICsJc3RydWN0IHZkdXNlX2RldiAqZGV2ID0gdmRwYV90b192ZHVzZSh2ZHBh KTsKPiArCXN0cnVjdCB2ZHVzZV92aXJ0cXVldWUgKnZxID0gJmRldi0+dnFzW2lkeF07Cj4gKwo+ ICsJdnEtPm51bSA9IG51bTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdmR1c2VfdmRwYV9zZXRf dnFfcmVhZHkoc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhLAo+ICsJCQkJCXUxNiBpZHgsIGJvb2wg cmVhZHkpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IHZkcGFfdG9fdmR1c2UodmRw YSk7Cj4gKwlzdHJ1Y3QgdmR1c2VfdmlydHF1ZXVlICp2cSA9ICZkZXYtPnZxc1tpZHhdOwo+ICsK PiArCXZxLT5yZWFkeSA9IHJlYWR5Owo+ICt9Cj4gKwo+ICtzdGF0aWMgYm9vbCB2ZHVzZV92ZHBh X2dldF92cV9yZWFkeShzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEsIHUxNiBpZHgpCj4gK3sKPiAr CXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IHZkcGFfdG9fdmR1c2UodmRwYSk7Cj4gKwlzdHJ1Y3Qg dmR1c2VfdmlydHF1ZXVlICp2cSA9ICZkZXYtPnZxc1tpZHhdOwo+ICsKPiArCXJldHVybiB2cS0+ cmVhZHk7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgdmR1c2VfdmRwYV9zZXRfdnFfc3RhdGUoc3Ry dWN0IHZkcGFfZGV2aWNlICp2ZHBhLCB1MTYgaWR4LAo+ICsJCQkJY29uc3Qgc3RydWN0IHZkcGFf dnFfc3RhdGUgKnN0YXRlKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBhX3Rv X3ZkdXNlKHZkcGEpOwo+ICsJc3RydWN0IHZkdXNlX3ZpcnRxdWV1ZSAqdnEgPSAmZGV2LT52cXNb aWR4XTsKPiArCj4gKwl2cS0+YXZhaWxfaWR4ID0gc3RhdGUtPmF2YWlsX2luZGV4Owo+ICsJcmV0 dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgdmR1c2VfdmRwYV9nZXRfdnFfc3RhdGUoc3Ry dWN0IHZkcGFfZGV2aWNlICp2ZHBhLCB1MTYgaWR4LAo+ICsJCQkJc3RydWN0IHZkcGFfdnFfc3Rh dGUgKnN0YXRlKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBhX3RvX3ZkdXNl KHZkcGEpOwo+ICsJc3RydWN0IHZkdXNlX3ZpcnRxdWV1ZSAqdnEgPSAmZGV2LT52cXNbaWR4XTsK PiArCj4gKwlyZXR1cm4gdmR1c2VfZGV2X2dldF92cV9zdGF0ZShkZXYsIHZxLCBzdGF0ZSk7Cj4g K30KPiArCj4gK3N0YXRpYyB1MzIgdmR1c2VfdmRwYV9nZXRfdnFfYWxpZ24oc3RydWN0IHZkcGFf ZGV2aWNlICp2ZHBhKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBhX3RvX3Zk dXNlKHZkcGEpOwo+ICsKPiArCXJldHVybiBkZXYtPnZxX2FsaWduOwo+ICt9Cj4gKwo+ICtzdGF0 aWMgdTY0IHZkdXNlX3ZkcGFfZ2V0X2ZlYXR1cmVzKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYSkK PiArewo+ICsJc3RydWN0IHZkdXNlX2RldiAqZGV2ID0gdmRwYV90b192ZHVzZSh2ZHBhKTsKPiAr Cj4gKwlyZXR1cm4gZGV2LT51c2VyX2ZlYXR1cmVzOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHZk dXNlX3ZkcGFfc2V0X2ZlYXR1cmVzKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYSwgdTY0IGZlYXR1 cmVzKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBhX3RvX3ZkdXNlKHZkcGEp Owo+ICsKPiArCWRldi0+ZmVhdHVyZXMgPSBmZWF0dXJlczsKPiArCXJldHVybiAwOwo+ICt9Cj4g Kwo+ICtzdGF0aWMgdm9pZCB2ZHVzZV92ZHBhX3NldF9jb25maWdfY2Ioc3RydWN0IHZkcGFfZGV2 aWNlICp2ZHBhLAo+ICsJCQkJICBzdHJ1Y3QgdmRwYV9jYWxsYmFjayAqY2IpCj4gK3sKPiArCXN0 cnVjdCB2ZHVzZV9kZXYgKmRldiA9IHZkcGFfdG9fdmR1c2UodmRwYSk7Cj4gKwo+ICsJc3Bpbl9s b2NrKCZkZXYtPmlycV9sb2NrKTsKPiArCWRldi0+Y29uZmlnX2NiLmNhbGxiYWNrID0gY2ItPmNh bGxiYWNrOwo+ICsJZGV2LT5jb25maWdfY2IucHJpdmF0ZSA9IGNiLT5wcml2YXRlOwo+ICsJc3Bp bl91bmxvY2soJmRldi0+aXJxX2xvY2spOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdTE2IHZkdXNlX3Zk cGFfZ2V0X3ZxX251bV9tYXgoc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhKQo+ICt7Cj4gKwlzdHJ1 Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBhX3RvX3ZkdXNlKHZkcGEpOwo+ICsKPiArCXJldHVybiBk ZXYtPnZxX3NpemVfbWF4Owo+ICt9Cj4gKwo+ICtzdGF0aWMgdTMyIHZkdXNlX3ZkcGFfZ2V0X2Rl dmljZV9pZChzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9k ZXYgKmRldiA9IHZkcGFfdG9fdmR1c2UodmRwYSk7Cj4gKwo+ICsJcmV0dXJuIGRldi0+ZGV2aWNl X2lkOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdTMyIHZkdXNlX3ZkcGFfZ2V0X3ZlbmRvcl9pZChzdHJ1 Y3QgdmRwYV9kZXZpY2UgKnZkcGEpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IHZk cGFfdG9fdmR1c2UodmRwYSk7Cj4gKwo+ICsJcmV0dXJuIGRldi0+dmVuZG9yX2lkOwo+ICt9Cj4g Kwo+ICtzdGF0aWMgdTggdmR1c2VfdmRwYV9nZXRfc3RhdHVzKHN0cnVjdCB2ZHBhX2RldmljZSAq dmRwYSkKPiArewo+ICsJc3RydWN0IHZkdXNlX2RldiAqZGV2ID0gdmRwYV90b192ZHVzZSh2ZHBh KTsKPiArCj4gKwlyZXR1cm4gZGV2LT5zdGF0dXM7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHZk dXNlX3ZkcGFfc2V0X3N0YXR1cyhzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEsIHU4IHN0YXR1cykK PiArewo+ICsJc3RydWN0IHZkdXNlX2RldiAqZGV2ID0gdmRwYV90b192ZHVzZSh2ZHBhKTsKPiAr CWJvb2wgc3RhcnRlZCA9ICEhKHN0YXR1cyAmIFZJUlRJT19DT05GSUdfU19EUklWRVJfT0spOwo+ ICsKPiArCWRldi0+c3RhdHVzID0gc3RhdHVzOwo+ICsKPiArCWlmIChkZXYtPnN0YXJ0ZWQgPT0g c3RhcnRlZCkKPiArCQlyZXR1cm47CgoKSWYgd2UgY2hlY2sgZGV2LT5zdGF0dXMgPT0gc3RhdHVz LCAob3Igb25seSBjaGVjayB0aGUgRFJJVkVSX09LIGJpdCkgCnRoZW4gdGhlcmUncyBubyBuZWVk IHRvIGludHJvZHVjZSBhbiBleHRyYSBkZXYtPnN0YXJ0ZWQuCgoKPiArCj4gKwlkZXYtPnN0YXJ0 ZWQgPSBzdGFydGVkOwo+ICsJaWYgKGRldi0+c3RhcnRlZCkgewo+ICsJCXZkdXNlX2Rldl9zdGFy dF9kYXRhcGxhbmUoZGV2KTsKPiArCX0gZWxzZSB7Cj4gKwkJdmR1c2VfZGV2X3Jlc2V0KGRldik7 Cj4gKwkJdmR1c2VfZGV2X3N0b3BfZGF0YXBsYW5lKGRldik7CgoKSSB3b25kZXIgaWYgbm9fcmVw bHkgd29yayBmb3IgdGhlIGNhc2Ugb2Ygdmhvc3QtdmRwYS4gRm9yIHZpcnRpby12RFBBLCAKd2Ug aGF2ZSBib3VuY2luZyBidWZmZXJzIHNvIGl0J3MgaGFybWxlc3MgaWYgdXNlcnNhcGNlIGRhdGFw bGFuZSBrZWVwcyAKcGVyZm9ybWluZyByZWFkL3dyaXRlLiBGb3Igdmhvc3QtdkRQQSB3ZSBkb24n dCBoYXZlIHN1Y2ggc3R1ZmZzLgoKCj4gKwl9Cj4gK30KPiArCj4gK3N0YXRpYyBzaXplX3QgdmR1 c2VfdmRwYV9nZXRfY29uZmlnX3NpemUoc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhKQo+ICt7Cj4g KwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBhX3RvX3ZkdXNlKHZkcGEpOwo+ICsKPiArCXJl dHVybiBkZXYtPmNvbmZpZ19zaXplOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCB2ZHVzZV92ZHBh X2dldF9jb25maWcoc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhLCB1bnNpZ25lZCBpbnQgb2Zmc2V0 LAo+ICsJCQkJICB2b2lkICpidWYsIHVuc2lnbmVkIGludCBsZW4pCj4gK3sKPiArCXN0cnVjdCB2 ZHVzZV9kZXYgKmRldiA9IHZkcGFfdG9fdmR1c2UodmRwYSk7Cj4gKwo+ICsJbWVtY3B5KGJ1Ziwg ZGV2LT5jb25maWcgKyBvZmZzZXQsIGxlbik7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHZkdXNl X3ZkcGFfc2V0X2NvbmZpZyhzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEsIHVuc2lnbmVkIGludCBv ZmZzZXQsCj4gKwkJCWNvbnN0IHZvaWQgKmJ1ZiwgdW5zaWduZWQgaW50IGxlbikKPiArewo+ICsJ LyogTm93IHdlIG9ubHkgc3VwcG9ydCByZWFkLW9ubHkgY29uZmlndXJhdGlvbiBzcGFjZSAqLwo+ ICt9Cj4gKwo+ICtzdGF0aWMgdTMyIHZkdXNlX3ZkcGFfZ2V0X2dlbmVyYXRpb24oc3RydWN0IHZk cGFfZGV2aWNlICp2ZHBhKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBhX3Rv X3ZkdXNlKHZkcGEpOwo+ICsKPiArCXJldHVybiBkZXYtPmdlbmVyYXRpb247Cj4gK30KPiArCj4g K3N0YXRpYyBpbnQgdmR1c2VfdmRwYV9zZXRfbWFwKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYSwK PiArCQkJCXN0cnVjdCB2aG9zdF9pb3RsYiAqaW90bGIpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9k ZXYgKmRldiA9IHZkcGFfdG9fdmR1c2UodmRwYSk7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXJldCA9 IHZkdXNlX2RvbWFpbl9zZXRfbWFwKGRldi0+ZG9tYWluLCBpb3RsYik7Cj4gKwlpZiAocmV0KQo+ ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJcmV0ID0gdmR1c2VfZGV2X3VwZGF0ZV9pb3RsYihkZXYs IDBVTEwsIFVMTE9OR19NQVgpOwo+ICsJaWYgKHJldCkgewo+ICsJCXZkdXNlX2RvbWFpbl9jbGVh cl9tYXAoZGV2LT5kb21haW4sIGlvdGxiKTsKPiArCQlyZXR1cm4gcmV0Owo+ICsJfQo+ICsKPiAr CXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCB2ZHVzZV92ZHBhX2ZyZWUoc3RydWN0 IHZkcGFfZGV2aWNlICp2ZHBhKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBh X3RvX3ZkdXNlKHZkcGEpOwo+ICsKPiArCWRldi0+dmRldiA9IE5VTEw7Cj4gK30KPiArCj4gK3N0 YXRpYyBjb25zdCBzdHJ1Y3QgdmRwYV9jb25maWdfb3BzIHZkdXNlX3ZkcGFfY29uZmlnX29wcyA9 IHsKPiArCS5zZXRfdnFfYWRkcmVzcwkJPSB2ZHVzZV92ZHBhX3NldF92cV9hZGRyZXNzLAo+ICsJ LmtpY2tfdnEJCT0gdmR1c2VfdmRwYV9raWNrX3ZxLAo+ICsJLnNldF92cV9jYgkJPSB2ZHVzZV92 ZHBhX3NldF92cV9jYiwKPiArCS5zZXRfdnFfbnVtICAgICAgICAgICAgID0gdmR1c2VfdmRwYV9z ZXRfdnFfbnVtLAo+ICsJLnNldF92cV9yZWFkeQkJPSB2ZHVzZV92ZHBhX3NldF92cV9yZWFkeSwK PiArCS5nZXRfdnFfcmVhZHkJCT0gdmR1c2VfdmRwYV9nZXRfdnFfcmVhZHksCj4gKwkuc2V0X3Zx X3N0YXRlCQk9IHZkdXNlX3ZkcGFfc2V0X3ZxX3N0YXRlLAo+ICsJLmdldF92cV9zdGF0ZQkJPSB2 ZHVzZV92ZHBhX2dldF92cV9zdGF0ZSwKPiArCS5nZXRfdnFfYWxpZ24JCT0gdmR1c2VfdmRwYV9n ZXRfdnFfYWxpZ24sCj4gKwkuZ2V0X2ZlYXR1cmVzCQk9IHZkdXNlX3ZkcGFfZ2V0X2ZlYXR1cmVz LAo+ICsJLnNldF9mZWF0dXJlcwkJPSB2ZHVzZV92ZHBhX3NldF9mZWF0dXJlcywKPiArCS5zZXRf Y29uZmlnX2NiCQk9IHZkdXNlX3ZkcGFfc2V0X2NvbmZpZ19jYiwKPiArCS5nZXRfdnFfbnVtX21h eAkJPSB2ZHVzZV92ZHBhX2dldF92cV9udW1fbWF4LAo+ICsJLmdldF9kZXZpY2VfaWQJCT0gdmR1 c2VfdmRwYV9nZXRfZGV2aWNlX2lkLAo+ICsJLmdldF92ZW5kb3JfaWQJCT0gdmR1c2VfdmRwYV9n ZXRfdmVuZG9yX2lkLAo+ICsJLmdldF9zdGF0dXMJCT0gdmR1c2VfdmRwYV9nZXRfc3RhdHVzLAo+ ICsJLnNldF9zdGF0dXMJCT0gdmR1c2VfdmRwYV9zZXRfc3RhdHVzLAo+ICsJLmdldF9jb25maWdf c2l6ZQk9IHZkdXNlX3ZkcGFfZ2V0X2NvbmZpZ19zaXplLAo+ICsJLmdldF9jb25maWcJCT0gdmR1 c2VfdmRwYV9nZXRfY29uZmlnLAo+ICsJLnNldF9jb25maWcJCT0gdmR1c2VfdmRwYV9zZXRfY29u ZmlnLAo+ICsJLmdldF9nZW5lcmF0aW9uCQk9IHZkdXNlX3ZkcGFfZ2V0X2dlbmVyYXRpb24sCj4g Kwkuc2V0X21hcAkJPSB2ZHVzZV92ZHBhX3NldF9tYXAsCj4gKwkuZnJlZQkJCT0gdmR1c2VfdmRw YV9mcmVlLAo+ICt9Owo+ICsKPiArc3RhdGljIGRtYV9hZGRyX3QgdmR1c2VfZGV2X21hcF9wYWdl KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHBhZ2UgKnBhZ2UsCj4gKwkJCQkgICAgIHVuc2ln bmVkIGxvbmcgb2Zmc2V0LCBzaXplX3Qgc2l6ZSwKPiArCQkJCSAgICAgZW51bSBkbWFfZGF0YV9k aXJlY3Rpb24gZGlyLAo+ICsJCQkJICAgICB1bnNpZ25lZCBsb25nIGF0dHJzKQo+ICt7Cj4gKwlz dHJ1Y3QgdmR1c2VfZGV2ICp2ZGV2ID0gZGV2X3RvX3ZkdXNlKGRldik7Cj4gKwlzdHJ1Y3QgdmR1 c2VfaW92YV9kb21haW4gKmRvbWFpbiA9IHZkZXYtPmRvbWFpbjsKPiArCj4gKwlyZXR1cm4gdmR1 c2VfZG9tYWluX21hcF9wYWdlKGRvbWFpbiwgcGFnZSwgb2Zmc2V0LCBzaXplLCBkaXIsIGF0dHJz KTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdmR1c2VfZGV2X3VubWFwX3BhZ2Uoc3RydWN0IGRl dmljZSAqZGV2LCBkbWFfYWRkcl90IGRtYV9hZGRyLAo+ICsJCQkJc2l6ZV90IHNpemUsIGVudW0g ZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwKPiArCQkJCXVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gK3sK PiArCXN0cnVjdCB2ZHVzZV9kZXYgKnZkZXYgPSBkZXZfdG9fdmR1c2UoZGV2KTsKPiArCXN0cnVj dCB2ZHVzZV9pb3ZhX2RvbWFpbiAqZG9tYWluID0gdmRldi0+ZG9tYWluOwo+ICsKPiArCXJldHVy biB2ZHVzZV9kb21haW5fdW5tYXBfcGFnZShkb21haW4sIGRtYV9hZGRyLCBzaXplLCBkaXIsIGF0 dHJzKTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgKnZkdXNlX2Rldl9hbGxvY19jb2hlcmVudChz dHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBzaXplLAo+ICsJCQkJCWRtYV9hZGRyX3QgKmRtYV9h ZGRyLCBnZnBfdCBmbGFnLAo+ICsJCQkJCXVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gK3sKPiArCXN0 cnVjdCB2ZHVzZV9kZXYgKnZkZXYgPSBkZXZfdG9fdmR1c2UoZGV2KTsKPiArCXN0cnVjdCB2ZHVz ZV9pb3ZhX2RvbWFpbiAqZG9tYWluID0gdmRldi0+ZG9tYWluOwo+ICsJdW5zaWduZWQgbG9uZyBp b3ZhOwo+ICsJdm9pZCAqYWRkcjsKPiArCj4gKwkqZG1hX2FkZHIgPSBETUFfTUFQUElOR19FUlJP UjsKPiArCWFkZHIgPSB2ZHVzZV9kb21haW5fYWxsb2NfY29oZXJlbnQoZG9tYWluLCBzaXplLAo+ ICsJCQkJKGRtYV9hZGRyX3QgKikmaW92YSwgZmxhZywgYXR0cnMpOwo+ICsJaWYgKCFhZGRyKQo+ ICsJCXJldHVybiBOVUxMOwo+ICsKPiArCSpkbWFfYWRkciA9IChkbWFfYWRkcl90KWlvdmE7Cj4g Kwo+ICsJcmV0dXJuIGFkZHI7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHZkdXNlX2Rldl9mcmVl X2NvaGVyZW50KHN0cnVjdCBkZXZpY2UgKmRldiwgc2l6ZV90IHNpemUsCj4gKwkJCQkJdm9pZCAq dmFkZHIsIGRtYV9hZGRyX3QgZG1hX2FkZHIsCj4gKwkJCQkJdW5zaWduZWQgbG9uZyBhdHRycykK PiArewo+ICsJc3RydWN0IHZkdXNlX2RldiAqdmRldiA9IGRldl90b192ZHVzZShkZXYpOwo+ICsJ c3RydWN0IHZkdXNlX2lvdmFfZG9tYWluICpkb21haW4gPSB2ZGV2LT5kb21haW47Cj4gKwo+ICsJ dmR1c2VfZG9tYWluX2ZyZWVfY29oZXJlbnQoZG9tYWluLCBzaXplLCB2YWRkciwgZG1hX2FkZHIs IGF0dHJzKTsKPiArfQo+ICsKPiArc3RhdGljIHNpemVfdCB2ZHVzZV9kZXZfbWF4X21hcHBpbmdf c2l6ZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKnZkZXYg PSBkZXZfdG9fdmR1c2UoZGV2KTsKPiArCXN0cnVjdCB2ZHVzZV9pb3ZhX2RvbWFpbiAqZG9tYWlu ID0gdmRldi0+ZG9tYWluOwo+ICsKPiArCXJldHVybiBkb21haW4tPmJvdW5jZV9zaXplOwo+ICt9 Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGRtYV9tYXBfb3BzIHZkdXNlX2Rldl9kbWFfb3Bz ID0gewo+ICsJLm1hcF9wYWdlID0gdmR1c2VfZGV2X21hcF9wYWdlLAo+ICsJLnVubWFwX3BhZ2Ug PSB2ZHVzZV9kZXZfdW5tYXBfcGFnZSwKPiArCS5hbGxvYyA9IHZkdXNlX2Rldl9hbGxvY19jb2hl cmVudCwKPiArCS5mcmVlID0gdmR1c2VfZGV2X2ZyZWVfY29oZXJlbnQsCj4gKwkubWF4X21hcHBp bmdfc2l6ZSA9IHZkdXNlX2Rldl9tYXhfbWFwcGluZ19zaXplLAo+ICt9Owo+ICsKPiArc3RhdGlj IHVuc2lnbmVkIGludCBwZXJtX3RvX2ZpbGVfZmxhZ3ModTggcGVybSkKPiArewo+ICsJdW5zaWdu ZWQgaW50IGZsYWdzID0gMDsKPiArCj4gKwlzd2l0Y2ggKHBlcm0pIHsKPiArCWNhc2UgVkRVU0Vf QUNDRVNTX1dPOgo+ICsJCWZsYWdzIHw9IE9fV1JPTkxZOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSBW RFVTRV9BQ0NFU1NfUk86Cj4gKwkJZmxhZ3MgfD0gT19SRE9OTFk7Cj4gKwkJYnJlYWs7Cj4gKwlj YXNlIFZEVVNFX0FDQ0VTU19SVzoKPiArCQlmbGFncyB8PSBPX1JEV1I7Cj4gKwkJYnJlYWs7Cj4g KwlkZWZhdWx0Ogo+ICsJCVdBUk4oMSwgImludmFsaWRhdGUgdmhvc3QgSU9UTEIgcGVybWlzc2lv blxuIik7Cj4gKwkJYnJlYWs7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIGZsYWdzOwo+ICt9Cj4gKwo+ ICtzdGF0aWMgaW50IHZkdXNlX2tpY2tmZF9zZXR1cChzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYsCj4g KwkJCXN0cnVjdCB2ZHVzZV92cV9ldmVudGZkICpldmVudGZkKQo+ICt7Cj4gKwlzdHJ1Y3QgZXZl bnRmZF9jdHggKmN0eCA9IE5VTEw7Cj4gKwlzdHJ1Y3QgdmR1c2VfdmlydHF1ZXVlICp2cTsKPiAr CXUzMiBpbmRleDsKPiArCj4gKwlpZiAoZXZlbnRmZC0+aW5kZXggPj0gZGV2LT52cV9udW0pCj4g KwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJaW5kZXggPSBhcnJheV9pbmRleF9ub3NwZWMoZXZl bnRmZC0+aW5kZXgsIGRldi0+dnFfbnVtKTsKPiArCXZxID0gJmRldi0+dnFzW2luZGV4XTsKPiAr CWlmIChldmVudGZkLT5mZCA+PSAwKSB7Cj4gKwkJY3R4ID0gZXZlbnRmZF9jdHhfZmRnZXQoZXZl bnRmZC0+ZmQpOwo+ICsJCWlmIChJU19FUlIoY3R4KSkKPiArCQkJcmV0dXJuIFBUUl9FUlIoY3R4 KTsKPiArCX0gZWxzZSBpZiAoZXZlbnRmZC0+ZmQgIT0gVkRVU0VfRVZFTlRGRF9ERUFTU0lHTikK PiArCQlyZXR1cm4gMDsKPiArCj4gKwlzcGluX2xvY2soJnZxLT5raWNrX2xvY2spOwo+ICsJaWYg KHZxLT5raWNrZmQpCj4gKwkJZXZlbnRmZF9jdHhfcHV0KHZxLT5raWNrZmQpOwo+ICsJdnEtPmtp Y2tmZCA9IGN0eDsKPiArCWlmICh2cS0+cmVhZHkgJiYgdnEtPmtpY2tlZCAmJiB2cS0+a2lja2Zk KSB7Cj4gKwkJZXZlbnRmZF9zaWduYWwodnEtPmtpY2tmZCwgMSk7Cj4gKwkJdnEtPmtpY2tlZCA9 IGZhbHNlOwo+ICsJfQo+ICsJc3Bpbl91bmxvY2soJnZxLT5raWNrX2xvY2spOwo+ICsKPiArCXJl dHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCB2ZHVzZV9kZXZfaXJxX2luamVjdChzdHJ1 Y3Qgd29ya19zdHJ1Y3QgKndvcmspCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IGNv bnRhaW5lcl9vZih3b3JrLCBzdHJ1Y3QgdmR1c2VfZGV2LCBpbmplY3QpOwo+ICsKPiArCXNwaW5f bG9ja19pcnEoJmRldi0+aXJxX2xvY2spOwo+ICsJaWYgKGRldi0+Y29uZmlnX2NiLmNhbGxiYWNr KQo+ICsJCWRldi0+Y29uZmlnX2NiLmNhbGxiYWNrKGRldi0+Y29uZmlnX2NiLnByaXZhdGUpOwo+ ICsJc3Bpbl91bmxvY2tfaXJxKCZkZXYtPmlycV9sb2NrKTsKPiArfQo+ICsKPiArc3RhdGljIHZv aWQgdmR1c2VfdnFfaXJxX2luamVjdChzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCj4gK3sKPiAr CXN0cnVjdCB2ZHVzZV92aXJ0cXVldWUgKnZxID0gY29udGFpbmVyX29mKHdvcmssCj4gKwkJCQkJ c3RydWN0IHZkdXNlX3ZpcnRxdWV1ZSwgaW5qZWN0KTsKPiArCj4gKwlzcGluX2xvY2tfaXJxKCZ2 cS0+aXJxX2xvY2spOwo+ICsJaWYgKHZxLT5yZWFkeSAmJiB2cS0+Y2IuY2FsbGJhY2spCj4gKwkJ dnEtPmNiLmNhbGxiYWNrKHZxLT5jYi5wcml2YXRlKTsKPiArCXNwaW5fdW5sb2NrX2lycSgmdnEt PmlycV9sb2NrKTsKPiArfQo+ICsKPiArc3RhdGljIGxvbmcgdmR1c2VfZGV2X2lvY3RsKHN0cnVj dCBmaWxlICpmaWxlLCB1bnNpZ25lZCBpbnQgY21kLAo+ICsJCQkgICAgdW5zaWduZWQgbG9uZyBh cmcpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IGZpbGUtPnByaXZhdGVfZGF0YTsK PiArCXZvaWQgX191c2VyICphcmdwID0gKHZvaWQgX191c2VyICopYXJnOwo+ICsJaW50IHJldDsK PiArCj4gKwlzd2l0Y2ggKGNtZCkgewo+ICsJY2FzZSBWRFVTRV9JT1RMQl9HRVRfRkQ6IHsKPiAr CQlzdHJ1Y3QgdmR1c2VfaW90bGJfZW50cnkgZW50cnk7Cj4gKwkJc3RydWN0IHZob3N0X2lvdGxi X21hcCAqbWFwOwo+ICsJCXN0cnVjdCB2ZHBhX21hcF9maWxlICptYXBfZmlsZTsKPiArCQlzdHJ1 Y3QgdmR1c2VfaW92YV9kb21haW4gKmRvbWFpbiA9IGRldi0+ZG9tYWluOwo+ICsJCXN0cnVjdCBm aWxlICpmID0gTlVMTDsKPiArCj4gKwkJcmV0ID0gLUVGQVVMVDsKPiArCQlpZiAoY29weV9mcm9t X3VzZXIoJmVudHJ5LCBhcmdwLCBzaXplb2YoZW50cnkpKSkKPiArCQkJYnJlYWs7Cj4gKwo+ICsJ CXJldCA9IC1FSU5WQUw7Cj4gKwkJaWYgKGVudHJ5LnN0YXJ0ID4gZW50cnkubGFzdCkKPiArCQkJ YnJlYWs7Cj4gKwo+ICsJCXNwaW5fbG9jaygmZG9tYWluLT5pb3RsYl9sb2NrKTsKPiArCQltYXAg PSB2aG9zdF9pb3RsYl9pdHJlZV9maXJzdChkb21haW4tPmlvdGxiLAo+ICsJCQkJCSAgICAgIGVu dHJ5LnN0YXJ0LCBlbnRyeS5sYXN0KTsKPiArCQlpZiAobWFwKSB7Cj4gKwkJCW1hcF9maWxlID0g KHN0cnVjdCB2ZHBhX21hcF9maWxlICopbWFwLT5vcGFxdWU7Cj4gKwkJCWYgPSBnZXRfZmlsZSht YXBfZmlsZS0+ZmlsZSk7Cj4gKwkJCWVudHJ5Lm9mZnNldCA9IG1hcF9maWxlLT5vZmZzZXQ7Cj4g KwkJCWVudHJ5LnN0YXJ0ID0gbWFwLT5zdGFydDsKPiArCQkJZW50cnkubGFzdCA9IG1hcC0+bGFz dDsKPiArCQkJZW50cnkucGVybSA9IG1hcC0+cGVybTsKPiArCQl9Cj4gKwkJc3Bpbl91bmxvY2so JmRvbWFpbi0+aW90bGJfbG9jayk7Cj4gKwkJcmV0ID0gLUVJTlZBTDsKPiArCQlpZiAoIWYpCj4g KwkJCWJyZWFrOwo+ICsKPiArCQlyZXQgPSAtRUZBVUxUOwo+ICsJCWlmIChjb3B5X3RvX3VzZXIo YXJncCwgJmVudHJ5LCBzaXplb2YoZW50cnkpKSkgewo+ICsJCQlmcHV0KGYpOwo+ICsJCQlicmVh azsKPiArCQl9Cj4gKwkJcmV0ID0gcmVjZWl2ZV9mZChmLCBwZXJtX3RvX2ZpbGVfZmxhZ3MoZW50 cnkucGVybSkpOwo+ICsJCWZwdXQoZik7Cj4gKwkJYnJlYWs7Cj4gKwl9Cj4gKwljYXNlIFZEVVNF X0RFVl9HRVRfRkVBVFVSRVM6Cj4gKwkJcmV0ID0gcHV0X3VzZXIoZGV2LT5mZWF0dXJlcywgKHU2 NCBfX3VzZXIgKilhcmdwKTsKPiArCQlicmVhazsKPiArCWNhc2UgVkRVU0VfREVWX1VQREFURV9D T05GSUc6IHsKPiArCQlzdHJ1Y3QgdmR1c2VfY29uZmlnX3VwZGF0ZSBjb25maWc7Cj4gKwkJdW5z aWduZWQgbG9uZyBzaXplID0gb2Zmc2V0b2Yoc3RydWN0IHZkdXNlX2NvbmZpZ191cGRhdGUsCj4g KwkJCQkJICAgICAgYnVmZmVyKTsKPiArCj4gKwkJcmV0ID0gLUVGQVVMVDsKPiArCQlpZiAoY29w eV9mcm9tX3VzZXIoJmNvbmZpZywgYXJncCwgc2l6ZSkpCj4gKwkJCWJyZWFrOwo+ICsKPiArCQly ZXQgPSAtRUlOVkFMOwo+ICsJCWlmIChjb25maWcubGVuZ3RoID09IDAgfHwKPiArCQkgICAgY29u ZmlnLmxlbmd0aCA+IGRldi0+Y29uZmlnX3NpemUgLSBjb25maWcub2Zmc2V0KQo+ICsJCQlicmVh azsKPiArCj4gKwkJcmV0ID0gLUVGQVVMVDsKPiArCQlpZiAoY29weV9mcm9tX3VzZXIoZGV2LT5j b25maWcgKyBjb25maWcub2Zmc2V0LCBhcmdwICsgc2l6ZSwKPiArCQkJCSAgIGNvbmZpZy5sZW5n dGgpKQo+ICsJCQlicmVhazsKPiArCj4gKwkJcmV0ID0gMDsKPiArCQlxdWV1ZV93b3JrKHZkdXNl X2lycV93cSwgJmRldi0+aW5qZWN0KTsKCgpJIHdvbmRlciBpZiBpdCdzIGJldHRlciB0byBzZXBh cmF0ZSBjb25maWcgaW50ZXJydXB0IG91dCBvZiBjb25maWcgCnVwZGF0ZSBvciB3ZSBuZWVkIGRv Y3VtZW50IHRoaXMuCgoKPiArCQlicmVhazsKPiArCX0KPiArCWNhc2UgVkRVU0VfVlFfR0VUX0lO Rk86IHsKCgpEbyB3ZSBuZWVkIHRvIGxpbWl0IHRoaXMgb25seSB3aGVuIERSSVZFUl9PSyBpcyBz ZXQ/CgoKPiArCQlzdHJ1Y3QgdmR1c2VfdnFfaW5mbyB2cV9pbmZvOwo+ICsJCXUzMiB2cV9pbmRl eDsKPiArCj4gKwkJcmV0ID0gLUVGQVVMVDsKPiArCQlpZiAoY29weV9mcm9tX3VzZXIoJnZxX2lu Zm8sIGFyZ3AsIHNpemVvZih2cV9pbmZvKSkpCj4gKwkJCWJyZWFrOwo+ICsKPiArCQlyZXQgPSAt RUlOVkFMOwo+ICsJCWlmICh2cV9pbmZvLmluZGV4ID49IGRldi0+dnFfbnVtKQo+ICsJCQlicmVh azsKPiArCj4gKwkJdnFfaW5kZXggPSBhcnJheV9pbmRleF9ub3NwZWModnFfaW5mby5pbmRleCwg ZGV2LT52cV9udW0pOwo+ICsJCXZxX2luZm8uZGVzY19hZGRyID0gZGV2LT52cXNbdnFfaW5kZXhd LmRlc2NfYWRkcjsKPiArCQl2cV9pbmZvLmRyaXZlcl9hZGRyID0gZGV2LT52cXNbdnFfaW5kZXhd LmRyaXZlcl9hZGRyOwo+ICsJCXZxX2luZm8uZGV2aWNlX2FkZHIgPSBkZXYtPnZxc1t2cV9pbmRl eF0uZGV2aWNlX2FkZHI7Cj4gKwkJdnFfaW5mby5udW0gPSBkZXYtPnZxc1t2cV9pbmRleF0ubnVt Owo+ICsJCXZxX2luZm8uYXZhaWxfaWR4ID0gZGV2LT52cXNbdnFfaW5kZXhdLmF2YWlsX2lkeDsK PiArCQl2cV9pbmZvLnJlYWR5ID0gZGV2LT52cXNbdnFfaW5kZXhdLnJlYWR5Owo+ICsKPiArCQly ZXQgPSAtRUZBVUxUOwo+ICsJCWlmIChjb3B5X3RvX3VzZXIoYXJncCwgJnZxX2luZm8sIHNpemVv Zih2cV9pbmZvKSkpCj4gKwkJCWJyZWFrOwo+ICsKPiArCQlyZXQgPSAwOwo+ICsJCWJyZWFrOwo+ ICsJfQo+ICsJY2FzZSBWRFVTRV9WUV9TRVRVUF9LSUNLRkQ6IHsKPiArCQlzdHJ1Y3QgdmR1c2Vf dnFfZXZlbnRmZCBldmVudGZkOwo+ICsKPiArCQlyZXQgPSAtRUZBVUxUOwo+ICsJCWlmIChjb3B5 X2Zyb21fdXNlcigmZXZlbnRmZCwgYXJncCwgc2l6ZW9mKGV2ZW50ZmQpKSkKPiArCQkJYnJlYWs7 Cj4gKwo+ICsJCXJldCA9IHZkdXNlX2tpY2tmZF9zZXR1cChkZXYsICZldmVudGZkKTsKPiArCQli cmVhazsKPiArCX0KPiArCWNhc2UgVkRVU0VfVlFfSU5KRUNUX0lSUTogewo+ICsJCXUzMiB2cV9p bmRleDsKPiArCj4gKwkJcmV0ID0gLUVGQVVMVDsKPiArCQlpZiAoZ2V0X3VzZXIodnFfaW5kZXgs ICh1MzIgX191c2VyICopYXJncCkpCj4gKwkJCWJyZWFrOwo+ICsKPiArCQlyZXQgPSAtRUlOVkFM Owo+ICsJCWlmICh2cV9pbmRleCA+PSBkZXYtPnZxX251bSkKPiArCQkJYnJlYWs7Cj4gKwo+ICsJ CXJldCA9IDA7Cj4gKwkJdnFfaW5kZXggPSBhcnJheV9pbmRleF9ub3NwZWModnFfaW5kZXgsIGRl di0+dnFfbnVtKTsKPiArCQlxdWV1ZV93b3JrKHZkdXNlX2lycV93cSwgJmRldi0+dnFzW3ZxX2lu ZGV4XS5pbmplY3QpOwo+ICsJCWJyZWFrOwo+ICsJfQo+ICsJZGVmYXVsdDoKPiArCQlyZXQgPSAt RU5PSU9DVExDTUQ7Cj4gKwkJYnJlYWs7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ ICsKPiArc3RhdGljIGludCB2ZHVzZV9kZXZfcmVsZWFzZShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBz dHJ1Y3QgZmlsZSAqZmlsZSkKPiArewo+ICsJc3RydWN0IHZkdXNlX2RldiAqZGV2ID0gZmlsZS0+ cHJpdmF0ZV9kYXRhOwo+ICsKPiArCXNwaW5fbG9jaygmZGV2LT5tc2dfbG9jayk7Cj4gKwkvKiBN YWtlIHN1cmUgdGhlIGluZmxpZ2h0IG1lc3NhZ2VzIGNhbiBwcm9jZXNzZWQgYWZ0ZXIgcmVjb25u Y2VjdGlvbiAqLwo+ICsJbGlzdF9zcGxpY2VfaW5pdCgmZGV2LT5yZWN2X2xpc3QsICZkZXYtPnNl bmRfbGlzdCk7Cj4gKwlzcGluX3VubG9jaygmZGV2LT5tc2dfbG9jayk7Cj4gKwlkZXYtPmNvbm5l Y3RlZCA9IGZhbHNlOwo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgc3RydWN0 IHZkdXNlX2RldiAqdmR1c2VfZGV2X2dldF9mcm9tX21pbm9yKGludCBtaW5vcikKPiArewo+ICsJ c3RydWN0IHZkdXNlX2RldiAqZGV2Owo+ICsKPiArCW11dGV4X2xvY2soJnZkdXNlX2xvY2spOwo+ ICsJZGV2ID0gaWRyX2ZpbmQoJnZkdXNlX2lkciwgbWlub3IpOwo+ICsJbXV0ZXhfdW5sb2NrKCZ2 ZHVzZV9sb2NrKTsKPiArCj4gKwlyZXR1cm4gZGV2Owo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHZk dXNlX2Rldl9vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQo+ICt7 Cj4gKwlpbnQgcmV0Owo+ICsJc3RydWN0IHZkdXNlX2RldiAqZGV2ID0gdmR1c2VfZGV2X2dldF9m cm9tX21pbm9yKGltaW5vcihpbm9kZSkpOwo+ICsKPiArCWlmICghZGV2KQo+ICsJCXJldHVybiAt RU5PREVWOwo+ICsKPiArCXJldCA9IC1FQlVTWTsKPiArCW11dGV4X2xvY2soJmRldi0+bG9jayk7 Cj4gKwlpZiAoZGV2LT5jb25uZWN0ZWQpCj4gKwkJZ290byB1bmxvY2s7Cj4gKwo+ICsJcmV0ID0g MDsKPiArCWRldi0+Y29ubmVjdGVkID0gdHJ1ZTsKPiArCWZpbGUtPnByaXZhdGVfZGF0YSA9IGRl djsKPiArdW5sb2NrOgo+ICsJbXV0ZXhfdW5sb2NrKCZkZXYtPmxvY2spOwo+ICsKPiArCXJldHVy biByZXQ7Cj4gK30KPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIHZk dXNlX2Rldl9mb3BzID0gewo+ICsJLm93bmVyCQk9IFRISVNfTU9EVUxFLAo+ICsJLm9wZW4JCT0g dmR1c2VfZGV2X29wZW4sCj4gKwkucmVsZWFzZQk9IHZkdXNlX2Rldl9yZWxlYXNlLAo+ICsJLnJl YWRfaXRlcgk9IHZkdXNlX2Rldl9yZWFkX2l0ZXIsCj4gKwkud3JpdGVfaXRlcgk9IHZkdXNlX2Rl dl93cml0ZV9pdGVyLAo+ICsJLnBvbGwJCT0gdmR1c2VfZGV2X3BvbGwsCj4gKwkudW5sb2NrZWRf aW9jdGwJPSB2ZHVzZV9kZXZfaW9jdGwsCj4gKwkuY29tcGF0X2lvY3RsCT0gY29tcGF0X3B0cl9p b2N0bCwKPiArCS5sbHNlZWsJCT0gbm9vcF9sbHNlZWssCj4gK307Cj4gKwo+ICtzdGF0aWMgc3Ry dWN0IHZkdXNlX2RldiAqdmR1c2VfZGV2X2NyZWF0ZSh2b2lkKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1 c2VfZGV2ICpkZXYgPSBremFsbG9jKHNpemVvZigqZGV2KSwgR0ZQX0tFUk5FTCk7Cj4gKwo+ICsJ aWYgKCFkZXYpCj4gKwkJcmV0dXJuIE5VTEw7Cj4gKwo+ICsJbXV0ZXhfaW5pdCgmZGV2LT5sb2Nr KTsKPiArCXNwaW5fbG9ja19pbml0KCZkZXYtPm1zZ19sb2NrKTsKPiArCUlOSVRfTElTVF9IRUFE KCZkZXYtPnNlbmRfbGlzdCk7Cj4gKwlJTklUX0xJU1RfSEVBRCgmZGV2LT5yZWN2X2xpc3QpOwo+ ICsJc3Bpbl9sb2NrX2luaXQoJmRldi0+aXJxX2xvY2spOwo+ICsKPiArCUlOSVRfV09SSygmZGV2 LT5pbmplY3QsIHZkdXNlX2Rldl9pcnFfaW5qZWN0KTsKPiArCWluaXRfd2FpdHF1ZXVlX2hlYWQo JmRldi0+d2FpdHEpOwo+ICsKPiArCXJldHVybiBkZXY7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lk IHZkdXNlX2Rldl9kZXN0cm95KHN0cnVjdCB2ZHVzZV9kZXYgKmRldikKPiArewo+ICsJa2ZyZWUo ZGV2KTsKPiArfQo+ICsKPiArc3RhdGljIHN0cnVjdCB2ZHVzZV9kZXYgKnZkdXNlX2ZpbmRfZGV2 KGNvbnN0IGNoYXIgKm5hbWUpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldjsKPiArCWlu dCBpZDsKPiArCj4gKwlpZHJfZm9yX2VhY2hfZW50cnkoJnZkdXNlX2lkciwgZGV2LCBpZCkKPiAr CQlpZiAoIXN0cmNtcChkZXYtPm5hbWUsIG5hbWUpKQo+ICsJCQlyZXR1cm4gZGV2Owo+ICsKPiAr CXJldHVybiBOVUxMOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHZkdXNlX2Rlc3Ryb3lfZGV2KGNo YXIgKm5hbWUpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IHZkdXNlX2ZpbmRfZGV2 KG5hbWUpOwo+ICsKPiArCWlmICghZGV2KQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsKPiArCW11 dGV4X2xvY2soJmRldi0+bG9jayk7Cj4gKwlpZiAoZGV2LT52ZGV2IHx8IGRldi0+Y29ubmVjdGVk KSB7Cj4gKwkJbXV0ZXhfdW5sb2NrKCZkZXYtPmxvY2spOwo+ICsJCXJldHVybiAtRUJVU1k7Cj4g Kwl9Cj4gKwlkZXYtPmNvbm5lY3RlZCA9IHRydWU7Cj4gKwltdXRleF91bmxvY2soJmRldi0+bG9j ayk7Cj4gKwo+ICsJdmR1c2VfZGV2X21zZ19jbGVhbnVwKGRldik7Cj4gKwlkZXZpY2VfZGVzdHJv eSh2ZHVzZV9jbGFzcywgTUtERVYoTUFKT1IodmR1c2VfbWFqb3IpLCBkZXYtPm1pbm9yKSk7Cj4g KwlpZHJfcmVtb3ZlKCZ2ZHVzZV9pZHIsIGRldi0+bWlub3IpOwo+ICsJa3ZmcmVlKGRldi0+Y29u ZmlnKTsKPiArCWtmcmVlKGRldi0+dnFzKTsKPiArCXZkdXNlX2RvbWFpbl9kZXN0cm95KGRldi0+ ZG9tYWluKTsKPiArCWtmcmVlKGRldi0+bmFtZSk7Cj4gKwl2ZHVzZV9kZXZfZGVzdHJveShkZXYp Owo+ICsJbW9kdWxlX3B1dChUSElTX01PRFVMRSk7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiAr Cj4gK3N0YXRpYyBib29sIGRldmljZV9pc19hbGxvd2VkKHUzMiBkZXZpY2VfaWQpCj4gK3sKPiAr CWludCBpOwo+ICsKPiArCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKGFsbG93ZWRfZGV2aWNl X2lkKTsgaSsrKQo+ICsJCWlmIChhbGxvd2VkX2RldmljZV9pZFtpXSA9PSBkZXZpY2VfaWQpCj4g KwkJCXJldHVybiB0cnVlOwo+ICsKPiArCXJldHVybiBmYWxzZTsKPiArfQo+ICsKPiArc3RhdGlj IGJvb2wgZmVhdHVyZXNfaXNfdmFsaWQodTY0IGZlYXR1cmVzKQo+ICt7Cj4gKwlpZiAoIShmZWF0 dXJlcyAmICgxVUxMIDw8IFZJUlRJT19GX0FDQ0VTU19QTEFURk9STSkpKQo+ICsJCXJldHVybiBm YWxzZTsKPiArCj4gKwkvKiBOb3cgd2Ugb25seSBzdXBwb3J0IHJlYWQtb25seSBjb25maWd1cmF0 aW9uIHNwYWNlICovCj4gKwlpZiAoZmVhdHVyZXMgJiAoMVVMTCA8PCBWSVJUSU9fQkxLX0ZfQ09O RklHX1dDRSkpCj4gKwkJcmV0dXJuIGZhbHNlOwo+ICsKPiArCXJldHVybiB0cnVlOwo+ICt9Cj4g Kwo+ICtzdGF0aWMgYm9vbCB2ZHVzZV92YWxpZGF0ZV9jb25maWcoc3RydWN0IHZkdXNlX2Rldl9j b25maWcgKmNvbmZpZykKPiArewo+ICsJaWYgKGNvbmZpZy0+Ym91bmNlX3NpemUgPiBWRFVTRV9N QVhfQk9VTkNFX1NJWkUpCj4gKwkJcmV0dXJuIGZhbHNlOwo+ICsKPiArCWlmIChjb25maWctPnZx X2FsaWduID4gUEFHRV9TSVpFKQo+ICsJCXJldHVybiBmYWxzZTsKPiArCj4gKwlpZiAoY29uZmln LT5jb25maWdfc2l6ZSA+IFBBR0VfU0laRSkKPiArCQlyZXR1cm4gZmFsc2U7Cj4gKwo+ICsJaWYg KCFkZXZpY2VfaXNfYWxsb3dlZChjb25maWctPmRldmljZV9pZCkpCj4gKwkJcmV0dXJuIGZhbHNl Owo+ICsKPiArCWlmICghZmVhdHVyZXNfaXNfdmFsaWQoY29uZmlnLT5mZWF0dXJlcykpCj4gKwkJ cmV0dXJuIGZhbHNlOwoKCkRvIHdlIG5lZWQgdG8gdmFsaWRhdGUgd2hldGhlciBvciBub3QgY29u ZmlnX3NpemUgaXMgdG9vIHNtYWxsIG90aGVyd2lzZSAKd2UgbWF5IGhhdmUgT09CIGFjY2VzcyBp biBnZXRfY29uZmlnKCk/CgoKPiArCj4gKwlyZXR1cm4gdHJ1ZTsKPiArfQo+ICsKPiArc3RhdGlj IGludCB2ZHVzZV9jcmVhdGVfZGV2KHN0cnVjdCB2ZHVzZV9kZXZfY29uZmlnICpjb25maWcsCj4g KwkJCSAgICB2b2lkICpjb25maWdfYnVmLCB1NjQgYXBpX3ZlcnNpb24pCj4gK3sKPiArCWludCBp LCByZXQ7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXY7Cj4gKwo+ICsJcmV0ID0gLUVFWElTVDsK PiArCWlmICh2ZHVzZV9maW5kX2Rldihjb25maWctPm5hbWUpKQo+ICsJCWdvdG8gZXJyOwo+ICsK PiArCXJldCA9IC1FTk9NRU07Cj4gKwlkZXYgPSB2ZHVzZV9kZXZfY3JlYXRlKCk7Cj4gKwlpZiAo IWRldikKPiArCQlnb3RvIGVycjsKPiArCj4gKwlkZXYtPmFwaV92ZXJzaW9uID0gYXBpX3ZlcnNp b247Cj4gKwlkZXYtPnVzZXJfZmVhdHVyZXMgPSBjb25maWctPmZlYXR1cmVzOwo+ICsJZGV2LT5k ZXZpY2VfaWQgPSBjb25maWctPmRldmljZV9pZDsKPiArCWRldi0+dmVuZG9yX2lkID0gY29uZmln LT52ZW5kb3JfaWQ7Cj4gKwlkZXYtPm5hbWUgPSBrc3RyZHVwKGNvbmZpZy0+bmFtZSwgR0ZQX0tF Uk5FTCk7Cj4gKwlpZiAoIWRldi0+bmFtZSkKPiArCQlnb3RvIGVycl9zdHI7Cj4gKwo+ICsJZGV2 LT5kb21haW4gPSB2ZHVzZV9kb21haW5fY3JlYXRlKFZEVVNFX0lPVkFfU0laRSAtIDEsCj4gKwkJ CQkJICBjb25maWctPmJvdW5jZV9zaXplKTsKPiArCWlmICghZGV2LT5kb21haW4pCj4gKwkJZ290 byBlcnJfZG9tYWluOwo+ICsKPiArCWRldi0+Y29uZmlnID0gY29uZmlnX2J1ZjsKPiArCWRldi0+ Y29uZmlnX3NpemUgPSBjb25maWctPmNvbmZpZ19zaXplOwo+ICsJZGV2LT52cV9hbGlnbiA9IGNv bmZpZy0+dnFfYWxpZ247Cj4gKwlkZXYtPnZxX3NpemVfbWF4ID0gY29uZmlnLT52cV9zaXplX21h eDsKPiArCWRldi0+dnFfbnVtID0gY29uZmlnLT52cV9udW07Cj4gKwlkZXYtPnZxcyA9IGtjYWxs b2MoZGV2LT52cV9udW0sIHNpemVvZigqZGV2LT52cXMpLCBHRlBfS0VSTkVMKTsKPiArCWlmICgh ZGV2LT52cXMpCj4gKwkJZ290byBlcnJfdnFzOwo+ICsKPiArCWZvciAoaSA9IDA7IGkgPCBkZXYt PnZxX251bTsgaSsrKSB7Cj4gKwkJZGV2LT52cXNbaV0uaW5kZXggPSBpOwo+ICsJCUlOSVRfV09S SygmZGV2LT52cXNbaV0uaW5qZWN0LCB2ZHVzZV92cV9pcnFfaW5qZWN0KTsKPiArCQlzcGluX2xv Y2tfaW5pdCgmZGV2LT52cXNbaV0ua2lja19sb2NrKTsKPiArCQlzcGluX2xvY2tfaW5pdCgmZGV2 LT52cXNbaV0uaXJxX2xvY2spOwo+ICsJfQo+ICsKPiArCXJldCA9IGlkcl9hbGxvYygmdmR1c2Vf aWRyLCBkZXYsIDEsIFZEVVNFX0RFVl9NQVgsIEdGUF9LRVJORUwpOwo+ICsJaWYgKHJldCA8IDAp Cj4gKwkJZ290byBlcnJfaWRyOwo+ICsKPiArCWRldi0+bWlub3IgPSByZXQ7Cj4gKwlkZXYtPmRl diA9IGRldmljZV9jcmVhdGUodmR1c2VfY2xhc3MsIE5VTEwsCj4gKwkJCQkgTUtERVYoTUFKT1Io dmR1c2VfbWFqb3IpLCBkZXYtPm1pbm9yKSwKPiArCQkJCSBOVUxMLCAiJXMiLCBjb25maWctPm5h bWUpOwo+ICsJaWYgKElTX0VSUihkZXYtPmRldikpIHsKPiArCQlyZXQgPSBQVFJfRVJSKGRldi0+ ZGV2KTsKPiArCQlnb3RvIGVycl9kZXY7Cj4gKwl9Cj4gKwlfX21vZHVsZV9nZXQoVEhJU19NT0RV TEUpOwo+ICsKPiArCXJldHVybiAwOwo+ICtlcnJfZGV2Ogo+ICsJaWRyX3JlbW92ZSgmdmR1c2Vf aWRyLCBkZXYtPm1pbm9yKTsKPiArZXJyX2lkcjoKPiArCWtmcmVlKGRldi0+dnFzKTsKPiArZXJy X3ZxczoKPiArCXZkdXNlX2RvbWFpbl9kZXN0cm95KGRldi0+ZG9tYWluKTsKPiArZXJyX2RvbWFp bjoKPiArCWtmcmVlKGRldi0+bmFtZSk7Cj4gK2Vycl9zdHI6Cj4gKwl2ZHVzZV9kZXZfZGVzdHJv eShkZXYpOwo+ICtlcnI6Cj4gKwlrdmZyZWUoY29uZmlnX2J1Zik7Cj4gKwlyZXR1cm4gcmV0Owo+ ICt9Cj4gKwo+ICtzdGF0aWMgbG9uZyB2ZHVzZV9pb2N0bChzdHJ1Y3QgZmlsZSAqZmlsZSwgdW5z aWduZWQgaW50IGNtZCwKPiArCQkJdW5zaWduZWQgbG9uZyBhcmcpCj4gK3sKPiArCWludCByZXQ7 Cj4gKwl2b2lkIF9fdXNlciAqYXJncCA9ICh2b2lkIF9fdXNlciAqKWFyZzsKPiArCXN0cnVjdCB2 ZHVzZV9jb250cm9sICpjb250cm9sID0gZmlsZS0+cHJpdmF0ZV9kYXRhOwo+ICsKPiArCW11dGV4 X2xvY2soJnZkdXNlX2xvY2spOwo+ICsJc3dpdGNoIChjbWQpIHsKPiArCWNhc2UgVkRVU0VfR0VU X0FQSV9WRVJTSU9OOgo+ICsJCXJldCA9IHB1dF91c2VyKGNvbnRyb2wtPmFwaV92ZXJzaW9uLCAo dTY0IF9fdXNlciAqKWFyZ3ApOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSBWRFVTRV9TRVRfQVBJX1ZF UlNJT046IHsKPiArCQl1NjQgYXBpX3ZlcnNpb247Cj4gKwo+ICsJCXJldCA9IC1FRkFVTFQ7Cj4g KwkJaWYgKGdldF91c2VyKGFwaV92ZXJzaW9uLCAodTY0IF9fdXNlciAqKWFyZ3ApKQo+ICsJCQli cmVhazsKPiArCj4gKwkJcmV0ID0gLUVJTlZBTDsKPiArCQlpZiAoYXBpX3ZlcnNpb24gPiBWRFVT RV9BUElfVkVSU0lPTikKPiArCQkJYnJlYWs7Cj4gKwo+ICsJCXJldCA9IDA7Cj4gKwkJY29udHJv bC0+YXBpX3ZlcnNpb24gPSBhcGlfdmVyc2lvbjsKPiArCQlicmVhazsKPiArCX0KPiArCWNhc2Ug VkRVU0VfQ1JFQVRFX0RFVjogewo+ICsJCXN0cnVjdCB2ZHVzZV9kZXZfY29uZmlnIGNvbmZpZzsK PiArCQl1bnNpZ25lZCBsb25nIHNpemUgPSBvZmZzZXRvZihzdHJ1Y3QgdmR1c2VfZGV2X2NvbmZp ZywgY29uZmlnKTsKPiArCQl2b2lkICpidWY7Cj4gKwo+ICsJCXJldCA9IC1FRkFVTFQ7Cj4gKwkJ aWYgKGNvcHlfZnJvbV91c2VyKCZjb25maWcsIGFyZ3AsIHNpemUpKQo+ICsJCQlicmVhazsKPiAr Cj4gKwkJcmV0ID0gLUVJTlZBTDsKPiArCQlpZiAodmR1c2VfdmFsaWRhdGVfY29uZmlnKCZjb25m aWcpID09IGZhbHNlKQo+ICsJCQlicmVhazsKPiArCj4gKwkJYnVmID0gdm1lbWR1cF91c2VyKGFy Z3AgKyBzaXplLCBjb25maWcuY29uZmlnX3NpemUpOwo+ICsJCWlmIChJU19FUlIoYnVmKSkgewo+ ICsJCQlyZXQgPSBQVFJfRVJSKGJ1Zik7Cj4gKwkJCWJyZWFrOwo+ICsJCX0KPiArCQlyZXQgPSB2 ZHVzZV9jcmVhdGVfZGV2KCZjb25maWcsIGJ1ZiwgY29udHJvbC0+YXBpX3ZlcnNpb24pOwo+ICsJ CWJyZWFrOwo+ICsJfQo+ICsJY2FzZSBWRFVTRV9ERVNUUk9ZX0RFVjogewo+ICsJCWNoYXIgbmFt ZVtWRFVTRV9OQU1FX01BWF07Cj4gKwo+ICsJCXJldCA9IC1FRkFVTFQ7Cj4gKwkJaWYgKGNvcHlf ZnJvbV91c2VyKG5hbWUsIGFyZ3AsIFZEVVNFX05BTUVfTUFYKSkKPiArCQkJYnJlYWs7Cj4gKwo+ ICsJCXJldCA9IHZkdXNlX2Rlc3Ryb3lfZGV2KG5hbWUpOwo+ICsJCWJyZWFrOwo+ICsJfQo+ICsJ ZGVmYXVsdDoKPiArCQlyZXQgPSAtRUlOVkFMOwo+ICsJCWJyZWFrOwo+ICsJfQo+ICsJbXV0ZXhf dW5sb2NrKCZ2ZHVzZV9sb2NrKTsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0 aWMgaW50IHZkdXNlX3JlbGVhc2Uoc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZp bGUpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9jb250cm9sICpjb250cm9sID0gZmlsZS0+cHJpdmF0 ZV9kYXRhOwo+ICsKPiArCWtmcmVlKGNvbnRyb2wpOwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4g K3N0YXRpYyBpbnQgdmR1c2Vfb3BlbihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAq ZmlsZSkKPiArewo+ICsJc3RydWN0IHZkdXNlX2NvbnRyb2wgKmNvbnRyb2w7Cj4gKwo+ICsJY29u dHJvbCA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCB2ZHVzZV9jb250cm9sKSwgR0ZQX0tFUk5FTCk7 Cj4gKwlpZiAoIWNvbnRyb2wpCj4gKwkJcmV0dXJuIC1FTk9NRU07Cj4gKwo+ICsJY29udHJvbC0+ YXBpX3ZlcnNpb24gPSBWRFVTRV9BUElfVkVSU0lPTjsKPiArCWZpbGUtPnByaXZhdGVfZGF0YSA9 IGNvbnRyb2w7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1 Y3QgZmlsZV9vcGVyYXRpb25zIHZkdXNlX2N0cmxfZm9wcyA9IHsKPiArCS5vd25lcgkJPSBUSElT X01PRFVMRSwKPiArCS5vcGVuCQk9IHZkdXNlX29wZW4sCj4gKwkucmVsZWFzZQk9IHZkdXNlX3Jl bGVhc2UsCj4gKwkudW5sb2NrZWRfaW9jdGwJPSB2ZHVzZV9pb2N0bCwKPiArCS5jb21wYXRfaW9j dGwJPSBjb21wYXRfcHRyX2lvY3RsLAo+ICsJLmxsc2VlawkJPSBub29wX2xsc2VlaywKPiArfTsK PiArCj4gK3N0YXRpYyBjaGFyICp2ZHVzZV9kZXZub2RlKHN0cnVjdCBkZXZpY2UgKmRldiwgdW1v ZGVfdCAqbW9kZSkKPiArewo+ICsJcmV0dXJuIGthc3ByaW50ZihHRlBfS0VSTkVMLCAidmR1c2Uv JXMiLCBkZXZfbmFtZShkZXYpKTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdmR1c2VfbWdtdGRl dl9yZWxlYXNlKHN0cnVjdCBkZXZpY2UgKmRldikKPiArewo+ICt9Cj4gKwo+ICtzdGF0aWMgc3Ry dWN0IGRldmljZSB2ZHVzZV9tZ210ZGV2ID0gewo+ICsJLmluaXRfbmFtZSA9ICJ2ZHVzZSIsCj4g KwkucmVsZWFzZSA9IHZkdXNlX21nbXRkZXZfcmVsZWFzZSwKPiArfTsKPiArCj4gK3N0YXRpYyBz dHJ1Y3QgdmRwYV9tZ210X2RldiBtZ210X2RldjsKPiArCj4gK3N0YXRpYyBpbnQgdmR1c2VfZGV2 X2luaXRfdmRwYShzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYsIGNvbnN0IGNoYXIgKm5hbWUpCj4gK3sK PiArCXN0cnVjdCB2ZHVzZV92ZHBhICp2ZGV2Owo+ICsJaW50IHJldDsKPiArCj4gKwlpZiAoZGV2 LT52ZGV2KQo+ICsJCXJldHVybiAtRUVYSVNUOwo+ICsKPiArCXZkZXYgPSB2ZHBhX2FsbG9jX2Rl dmljZShzdHJ1Y3QgdmR1c2VfdmRwYSwgdmRwYSwgZGV2LT5kZXYsCj4gKwkJCQkgJnZkdXNlX3Zk cGFfY29uZmlnX29wcywgbmFtZSwgdHJ1ZSk7Cj4gKwlpZiAoIXZkZXYpCj4gKwkJcmV0dXJuIC1F Tk9NRU07Cj4gKwo+ICsJZGV2LT52ZGV2ID0gdmRldjsKPiArCXZkZXYtPmRldiA9IGRldjsKPiAr CXZkZXYtPnZkcGEuZGV2LmRtYV9tYXNrID0gJnZkZXYtPnZkcGEuZGV2LmNvaGVyZW50X2RtYV9t YXNrOwo+ICsJcmV0ID0gZG1hX3NldF9tYXNrX2FuZF9jb2hlcmVudCgmdmRldi0+dmRwYS5kZXYs IERNQV9CSVRfTUFTSyg2NCkpOwo+ICsJaWYgKHJldCkgewo+ICsJCXB1dF9kZXZpY2UoJnZkZXYt PnZkcGEuZGV2KTsKPiArCQlyZXR1cm4gcmV0Owo+ICsJfQo+ICsJc2V0X2RtYV9vcHMoJnZkZXYt PnZkcGEuZGV2LCAmdmR1c2VfZGV2X2RtYV9vcHMpOwo+ICsJdmRldi0+dmRwYS5kbWFfZGV2ID0g JnZkZXYtPnZkcGEuZGV2Owo+ICsJdmRldi0+dmRwYS5tZGV2ID0gJm1nbXRfZGV2Owo+ICsKPiAr CXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHZkcGFfZGV2X2FkZChzdHJ1Y3QgdmRw YV9tZ210X2RldiAqbWRldiwgY29uc3QgY2hhciAqbmFtZSkKPiArewo+ICsJc3RydWN0IHZkdXNl X2RldiAqZGV2Owo+ICsJaW50IHJldDsKPiArCj4gKwltdXRleF9sb2NrKCZ2ZHVzZV9sb2NrKTsK PiArCWRldiA9IHZkdXNlX2ZpbmRfZGV2KG5hbWUpOwo+ICsJaWYgKCFkZXYpIHsKPiArCQltdXRl eF91bmxvY2soJnZkdXNlX2xvY2spOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsJfQo+ICsJcmV0 ID0gdmR1c2VfZGV2X2luaXRfdmRwYShkZXYsIG5hbWUpOwo+ICsJbXV0ZXhfdW5sb2NrKCZ2ZHVz ZV9sb2NrKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiArCj4gKwlyZXQgPSBfdmRw YV9yZWdpc3Rlcl9kZXZpY2UoJmRldi0+dmRldi0+dmRwYSwgZGV2LT52cV9udW0pOwo+ICsJaWYg KHJldCkgewo+ICsJCXB1dF9kZXZpY2UoJmRldi0+dmRldi0+dmRwYS5kZXYpOwo+ICsJCXJldHVy biByZXQ7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHZk cGFfZGV2X2RlbChzdHJ1Y3QgdmRwYV9tZ210X2RldiAqbWRldiwgc3RydWN0IHZkcGFfZGV2aWNl ICpkZXYpCj4gK3sKPiArCV92ZHBhX3VucmVnaXN0ZXJfZGV2aWNlKGRldik7Cj4gK30KPiArCj4g K3N0YXRpYyBjb25zdCBzdHJ1Y3QgdmRwYV9tZ210ZGV2X29wcyB2ZHBhX2Rldl9tZ210ZGV2X29w cyA9IHsKPiArCS5kZXZfYWRkID0gdmRwYV9kZXZfYWRkLAo+ICsJLmRldl9kZWwgPSB2ZHBhX2Rl dl9kZWwsCj4gK307Cj4gKwo+ICtzdGF0aWMgc3RydWN0IHZpcnRpb19kZXZpY2VfaWQgaWRfdGFi bGVbXSA9IHsKPiArCXsgVklSVElPX0lEX0JMT0NLLCBWSVJUSU9fREVWX0FOWV9JRCB9LAo+ICsJ eyAwIH0sCj4gK307Cj4gKwo+ICtzdGF0aWMgc3RydWN0IHZkcGFfbWdtdF9kZXYgbWdtdF9kZXYg PSB7Cj4gKwkuZGV2aWNlID0gJnZkdXNlX21nbXRkZXYsCj4gKwkuaWRfdGFibGUgPSBpZF90YWJs ZSwKPiArCS5vcHMgPSAmdmRwYV9kZXZfbWdtdGRldl9vcHMsCj4gK307Cj4gKwo+ICtzdGF0aWMg aW50IHZkdXNlX21nbXRkZXZfaW5pdCh2b2lkKQo+ICt7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXJl dCA9IGRldmljZV9yZWdpc3RlcigmdmR1c2VfbWdtdGRldik7Cj4gKwlpZiAocmV0KQo+ICsJCXJl dHVybiByZXQ7Cj4gKwo+ICsJcmV0ID0gdmRwYV9tZ210ZGV2X3JlZ2lzdGVyKCZtZ210X2Rldik7 Cj4gKwlpZiAocmV0KQo+ICsJCWdvdG8gZXJyOwo+ICsKPiArCXJldHVybiAwOwo+ICtlcnI6Cj4g KwlkZXZpY2VfdW5yZWdpc3RlcigmdmR1c2VfbWdtdGRldik7Cj4gKwlyZXR1cm4gcmV0Owo+ICt9 Cj4gKwo+ICtzdGF0aWMgdm9pZCB2ZHVzZV9tZ210ZGV2X2V4aXQodm9pZCkKPiArewo+ICsJdmRw YV9tZ210ZGV2X3VucmVnaXN0ZXIoJm1nbXRfZGV2KTsKPiArCWRldmljZV91bnJlZ2lzdGVyKCZ2 ZHVzZV9tZ210ZGV2KTsKPiArfQo+ICsKPiArc3RhdGljIGludCB2ZHVzZV9pbml0KHZvaWQpCj4g K3sKPiArCWludCByZXQ7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpkZXY7Cj4gKwo+ICsJdmR1c2VfY2xh c3MgPSBjbGFzc19jcmVhdGUoVEhJU19NT0RVTEUsICJ2ZHVzZSIpOwo+ICsJaWYgKElTX0VSUih2 ZHVzZV9jbGFzcykpCj4gKwkJcmV0dXJuIFBUUl9FUlIodmR1c2VfY2xhc3MpOwo+ICsKPiArCXZk dXNlX2NsYXNzLT5kZXZub2RlID0gdmR1c2VfZGV2bm9kZTsKPiArCj4gKwlyZXQgPSBhbGxvY19j aHJkZXZfcmVnaW9uKCZ2ZHVzZV9tYWpvciwgMCwgVkRVU0VfREVWX01BWCwgInZkdXNlIik7Cj4g KwlpZiAocmV0KQo+ICsJCWdvdG8gZXJyX2NoYXJkZXZfcmVnaW9uOwo+ICsKPiArCS8qIC9kZXYv dmR1c2UvY29udHJvbCAqLwo+ICsJY2Rldl9pbml0KCZ2ZHVzZV9jdHJsX2NkZXYsICZ2ZHVzZV9j dHJsX2ZvcHMpOwo+ICsJdmR1c2VfY3RybF9jZGV2Lm93bmVyID0gVEhJU19NT0RVTEU7Cj4gKwly ZXQgPSBjZGV2X2FkZCgmdmR1c2VfY3RybF9jZGV2LCB2ZHVzZV9tYWpvciwgMSk7Cj4gKwlpZiAo cmV0KQo+ICsJCWdvdG8gZXJyX2N0cmxfY2RldjsKPiArCj4gKwlkZXYgPSBkZXZpY2VfY3JlYXRl KHZkdXNlX2NsYXNzLCBOVUxMLCB2ZHVzZV9tYWpvciwgTlVMTCwgImNvbnRyb2wiKTsKPiArCWlm IChJU19FUlIoZGV2KSkgewo+ICsJCXJldCA9IFBUUl9FUlIoZGV2KTsKPiArCQlnb3RvIGVycl9k ZXZpY2U7Cj4gKwl9Cj4gKwo+ICsJLyogL2Rldi92ZHVzZS8kREVWSUNFICovCj4gKwljZGV2X2lu aXQoJnZkdXNlX2NkZXYsICZ2ZHVzZV9kZXZfZm9wcyk7Cj4gKwl2ZHVzZV9jZGV2Lm93bmVyID0g VEhJU19NT0RVTEU7Cj4gKwlyZXQgPSBjZGV2X2FkZCgmdmR1c2VfY2RldiwgTUtERVYoTUFKT1Io dmR1c2VfbWFqb3IpLCAxKSwKPiArCQkgICAgICAgVkRVU0VfREVWX01BWCAtIDEpOwo+ICsJaWYg KHJldCkKPiArCQlnb3RvIGVycl9jZGV2Owo+ICsKPiArCXZkdXNlX2lycV93cSA9IGFsbG9jX3dv cmtxdWV1ZSgidmR1c2UtaXJxIiwKPiArCQkJCVdRX0hJR0hQUkkgfCBXUV9TWVNGUyB8IFdRX1VO Qk9VTkQsIDApOwo+ICsJaWYgKCF2ZHVzZV9pcnFfd3EpCj4gKwkJZ290byBlcnJfd3E7Cj4gKwo+ ICsJcmV0ID0gdmR1c2VfZG9tYWluX2luaXQoKTsKPiArCWlmIChyZXQpCj4gKwkJZ290byBlcnJf ZG9tYWluOwo+ICsKPiArCXJldCA9IHZkdXNlX21nbXRkZXZfaW5pdCgpOwo+ICsJaWYgKHJldCkK PiArCQlnb3RvIGVycl9tZ210ZGV2Owo+ICsKPiArCXJldHVybiAwOwo+ICtlcnJfbWdtdGRldjoK PiArCXZkdXNlX2RvbWFpbl9leGl0KCk7Cj4gK2Vycl9kb21haW46Cj4gKwlkZXN0cm95X3dvcmtx dWV1ZSh2ZHVzZV9pcnFfd3EpOwo+ICtlcnJfd3E6Cj4gKwljZGV2X2RlbCgmdmR1c2VfY2Rldik7 Cj4gK2Vycl9jZGV2Ogo+ICsJZGV2aWNlX2Rlc3Ryb3kodmR1c2VfY2xhc3MsIHZkdXNlX21ham9y KTsKPiArZXJyX2RldmljZToKPiArCWNkZXZfZGVsKCZ2ZHVzZV9jdHJsX2NkZXYpOwo+ICtlcnJf Y3RybF9jZGV2Ogo+ICsJdW5yZWdpc3Rlcl9jaHJkZXZfcmVnaW9uKHZkdXNlX21ham9yLCBWRFVT RV9ERVZfTUFYKTsKPiArZXJyX2NoYXJkZXZfcmVnaW9uOgo+ICsJY2xhc3NfZGVzdHJveSh2ZHVz ZV9jbGFzcyk7Cj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gK21vZHVsZV9pbml0KHZkdXNlX2luaXQp Owo+ICsKPiArc3RhdGljIHZvaWQgdmR1c2VfZXhpdCh2b2lkKQo+ICt7Cj4gKwl2ZHVzZV9tZ210 ZGV2X2V4aXQoKTsKPiArCXZkdXNlX2RvbWFpbl9leGl0KCk7Cj4gKwlkZXN0cm95X3dvcmtxdWV1 ZSh2ZHVzZV9pcnFfd3EpOwo+ICsJY2Rldl9kZWwoJnZkdXNlX2NkZXYpOwo+ICsJZGV2aWNlX2Rl c3Ryb3kodmR1c2VfY2xhc3MsIHZkdXNlX21ham9yKTsKPiArCWNkZXZfZGVsKCZ2ZHVzZV9jdHJs X2NkZXYpOwo+ICsJdW5yZWdpc3Rlcl9jaHJkZXZfcmVnaW9uKHZkdXNlX21ham9yLCBWRFVTRV9E RVZfTUFYKTsKPiArCWNsYXNzX2Rlc3Ryb3kodmR1c2VfY2xhc3MpOwo+ICt9Cj4gK21vZHVsZV9l eGl0KHZkdXNlX2V4aXQpOwo+ICsKPiArTU9EVUxFX0xJQ0VOU0UoRFJWX0xJQ0VOU0UpOwo+ICtN T0RVTEVfQVVUSE9SKERSVl9BVVRIT1IpOwo+ICtNT0RVTEVfREVTQ1JJUFRJT04oRFJWX0RFU0Mp Owo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL3VhcGkvbGludXgvdmR1c2UuaCBiL2luY2x1ZGUvdWFw aS9saW51eC92ZHVzZS5oCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAw MDAuLmYyMWIyZTUxYjVjOAo+IC0tLSAvZGV2L251bGwKPiArKysgYi9pbmNsdWRlL3VhcGkvbGlu dXgvdmR1c2UuaAo+IEBAIC0wLDAgKzEsMTQzIEBACj4gKy8qIFNQRFgtTGljZW5zZS1JZGVudGlm aWVyOiBHUEwtMi4wIFdJVEggTGludXgtc3lzY2FsbC1ub3RlICovCj4gKyNpZm5kZWYgX1VBUElf VkRVU0VfSF8KPiArI2RlZmluZSBfVUFQSV9WRFVTRV9IXwo+ICsKPiArI2luY2x1ZGUgPGxpbnV4 L3R5cGVzLmg+Cj4gKwo+ICsjZGVmaW5lIFZEVVNFX0FQSV9WRVJTSU9OCTAKPiArCj4gKyNkZWZp bmUgVkRVU0VfTkFNRV9NQVgJMjU2Cj4gKwo+ICsvKiB0aGUgY29udHJvbCBtZXNzYWdlcyBkZWZp bml0aW9uIGZvciByZWFkL3dyaXRlICovCj4gKwo+ICtlbnVtIHZkdXNlX3JlcV90eXBlIHsKPiAr CS8qIEdldCB0aGUgc3RhdGUgZm9yIHZpcnRxdWV1ZSBmcm9tIHVzZXJzcGFjZSAqLwo+ICsJVkRV U0VfR0VUX1ZRX1NUQVRFLAo+ICsJLyogTm90aWZ5IHVzZXJzcGFjZSB0byBzdGFydCB0aGUgZGF0 YXBsYW5lLCBubyByZXBseSAqLwo+ICsJVkRVU0VfU1RBUlRfREFUQVBMQU5FLAo+ICsJLyogTm90 aWZ5IHVzZXJzcGFjZSB0byBzdG9wIHRoZSBkYXRhcGxhbmUsIG5vIHJlcGx5ICovCj4gKwlWRFVT RV9TVE9QX0RBVEFQTEFORSwKPiArCS8qIE5vdGlmeSB1c2Vyc3BhY2UgdG8gdXBkYXRlIHRoZSBt ZW1vcnkgbWFwcGluZyBpbiBkZXZpY2UgSU9UTEIgKi8KPiArCVZEVVNFX1VQREFURV9JT1RMQiwK PiArfTsKPiArCj4gK3N0cnVjdCB2ZHVzZV92cV9zdGF0ZSB7Cj4gKwlfX3UzMiBpbmRleDsgLyog dmlydHF1ZXVlIGluZGV4ICovCj4gKwlfX3UzMiBhdmFpbF9pZHg7IC8qIHZpcnRxdWV1ZSBzdGF0 ZSAobGFzdF9hdmFpbF9pZHgpICovCj4gK307CgoKVGhpcyBuZWVkcyBzb21lIHR3ZWFrcyB0byBz dXBwb3J0IHBhY2tlZCB2aXJ0cXVldWUuCgoKPiArCj4gK3N0cnVjdCB2ZHVzZV9pb3ZhX3Jhbmdl IHsKPiArCV9fdTY0IHN0YXJ0OyAvKiBzdGFydCBvZiB0aGUgSU9WQSByYW5nZSAqLwo+ICsJX191 NjQgbGFzdDsgLyogZW5kIG9mIHRoZSBJT1ZBIHJhbmdlICovCj4gK307Cj4gKwo+ICtzdHJ1Y3Qg dmR1c2VfZGV2X3JlcXVlc3Qgewo+ICsJX191MzIgdHlwZTsgLyogcmVxdWVzdCB0eXBlICovCj4g KwlfX3UzMiByZXF1ZXN0X2lkOyAvKiByZXF1ZXN0IGlkICovCj4gKyNkZWZpbmUgVkRVU0VfUkVR X0ZMQUdTX05PX1JFUExZCSgxIDw8IDApIC8qIE5vIG5lZWQgdG8gcmVwbHkgKi8KPiArCV9fdTMy IGZsYWdzOyAvKiByZXF1ZXN0IGZsYWdzICovCj4gKwlfX3UzMiByZXNlcnZlZDsgLyogZm9yIGZ1 dHVyZSB1c2UgKi8KPiArCXVuaW9uIHsKPiArCQlzdHJ1Y3QgdmR1c2VfdnFfc3RhdGUgdnFfc3Rh dGU7IC8qIHZpcnRxdWV1ZSBzdGF0ZSAqLwo+ICsJCXN0cnVjdCB2ZHVzZV9pb3ZhX3JhbmdlIGlv dmE7IC8qIGlvdmEgcmFuZ2UgZm9yIHVwZGF0aW5nICovCj4gKwkJX191MzIgcGFkZGluZ1sxNl07 IC8qIHBhZGRpbmcgKi8KPiArCX07Cj4gK307Cj4gKwo+ICtzdHJ1Y3QgdmR1c2VfZGV2X3Jlc3Bv bnNlIHsKPiArCV9fdTMyIHJlcXVlc3RfaWQ7IC8qIGNvcnJlc3BvbmRpbmcgcmVxdWVzdCBpZCAq Lwo+ICsjZGVmaW5lIFZEVVNFX1JFUV9SRVNVTFRfT0sJMHgwMAo+ICsjZGVmaW5lIFZEVVNFX1JF UV9SRVNVTFRfRkFJTEVECTB4MDEKPiArCV9fdTMyIHJlc3VsdDsgLyogdGhlIHJlc3VsdCBvZiBy ZXF1ZXN0ICovCj4gKwlfX3UzMiByZXNlcnZlZFsyXTsgLyogZm9yIGZ1dHVyZSB1c2UgKi8KPiAr CXVuaW9uIHsKPiArCQlzdHJ1Y3QgdmR1c2VfdnFfc3RhdGUgdnFfc3RhdGU7IC8qIHZpcnRxdWV1 ZSBzdGF0ZSAqLwo+ICsJCV9fdTMyIHBhZGRpbmdbMTZdOyAvKiBwYWRkaW5nICovCj4gKwl9Owo+ ICt9Owo+ICsKPiArLyogaW9jdGxzICovCj4gKwo+ICtzdHJ1Y3QgdmR1c2VfZGV2X2NvbmZpZyB7 Cj4gKwljaGFyIG5hbWVbVkRVU0VfTkFNRV9NQVhdOyAvKiB2ZHVzZSBkZXZpY2UgbmFtZSAqLwo+ ICsJX191MzIgdmVuZG9yX2lkOyAvKiB2aXJ0aW8gdmVuZG9yIGlkICovCj4gKwlfX3UzMiBkZXZp Y2VfaWQ7IC8qIHZpcnRpbyBkZXZpY2UgaWQgKi8KPiArCV9fdTY0IGZlYXR1cmVzOyAvKiBkZXZp Y2UgZmVhdHVyZXMgKi8KPiArCV9fdTY0IGJvdW5jZV9zaXplOyAvKiBib3VuY2UgYnVmZmVyIHNp emUgZm9yIGlvbW11ICovCj4gKwlfX3UxNiB2cV9zaXplX21heDsgLyogdGhlIG1heCBzaXplIG9m IHZpcnRxdWV1ZSAqLwo+ICsJX191MTYgcGFkZGluZzsgLyogcGFkZGluZyAqLwo+ICsJX191MzIg dnFfbnVtOyAvKiB0aGUgbnVtYmVyIG9mIHZpcnRxdWV1ZXMgKi8KPiArCV9fdTMyIHZxX2FsaWdu OyAvKiB0aGUgYWxsb2NhdGlvbiBhbGlnbm1lbnQgb2YgdmlydHF1ZXVlJ3MgbWV0YWRhdGEgKi8K PiArCV9fdTMyIGNvbmZpZ19zaXplOyAvKiB0aGUgc2l6ZSBvZiB0aGUgY29uZmlndXJhdGlvbiBz cGFjZSAqLwo+ICsJX191MzIgcmVzZXJ2ZWRbMTVdOyAvKiBmb3IgZnV0dXJlIHVzZSAqLwo+ICsJ X191OCBjb25maWdbMF07IC8qIHRoZSBidWZmZXIgb2YgdGhlIGNvbmZpZ3VyYXRpb24gc3BhY2Ug Ki8KPiArfTsKPiArCj4gK3N0cnVjdCB2ZHVzZV9pb3RsYl9lbnRyeSB7Cj4gKwlfX3U2NCBvZmZz ZXQ7IC8qIHRoZSBtbWFwIG9mZnNldCBvbiBmZCAqLwo+ICsJX191NjQgc3RhcnQ7IC8qIHN0YXJ0 IG9mIHRoZSBJT1ZBIHJhbmdlICovCj4gKwlfX3U2NCBsYXN0OyAvKiBsYXN0IG9mIHRoZSBJT1ZB IHJhbmdlICovCj4gKyNkZWZpbmUgVkRVU0VfQUNDRVNTX1JPIDB4MQo+ICsjZGVmaW5lIFZEVVNF X0FDQ0VTU19XTyAweDIKPiArI2RlZmluZSBWRFVTRV9BQ0NFU1NfUlcgMHgzCj4gKwlfX3U4IHBl cm07IC8qIGFjY2VzcyBwZXJtaXNzaW9uIG9mIHRoaXMgcmFuZ2UgKi8KPiArfTsKPiArCj4gK3N0 cnVjdCB2ZHVzZV9jb25maWdfdXBkYXRlIHsKPiArCV9fdTMyIG9mZnNldDsgLyogb2Zmc2V0IGZy b20gdGhlIGJlZ2lubmluZyBvZiBjb25maWd1cmF0aW9uIHNwYWNlICovCj4gKwlfX3UzMiBsZW5n dGg7IC8qIHRoZSBsZW5ndGggdG8gd3JpdGUgdG8gY29uZmlndXJhdGlvbiBzcGFjZSAqLwo+ICsJ X191OCBidWZmZXJbMF07IC8qIGJ1ZmZlciB1c2VkIHRvIHdyaXRlIGZyb20gKi8KPiArfTsKPiAr Cj4gK3N0cnVjdCB2ZHVzZV92cV9pbmZvIHsKPiArCV9fdTMyIGluZGV4OyAvKiB2aXJ0cXVldWUg aW5kZXggKi8KPiArCV9fdTMyIGF2YWlsX2lkeDsgLyogdmlydHF1ZXVlIHN0YXRlIChsYXN0X2F2 YWlsX2lkeCkgKi8KPiArCV9fdTY0IGRlc2NfYWRkcjsgLyogYWRkcmVzcyBvZiBkZXNjIGFyZWEg Ki8KPiArCV9fdTY0IGRyaXZlcl9hZGRyOyAvKiBhZGRyZXNzIG9mIGRyaXZlciBhcmVhICovCj4g KwlfX3U2NCBkZXZpY2VfYWRkcjsgLyogYWRkcmVzcyBvZiBkZXZpY2UgYXJlYSAqLwo+ICsJX191 MzIgbnVtOyAvKiB0aGUgc2l6ZSBvZiB2aXJ0cXVldWUgKi8KPiArCV9fdTggcmVhZHk7IC8qIHJl YWR5IHN0YXR1cyBvZiB2aXJ0cXVldWUgKi8KPiArfTsKPiArCj4gK3N0cnVjdCB2ZHVzZV92cV9l dmVudGZkIHsKPiArCV9fdTMyIGluZGV4OyAvKiB2aXJ0cXVldWUgaW5kZXggKi8KPiArI2RlZmlu ZSBWRFVTRV9FVkVOVEZEX0RFQVNTSUdOIC0xCj4gKwlpbnQgZmQ7IC8qIGV2ZW50ZmQsIC0xIG1l YW5zIGRlLWFzc2lnbmluZyB0aGUgZXZlbnRmZCAqLwo+ICt9Owo+ICsKPiArI2RlZmluZSBWRFVT RV9CQVNFCTB4ODEKPiArCj4gKy8qIEdldCB0aGUgdmVyc2lvbiBvZiBWRFVTRSBBUEkuIFRoaXMg aXMgdXNlZCBmb3IgZnV0dXJlIGV4dGVuc2lvbiAqLwo+ICsjZGVmaW5lIFZEVVNFX0dFVF9BUElf VkVSU0lPTglfSU9SKFZEVVNFX0JBU0UsIDB4MDAsIF9fdTY0KQo+ICsKPiArLyogU2V0IHRoZSB2 ZXJzaW9uIG9mIFZEVVNFIEFQSS4gKi8KPiArI2RlZmluZSBWRFVTRV9TRVRfQVBJX1ZFUlNJT04J X0lPVyhWRFVTRV9CQVNFLCAweDAxLCBfX3U2NCkKPiArCj4gKy8qIENyZWF0ZSBhIHZkdXNlIGRl dmljZSB3aGljaCBpcyByZXByZXNlbnRlZCBieSBhIGNoYXIgZGV2aWNlICgvZGV2L3ZkdXNlLzxu YW1lPikgKi8KPiArI2RlZmluZSBWRFVTRV9DUkVBVEVfREVWCV9JT1coVkRVU0VfQkFTRSwgMHgw Miwgc3RydWN0IHZkdXNlX2Rldl9jb25maWcpCj4gKwo+ICsvKiBEZXN0cm95IGEgdmR1c2UgZGV2 aWNlLiBNYWtlIHN1cmUgdGhlcmUgYXJlIG5vIHJlZmVyZW5jZXMgdG8gdGhlIGNoYXIgZGV2aWNl ICovCj4gKyNkZWZpbmUgVkRVU0VfREVTVFJPWV9ERVYJX0lPVyhWRFVTRV9CQVNFLCAweDAzLCBj aGFyW1ZEVVNFX05BTUVfTUFYXSkKPiArCj4gKy8qCj4gKyAqIEdldCBhIGZpbGUgZGVzY3JpcHRv ciBmb3IgdGhlIGZpcnN0IG92ZXJsYXBwZWQgaW92YSByZWdpb24sCj4gKyAqIC1FSU5WQUwgbWVh bnMgdGhlIGlvdmEgcmVnaW9uIGRvZXNuJ3QgZXhpc3QuCj4gKyAqLwo+ICsjZGVmaW5lIFZEVVNF X0lPVExCX0dFVF9GRAlfSU9XUihWRFVTRV9CQVNFLCAweDA0LCBzdHJ1Y3QgdmR1c2VfaW90bGJf ZW50cnkpCj4gKwo+ICsvKiBHZXQgdGhlIG5lZ290aWF0ZWQgZmVhdHVyZXMgKi8KPiArI2RlZmlu ZSBWRFVTRV9ERVZfR0VUX0ZFQVRVUkVTCV9JT1IoVkRVU0VfQkFTRSwgMHgwNSwgX191NjQpCj4g Kwo+ICsvKiBVcGRhdGUgdGhlIGNvbmZpZ3VyYXRpb24gc3BhY2UgKi8KPiArI2RlZmluZSBWRFVT RV9ERVZfVVBEQVRFX0NPTkZJRwlfSU9XKFZEVVNFX0JBU0UsIDB4MDYsIHN0cnVjdCB2ZHVzZV9j b25maWdfdXBkYXRlKQo+ICsKPiArLyogR2V0IHRoZSBzcGVjaWZpZWQgdmlydHF1ZXVlJ3MgaW5m b3JtYXRpb24gKi8KPiArI2RlZmluZSBWRFVTRV9WUV9HRVRfSU5GTwlfSU9XUihWRFVTRV9CQVNF LCAweDA3LCBzdHJ1Y3QgdmR1c2VfdnFfaW5mbykKPiArCj4gKy8qIFNldHVwIGFuIGV2ZW50ZmQg dG8gcmVjZWl2ZSBraWNrIGZvciB2aXJ0cXVldWUgKi8KPiArI2RlZmluZSBWRFVTRV9WUV9TRVRV UF9LSUNLRkQJX0lPVyhWRFVTRV9CQVNFLCAweDA4LCBzdHJ1Y3QgdmR1c2VfdnFfZXZlbnRmZCkK PiArCj4gKy8qIEluamVjdCBhbiBpbnRlcnJ1cHQgZm9yIHNwZWNpZmljIHZpcnRxdWV1ZSAqLwo+ ICsjZGVmaW5lIFZEVVNFX1ZRX0lOSkVDVF9JUlEJX0lPVyhWRFVTRV9CQVNFLCAweDA5LCBfX3Uz MikKPiArCj4gKyNlbmRpZiAvKiBfVUFQSV9WRFVTRV9IXyAqLwoKCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClZpcnR1YWxpemF0aW9uIG1haWxpbmcgbGlz dApWaXJ0dWFsaXphdGlvbkBsaXN0cy5saW51eC1mb3VuZGF0aW9uLm9yZwpodHRwczovL2xpc3Rz LmxpbnV4Zm91bmRhdGlvbi5vcmcvbWFpbG1hbi9saXN0aW5mby92aXJ0dWFsaXphdGlvbg==