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.3 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,URIBL_BLOCKED,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 8A0F8C433E0 for ; Thu, 4 Mar 2021 06:29:52 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 52D3264EF9 for ; Thu, 4 Mar 2021 06:29:52 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235251AbhCDG3U (ORCPT ); Thu, 4 Mar 2021 01:29:20 -0500 Received: from us-smtp-delivery-124.mimecast.com ([216.205.24.124]:54290 "EHLO us-smtp-delivery-124.mimecast.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235253AbhCDG3J (ORCPT ); Thu, 4 Mar 2021 01:29:09 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1614839263; 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=5fRUeNYSC7f7t+UgXPO/yXd0ICDYWA8w23nTO80qTLA=; b=LLZGpoXaTLIBUN7kCWJ73iO3tiNPsHtkVC53q06HlXpCp9ilNn0uC51GUt7kyBlSxZwbSm j8OMlrf45lK73MAxd/cPHD9/FhsnhVPIcRY2QXbYXj7bhU/Hf2dOlXoegLsDNiP/8g8oKy VrkXT3IIA+GqH2Od0k0BBMOJ3gHDCh8= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-243-jzX9mJGnMKGabdgMpuwbnA-1; Thu, 04 Mar 2021 01:27:41 -0500 X-MC-Unique: jzX9mJGnMKGabdgMpuwbnA-1 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.phx2.redhat.com [10.5.11.22]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id EC3D51842154; Thu, 4 Mar 2021 06:27:37 +0000 (UTC) Received: from wangxiaodeMacBook-Air.local (ovpn-13-244.pek2.redhat.com [10.72.13.244]) by smtp.corp.redhat.com (Postfix) with ESMTP id 07C7210013D6; Thu, 4 Mar 2021 06:27:22 +0000 (UTC) Subject: Re: [RFC v4 07/11] vduse: Introduce VDUSE - vDPA Device in Userspace To: Xie Yongji , mst@redhat.com, stefanha@redhat.com, sgarzare@redhat.com, parav@nvidia.com, bob.liu@oracle.com, hch@infradead.org, rdunlap@infradead.org, willy@infradead.org, viro@zeniv.linux.org.uk, axboe@kernel.dk, bcrl@kvack.org, corbet@lwn.net Cc: virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, kvm@vger.kernel.org, linux-aio@kvack.org, linux-fsdevel@vger.kernel.org References: <20210223115048.435-1-xieyongji@bytedance.com> <20210223115048.435-8-xieyongji@bytedance.com> From: Jason Wang Message-ID: Date: Thu, 4 Mar 2021 14:27:21 +0800 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.16; rv:78.0) Gecko/20100101 Thunderbird/78.8.0 MIME-Version: 1.0 In-Reply-To: <20210223115048.435-8-xieyongji@bytedance.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Content-Language: en-GB X-Scanned-By: MIMEDefang 2.84 on 10.5.11.22 Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org On 2021/2/23 7:50 下午, Xie Yongji wrote: > This VDUSE driver enables implementing vDPA devices in userspace. > Both control path and data path of vDPA devices will be able to > be handled in userspace. > > In the control path, the VDUSE driver will make use of message > mechnism to forward the config operation from vdpa bus driver > to userspace. Userspace can use read()/write() to receive/reply > those control messages. > > In the data path, VDUSE_IOTLB_GET_FD ioctl will be used to get > the file descriptors referring to vDPA device's iova regions. Then > userspace can use mmap() to access those iova regions. Besides, > userspace can use ioctl() to inject interrupt and use the eventfd > mechanism to receive virtqueue kicks. > > 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 | 1348 ++++++++++++++++++++ > include/uapi/linux/vduse.h | 136 ++ > 6 files changed, 1501 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 a4c75a28c839..71722e6f8f23 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 ffd1e098bfd2..92f07715e3b6 100644 > --- a/drivers/vdpa/Kconfig > +++ b/drivers/vdpa/Kconfig > @@ -25,6 +25,16 @@ config VDPA_SIM_NET > help > vDPA networking device simulator which loops TX traffic back to RX. > > +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 d160e9b63a66..66e97778ad03 100644 > --- a/drivers/vdpa/Makefile > +++ b/drivers/vdpa/Makefile > @@ -1,5 +1,6 @@ > # 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/ > 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..393bf99c48be > --- /dev/null > +++ b/drivers/vdpa/vdpa_user/vduse_dev.c > @@ -0,0 +1,1348 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * VDUSE: vDPA Device in Userspace > + * > + * Copyright (C) 2020 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 "iova_domain.h" > + > +#define DRV_VERSION "1.0" > +#define DRV_AUTHOR "Yongji Xie " > +#define DRV_DESC "vDPA Device in Userspace" > +#define DRV_LICENSE "GPL v2" > + > +#define VDUSE_DEV_MAX (1U << MINORBITS) > + > +struct vduse_virtqueue { > + u16 index; > + bool ready; > + spinlock_t kick_lock; > + spinlock_t irq_lock; > + struct eventfd_ctx *kickfd; > + struct vdpa_callback cb; > +}; > + > +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 cdev cdev; > + struct vduse_virtqueue *vqs; > + struct vduse_iova_domain *domain; > + struct vhost_iotlb *iommu; > + spinlock_t iommu_lock; > + atomic_t bounce_map; > + struct mutex msg_lock; > + atomic64_t msg_unique; "next_request_id" should be better. > + wait_queue_head_t waitq; > + struct list_head send_list; > + struct list_head recv_list; > + struct list_head list; > + bool connected; > + int minor; > + u16 vq_size_max; > + u16 vq_num; > + u32 vq_align; > + u32 device_id; > + u32 vendor_id; > +}; > + > +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; > +}; > + > +static unsigned long max_bounce_size = (64 * 1024 * 1024); > +module_param(max_bounce_size, ulong, 0444); > +MODULE_PARM_DESC(max_bounce_size, "Maximum bounce buffer size. (default: 64M)"); > + > +static unsigned long max_iova_size = (128 * 1024 * 1024); > +module_param(max_iova_size, ulong, 0444); > +MODULE_PARM_DESC(max_iova_size, "Maximum iova space size (default: 128M)"); > + > +static DEFINE_MUTEX(vduse_lock); > +static LIST_HEAD(vduse_devs); > +static DEFINE_IDA(vduse_ida); > + > +static dev_t vduse_major; > +static struct class *vduse_class; > + > +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 unique) > +{ > + struct vduse_dev_msg *tmp, *msg = NULL; > + > + list_for_each_entry(tmp, head, list) { Shoudl we use list_for_each_entry_safe()? > + if (tmp->req.unique == unique) { > + msg = tmp; > + list_del(&tmp->list); > + break; > + } > + } > + > + return msg; > +} > + > +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_sync(struct vduse_dev *dev, struct vduse_dev_msg *msg) > +{ > + int ret; > + > + init_waitqueue_head(&msg->waitq); > + mutex_lock(&dev->msg_lock); > + vduse_enqueue_msg(&dev->send_list, msg); > + wake_up(&dev->waitq); > + mutex_unlock(&dev->msg_lock); > + ret = wait_event_interruptible(msg->waitq, msg->completed); > + mutex_lock(&dev->msg_lock); > + if (!msg->completed) > + list_del(&msg->list); > + else > + ret = msg->resp.result; > + mutex_unlock(&dev->msg_lock); > + > + return ret; > +} > + > +static u64 vduse_dev_get_features(struct vduse_dev *dev) > +{ > + struct vduse_dev_msg msg = { 0 }; > + > + msg.req.type = VDUSE_GET_FEATURES; > + msg.req.unique = atomic64_fetch_inc(&dev->msg_unique); > + > + return vduse_dev_msg_sync(dev, &msg) ? 0 : msg.resp.features; > +} > + > +static int vduse_dev_set_features(struct vduse_dev *dev, u64 features) > +{ > + struct vduse_dev_msg msg = { 0 }; > + > + msg.req.type = VDUSE_SET_FEATURES; > + msg.req.unique = atomic64_fetch_inc(&dev->msg_unique); > + msg.req.features = features; > + > + return vduse_dev_msg_sync(dev, &msg); > +} > + > +static u8 vduse_dev_get_status(struct vduse_dev *dev) > +{ > + struct vduse_dev_msg msg = { 0 }; > + > + msg.req.type = VDUSE_GET_STATUS; > + msg.req.unique = atomic64_fetch_inc(&dev->msg_unique); > + > + return vduse_dev_msg_sync(dev, &msg) ? 0 : msg.resp.status; > +} > + > +static void vduse_dev_set_status(struct vduse_dev *dev, u8 status) > +{ > + struct vduse_dev_msg msg = { 0 }; > + > + msg.req.type = VDUSE_SET_STATUS; > + msg.req.unique = atomic64_fetch_inc(&dev->msg_unique); > + msg.req.status = status; > + > + vduse_dev_msg_sync(dev, &msg); > +} > + > +static void vduse_dev_get_config(struct vduse_dev *dev, unsigned int offset, > + void *buf, unsigned int len) Btw, the ident looks odd here and other may places wherhe functions has more than one line of arguments. > +{ > + struct vduse_dev_msg msg = { 0 }; > + unsigned int sz; > + > + while (len) { > + sz = min_t(unsigned int, len, sizeof(msg.req.config.data)); > + msg.req.type = VDUSE_GET_CONFIG; > + msg.req.unique = atomic64_fetch_inc(&dev->msg_unique); > + msg.req.config.offset = offset; > + msg.req.config.len = sz; > + vduse_dev_msg_sync(dev, &msg); > + memcpy(buf, msg.resp.config.data, sz); > + buf += sz; > + offset += sz; > + len -= sz; > + } > +} > + > +static void vduse_dev_set_config(struct vduse_dev *dev, unsigned int offset, > + const void *buf, unsigned int len) > +{ > + struct vduse_dev_msg msg = { 0 }; > + unsigned int sz; > + > + while (len) { > + sz = min_t(unsigned int, len, sizeof(msg.req.config.data)); > + msg.req.type = VDUSE_SET_CONFIG; > + msg.req.unique = atomic64_fetch_inc(&dev->msg_unique); > + msg.req.config.offset = offset; > + msg.req.config.len = sz; > + memcpy(msg.req.config.data, buf, sz); > + vduse_dev_msg_sync(dev, &msg); > + buf += sz; > + offset += sz; > + len -= sz; > + } > +} > + > +static void vduse_dev_set_vq_num(struct vduse_dev *dev, > + struct vduse_virtqueue *vq, u32 num) > +{ > + struct vduse_dev_msg msg = { 0 }; > + > + msg.req.type = VDUSE_SET_VQ_NUM; > + msg.req.unique = atomic64_fetch_inc(&dev->msg_unique); > + msg.req.vq_num.index = vq->index; > + msg.req.vq_num.num = num; > + > + vduse_dev_msg_sync(dev, &msg); > +} > + > +static int vduse_dev_set_vq_addr(struct vduse_dev *dev, > + struct vduse_virtqueue *vq, u64 desc_addr, > + u64 driver_addr, u64 device_addr) > +{ > + struct vduse_dev_msg msg = { 0 }; > + > + msg.req.type = VDUSE_SET_VQ_ADDR; > + msg.req.unique = atomic64_fetch_inc(&dev->msg_unique); > + msg.req.vq_addr.index = vq->index; > + msg.req.vq_addr.desc_addr = desc_addr; > + msg.req.vq_addr.driver_addr = driver_addr; > + msg.req.vq_addr.device_addr = device_addr; > + > + return vduse_dev_msg_sync(dev, &msg); > +} > + > +static void vduse_dev_set_vq_ready(struct vduse_dev *dev, > + struct vduse_virtqueue *vq, bool ready) > +{ > + struct vduse_dev_msg msg = { 0 }; > + > + msg.req.type = VDUSE_SET_VQ_READY; > + msg.req.unique = atomic64_fetch_inc(&dev->msg_unique); > + msg.req.vq_ready.index = vq->index; > + msg.req.vq_ready.ready = ready; > + > + vduse_dev_msg_sync(dev, &msg); > +} > + > +static bool vduse_dev_get_vq_ready(struct vduse_dev *dev, > + struct vduse_virtqueue *vq) > +{ > + struct vduse_dev_msg msg = { 0 }; > + > + msg.req.type = VDUSE_GET_VQ_READY; > + msg.req.unique = atomic64_fetch_inc(&dev->msg_unique); > + msg.req.vq_ready.index = vq->index; > + > + return vduse_dev_msg_sync(dev, &msg) ? false : msg.resp.vq_ready.ready; > +} > + > +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; > + > + msg.req.type = VDUSE_GET_VQ_STATE; > + msg.req.unique = atomic64_fetch_inc(&dev->msg_unique); > + msg.req.vq_state.index = vq->index; > + > + ret = vduse_dev_msg_sync(dev, &msg); > + if (!ret) > + state->avail_index = msg.resp.vq_state.avail_idx; > + > + return ret; > +} > + > +static int vduse_dev_set_vq_state(struct vduse_dev *dev, > + struct vduse_virtqueue *vq, > + const struct vdpa_vq_state *state) > +{ > + struct vduse_dev_msg msg = { 0 }; > + > + msg.req.type = VDUSE_SET_VQ_STATE; > + msg.req.unique = atomic64_fetch_inc(&dev->msg_unique); > + msg.req.vq_state.index = vq->index; > + msg.req.vq_state.avail_idx = state->avail_index; > + > + return vduse_dev_msg_sync(dev, &msg); > +} > + > +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.unique = atomic64_fetch_inc(&dev->msg_unique); > + msg.req.iova.start = start; > + msg.req.iova.last = last; > + > + return vduse_dev_msg_sync(dev, &msg); > +} > + > +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 = 0; > + > + if (iov_iter_count(to) < size) > + return 0; > + > + mutex_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; > + > + mutex_unlock(&dev->msg_lock); > + ret = wait_event_interruptible_exclusive(dev->waitq, > + !list_empty(&dev->send_list)); > + if (ret) > + return ret; > + > + mutex_lock(&dev->msg_lock); > + } > + ret = copy_to_iter(&msg->req, size, to); > + if (ret != size) { > + ret = -EFAULT; > + vduse_enqueue_msg(&dev->send_list, msg); > + goto unlock; > + } > + vduse_enqueue_msg(&dev->recv_list, msg); > +unlock: > + mutex_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; > + > + mutex_lock(&dev->msg_lock); > + msg = vduse_find_msg(&dev->recv_list, resp.request_id); > + if (!msg) { > + ret = -EINVAL; > + goto unlock; > + } > + > + memcpy(&msg->resp, &resp, sizeof(resp)); > + msg->completed = 1; > + wake_up(&msg->waitq); > +unlock: > + mutex_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; > + > + return mask; > +} > + > +static int vduse_iotlb_add_range(struct vduse_dev *dev, > + u64 start, u64 last, > + u64 addr, unsigned int perm, > + struct file *file, u64 offset) > +{ > + struct vdpa_map_file *map_file; > + int ret; > + > + map_file = kmalloc(sizeof(*map_file), GFP_ATOMIC); > + if (!map_file) > + return -ENOMEM; > + > + map_file->file = get_file(file); > + map_file->offset = offset; > + > + spin_lock(&dev->iommu_lock); > + ret = vhost_iotlb_add_range_ctx(dev->iommu, start, last, > + addr, perm, map_file); > + spin_unlock(&dev->iommu_lock); > + if (ret) { > + fput(map_file->file); > + kfree(map_file); > + return ret; > + } > + return 0; > +} > + > +static void vduse_iotlb_del_range(struct vduse_dev *dev, u64 start, u64 last) > +{ > + struct vdpa_map_file *map_file; > + struct vhost_iotlb_map *map; > + > + spin_lock(&dev->iommu_lock); > + while ((map = vhost_iotlb_itree_first(dev->iommu, start, last))) { > + map_file = (struct vdpa_map_file *)map->opaque; > + fput(map_file->file); > + kfree(map_file); > + vhost_iotlb_map_free(dev->iommu, map); > + } > + spin_unlock(&dev->iommu_lock); > +} > + > +static void vduse_dev_reset(struct vduse_dev *dev) > +{ > + int i; > + > + atomic_set(&dev->bounce_map, 0); > + vduse_iotlb_del_range(dev, 0ULL, ULLONG_MAX); > + vduse_dev_update_iotlb(dev, 0ULL, ULLONG_MAX); > + > + for (i = 0; i < dev->vq_num; i++) { > + struct vduse_virtqueue *vq = &dev->vqs[i]; > + > + spin_lock(&vq->irq_lock); > + vq->ready = false; > + 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]; > + > + return vduse_dev_set_vq_addr(dev, vq, desc_area, > + driver_area, device_area); > +} > + > +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 && vq->kickfd) > + eventfd_signal(vq->kickfd, 1); > + 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]; > + > + vduse_dev_set_vq_num(dev, vq, 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]; > + > + vduse_dev_set_vq_ready(dev, vq, ready); > + 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]; > + > + vq->ready = vduse_dev_get_vq_ready(dev, vq); > + > + 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]; > + > + return vduse_dev_set_vq_state(dev, vq, state); > +} > + > +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); > + u64 fixed = (1ULL << VIRTIO_F_ACCESS_PLATFORM); > + > + return (vduse_dev_get_features(dev) | fixed); What happens if we don't do such fixup. I think we should fail if usersapce doesnt offer ACCESS_PLATFORM instead. > +} > + > +static int vduse_vdpa_set_features(struct vdpa_device *vdpa, u64 features) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + > + return vduse_dev_set_features(dev, features); > +} > + > +static void vduse_vdpa_set_config_cb(struct vdpa_device *vdpa, > + struct vdpa_callback *cb) > +{ > + /* We don't support config interrupt */ > +} > + > +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 vduse_dev_get_status(dev); > +} > + > +static void vduse_vdpa_set_status(struct vdpa_device *vdpa, u8 status) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + > + if (status == 0) > + vduse_dev_reset(dev); > + > + vduse_dev_set_status(dev, status); > +} > + > +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); > + > + vduse_dev_get_config(dev, offset, buf, len); > +} > + > +static void vduse_vdpa_set_config(struct vdpa_device *vdpa, unsigned int offset, > + const void *buf, unsigned int len) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + > + vduse_dev_set_config(dev, offset, buf, len); > +} > + > +static int vduse_vdpa_set_map(struct vdpa_device *vdpa, > + struct vhost_iotlb *iotlb) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + struct vhost_iotlb_map *map; > + struct vdpa_map_file *map_file; > + u64 start = 0ULL, last = ULLONG_MAX; > + int ret = 0; > + > + vduse_iotlb_del_range(dev, start, last); > + > + for (map = vhost_iotlb_itree_first(iotlb, start, last); map; > + map = vhost_iotlb_itree_next(map, start, last)) { > + map_file = (struct vdpa_map_file *)map->opaque; > + if (!map_file->file) > + continue; > + > + ret = vduse_iotlb_add_range(dev, map->start, map->last, > + map->addr, map->perm, > + map_file->file, > + map_file->offset); > + if (ret) > + break; > + } > + vduse_dev_update_iotlb(dev, start, last); > + > + return ret; > +} > + > +static void vduse_vdpa_free(struct vdpa_device *vdpa) > +{ > + struct vduse_dev *dev = vdpa_to_vduse(vdpa); > + > + WARN_ON(!list_empty(&dev->send_list)); > + WARN_ON(!list_empty(&dev->recv_list)); > + 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 = vduse_vdpa_get_config, > + .set_config = vduse_vdpa_set_config, > + .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; > + > + if (atomic_xchg(&vdev->bounce_map, 1) == 0 && > + vduse_iotlb_add_range(vdev, 0, domain->bounce_size - 1, > + 0, VDUSE_ACCESS_RW, > + vduse_domain_file(domain), 0)) { > + atomic_set(&vdev->bounce_map, 0); > + return DMA_MAPPING_ERROR; Can we add the bounce mapping page by page here? > + } > + > + 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; > + > + if (vduse_iotlb_add_range(vdev, iova, iova + size - 1, > + iova, VDUSE_ACCESS_RW, > + vduse_domain_file(domain), iova)) { > + vduse_domain_free_coherent(domain, size, addr, iova, attrs); > + 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; > + unsigned long start = (unsigned long)dma_addr; > + unsigned long last = start + size - 1; > + > + vduse_iotlb_del_range(vdev, start, last); > + vduse_dev_update_iotlb(vdev, start, last); > + vduse_domain_free_coherent(domain, size, vaddr, dma_addr, attrs); > +} > + > +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, > +}; > + > +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; > + > + if (eventfd->index >= dev->vq_num) > + return -EINVAL; > + > + vq = &dev->vqs[eventfd->index]; > + if (eventfd->fd > 0) { > + ctx = eventfd_ctx_fdget(eventfd->fd); > + if (IS_ERR(ctx)) > + return PTR_ERR(ctx); > + } > + spin_lock(&vq->kick_lock); > + if (vq->kickfd) > + eventfd_ctx_put(vq->kickfd); > + vq->kickfd = ctx; > + spin_unlock(&vq->kick_lock); > + > + return 0; > +} > + > +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 file *f = NULL; > + > + ret = -EFAULT; > + if (copy_from_user(&entry, argp, sizeof(entry))) > + break; > + > + spin_lock(&dev->iommu_lock); > + map = vhost_iotlb_itree_first(dev->iommu, 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(&dev->iommu_lock); > + if (!f) { > + ret = -EINVAL; > + break; > + } > + if (copy_to_user(argp, &entry, sizeof(entry))) { > + fput(f); > + ret = -EFAULT; > + break; > + } > + ret = get_unused_fd_flags(perm_to_file_flags(entry.perm)); > + if (ret < 0) { > + fput(f); > + break; > + } > + fd_install(ret, f); > + 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_INJECT_VQ_IRQ: { > + struct vduse_virtqueue *vq; > + > + ret = -EINVAL; > + if (arg >= dev->vq_num) > + break; > + > + vq = &dev->vqs[arg]; > + spin_lock_irq(&vq->irq_lock); > + if (vq->ready && vq->cb.callback) { > + vq->cb.callback(vq->cb.private); > + ret = 0; > + } > + spin_unlock_irq(&vq->irq_lock); > + 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; > + struct vduse_dev_msg *msg; > + int i; > + > + for (i = 0; i < dev->vq_num; i++) { > + struct vduse_virtqueue *vq = &dev->vqs[i]; > + > + spin_lock(&vq->kick_lock); > + if (vq->kickfd) > + eventfd_ctx_put(vq->kickfd); > + vq->kickfd = NULL; > + spin_unlock(&vq->kick_lock); > + } > + > + mutex_lock(&dev->msg_lock); > + while ((msg = vduse_dequeue_msg(&dev->recv_list))) > + vduse_enqueue_msg(&dev->send_list, msg); > + mutex_unlock(&dev->msg_lock); > + > + dev->connected = false; > + > + return 0; > +} > + > +static int vduse_dev_open(struct inode *inode, struct file *file) > +{ > + struct vduse_dev *dev = container_of(inode->i_cdev, > + struct vduse_dev, cdev); > + int ret = -EBUSY; > + > + mutex_lock(&vduse_lock); > + if (dev->connected) > + goto unlock; > + > + ret = 0; > + dev->connected = true; > + file->private_data = dev; > +unlock: > + mutex_unlock(&vduse_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; > + > + dev->iommu = vhost_iotlb_alloc(0, 0); > + if (!dev->iommu) { > + kfree(dev); > + return NULL; > + } > + > + mutex_init(&dev->msg_lock); > + INIT_LIST_HEAD(&dev->send_list); > + INIT_LIST_HEAD(&dev->recv_list); > + atomic64_set(&dev->msg_unique, 0); > + spin_lock_init(&dev->iommu_lock); > + atomic_set(&dev->bounce_map, 0); > + > + init_waitqueue_head(&dev->waitq); > + > + return dev; > +} > + > +static void vduse_dev_destroy(struct vduse_dev *dev) > +{ > + vhost_iotlb_free(dev->iommu); > + mutex_destroy(&dev->msg_lock); > + kfree(dev); > +} > + > +static struct vduse_dev *vduse_find_dev(const char *name) > +{ > + struct vduse_dev *tmp, *dev = NULL; > + > + list_for_each_entry(tmp, &vduse_devs, list) { > + if (!strcmp(dev_name(&tmp->dev), name)) { > + dev = tmp; > + break; > + } > + } > + return dev; > +} > + > +static int vduse_destroy_dev(char *name) > +{ > + struct vduse_dev *dev = vduse_find_dev(name); > + > + if (!dev) > + return -EINVAL; > + > + if (dev->vdev || dev->connected) > + return -EBUSY; > + > + dev->connected = true; > + list_del(&dev->list); > + cdev_device_del(&dev->cdev, &dev->dev); > + put_device(&dev->dev); > + > + return 0; > +} > + > +static void vduse_release_dev(struct device *device) > +{ > + struct vduse_dev *dev = > + container_of(device, struct vduse_dev, dev); > + > + ida_simple_remove(&vduse_ida, dev->minor); > + kfree(dev->vqs); > + vduse_domain_destroy(dev->domain); > + vduse_dev_destroy(dev); > + module_put(THIS_MODULE); > +} > + > +static int vduse_create_dev(struct vduse_dev_config *config) > +{ > + int i, ret = -ENOMEM; > + struct vduse_dev *dev; > + > + if (config->bounce_size > max_bounce_size) > + return -EINVAL; > + > + if (config->bounce_size > max_iova_size) > + return -EINVAL; > + > + if (vduse_find_dev(config->name)) > + return -EEXIST; > + > + dev = vduse_dev_create(); > + if (!dev) > + return -ENOMEM; > + > + dev->device_id = config->device_id; > + dev->vendor_id = config->vendor_id; > + dev->domain = vduse_domain_create(max_iova_size - 1, > + config->bounce_size); > + if (!dev->domain) > + goto err_domain; > + > + 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; > + spin_lock_init(&dev->vqs[i].kick_lock); > + spin_lock_init(&dev->vqs[i].irq_lock); > + } > + > + ret = ida_simple_get(&vduse_ida, 0, VDUSE_DEV_MAX, GFP_KERNEL); > + if (ret < 0) > + goto err_ida; > + > + dev->minor = ret; > + device_initialize(&dev->dev); > + dev->dev.release = vduse_release_dev; > + dev->dev.class = vduse_class; > + dev->dev.devt = MKDEV(MAJOR(vduse_major), dev->minor); > + ret = dev_set_name(&dev->dev, "%s", config->name); Do we need to add a namespce here? E.g "vduse-%s", config->name. > + if (ret) > + goto err_name; > + > + cdev_init(&dev->cdev, &vduse_dev_fops); > + dev->cdev.owner = THIS_MODULE; > + > + ret = cdev_device_add(&dev->cdev, &dev->dev); > + if (ret) { > + put_device(&dev->dev); > + return ret; > + } > + list_add(&dev->list, &vduse_devs); > + __module_get(THIS_MODULE); > + > + return 0; > +err_name: > + ida_simple_remove(&vduse_ida, dev->minor); > +err_ida: > + kfree(dev->vqs); > +err_vqs: > + vduse_domain_destroy(dev->domain); > +err_domain: > + vduse_dev_destroy(dev); > + return ret; > +} > + > +static long vduse_ioctl(struct file *file, unsigned int cmd, > + unsigned long arg) > +{ > + int ret; > + void __user *argp = (void __user *)arg; > + > + mutex_lock(&vduse_lock); > + switch (cmd) { > + case VDUSE_CREATE_DEV: { > + struct vduse_dev_config config; > + > + ret = -EFAULT; > + if (copy_from_user(&config, argp, sizeof(config))) > + break; > + > + ret = vduse_create_dev(&config); > + 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 const struct file_operations vduse_fops = { > + .owner = THIS_MODULE, > + .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 struct miscdevice vduse_misc = { > + .fops = &vduse_fops, > + .minor = MISC_DYNAMIC_MINOR, > + .name = "vduse", > + .nodename = "vduse/control", > +}; > + > +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_add_vdpa(struct vduse_dev *dev, const char *name) > +{ > + struct vduse_vdpa *vdev = dev->vdev; > + int ret; > + > + if (vdev) > + return -EEXIST; > + > + vdev = vdpa_alloc_device(struct vduse_vdpa, vdpa, NULL, I think the char dev should be used as the parent here. > + &vduse_vdpa_config_ops, > + dev->vq_num, name, true); > + if (!vdev) > + return -ENOMEM; > + > + 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) > + goto err; > + > + set_dma_ops(&vdev->vdpa.dev, &vduse_dev_dma_ops); > + vdev->vdpa.dma_dev = &vdev->vdpa.dev; > + vdev->vdpa.mdev = &mgmt_dev; > + > + ret = _vdpa_register_device(&vdev->vdpa); > + if (ret) > + goto err; > + > + dev->vdev = vdev; > + > + return 0; > +err: > + put_device(&vdev->vdpa.dev); > + return ret; > +} > + > +static int vdpa_dev_add(struct vdpa_mgmt_dev *mdev, const char *name) > +{ > + struct vduse_dev *dev; > + int ret = -EINVAL; > + > + mutex_lock(&vduse_lock); > + dev = vduse_find_dev(name); > + if (!dev) > + goto unlock; Any reason for this check? I think vdpa core layer has already did for the name check for us. > + > + ret = vduse_dev_add_vdpa(dev, name); > +unlock: > + mutex_unlock(&vduse_lock); > + > + return ret; > +} > + > +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_DEV_ANY_ID, 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; > + > + ret = misc_register(&vduse_misc); > + if (ret) > + return ret; > + > + vduse_class = class_create(THIS_MODULE, "vduse"); > + if (IS_ERR(vduse_class)) { > + ret = PTR_ERR(vduse_class); > + goto err_class; > + } > + vduse_class->devnode = vduse_devnode; > + > + ret = alloc_chrdev_region(&vduse_major, 0, VDUSE_DEV_MAX, "vduse"); > + if (ret) > + goto err_chardev; > + > + ret = vduse_domain_init(); > + if (ret) > + goto err_domain; > + > + ret = vduse_mgmtdev_init(); > + if (ret) > + goto err_mgmtdev; Should we validate max_bounce_size < max_iova_size here? Thanks > + > + return 0; > +err_mgmtdev: > + vduse_domain_exit(); > +err_domain: > + unregister_chrdev_region(vduse_major, VDUSE_DEV_MAX); > +err_chardev: > + class_destroy(vduse_class); > +err_class: > + misc_deregister(&vduse_misc); > + return ret; > +} > +module_init(vduse_init); > + > +static void vduse_exit(void) > +{ > + misc_deregister(&vduse_misc); > + class_destroy(vduse_class); > + unregister_chrdev_region(vduse_major, VDUSE_DEV_MAX); > + vduse_domain_exit(); > + vduse_mgmtdev_exit(); > +} > +module_exit(vduse_exit); > + > +MODULE_VERSION(DRV_VERSION); > +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..9391c4acfa53 > --- /dev/null > +++ b/include/uapi/linux/vduse.h > @@ -0,0 +1,136 @@ > +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ > +#ifndef _UAPI_VDUSE_H_ > +#define _UAPI_VDUSE_H_ > + > +#include > + > +#define VDUSE_CONFIG_DATA_LEN 256 > +#define VDUSE_NAME_MAX 256 > + > +/* the control messages definition for read/write */ > + > +enum vduse_req_type { > + VDUSE_SET_VQ_NUM, > + VDUSE_SET_VQ_ADDR, > + VDUSE_SET_VQ_READY, > + VDUSE_GET_VQ_READY, > + VDUSE_SET_VQ_STATE, > + VDUSE_GET_VQ_STATE, > + VDUSE_SET_FEATURES, > + VDUSE_GET_FEATURES, > + VDUSE_SET_STATUS, > + VDUSE_GET_STATUS, > + VDUSE_SET_CONFIG, > + VDUSE_GET_CONFIG, > + VDUSE_UPDATE_IOTLB, > +}; > + > +struct vduse_vq_num { > + __u32 index; > + __u32 num; > +}; > + > +struct vduse_vq_addr { > + __u32 index; > + __u64 desc_addr; > + __u64 driver_addr; > + __u64 device_addr; > +}; > + > +struct vduse_vq_ready { > + __u32 index; > + __u8 ready; > +}; > + > +struct vduse_vq_state { > + __u32 index; > + __u16 avail_idx; > +}; > + > +struct vduse_dev_config_data { > + __u32 offset; > + __u32 len; > + __u8 data[VDUSE_CONFIG_DATA_LEN]; > +}; > + > +struct vduse_iova_range { > + __u64 start; > + __u64 last; > +}; > + > +struct vduse_dev_request { > + __u32 type; /* request type */ > + __u32 unique; /* request id */ Let's simply use "request_id" here. > + __u32 reserved[2]; /* for feature use */ > + union { > + struct vduse_vq_num vq_num; /* virtqueue num */ > + struct vduse_vq_addr vq_addr; /* virtqueue address */ > + struct vduse_vq_ready vq_ready; /* virtqueue ready status */ > + struct vduse_vq_state vq_state; /* virtqueue state */ > + struct vduse_dev_config_data config; /* virtio device config space */ > + struct vduse_iova_range iova; /* iova range for updating */ > + __u64 features; /* virtio features */ > + __u8 status; /* device status */ It might be better to use struct for feaures and status as well for consistency. And to be safe, let's add explicity padding here. > + }; > +}; > + > +struct vduse_dev_response { > + __u32 request_id; /* corresponding request id */ > +#define VDUSE_REQUEST_OK 0x00 > +#define VDUSE_REQUEST_FAILED 0x01 > + __u8 result; /* the result of request */ > + __u8 reserved[11]; /* for feature use */ Looks like this will be a hole which is similar to 429711aec282c4b5fe5bbd7b2f0bbbff4110ffb2. Need to make sure the reserved end at 8 byte boundary. > + union { > + struct vduse_vq_ready vq_ready; /* virtqueue ready status */ > + struct vduse_vq_state vq_state; /* virtqueue state */ > + struct vduse_dev_config_data config; /* virtio device config space */ > + __u64 features; /* virtio features */ > + __u8 status; /* device status */ > + }; > +}; > + > +/* 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 bounce_size; /* bounce buffer size for iommu */ > + __u16 vq_num; /* the number of virtqueues */ > + __u16 vq_size_max; /* the max size of virtqueue */ > + __u32 vq_align; /* the allocation alignment of virtqueue's metadata */ > +}; > + > +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_vq_eventfd { > + __u32 index; /* virtqueue index */ > + int fd; /* eventfd, -1 means de-assigning the eventfd */ Let's define a macro for this. > +}; > + > +#define VDUSE_BASE 0x81 > + > +/* Create a vduse device which is represented by a char device (/dev/vduse/) */ > +#define VDUSE_CREATE_DEV _IOW(VDUSE_BASE, 0x01, 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, 0x02, char[VDUSE_NAME_MAX]) > + > +/* Get a file descriptor for the mmap'able iova region */ > +#define VDUSE_IOTLB_GET_FD _IOWR(VDUSE_BASE, 0x03, struct vduse_iotlb_entry) > + > +/* Setup an eventfd to receive kick for virtqueue */ > +#define VDUSE_VQ_SETUP_KICKFD _IOW(VDUSE_BASE, 0x04, struct vduse_vq_eventfd) > + > +/* Inject an interrupt for specific virtqueue */ > +#define VDUSE_INJECT_VQ_IRQ _IO(VDUSE_BASE, 0x05) I wonder do we need a version/feature handshake that is for future extension instead of just reserve bits in uABI? E.g VDUSE_GET_VERSION ... Thanks > + > +#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_BLOCKED, 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 2BB28C433E0 for ; Thu, 4 Mar 2021 06:27:55 +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 ABE4664EE3 for ; Thu, 4 Mar 2021 06:27:54 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org ABE4664EE3 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 5FB3C47A73; Thu, 4 Mar 2021 06:27:54 +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 EZphzIG1okE8; Thu, 4 Mar 2021 06:27:52 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by smtp4.osuosl.org (Postfix) with ESMTP id C05D945BF2; Thu, 4 Mar 2021 06:27:51 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 85017C000A; Thu, 4 Mar 2021 06:27:51 +0000 (UTC) Received: from smtp1.osuosl.org (smtp1.osuosl.org [IPv6:2605:bc80:3010::138]) by lists.linuxfoundation.org (Postfix) with ESMTP id 494B9C0001 for ; Thu, 4 Mar 2021 06:27:49 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp1.osuosl.org (Postfix) with ESMTP id 2D3F884339 for ; Thu, 4 Mar 2021 06:27:49 +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 vVVbvPsO2f_k for ; Thu, 4 Mar 2021 06:27:46 +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 [216.205.24.124]) by smtp1.osuosl.org (Postfix) with ESMTPS id 54B19842A2 for ; Thu, 4 Mar 2021 06:27:46 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1614839265; 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=5fRUeNYSC7f7t+UgXPO/yXd0ICDYWA8w23nTO80qTLA=; b=gCdVHUYYXzIATRebeWyZFsYIQTsXZXzaUrLceyX7526h6C8meoAvWzWmxIWldn+91wNkuC 5PP5ZRIh0NuQRIhsDFroOVX6heP1fLXRg8X67oyWEaJgc9VTSjiBY/1Lvl5pXH61QaTYnc DNhwnUI/w1cBJB1E2NBHBMlF4m7D0EI= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-243-jzX9mJGnMKGabdgMpuwbnA-1; Thu, 04 Mar 2021 01:27:41 -0500 X-MC-Unique: jzX9mJGnMKGabdgMpuwbnA-1 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.phx2.redhat.com [10.5.11.22]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id EC3D51842154; Thu, 4 Mar 2021 06:27:37 +0000 (UTC) Received: from wangxiaodeMacBook-Air.local (ovpn-13-244.pek2.redhat.com [10.72.13.244]) by smtp.corp.redhat.com (Postfix) with ESMTP id 07C7210013D6; Thu, 4 Mar 2021 06:27:22 +0000 (UTC) Subject: Re: [RFC v4 07/11] vduse: Introduce VDUSE - vDPA Device in Userspace To: Xie Yongji , mst@redhat.com, stefanha@redhat.com, sgarzare@redhat.com, parav@nvidia.com, bob.liu@oracle.com, hch@infradead.org, rdunlap@infradead.org, willy@infradead.org, viro@zeniv.linux.org.uk, axboe@kernel.dk, bcrl@kvack.org, corbet@lwn.net References: <20210223115048.435-1-xieyongji@bytedance.com> <20210223115048.435-8-xieyongji@bytedance.com> From: Jason Wang Message-ID: Date: Thu, 4 Mar 2021 14:27:21 +0800 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.16; rv:78.0) Gecko/20100101 Thunderbird/78.8.0 MIME-Version: 1.0 In-Reply-To: <20210223115048.435-8-xieyongji@bytedance.com> Content-Language: en-GB X-Scanned-By: MIMEDefang 2.84 on 10.5.11.22 Cc: linux-aio@kvack.org, netdev@vger.kernel.org, linux-fsdevel@vger.kernel.org, kvm@vger.kernel.org, virtualization@lists.linux-foundation.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="utf-8"; Format="flowed" Errors-To: virtualization-bounces@lists.linux-foundation.org Sender: "Virtualization" Ck9uIDIwMjEvMi8yMyA3OjUwIOS4i+WNiCwgWGllIFlvbmdqaSB3cm90ZToKPiBUaGlzIFZEVVNF IGRyaXZlciBlbmFibGVzIGltcGxlbWVudGluZyB2RFBBIGRldmljZXMgaW4gdXNlcnNwYWNlLgo+ IEJvdGggY29udHJvbCBwYXRoIGFuZCBkYXRhIHBhdGggb2YgdkRQQSBkZXZpY2VzIHdpbGwgYmUg YWJsZSB0bwo+IGJlIGhhbmRsZWQgaW4gdXNlcnNwYWNlLgo+Cj4gSW4gdGhlIGNvbnRyb2wgcGF0 aCwgdGhlIFZEVVNFIGRyaXZlciB3aWxsIG1ha2UgdXNlIG9mIG1lc3NhZ2UKPiBtZWNobmlzbSB0 byBmb3J3YXJkIHRoZSBjb25maWcgb3BlcmF0aW9uIGZyb20gdmRwYSBidXMgZHJpdmVyCj4gdG8g dXNlcnNwYWNlLiBVc2Vyc3BhY2UgY2FuIHVzZSByZWFkKCkvd3JpdGUoKSB0byByZWNlaXZlL3Jl cGx5Cj4gdGhvc2UgY29udHJvbCBtZXNzYWdlcy4KPgo+IEluIHRoZSBkYXRhIHBhdGgsIFZEVVNF X0lPVExCX0dFVF9GRCBpb2N0bCB3aWxsIGJlIHVzZWQgdG8gZ2V0Cj4gdGhlIGZpbGUgZGVzY3Jp cHRvcnMgcmVmZXJyaW5nIHRvIHZEUEEgZGV2aWNlJ3MgaW92YSByZWdpb25zLiBUaGVuCj4gdXNl cnNwYWNlIGNhbiB1c2UgbW1hcCgpIHRvIGFjY2VzcyB0aG9zZSBpb3ZhIHJlZ2lvbnMuIEJlc2lk ZXMsCj4gdXNlcnNwYWNlIGNhbiB1c2UgaW9jdGwoKSB0byBpbmplY3QgaW50ZXJydXB0IGFuZCB1 c2UgdGhlIGV2ZW50ZmQKPiBtZWNoYW5pc20gdG8gcmVjZWl2ZSB2aXJ0cXVldWUga2lja3MuCj4K PiBTaWduZWQtb2ZmLWJ5OiBYaWUgWW9uZ2ppIDx4aWV5b25namlAYnl0ZWRhbmNlLmNvbT4KPiAt LS0KPiAgIERvY3VtZW50YXRpb24vdXNlcnNwYWNlLWFwaS9pb2N0bC9pb2N0bC1udW1iZXIucnN0 IHwgICAgMSArCj4gICBkcml2ZXJzL3ZkcGEvS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB8ICAgMTAgKwo+ICAgZHJpdmVycy92ZHBhL01ha2VmaWxlICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgfCAgICAxICsKPiAgIGRyaXZlcnMvdmRwYS92ZHBhX3VzZXIvTWFrZWZp bGUgICAgICAgICAgICAgICAgICAgIHwgICAgNSArCj4gICBkcml2ZXJzL3ZkcGEvdmRwYV91c2Vy L3ZkdXNlX2Rldi5jICAgICAgICAgICAgICAgICB8IDEzNDggKysrKysrKysrKysrKysrKysrKysK PiAgIGluY2x1ZGUvdWFwaS9saW51eC92ZHVzZS5oICAgICAgICAgICAgICAgICAgICAgICAgIHwg IDEzNiArKwo+ICAgNiBmaWxlcyBjaGFuZ2VkLCAxNTAxIGluc2VydGlvbnMoKykKPiAgIGNyZWF0 ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3ZkcGEvdmRwYV91c2VyL01ha2VmaWxlCj4gICBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy92ZHBhL3ZkcGFfdXNlci92ZHVzZV9kZXYuYwo+ICAgY3JlYXRl IG1vZGUgMTAwNjQ0IGluY2x1ZGUvdWFwaS9saW51eC92ZHVzZS5oCj4KPiBkaWZmIC0tZ2l0IGEv RG9jdW1lbnRhdGlvbi91c2Vyc3BhY2UtYXBpL2lvY3RsL2lvY3RsLW51bWJlci5yc3QgYi9Eb2N1 bWVudGF0aW9uL3VzZXJzcGFjZS1hcGkvaW9jdGwvaW9jdGwtbnVtYmVyLnJzdAo+IGluZGV4IGE0 Yzc1YTI4YzgzOS4uNzE3MjJlNmY4ZjIzIDEwMDY0NAo+IC0tLSBhL0RvY3VtZW50YXRpb24vdXNl cnNwYWNlLWFwaS9pb2N0bC9pb2N0bC1udW1iZXIucnN0Cj4gKysrIGIvRG9jdW1lbnRhdGlvbi91 c2Vyc3BhY2UtYXBpL2lvY3RsL2lvY3RsLW51bWJlci5yc3QKPiBAQCAtMzAwLDYgKzMwMCw3IEBA IENvZGUgIFNlcSMgICAgSW5jbHVkZSBGaWxlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIENvbW1lbnRzCj4gICAneicgICAxMC00RiAgZHJpdmVycy9zMzkwL2NyeXB0 by96Y3J5cHRfYXBpLmggICAgICAgICAgICAgICAgICAgICAgICBjb25mbGljdCEKPiAgICd8JyAg IDAwLTdGICBsaW51eC9tZWRpYS5oCj4gICAweDgwICAwMC0xRiAgbGludXgvZmIuaAo+ICsweDgx ICAwMC0xRiAgbGludXgvdmR1c2UuaAo+ICAgMHg4OSAgMDAtMDYgIGFyY2gveDg2L2luY2x1ZGUv YXNtL3NvY2tpb3MuaAo+ICAgMHg4OSAgMEItREYgIGxpbnV4L3NvY2tpb3MuaAo+ICAgMHg4OSAg RTAtRUYgIGxpbnV4L3NvY2tpb3MuaCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgU0lPQ1BST1RPUFJJVkFURSByYW5nZQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3ZkcGEv S2NvbmZpZyBiL2RyaXZlcnMvdmRwYS9LY29uZmlnCj4gaW5kZXggZmZkMWUwOThiZmQyLi45MmYw NzcxNWUzYjYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy92ZHBhL0tjb25maWcKPiArKysgYi9kcml2 ZXJzL3ZkcGEvS2NvbmZpZwo+IEBAIC0yNSw2ICsyNSwxNiBAQCBjb25maWcgVkRQQV9TSU1fTkVU Cj4gICAJaGVscAo+ICAgCSAgdkRQQSBuZXR3b3JraW5nIGRldmljZSBzaW11bGF0b3Igd2hpY2gg bG9vcHMgVFggdHJhZmZpYyBiYWNrIHRvIFJYLgo+ICAgCj4gK2NvbmZpZyBWRFBBX1VTRVIKPiAr CXRyaXN0YXRlICJWRFVTRSAodkRQQSBEZXZpY2UgaW4gVXNlcnNwYWNlKSBzdXBwb3J0Igo+ICsJ ZGVwZW5kcyBvbiBFVkVOVEZEICYmIE1NVSAmJiBIQVNfRE1BCj4gKwlzZWxlY3QgRE1BX09QUwo+ ICsJc2VsZWN0IFZIT1NUX0lPVExCCj4gKwlzZWxlY3QgSU9NTVVfSU9WQQo+ICsJaGVscAo+ICsJ ICBXaXRoIFZEVVNFIGl0IGlzIHBvc3NpYmxlIHRvIGVtdWxhdGUgYSB2RFBBIERldmljZQo+ICsJ ICBpbiBhIHVzZXJzcGFjZSBwcm9ncmFtLgo+ICsKPiAgIGNvbmZpZyBJRkNWRgo+ICAgCXRyaXN0 YXRlICJJbnRlbCBJRkMgVkYgdkRQQSBkcml2ZXIiCj4gICAJZGVwZW5kcyBvbiBQQ0lfTVNJCj4g ZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmRwYS9NYWtlZmlsZSBiL2RyaXZlcnMvdmRwYS9NYWtlZmls ZQo+IGluZGV4IGQxNjBlOWI2M2E2Ni4uNjZlOTc3NzhhZDAzIDEwMDY0NAo+IC0tLSBhL2RyaXZl cnMvdmRwYS9NYWtlZmlsZQo+ICsrKyBiL2RyaXZlcnMvdmRwYS9NYWtlZmlsZQo+IEBAIC0xLDUg KzEsNiBAQAo+ICAgIyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAo+ICAgb2JqLSQo Q09ORklHX1ZEUEEpICs9IHZkcGEubwo+ICAgb2JqLSQoQ09ORklHX1ZEUEFfU0lNKSArPSB2ZHBh X3NpbS8KPiArb2JqLSQoQ09ORklHX1ZEUEFfVVNFUikgKz0gdmRwYV91c2VyLwo+ICAgb2JqLSQo Q09ORklHX0lGQ1ZGKSAgICArPSBpZmN2Zi8KPiAgIG9iai0kKENPTkZJR19NTFg1X1ZEUEEpICs9 IG1seDUvCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmRwYS92ZHBhX3VzZXIvTWFrZWZpbGUgYi9k cml2ZXJzL3ZkcGEvdmRwYV91c2VyL01ha2VmaWxlCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBp bmRleCAwMDAwMDAwMDAwMDAuLjI2MGUwYjI2YWY5OQo+IC0tLSAvZGV2L251bGwKPiArKysgYi9k cml2ZXJzL3ZkcGEvdmRwYV91c2VyL01ha2VmaWxlCj4gQEAgLTAsMCArMSw1IEBACj4gKyMgU1BE WC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKPiArCj4gK3ZkdXNlLXkgOj0gdmR1c2VfZGV2 Lm8gaW92YV9kb21haW4ubwo+ICsKPiArb2JqLSQoQ09ORklHX1ZEUEFfVVNFUikgKz0gdmR1c2Uu bwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3ZkcGEvdmRwYV91c2VyL3ZkdXNlX2Rldi5jIGIvZHJp dmVycy92ZHBhL3ZkcGFfdXNlci92ZHVzZV9kZXYuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4g aW5kZXggMDAwMDAwMDAwMDAwLi4zOTNiZjk5YzQ4YmUKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIv ZHJpdmVycy92ZHBhL3ZkcGFfdXNlci92ZHVzZV9kZXYuYwo+IEBAIC0wLDAgKzEsMTM0OCBAQAo+ ICsvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5Cj4gKy8qCj4gKyAqIFZE VVNFOiB2RFBBIERldmljZSBpbiBVc2Vyc3BhY2UKPiArICoKPiArICogQ29weXJpZ2h0IChDKSAy MDIwIEJ5dGVkYW5jZSBJbmMuIGFuZC9vciBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNl cnZlZC4KPiArICoKPiArICogQXV0aG9yOiBYaWUgWW9uZ2ppIDx4aWV5b25namlAYnl0ZWRhbmNl LmNvbT4KPiArICoKPiArICovCj4gKwo+ICsjaW5jbHVkZSA8bGludXgvaW5pdC5oPgo+ICsjaW5j bHVkZSA8bGludXgvbW9kdWxlLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9taXNjZGV2aWNlLmg+Cj4g KyNpbmNsdWRlIDxsaW51eC9jZGV2Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KPiAr I2luY2x1ZGUgPGxpbnV4L2V2ZW50ZmQuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KPiAr I2luY2x1ZGUgPGxpbnV4L3dhaXQuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2RtYS1tYXAtb3BzLmg+ Cj4gKyNpbmNsdWRlIDxsaW51eC9wb2xsLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9maWxlLmg+Cj4g KyNpbmNsdWRlIDxsaW51eC91aW8uaD4KPiArI2luY2x1ZGUgPGxpbnV4L3ZkcGEuaD4KPiArI2lu Y2x1ZGUgPHVhcGkvbGludXgvdmR1c2UuaD4KPiArI2luY2x1ZGUgPHVhcGkvbGludXgvdmRwYS5o Pgo+ICsjaW5jbHVkZSA8dWFwaS9saW51eC92aXJ0aW9fY29uZmlnLmg+Cj4gKyNpbmNsdWRlIDxs aW51eC9tb2RfZGV2aWNldGFibGUuaD4KPiArCj4gKyNpbmNsdWRlICJpb3ZhX2RvbWFpbi5oIgo+ ICsKPiArI2RlZmluZSBEUlZfVkVSU0lPTiAgIjEuMCIKPiArI2RlZmluZSBEUlZfQVVUSE9SICAg IllvbmdqaSBYaWUgPHhpZXlvbmdqaUBieXRlZGFuY2UuY29tPiIKPiArI2RlZmluZSBEUlZfREVT QyAgICAgInZEUEEgRGV2aWNlIGluIFVzZXJzcGFjZSIKPiArI2RlZmluZSBEUlZfTElDRU5TRSAg IkdQTCB2MiIKPiArCj4gKyNkZWZpbmUgVkRVU0VfREVWX01BWCAoMVUgPDwgTUlOT1JCSVRTKQo+ ICsKPiArc3RydWN0IHZkdXNlX3ZpcnRxdWV1ZSB7Cj4gKwl1MTYgaW5kZXg7Cj4gKwlib29sIHJl YWR5Owo+ICsJc3BpbmxvY2tfdCBraWNrX2xvY2s7Cj4gKwlzcGlubG9ja190IGlycV9sb2NrOwo+ ICsJc3RydWN0IGV2ZW50ZmRfY3R4ICpraWNrZmQ7Cj4gKwlzdHJ1Y3QgdmRwYV9jYWxsYmFjayBj YjsKPiArfTsKPiArCj4gK3N0cnVjdCB2ZHVzZV9kZXY7Cj4gKwo+ICtzdHJ1Y3QgdmR1c2VfdmRw YSB7Cj4gKwlzdHJ1Y3QgdmRwYV9kZXZpY2UgdmRwYTsKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRl djsKPiArfTsKPiArCj4gK3N0cnVjdCB2ZHVzZV9kZXYgewo+ICsJc3RydWN0IHZkdXNlX3ZkcGEg KnZkZXY7Cj4gKwlzdHJ1Y3QgZGV2aWNlIGRldjsKPiArCXN0cnVjdCBjZGV2IGNkZXY7Cj4gKwlz dHJ1Y3QgdmR1c2VfdmlydHF1ZXVlICp2cXM7Cj4gKwlzdHJ1Y3QgdmR1c2VfaW92YV9kb21haW4g KmRvbWFpbjsKPiArCXN0cnVjdCB2aG9zdF9pb3RsYiAqaW9tbXU7Cj4gKwlzcGlubG9ja190IGlv bW11X2xvY2s7Cj4gKwlhdG9taWNfdCBib3VuY2VfbWFwOwo+ICsJc3RydWN0IG11dGV4IG1zZ19s b2NrOwo+ICsJYXRvbWljNjRfdCBtc2dfdW5pcXVlOwoKCiJuZXh0X3JlcXVlc3RfaWQiIHNob3Vs ZCBiZSBiZXR0ZXIuCgoKPiArCXdhaXRfcXVldWVfaGVhZF90IHdhaXRxOwo+ICsJc3RydWN0IGxp c3RfaGVhZCBzZW5kX2xpc3Q7Cj4gKwlzdHJ1Y3QgbGlzdF9oZWFkIHJlY3ZfbGlzdDsKPiArCXN0 cnVjdCBsaXN0X2hlYWQgbGlzdDsKPiArCWJvb2wgY29ubmVjdGVkOwo+ICsJaW50IG1pbm9yOwo+ ICsJdTE2IHZxX3NpemVfbWF4Owo+ICsJdTE2IHZxX251bTsKPiArCXUzMiB2cV9hbGlnbjsKPiAr CXUzMiBkZXZpY2VfaWQ7Cj4gKwl1MzIgdmVuZG9yX2lkOwo+ICt9Owo+ICsKPiArc3RydWN0IHZk dXNlX2Rldl9tc2cgewo+ICsJc3RydWN0IHZkdXNlX2Rldl9yZXF1ZXN0IHJlcTsKPiArCXN0cnVj dCB2ZHVzZV9kZXZfcmVzcG9uc2UgcmVzcDsKPiArCXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsKPiAr CXdhaXRfcXVldWVfaGVhZF90IHdhaXRxOwo+ICsJYm9vbCBjb21wbGV0ZWQ7Cj4gK307Cj4gKwo+ ICtzdGF0aWMgdW5zaWduZWQgbG9uZyBtYXhfYm91bmNlX3NpemUgPSAoNjQgKiAxMDI0ICogMTAy NCk7Cj4gK21vZHVsZV9wYXJhbShtYXhfYm91bmNlX3NpemUsIHVsb25nLCAwNDQ0KTsKPiArTU9E VUxFX1BBUk1fREVTQyhtYXhfYm91bmNlX3NpemUsICJNYXhpbXVtIGJvdW5jZSBidWZmZXIgc2l6 ZS4gKGRlZmF1bHQ6IDY0TSkiKTsKPiArCj4gK3N0YXRpYyB1bnNpZ25lZCBsb25nIG1heF9pb3Zh X3NpemUgPSAoMTI4ICogMTAyNCAqIDEwMjQpOwo+ICttb2R1bGVfcGFyYW0obWF4X2lvdmFfc2l6 ZSwgdWxvbmcsIDA0NDQpOwo+ICtNT0RVTEVfUEFSTV9ERVNDKG1heF9pb3ZhX3NpemUsICJNYXhp bXVtIGlvdmEgc3BhY2Ugc2l6ZSAoZGVmYXVsdDogMTI4TSkiKTsKPiArCj4gK3N0YXRpYyBERUZJ TkVfTVVURVgodmR1c2VfbG9jayk7Cj4gK3N0YXRpYyBMSVNUX0hFQUQodmR1c2VfZGV2cyk7Cj4g K3N0YXRpYyBERUZJTkVfSURBKHZkdXNlX2lkYSk7Cj4gKwo+ICtzdGF0aWMgZGV2X3QgdmR1c2Vf bWFqb3I7Cj4gK3N0YXRpYyBzdHJ1Y3QgY2xhc3MgKnZkdXNlX2NsYXNzOwo+ICsKPiArc3RhdGlj IGlubGluZSBzdHJ1Y3QgdmR1c2VfZGV2ICp2ZHBhX3RvX3ZkdXNlKHN0cnVjdCB2ZHBhX2Rldmlj ZSAqdmRwYSkKPiArewo+ICsJc3RydWN0IHZkdXNlX3ZkcGEgKnZkZXYgPSBjb250YWluZXJfb2Yo dmRwYSwgc3RydWN0IHZkdXNlX3ZkcGEsIHZkcGEpOwo+ICsKPiArCXJldHVybiB2ZGV2LT5kZXY7 Cj4gK30KPiArCj4gK3N0YXRpYyBpbmxpbmUgc3RydWN0IHZkdXNlX2RldiAqZGV2X3RvX3ZkdXNl KHN0cnVjdCBkZXZpY2UgKmRldikKPiArewo+ICsJc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhID0g ZGV2X3RvX3ZkcGEoZGV2KTsKPiArCj4gKwlyZXR1cm4gdmRwYV90b192ZHVzZSh2ZHBhKTsKPiAr fQo+ICsKPiArc3RhdGljIHN0cnVjdCB2ZHVzZV9kZXZfbXNnICp2ZHVzZV9maW5kX21zZyhzdHJ1 Y3QgbGlzdF9oZWFkICpoZWFkLAo+ICsJCQkJCSAgICB1aW50MzJfdCB1bmlxdWUpCj4gK3sKPiAr CXN0cnVjdCB2ZHVzZV9kZXZfbXNnICp0bXAsICptc2cgPSBOVUxMOwo+ICsKPiArCWxpc3RfZm9y X2VhY2hfZW50cnkodG1wLCBoZWFkLCBsaXN0KSB7CgoKU2hvdWRsIHdlIHVzZSBsaXN0X2Zvcl9l YWNoX2VudHJ5X3NhZmUoKT8KCgo+ICsJCWlmICh0bXAtPnJlcS51bmlxdWUgPT0gdW5pcXVlKSB7 Cj4gKwkJCW1zZyA9IHRtcDsKPiArCQkJbGlzdF9kZWwoJnRtcC0+bGlzdCk7Cj4gKwkJCWJyZWFr Owo+ICsJCX0KPiArCX0KPiArCj4gKwlyZXR1cm4gbXNnOwo+ICt9Cj4gKwo+ICtzdGF0aWMgc3Ry dWN0IHZkdXNlX2Rldl9tc2cgKnZkdXNlX2RlcXVldWVfbXNnKHN0cnVjdCBsaXN0X2hlYWQgKmhl YWQpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXZfbXNnICptc2cgPSBOVUxMOwo+ICsKPiArCWlm ICghbGlzdF9lbXB0eShoZWFkKSkgewo+ICsJCW1zZyA9IGxpc3RfZmlyc3RfZW50cnkoaGVhZCwg c3RydWN0IHZkdXNlX2Rldl9tc2csIGxpc3QpOwo+ICsJCWxpc3RfZGVsKCZtc2ctPmxpc3QpOwo+ ICsJfQo+ICsKPiArCXJldHVybiBtc2c7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHZkdXNlX2Vu cXVldWVfbXNnKHN0cnVjdCBsaXN0X2hlYWQgKmhlYWQsCj4gKwkJCSAgICAgIHN0cnVjdCB2ZHVz ZV9kZXZfbXNnICptc2cpCj4gK3sKPiArCWxpc3RfYWRkX3RhaWwoJm1zZy0+bGlzdCwgaGVhZCk7 Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgdmR1c2VfZGV2X21zZ19zeW5jKHN0cnVjdCB2ZHVzZV9k ZXYgKmRldiwgc3RydWN0IHZkdXNlX2Rldl9tc2cgKm1zZykKPiArewo+ICsJaW50IHJldDsKPiAr Cj4gKwlpbml0X3dhaXRxdWV1ZV9oZWFkKCZtc2ctPndhaXRxKTsKPiArCW11dGV4X2xvY2soJmRl di0+bXNnX2xvY2spOwo+ICsJdmR1c2VfZW5xdWV1ZV9tc2coJmRldi0+c2VuZF9saXN0LCBtc2cp Owo+ICsJd2FrZV91cCgmZGV2LT53YWl0cSk7Cj4gKwltdXRleF91bmxvY2soJmRldi0+bXNnX2xv Y2spOwo+ICsJcmV0ID0gd2FpdF9ldmVudF9pbnRlcnJ1cHRpYmxlKG1zZy0+d2FpdHEsIG1zZy0+ Y29tcGxldGVkKTsKPiArCW11dGV4X2xvY2soJmRldi0+bXNnX2xvY2spOwo+ICsJaWYgKCFtc2ct PmNvbXBsZXRlZCkKPiArCQlsaXN0X2RlbCgmbXNnLT5saXN0KTsKPiArCWVsc2UKPiArCQlyZXQg PSBtc2ctPnJlc3AucmVzdWx0Owo+ICsJbXV0ZXhfdW5sb2NrKCZkZXYtPm1zZ19sb2NrKTsKPiAr Cj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgdTY0IHZkdXNlX2Rldl9nZXRfZmVh dHVyZXMoc3RydWN0IHZkdXNlX2RldiAqZGV2KQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2X21z ZyBtc2cgPSB7IDAgfTsKPiArCj4gKwltc2cucmVxLnR5cGUgPSBWRFVTRV9HRVRfRkVBVFVSRVM7 Cj4gKwltc2cucmVxLnVuaXF1ZSA9IGF0b21pYzY0X2ZldGNoX2luYygmZGV2LT5tc2dfdW5pcXVl KTsKPiArCj4gKwlyZXR1cm4gdmR1c2VfZGV2X21zZ19zeW5jKGRldiwgJm1zZykgPyAwIDogbXNn LnJlc3AuZmVhdHVyZXM7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgdmR1c2VfZGV2X3NldF9mZWF0 dXJlcyhzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYsIHU2NCBmZWF0dXJlcykKPiArewo+ICsJc3RydWN0 IHZkdXNlX2Rldl9tc2cgbXNnID0geyAwIH07Cj4gKwo+ICsJbXNnLnJlcS50eXBlID0gVkRVU0Vf U0VUX0ZFQVRVUkVTOwo+ICsJbXNnLnJlcS51bmlxdWUgPSBhdG9taWM2NF9mZXRjaF9pbmMoJmRl di0+bXNnX3VuaXF1ZSk7Cj4gKwltc2cucmVxLmZlYXR1cmVzID0gZmVhdHVyZXM7Cj4gKwo+ICsJ cmV0dXJuIHZkdXNlX2Rldl9tc2dfc3luYyhkZXYsICZtc2cpOwo+ICt9Cj4gKwo+ICtzdGF0aWMg dTggdmR1c2VfZGV2X2dldF9zdGF0dXMoc3RydWN0IHZkdXNlX2RldiAqZGV2KQo+ICt7Cj4gKwlz dHJ1Y3QgdmR1c2VfZGV2X21zZyBtc2cgPSB7IDAgfTsKPiArCj4gKwltc2cucmVxLnR5cGUgPSBW RFVTRV9HRVRfU1RBVFVTOwo+ICsJbXNnLnJlcS51bmlxdWUgPSBhdG9taWM2NF9mZXRjaF9pbmMo JmRldi0+bXNnX3VuaXF1ZSk7Cj4gKwo+ICsJcmV0dXJuIHZkdXNlX2Rldl9tc2dfc3luYyhkZXYs ICZtc2cpID8gMCA6IG1zZy5yZXNwLnN0YXR1czsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdmR1 c2VfZGV2X3NldF9zdGF0dXMoc3RydWN0IHZkdXNlX2RldiAqZGV2LCB1OCBzdGF0dXMpCj4gK3sK PiArCXN0cnVjdCB2ZHVzZV9kZXZfbXNnIG1zZyA9IHsgMCB9Owo+ICsKPiArCW1zZy5yZXEudHlw ZSA9IFZEVVNFX1NFVF9TVEFUVVM7Cj4gKwltc2cucmVxLnVuaXF1ZSA9IGF0b21pYzY0X2ZldGNo X2luYygmZGV2LT5tc2dfdW5pcXVlKTsKPiArCW1zZy5yZXEuc3RhdHVzID0gc3RhdHVzOwo+ICsK PiArCXZkdXNlX2Rldl9tc2dfc3luYyhkZXYsICZtc2cpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9p ZCB2ZHVzZV9kZXZfZ2V0X2NvbmZpZyhzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYsIHVuc2lnbmVkIGlu dCBvZmZzZXQsCj4gKwkJCQkJdm9pZCAqYnVmLCB1bnNpZ25lZCBpbnQgbGVuKQoKCkJ0dywgdGhl IGlkZW50IGxvb2tzIG9kZCBoZXJlIGFuZCBvdGhlciBtYXkgcGxhY2VzIHdoZXJoZSBmdW5jdGlv bnMgaGFzIAptb3JlIHRoYW4gb25lIGxpbmUgb2YgYXJndW1lbnRzLgoKCj4gK3sKPiArCXN0cnVj dCB2ZHVzZV9kZXZfbXNnIG1zZyA9IHsgMCB9Owo+ICsJdW5zaWduZWQgaW50IHN6Owo+ICsKPiAr CXdoaWxlIChsZW4pIHsKPiArCQlzeiA9IG1pbl90KHVuc2lnbmVkIGludCwgbGVuLCBzaXplb2Yo bXNnLnJlcS5jb25maWcuZGF0YSkpOwo+ICsJCW1zZy5yZXEudHlwZSA9IFZEVVNFX0dFVF9DT05G SUc7Cj4gKwkJbXNnLnJlcS51bmlxdWUgPSBhdG9taWM2NF9mZXRjaF9pbmMoJmRldi0+bXNnX3Vu aXF1ZSk7Cj4gKwkJbXNnLnJlcS5jb25maWcub2Zmc2V0ID0gb2Zmc2V0Owo+ICsJCW1zZy5yZXEu Y29uZmlnLmxlbiA9IHN6Owo+ICsJCXZkdXNlX2Rldl9tc2dfc3luYyhkZXYsICZtc2cpOwo+ICsJ CW1lbWNweShidWYsIG1zZy5yZXNwLmNvbmZpZy5kYXRhLCBzeik7Cj4gKwkJYnVmICs9IHN6Owo+ ICsJCW9mZnNldCArPSBzejsKPiArCQlsZW4gLT0gc3o7Cj4gKwl9Cj4gK30KPiArCj4gK3N0YXRp YyB2b2lkIHZkdXNlX2Rldl9zZXRfY29uZmlnKHN0cnVjdCB2ZHVzZV9kZXYgKmRldiwgdW5zaWdu ZWQgaW50IG9mZnNldCwKPiArCQkJCQljb25zdCB2b2lkICpidWYsIHVuc2lnbmVkIGludCBsZW4p Cj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXZfbXNnIG1zZyA9IHsgMCB9Owo+ICsJdW5zaWduZWQg aW50IHN6Owo+ICsKPiArCXdoaWxlIChsZW4pIHsKPiArCQlzeiA9IG1pbl90KHVuc2lnbmVkIGlu dCwgbGVuLCBzaXplb2YobXNnLnJlcS5jb25maWcuZGF0YSkpOwo+ICsJCW1zZy5yZXEudHlwZSA9 IFZEVVNFX1NFVF9DT05GSUc7Cj4gKwkJbXNnLnJlcS51bmlxdWUgPSBhdG9taWM2NF9mZXRjaF9p bmMoJmRldi0+bXNnX3VuaXF1ZSk7Cj4gKwkJbXNnLnJlcS5jb25maWcub2Zmc2V0ID0gb2Zmc2V0 Owo+ICsJCW1zZy5yZXEuY29uZmlnLmxlbiA9IHN6Owo+ICsJCW1lbWNweShtc2cucmVxLmNvbmZp Zy5kYXRhLCBidWYsIHN6KTsKPiArCQl2ZHVzZV9kZXZfbXNnX3N5bmMoZGV2LCAmbXNnKTsKPiAr CQlidWYgKz0gc3o7Cj4gKwkJb2Zmc2V0ICs9IHN6Owo+ICsJCWxlbiAtPSBzejsKPiArCX0KPiAr fQo+ICsKPiArc3RhdGljIHZvaWQgdmR1c2VfZGV2X3NldF92cV9udW0oc3RydWN0IHZkdXNlX2Rl diAqZGV2LAo+ICsJCQkJc3RydWN0IHZkdXNlX3ZpcnRxdWV1ZSAqdnEsIHUzMiBudW0pCj4gK3sK PiArCXN0cnVjdCB2ZHVzZV9kZXZfbXNnIG1zZyA9IHsgMCB9Owo+ICsKPiArCW1zZy5yZXEudHlw ZSA9IFZEVVNFX1NFVF9WUV9OVU07Cj4gKwltc2cucmVxLnVuaXF1ZSA9IGF0b21pYzY0X2ZldGNo X2luYygmZGV2LT5tc2dfdW5pcXVlKTsKPiArCW1zZy5yZXEudnFfbnVtLmluZGV4ID0gdnEtPmlu ZGV4Owo+ICsJbXNnLnJlcS52cV9udW0ubnVtID0gbnVtOwo+ICsKPiArCXZkdXNlX2Rldl9tc2df c3luYyhkZXYsICZtc2cpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHZkdXNlX2Rldl9zZXRfdnFf YWRkcihzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYsCj4gKwkJCQlzdHJ1Y3QgdmR1c2VfdmlydHF1ZXVl ICp2cSwgdTY0IGRlc2NfYWRkciwKPiArCQkJCXU2NCBkcml2ZXJfYWRkciwgdTY0IGRldmljZV9h ZGRyKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2X21zZyBtc2cgPSB7IDAgfTsKPiArCj4gKwlt c2cucmVxLnR5cGUgPSBWRFVTRV9TRVRfVlFfQUREUjsKPiArCW1zZy5yZXEudW5pcXVlID0gYXRv bWljNjRfZmV0Y2hfaW5jKCZkZXYtPm1zZ191bmlxdWUpOwo+ICsJbXNnLnJlcS52cV9hZGRyLmlu ZGV4ID0gdnEtPmluZGV4Owo+ICsJbXNnLnJlcS52cV9hZGRyLmRlc2NfYWRkciA9IGRlc2NfYWRk cjsKPiArCW1zZy5yZXEudnFfYWRkci5kcml2ZXJfYWRkciA9IGRyaXZlcl9hZGRyOwo+ICsJbXNn LnJlcS52cV9hZGRyLmRldmljZV9hZGRyID0gZGV2aWNlX2FkZHI7Cj4gKwo+ICsJcmV0dXJuIHZk dXNlX2Rldl9tc2dfc3luYyhkZXYsICZtc2cpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCB2ZHVz ZV9kZXZfc2V0X3ZxX3JlYWR5KHN0cnVjdCB2ZHVzZV9kZXYgKmRldiwKPiArCQkJCXN0cnVjdCB2 ZHVzZV92aXJ0cXVldWUgKnZxLCBib29sIHJlYWR5KQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2 X21zZyBtc2cgPSB7IDAgfTsKPiArCj4gKwltc2cucmVxLnR5cGUgPSBWRFVTRV9TRVRfVlFfUkVB RFk7Cj4gKwltc2cucmVxLnVuaXF1ZSA9IGF0b21pYzY0X2ZldGNoX2luYygmZGV2LT5tc2dfdW5p cXVlKTsKPiArCW1zZy5yZXEudnFfcmVhZHkuaW5kZXggPSB2cS0+aW5kZXg7Cj4gKwltc2cucmVx LnZxX3JlYWR5LnJlYWR5ID0gcmVhZHk7Cj4gKwo+ICsJdmR1c2VfZGV2X21zZ19zeW5jKGRldiwg Jm1zZyk7Cj4gK30KPiArCj4gK3N0YXRpYyBib29sIHZkdXNlX2Rldl9nZXRfdnFfcmVhZHkoc3Ry dWN0IHZkdXNlX2RldiAqZGV2LAo+ICsJCQkJICAgc3RydWN0IHZkdXNlX3ZpcnRxdWV1ZSAqdnEp Cj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXZfbXNnIG1zZyA9IHsgMCB9Owo+ICsKPiArCW1zZy5y ZXEudHlwZSA9IFZEVVNFX0dFVF9WUV9SRUFEWTsKPiArCW1zZy5yZXEudW5pcXVlID0gYXRvbWlj NjRfZmV0Y2hfaW5jKCZkZXYtPm1zZ191bmlxdWUpOwo+ICsJbXNnLnJlcS52cV9yZWFkeS5pbmRl eCA9IHZxLT5pbmRleDsKPiArCj4gKwlyZXR1cm4gdmR1c2VfZGV2X21zZ19zeW5jKGRldiwgJm1z ZykgPyBmYWxzZSA6IG1zZy5yZXNwLnZxX3JlYWR5LnJlYWR5Owo+ICt9Cj4gKwo+ICtzdGF0aWMg aW50IHZkdXNlX2Rldl9nZXRfdnFfc3RhdGUoc3RydWN0IHZkdXNlX2RldiAqZGV2LAo+ICsJCQkJ c3RydWN0IHZkdXNlX3ZpcnRxdWV1ZSAqdnEsCj4gKwkJCQlzdHJ1Y3QgdmRwYV92cV9zdGF0ZSAq c3RhdGUpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXZfbXNnIG1zZyA9IHsgMCB9Owo+ICsJaW50 IHJldDsKPiArCj4gKwltc2cucmVxLnR5cGUgPSBWRFVTRV9HRVRfVlFfU1RBVEU7Cj4gKwltc2cu cmVxLnVuaXF1ZSA9IGF0b21pYzY0X2ZldGNoX2luYygmZGV2LT5tc2dfdW5pcXVlKTsKPiArCW1z Zy5yZXEudnFfc3RhdGUuaW5kZXggPSB2cS0+aW5kZXg7Cj4gKwo+ICsJcmV0ID0gdmR1c2VfZGV2 X21zZ19zeW5jKGRldiwgJm1zZyk7Cj4gKwlpZiAoIXJldCkKPiArCQlzdGF0ZS0+YXZhaWxfaW5k ZXggPSBtc2cucmVzcC52cV9zdGF0ZS5hdmFpbF9pZHg7Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiAr fQo+ICsKPiArc3RhdGljIGludCB2ZHVzZV9kZXZfc2V0X3ZxX3N0YXRlKHN0cnVjdCB2ZHVzZV9k ZXYgKmRldiwKPiArCQkJCXN0cnVjdCB2ZHVzZV92aXJ0cXVldWUgKnZxLAo+ICsJCQkJY29uc3Qg c3RydWN0IHZkcGFfdnFfc3RhdGUgKnN0YXRlKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2X21z ZyBtc2cgPSB7IDAgfTsKPiArCj4gKwltc2cucmVxLnR5cGUgPSBWRFVTRV9TRVRfVlFfU1RBVEU7 Cj4gKwltc2cucmVxLnVuaXF1ZSA9IGF0b21pYzY0X2ZldGNoX2luYygmZGV2LT5tc2dfdW5pcXVl KTsKPiArCW1zZy5yZXEudnFfc3RhdGUuaW5kZXggPSB2cS0+aW5kZXg7Cj4gKwltc2cucmVxLnZx X3N0YXRlLmF2YWlsX2lkeCA9IHN0YXRlLT5hdmFpbF9pbmRleDsKPiArCj4gKwlyZXR1cm4gdmR1 c2VfZGV2X21zZ19zeW5jKGRldiwgJm1zZyk7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgdmR1c2Vf ZGV2X3VwZGF0ZV9pb3RsYihzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYsCj4gKwkJCQl1NjQgc3RhcnQs IHU2NCBsYXN0KQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2X21zZyBtc2cgPSB7IDAgfTsKPiAr Cj4gKwlpZiAobGFzdCA8IHN0YXJ0KQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsKPiArCW1zZy5y ZXEudHlwZSA9IFZEVVNFX1VQREFURV9JT1RMQjsKPiArCW1zZy5yZXEudW5pcXVlID0gYXRvbWlj NjRfZmV0Y2hfaW5jKCZkZXYtPm1zZ191bmlxdWUpOwo+ICsJbXNnLnJlcS5pb3ZhLnN0YXJ0ID0g c3RhcnQ7Cj4gKwltc2cucmVxLmlvdmEubGFzdCA9IGxhc3Q7Cj4gKwo+ICsJcmV0dXJuIHZkdXNl X2Rldl9tc2dfc3luYyhkZXYsICZtc2cpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgc3NpemVfdCB2ZHVz ZV9kZXZfcmVhZF9pdGVyKHN0cnVjdCBraW9jYiAqaW9jYiwgc3RydWN0IGlvdl9pdGVyICp0bykK PiArewo+ICsJc3RydWN0IGZpbGUgKmZpbGUgPSBpb2NiLT5raV9maWxwOwo+ICsJc3RydWN0IHZk dXNlX2RldiAqZGV2ID0gZmlsZS0+cHJpdmF0ZV9kYXRhOwo+ICsJc3RydWN0IHZkdXNlX2Rldl9t c2cgKm1zZzsKPiArCWludCBzaXplID0gc2l6ZW9mKHN0cnVjdCB2ZHVzZV9kZXZfcmVxdWVzdCk7 Cj4gKwlzc2l6ZV90IHJldCA9IDA7Cj4gKwo+ICsJaWYgKGlvdl9pdGVyX2NvdW50KHRvKSA8IHNp emUpCj4gKwkJcmV0dXJuIDA7Cj4gKwo+ICsJbXV0ZXhfbG9jaygmZGV2LT5tc2dfbG9jayk7Cj4g Kwl3aGlsZSAoMSkgewo+ICsJCW1zZyA9IHZkdXNlX2RlcXVldWVfbXNnKCZkZXYtPnNlbmRfbGlz dCk7Cj4gKwkJaWYgKG1zZykKPiArCQkJYnJlYWs7Cj4gKwo+ICsJCXJldCA9IC1FQUdBSU47Cj4g KwkJaWYgKGZpbGUtPmZfZmxhZ3MgJiBPX05PTkJMT0NLKQo+ICsJCQlnb3RvIHVubG9jazsKPiAr Cj4gKwkJbXV0ZXhfdW5sb2NrKCZkZXYtPm1zZ19sb2NrKTsKPiArCQlyZXQgPSB3YWl0X2V2ZW50 X2ludGVycnVwdGlibGVfZXhjbHVzaXZlKGRldi0+d2FpdHEsCj4gKwkJCQkJIWxpc3RfZW1wdHko JmRldi0+c2VuZF9saXN0KSk7Cj4gKwkJaWYgKHJldCkKPiArCQkJcmV0dXJuIHJldDsKPiArCj4g KwkJbXV0ZXhfbG9jaygmZGV2LT5tc2dfbG9jayk7Cj4gKwl9Cj4gKwlyZXQgPSBjb3B5X3RvX2l0 ZXIoJm1zZy0+cmVxLCBzaXplLCB0byk7Cj4gKwlpZiAocmV0ICE9IHNpemUpIHsKPiArCQlyZXQg PSAtRUZBVUxUOwo+ICsJCXZkdXNlX2VucXVldWVfbXNnKCZkZXYtPnNlbmRfbGlzdCwgbXNnKTsK PiArCQlnb3RvIHVubG9jazsKPiArCX0KPiArCXZkdXNlX2VucXVldWVfbXNnKCZkZXYtPnJlY3Zf bGlzdCwgbXNnKTsKPiArdW5sb2NrOgo+ICsJbXV0ZXhfdW5sb2NrKCZkZXYtPm1zZ19sb2NrKTsK PiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgc3NpemVfdCB2ZHVzZV9kZXZf d3JpdGVfaXRlcihzdHJ1Y3Qga2lvY2IgKmlvY2IsIHN0cnVjdCBpb3ZfaXRlciAqZnJvbSkKPiAr ewo+ICsJc3RydWN0IGZpbGUgKmZpbGUgPSBpb2NiLT5raV9maWxwOwo+ICsJc3RydWN0IHZkdXNl X2RldiAqZGV2ID0gZmlsZS0+cHJpdmF0ZV9kYXRhOwo+ICsJc3RydWN0IHZkdXNlX2Rldl9yZXNw b25zZSByZXNwOwo+ICsJc3RydWN0IHZkdXNlX2Rldl9tc2cgKm1zZzsKPiArCXNpemVfdCByZXQ7 Cj4gKwo+ICsJcmV0ID0gY29weV9mcm9tX2l0ZXIoJnJlc3AsIHNpemVvZihyZXNwKSwgZnJvbSk7 Cj4gKwlpZiAocmV0ICE9IHNpemVvZihyZXNwKSkKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCj4g KwltdXRleF9sb2NrKCZkZXYtPm1zZ19sb2NrKTsKPiArCW1zZyA9IHZkdXNlX2ZpbmRfbXNnKCZk ZXYtPnJlY3ZfbGlzdCwgcmVzcC5yZXF1ZXN0X2lkKTsKPiArCWlmICghbXNnKSB7Cj4gKwkJcmV0 ID0gLUVJTlZBTDsKPiArCQlnb3RvIHVubG9jazsKPiArCX0KPiArCj4gKwltZW1jcHkoJm1zZy0+ cmVzcCwgJnJlc3AsIHNpemVvZihyZXNwKSk7Cj4gKwltc2ctPmNvbXBsZXRlZCA9IDE7Cj4gKwl3 YWtlX3VwKCZtc2ctPndhaXRxKTsKPiArdW5sb2NrOgo+ICsJbXV0ZXhfdW5sb2NrKCZkZXYtPm1z Z19sb2NrKTsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgX19wb2xsX3Qg dmR1c2VfZGV2X3BvbGwoc3RydWN0IGZpbGUgKmZpbGUsIHBvbGxfdGFibGUgKndhaXQpCj4gK3sK PiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IGZpbGUtPnByaXZhdGVfZGF0YTsKPiArCV9fcG9s bF90IG1hc2sgPSAwOwo+ICsKPiArCXBvbGxfd2FpdChmaWxlLCAmZGV2LT53YWl0cSwgd2FpdCk7 Cj4gKwo+ICsJaWYgKCFsaXN0X2VtcHR5KCZkZXYtPnNlbmRfbGlzdCkpCj4gKwkJbWFzayB8PSBF UE9MTElOIHwgRVBPTExSRE5PUk07Cj4gKwo+ICsJcmV0dXJuIG1hc2s7Cj4gK30KPiArCj4gK3N0 YXRpYyBpbnQgdmR1c2VfaW90bGJfYWRkX3JhbmdlKHN0cnVjdCB2ZHVzZV9kZXYgKmRldiwKPiAr CQkJCSB1NjQgc3RhcnQsIHU2NCBsYXN0LAo+ICsJCQkJIHU2NCBhZGRyLCB1bnNpZ25lZCBpbnQg cGVybSwKPiArCQkJCSBzdHJ1Y3QgZmlsZSAqZmlsZSwgdTY0IG9mZnNldCkKPiArewo+ICsJc3Ry dWN0IHZkcGFfbWFwX2ZpbGUgKm1hcF9maWxlOwo+ICsJaW50IHJldDsKPiArCj4gKwltYXBfZmls ZSA9IGttYWxsb2Moc2l6ZW9mKCptYXBfZmlsZSksIEdGUF9BVE9NSUMpOwo+ICsJaWYgKCFtYXBf ZmlsZSkKPiArCQlyZXR1cm4gLUVOT01FTTsKPiArCj4gKwltYXBfZmlsZS0+ZmlsZSA9IGdldF9m aWxlKGZpbGUpOwo+ICsJbWFwX2ZpbGUtPm9mZnNldCA9IG9mZnNldDsKPiArCj4gKwlzcGluX2xv Y2soJmRldi0+aW9tbXVfbG9jayk7Cj4gKwlyZXQgPSB2aG9zdF9pb3RsYl9hZGRfcmFuZ2VfY3R4 KGRldi0+aW9tbXUsIHN0YXJ0LCBsYXN0LAo+ICsJCQkJCWFkZHIsIHBlcm0sIG1hcF9maWxlKTsK PiArCXNwaW5fdW5sb2NrKCZkZXYtPmlvbW11X2xvY2spOwo+ICsJaWYgKHJldCkgewo+ICsJCWZw dXQobWFwX2ZpbGUtPmZpbGUpOwo+ICsJCWtmcmVlKG1hcF9maWxlKTsKPiArCQlyZXR1cm4gcmV0 Owo+ICsJfQo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHZkdXNlX2lvdGxi X2RlbF9yYW5nZShzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYsIHU2NCBzdGFydCwgdTY0IGxhc3QpCj4g K3sKPiArCXN0cnVjdCB2ZHBhX21hcF9maWxlICptYXBfZmlsZTsKPiArCXN0cnVjdCB2aG9zdF9p b3RsYl9tYXAgKm1hcDsKPiArCj4gKwlzcGluX2xvY2soJmRldi0+aW9tbXVfbG9jayk7Cj4gKwl3 aGlsZSAoKG1hcCA9IHZob3N0X2lvdGxiX2l0cmVlX2ZpcnN0KGRldi0+aW9tbXUsIHN0YXJ0LCBs YXN0KSkpIHsKPiArCQltYXBfZmlsZSA9IChzdHJ1Y3QgdmRwYV9tYXBfZmlsZSAqKW1hcC0+b3Bh cXVlOwo+ICsJCWZwdXQobWFwX2ZpbGUtPmZpbGUpOwo+ICsJCWtmcmVlKG1hcF9maWxlKTsKPiAr CQl2aG9zdF9pb3RsYl9tYXBfZnJlZShkZXYtPmlvbW11LCBtYXApOwo+ICsJfQo+ICsJc3Bpbl91 bmxvY2soJmRldi0+aW9tbXVfbG9jayk7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHZkdXNlX2Rl dl9yZXNldChzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYpCj4gK3sKPiArCWludCBpOwo+ICsKPiArCWF0 b21pY19zZXQoJmRldi0+Ym91bmNlX21hcCwgMCk7Cj4gKwl2ZHVzZV9pb3RsYl9kZWxfcmFuZ2Uo ZGV2LCAwVUxMLCBVTExPTkdfTUFYKTsKPiArCXZkdXNlX2Rldl91cGRhdGVfaW90bGIoZGV2LCAw VUxMLCBVTExPTkdfTUFYKTsKPiArCj4gKwlmb3IgKGkgPSAwOyBpIDwgZGV2LT52cV9udW07IGkr Kykgewo+ICsJCXN0cnVjdCB2ZHVzZV92aXJ0cXVldWUgKnZxID0gJmRldi0+dnFzW2ldOwo+ICsK PiArCQlzcGluX2xvY2soJnZxLT5pcnFfbG9jayk7Cj4gKwkJdnEtPnJlYWR5ID0gZmFsc2U7Cj4g KwkJdnEtPmNiLmNhbGxiYWNrID0gTlVMTDsKPiArCQl2cS0+Y2IucHJpdmF0ZSA9IE5VTEw7Cj4g KwkJc3Bpbl91bmxvY2soJnZxLT5pcnFfbG9jayk7Cj4gKwl9Cj4gK30KPiArCj4gK3N0YXRpYyBp bnQgdmR1c2VfdmRwYV9zZXRfdnFfYWRkcmVzcyhzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEsIHUx NiBpZHgsCj4gKwkJCQl1NjQgZGVzY19hcmVhLCB1NjQgZHJpdmVyX2FyZWEsCj4gKwkJCQl1NjQg ZGV2aWNlX2FyZWEpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IHZkcGFfdG9fdmR1 c2UodmRwYSk7Cj4gKwlzdHJ1Y3QgdmR1c2VfdmlydHF1ZXVlICp2cSA9ICZkZXYtPnZxc1tpZHhd Owo+ICsKPiArCXJldHVybiB2ZHVzZV9kZXZfc2V0X3ZxX2FkZHIoZGV2LCB2cSwgZGVzY19hcmVh LAo+ICsJCQkJCWRyaXZlcl9hcmVhLCBkZXZpY2VfYXJlYSk7Cj4gK30KPiArCj4gK3N0YXRpYyB2 b2lkIHZkdXNlX3ZkcGFfa2lja192cShzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEsIHUxNiBpZHgp Cj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IHZkcGFfdG9fdmR1c2UodmRwYSk7Cj4g KwlzdHJ1Y3QgdmR1c2VfdmlydHF1ZXVlICp2cSA9ICZkZXYtPnZxc1tpZHhdOwo+ICsKPiArCXNw aW5fbG9jaygmdnEtPmtpY2tfbG9jayk7Cj4gKwlpZiAodnEtPnJlYWR5ICYmIHZxLT5raWNrZmQp Cj4gKwkJZXZlbnRmZF9zaWduYWwodnEtPmtpY2tmZCwgMSk7Cj4gKwlzcGluX3VubG9jaygmdnEt PmtpY2tfbG9jayk7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHZkdXNlX3ZkcGFfc2V0X3ZxX2Ni KHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYSwgdTE2IGlkeCwKPiArCQkJICAgICAgc3RydWN0IHZk cGFfY2FsbGJhY2sgKmNiKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBhX3Rv X3ZkdXNlKHZkcGEpOwo+ICsJc3RydWN0IHZkdXNlX3ZpcnRxdWV1ZSAqdnEgPSAmZGV2LT52cXNb aWR4XTsKPiArCj4gKwlzcGluX2xvY2soJnZxLT5pcnFfbG9jayk7Cj4gKwl2cS0+Y2IuY2FsbGJh Y2sgPSBjYi0+Y2FsbGJhY2s7Cj4gKwl2cS0+Y2IucHJpdmF0ZSA9IGNiLT5wcml2YXRlOwo+ICsJ c3Bpbl91bmxvY2soJnZxLT5pcnFfbG9jayk7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHZkdXNl X3ZkcGFfc2V0X3ZxX251bShzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEsIHUxNiBpZHgsIHUzMiBu dW0pCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IHZkcGFfdG9fdmR1c2UodmRwYSk7 Cj4gKwlzdHJ1Y3QgdmR1c2VfdmlydHF1ZXVlICp2cSA9ICZkZXYtPnZxc1tpZHhdOwo+ICsKPiAr CXZkdXNlX2Rldl9zZXRfdnFfbnVtKGRldiwgdnEsIG51bSk7Cj4gK30KPiArCj4gK3N0YXRpYyB2 b2lkIHZkdXNlX3ZkcGFfc2V0X3ZxX3JlYWR5KHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYSwKPiAr CQkJCQl1MTYgaWR4LCBib29sIHJlYWR5KQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYg PSB2ZHBhX3RvX3ZkdXNlKHZkcGEpOwo+ICsJc3RydWN0IHZkdXNlX3ZpcnRxdWV1ZSAqdnEgPSAm ZGV2LT52cXNbaWR4XTsKPiArCj4gKwl2ZHVzZV9kZXZfc2V0X3ZxX3JlYWR5KGRldiwgdnEsIHJl YWR5KTsKPiArCXZxLT5yZWFkeSA9IHJlYWR5Owo+ICt9Cj4gKwo+ICtzdGF0aWMgYm9vbCB2ZHVz ZV92ZHBhX2dldF92cV9yZWFkeShzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEsIHUxNiBpZHgpCj4g K3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IHZkcGFfdG9fdmR1c2UodmRwYSk7Cj4gKwlz dHJ1Y3QgdmR1c2VfdmlydHF1ZXVlICp2cSA9ICZkZXYtPnZxc1tpZHhdOwo+ICsKPiArCXZxLT5y ZWFkeSA9IHZkdXNlX2Rldl9nZXRfdnFfcmVhZHkoZGV2LCB2cSk7Cj4gKwo+ICsJcmV0dXJuIHZx LT5yZWFkeTsKPiArfQo+ICsKPiArc3RhdGljIGludCB2ZHVzZV92ZHBhX3NldF92cV9zdGF0ZShz dHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEsIHUxNiBpZHgsCj4gKwkJCQljb25zdCBzdHJ1Y3QgdmRw YV92cV9zdGF0ZSAqc3RhdGUpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IHZkcGFf dG9fdmR1c2UodmRwYSk7Cj4gKwlzdHJ1Y3QgdmR1c2VfdmlydHF1ZXVlICp2cSA9ICZkZXYtPnZx c1tpZHhdOwo+ICsKPiArCXJldHVybiB2ZHVzZV9kZXZfc2V0X3ZxX3N0YXRlKGRldiwgdnEsIHN0 YXRlKTsKPiArfQo+ICsKPiArc3RhdGljIGludCB2ZHVzZV92ZHBhX2dldF92cV9zdGF0ZShzdHJ1 Y3QgdmRwYV9kZXZpY2UgKnZkcGEsIHUxNiBpZHgsCj4gKwkJCQlzdHJ1Y3QgdmRwYV92cV9zdGF0 ZSAqc3RhdGUpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IHZkcGFfdG9fdmR1c2Uo dmRwYSk7Cj4gKwlzdHJ1Y3QgdmR1c2VfdmlydHF1ZXVlICp2cSA9ICZkZXYtPnZxc1tpZHhdOwo+ ICsKPiArCXJldHVybiB2ZHVzZV9kZXZfZ2V0X3ZxX3N0YXRlKGRldiwgdnEsIHN0YXRlKTsKPiAr fQo+ICsKPiArc3RhdGljIHUzMiB2ZHVzZV92ZHBhX2dldF92cV9hbGlnbihzdHJ1Y3QgdmRwYV9k ZXZpY2UgKnZkcGEpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IHZkcGFfdG9fdmR1 c2UodmRwYSk7Cj4gKwo+ICsJcmV0dXJuIGRldi0+dnFfYWxpZ247Cj4gK30KPiArCj4gK3N0YXRp YyB1NjQgdmR1c2VfdmRwYV9nZXRfZmVhdHVyZXMoc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhKQo+ ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBhX3RvX3ZkdXNlKHZkcGEpOwo+ICsJ dTY0IGZpeGVkID0gKDFVTEwgPDwgVklSVElPX0ZfQUNDRVNTX1BMQVRGT1JNKTsKPiArCj4gKwly ZXR1cm4gKHZkdXNlX2Rldl9nZXRfZmVhdHVyZXMoZGV2KSB8IGZpeGVkKTsKCgpXaGF0IGhhcHBl bnMgaWYgd2UgZG9uJ3QgZG8gc3VjaCBmaXh1cC4gSSB0aGluayB3ZSBzaG91bGQgZmFpbCBpZiAK dXNlcnNhcGNlIGRvZXNudCBvZmZlciBBQ0NFU1NfUExBVEZPUk0gaW5zdGVhZC4KCgo+ICt9Cj4g Kwo+ICtzdGF0aWMgaW50IHZkdXNlX3ZkcGFfc2V0X2ZlYXR1cmVzKHN0cnVjdCB2ZHBhX2Rldmlj ZSAqdmRwYSwgdTY0IGZlYXR1cmVzKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSB2 ZHBhX3RvX3ZkdXNlKHZkcGEpOwo+ICsKPiArCXJldHVybiB2ZHVzZV9kZXZfc2V0X2ZlYXR1cmVz KGRldiwgZmVhdHVyZXMpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCB2ZHVzZV92ZHBhX3NldF9j b25maWdfY2Ioc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhLAo+ICsJCQkJICBzdHJ1Y3QgdmRwYV9j YWxsYmFjayAqY2IpCj4gK3sKPiArCS8qIFdlIGRvbid0IHN1cHBvcnQgY29uZmlnIGludGVycnVw dCAqLwo+ICt9Cj4gKwo+ICtzdGF0aWMgdTE2IHZkdXNlX3ZkcGFfZ2V0X3ZxX251bV9tYXgoc3Ry dWN0IHZkcGFfZGV2aWNlICp2ZHBhKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSB2 ZHBhX3RvX3ZkdXNlKHZkcGEpOwo+ICsKPiArCXJldHVybiBkZXYtPnZxX3NpemVfbWF4Owo+ICt9 Cj4gKwo+ICtzdGF0aWMgdTMyIHZkdXNlX3ZkcGFfZ2V0X2RldmljZV9pZChzdHJ1Y3QgdmRwYV9k ZXZpY2UgKnZkcGEpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IHZkcGFfdG9fdmR1 c2UodmRwYSk7Cj4gKwo+ICsJcmV0dXJuIGRldi0+ZGV2aWNlX2lkOwo+ICt9Cj4gKwo+ICtzdGF0 aWMgdTMyIHZkdXNlX3ZkcGFfZ2V0X3ZlbmRvcl9pZChzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEp Cj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldiA9IHZkcGFfdG9fdmR1c2UodmRwYSk7Cj4g Kwo+ICsJcmV0dXJuIGRldi0+dmVuZG9yX2lkOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdTggdmR1c2Vf dmRwYV9nZXRfc3RhdHVzKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYSkKPiArewo+ICsJc3RydWN0 IHZkdXNlX2RldiAqZGV2ID0gdmRwYV90b192ZHVzZSh2ZHBhKTsKPiArCj4gKwlyZXR1cm4gdmR1 c2VfZGV2X2dldF9zdGF0dXMoZGV2KTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdmR1c2VfdmRw YV9zZXRfc3RhdHVzKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYSwgdTggc3RhdHVzKQo+ICt7Cj4g KwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBhX3RvX3ZkdXNlKHZkcGEpOwo+ICsKPiArCWlm IChzdGF0dXMgPT0gMCkKPiArCQl2ZHVzZV9kZXZfcmVzZXQoZGV2KTsKPiArCj4gKwl2ZHVzZV9k ZXZfc2V0X3N0YXR1cyhkZXYsIHN0YXR1cyk7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHZkdXNl X3ZkcGFfZ2V0X2NvbmZpZyhzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEsIHVuc2lnbmVkIGludCBv ZmZzZXQsCj4gKwkJCSAgICAgdm9pZCAqYnVmLCB1bnNpZ25lZCBpbnQgbGVuKQo+ICt7Cj4gKwlz dHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHBhX3RvX3ZkdXNlKHZkcGEpOwo+ICsKPiArCXZkdXNl X2Rldl9nZXRfY29uZmlnKGRldiwgb2Zmc2V0LCBidWYsIGxlbik7Cj4gK30KPiArCj4gK3N0YXRp YyB2b2lkIHZkdXNlX3ZkcGFfc2V0X2NvbmZpZyhzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEsIHVu c2lnbmVkIGludCBvZmZzZXQsCj4gKwkJCWNvbnN0IHZvaWQgKmJ1ZiwgdW5zaWduZWQgaW50IGxl bikKPiArewo+ICsJc3RydWN0IHZkdXNlX2RldiAqZGV2ID0gdmRwYV90b192ZHVzZSh2ZHBhKTsK PiArCj4gKwl2ZHVzZV9kZXZfc2V0X2NvbmZpZyhkZXYsIG9mZnNldCwgYnVmLCBsZW4pOwo+ICt9 Cj4gKwo+ICtzdGF0aWMgaW50IHZkdXNlX3ZkcGFfc2V0X21hcChzdHJ1Y3QgdmRwYV9kZXZpY2Ug KnZkcGEsCj4gKwkJCQlzdHJ1Y3Qgdmhvc3RfaW90bGIgKmlvdGxiKQo+ICt7Cj4gKwlzdHJ1Y3Qg dmR1c2VfZGV2ICpkZXYgPSB2ZHBhX3RvX3ZkdXNlKHZkcGEpOwo+ICsJc3RydWN0IHZob3N0X2lv dGxiX21hcCAqbWFwOwo+ICsJc3RydWN0IHZkcGFfbWFwX2ZpbGUgKm1hcF9maWxlOwo+ICsJdTY0 IHN0YXJ0ID0gMFVMTCwgbGFzdCA9IFVMTE9OR19NQVg7Cj4gKwlpbnQgcmV0ID0gMDsKPiArCj4g Kwl2ZHVzZV9pb3RsYl9kZWxfcmFuZ2UoZGV2LCBzdGFydCwgbGFzdCk7Cj4gKwo+ICsJZm9yICht YXAgPSB2aG9zdF9pb3RsYl9pdHJlZV9maXJzdChpb3RsYiwgc3RhcnQsIGxhc3QpOyBtYXA7Cj4g KwkJbWFwID0gdmhvc3RfaW90bGJfaXRyZWVfbmV4dChtYXAsIHN0YXJ0LCBsYXN0KSkgewo+ICsJ CW1hcF9maWxlID0gKHN0cnVjdCB2ZHBhX21hcF9maWxlICopbWFwLT5vcGFxdWU7Cj4gKwkJaWYg KCFtYXBfZmlsZS0+ZmlsZSkKPiArCQkJY29udGludWU7Cj4gKwo+ICsJCXJldCA9IHZkdXNlX2lv dGxiX2FkZF9yYW5nZShkZXYsIG1hcC0+c3RhcnQsIG1hcC0+bGFzdCwKPiArCQkJCQkgICAgbWFw LT5hZGRyLCBtYXAtPnBlcm0sCj4gKwkJCQkJICAgIG1hcF9maWxlLT5maWxlLAo+ICsJCQkJCSAg ICBtYXBfZmlsZS0+b2Zmc2V0KTsKPiArCQlpZiAocmV0KQo+ICsJCQlicmVhazsKPiArCX0KPiAr CXZkdXNlX2Rldl91cGRhdGVfaW90bGIoZGV2LCBzdGFydCwgbGFzdCk7Cj4gKwo+ICsJcmV0dXJu IHJldDsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdmR1c2VfdmRwYV9mcmVlKHN0cnVjdCB2ZHBh X2RldmljZSAqdmRwYSkKPiArewo+ICsJc3RydWN0IHZkdXNlX2RldiAqZGV2ID0gdmRwYV90b192 ZHVzZSh2ZHBhKTsKPiArCj4gKwlXQVJOX09OKCFsaXN0X2VtcHR5KCZkZXYtPnNlbmRfbGlzdCkp Owo+ICsJV0FSTl9PTighbGlzdF9lbXB0eSgmZGV2LT5yZWN2X2xpc3QpKTsKPiArCWRldi0+dmRl diA9IE5VTEw7Cj4gK30KPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdmRwYV9jb25maWdfb3Bz IHZkdXNlX3ZkcGFfY29uZmlnX29wcyA9IHsKPiArCS5zZXRfdnFfYWRkcmVzcwkJPSB2ZHVzZV92 ZHBhX3NldF92cV9hZGRyZXNzLAo+ICsJLmtpY2tfdnEJCT0gdmR1c2VfdmRwYV9raWNrX3ZxLAo+ ICsJLnNldF92cV9jYgkJPSB2ZHVzZV92ZHBhX3NldF92cV9jYiwKPiArCS5zZXRfdnFfbnVtICAg ICAgICAgICAgID0gdmR1c2VfdmRwYV9zZXRfdnFfbnVtLAo+ICsJLnNldF92cV9yZWFkeQkJPSB2 ZHVzZV92ZHBhX3NldF92cV9yZWFkeSwKPiArCS5nZXRfdnFfcmVhZHkJCT0gdmR1c2VfdmRwYV9n ZXRfdnFfcmVhZHksCj4gKwkuc2V0X3ZxX3N0YXRlCQk9IHZkdXNlX3ZkcGFfc2V0X3ZxX3N0YXRl LAo+ICsJLmdldF92cV9zdGF0ZQkJPSB2ZHVzZV92ZHBhX2dldF92cV9zdGF0ZSwKPiArCS5nZXRf dnFfYWxpZ24JCT0gdmR1c2VfdmRwYV9nZXRfdnFfYWxpZ24sCj4gKwkuZ2V0X2ZlYXR1cmVzCQk9 IHZkdXNlX3ZkcGFfZ2V0X2ZlYXR1cmVzLAo+ICsJLnNldF9mZWF0dXJlcwkJPSB2ZHVzZV92ZHBh X3NldF9mZWF0dXJlcywKPiArCS5zZXRfY29uZmlnX2NiCQk9IHZkdXNlX3ZkcGFfc2V0X2NvbmZp Z19jYiwKPiArCS5nZXRfdnFfbnVtX21heAkJPSB2ZHVzZV92ZHBhX2dldF92cV9udW1fbWF4LAo+ ICsJLmdldF9kZXZpY2VfaWQJCT0gdmR1c2VfdmRwYV9nZXRfZGV2aWNlX2lkLAo+ICsJLmdldF92 ZW5kb3JfaWQJCT0gdmR1c2VfdmRwYV9nZXRfdmVuZG9yX2lkLAo+ICsJLmdldF9zdGF0dXMJCT0g dmR1c2VfdmRwYV9nZXRfc3RhdHVzLAo+ICsJLnNldF9zdGF0dXMJCT0gdmR1c2VfdmRwYV9zZXRf c3RhdHVzLAo+ICsJLmdldF9jb25maWcJCT0gdmR1c2VfdmRwYV9nZXRfY29uZmlnLAo+ICsJLnNl dF9jb25maWcJCT0gdmR1c2VfdmRwYV9zZXRfY29uZmlnLAo+ICsJLnNldF9tYXAJCT0gdmR1c2Vf dmRwYV9zZXRfbWFwLAo+ICsJLmZyZWUJCQk9IHZkdXNlX3ZkcGFfZnJlZSwKPiArfTsKPiArCj4g K3N0YXRpYyBkbWFfYWRkcl90IHZkdXNlX2Rldl9tYXBfcGFnZShzdHJ1Y3QgZGV2aWNlICpkZXYs IHN0cnVjdCBwYWdlICpwYWdlLAo+ICsJCQkJCXVuc2lnbmVkIGxvbmcgb2Zmc2V0LCBzaXplX3Qg c2l6ZSwKPiArCQkJCQllbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsCj4gKwkJCQkJdW5zaWdu ZWQgbG9uZyBhdHRycykKPiArewo+ICsJc3RydWN0IHZkdXNlX2RldiAqdmRldiA9IGRldl90b192 ZHVzZShkZXYpOwo+ICsJc3RydWN0IHZkdXNlX2lvdmFfZG9tYWluICpkb21haW4gPSB2ZGV2LT5k b21haW47Cj4gKwo+ICsJaWYgKGF0b21pY194Y2hnKCZ2ZGV2LT5ib3VuY2VfbWFwLCAxKSA9PSAw ICYmCj4gKwkJdmR1c2VfaW90bGJfYWRkX3JhbmdlKHZkZXYsIDAsIGRvbWFpbi0+Ym91bmNlX3Np emUgLSAxLAo+ICsJCQkJICAgICAgMCwgVkRVU0VfQUNDRVNTX1JXLAo+ICsJCQkJICAgICAgdmR1 c2VfZG9tYWluX2ZpbGUoZG9tYWluKSwgMCkpIHsKPiArCQlhdG9taWNfc2V0KCZ2ZGV2LT5ib3Vu Y2VfbWFwLCAwKTsKPiArCQlyZXR1cm4gRE1BX01BUFBJTkdfRVJST1I7CgoKQ2FuIHdlIGFkZCB0 aGUgYm91bmNlIG1hcHBpbmcgcGFnZSBieSBwYWdlIGhlcmU/CgoKPiArCX0KPiArCj4gKwlyZXR1 cm4gdmR1c2VfZG9tYWluX21hcF9wYWdlKGRvbWFpbiwgcGFnZSwgb2Zmc2V0LCBzaXplLCBkaXIs IGF0dHJzKTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdmR1c2VfZGV2X3VubWFwX3BhZ2Uoc3Ry dWN0IGRldmljZSAqZGV2LCBkbWFfYWRkcl90IGRtYV9hZGRyLAo+ICsJCQkJc2l6ZV90IHNpemUs IGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwKPiArCQkJCXVuc2lnbmVkIGxvbmcgYXR0cnMp Cj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKnZkZXYgPSBkZXZfdG9fdmR1c2UoZGV2KTsKPiAr CXN0cnVjdCB2ZHVzZV9pb3ZhX2RvbWFpbiAqZG9tYWluID0gdmRldi0+ZG9tYWluOwo+ICsKPiAr CXJldHVybiB2ZHVzZV9kb21haW5fdW5tYXBfcGFnZShkb21haW4sIGRtYV9hZGRyLCBzaXplLCBk aXIsIGF0dHJzKTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgKnZkdXNlX2Rldl9hbGxvY19jb2hl cmVudChzdHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBzaXplLAo+ICsJCQkJCWRtYV9hZGRyX3Qg KmRtYV9hZGRyLCBnZnBfdCBmbGFnLAo+ICsJCQkJCXVuc2lnbmVkIGxvbmcgYXR0cnMpCj4gK3sK PiArCXN0cnVjdCB2ZHVzZV9kZXYgKnZkZXYgPSBkZXZfdG9fdmR1c2UoZGV2KTsKPiArCXN0cnVj dCB2ZHVzZV9pb3ZhX2RvbWFpbiAqZG9tYWluID0gdmRldi0+ZG9tYWluOwo+ICsJdW5zaWduZWQg bG9uZyBpb3ZhOwo+ICsJdm9pZCAqYWRkcjsKPiArCj4gKwkqZG1hX2FkZHIgPSBETUFfTUFQUElO R19FUlJPUjsKPiArCWFkZHIgPSB2ZHVzZV9kb21haW5fYWxsb2NfY29oZXJlbnQoZG9tYWluLCBz aXplLAo+ICsJCQkJKGRtYV9hZGRyX3QgKikmaW92YSwgZmxhZywgYXR0cnMpOwo+ICsJaWYgKCFh ZGRyKQo+ICsJCXJldHVybiBOVUxMOwo+ICsKPiArCWlmICh2ZHVzZV9pb3RsYl9hZGRfcmFuZ2Uo dmRldiwgaW92YSwgaW92YSArIHNpemUgLSAxLAo+ICsJCQkJICBpb3ZhLCBWRFVTRV9BQ0NFU1Nf UlcsCj4gKwkJCQkgIHZkdXNlX2RvbWFpbl9maWxlKGRvbWFpbiksIGlvdmEpKSB7Cj4gKwkJdmR1 c2VfZG9tYWluX2ZyZWVfY29oZXJlbnQoZG9tYWluLCBzaXplLCBhZGRyLCBpb3ZhLCBhdHRycyk7 Cj4gKwkJcmV0dXJuIE5VTEw7Cj4gKwl9Cj4gKwkqZG1hX2FkZHIgPSAoZG1hX2FkZHJfdClpb3Zh Owo+ICsKPiArCXJldHVybiBhZGRyOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCB2ZHVzZV9kZXZf ZnJlZV9jb2hlcmVudChzdHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBzaXplLAo+ICsJCQkJCXZv aWQgKnZhZGRyLCBkbWFfYWRkcl90IGRtYV9hZGRyLAo+ICsJCQkJCXVuc2lnbmVkIGxvbmcgYXR0 cnMpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKnZkZXYgPSBkZXZfdG9fdmR1c2UoZGV2KTsK PiArCXN0cnVjdCB2ZHVzZV9pb3ZhX2RvbWFpbiAqZG9tYWluID0gdmRldi0+ZG9tYWluOwo+ICsJ dW5zaWduZWQgbG9uZyBzdGFydCA9ICh1bnNpZ25lZCBsb25nKWRtYV9hZGRyOwo+ICsJdW5zaWdu ZWQgbG9uZyBsYXN0ID0gc3RhcnQgKyBzaXplIC0gMTsKPiArCj4gKwl2ZHVzZV9pb3RsYl9kZWxf cmFuZ2UodmRldiwgc3RhcnQsIGxhc3QpOwo+ICsJdmR1c2VfZGV2X3VwZGF0ZV9pb3RsYih2ZGV2 LCBzdGFydCwgbGFzdCk7Cj4gKwl2ZHVzZV9kb21haW5fZnJlZV9jb2hlcmVudChkb21haW4sIHNp emUsIHZhZGRyLCBkbWFfYWRkciwgYXR0cnMpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3Ry dWN0IGRtYV9tYXBfb3BzIHZkdXNlX2Rldl9kbWFfb3BzID0gewo+ICsJLm1hcF9wYWdlID0gdmR1 c2VfZGV2X21hcF9wYWdlLAo+ICsJLnVubWFwX3BhZ2UgPSB2ZHVzZV9kZXZfdW5tYXBfcGFnZSwK PiArCS5hbGxvYyA9IHZkdXNlX2Rldl9hbGxvY19jb2hlcmVudCwKPiArCS5mcmVlID0gdmR1c2Vf ZGV2X2ZyZWVfY29oZXJlbnQsCj4gK307Cj4gKwo+ICtzdGF0aWMgdW5zaWduZWQgaW50IHBlcm1f dG9fZmlsZV9mbGFncyh1OCBwZXJtKQo+ICt7Cj4gKwl1bnNpZ25lZCBpbnQgZmxhZ3MgPSAwOwo+ ICsKPiArCXN3aXRjaCAocGVybSkgewo+ICsJY2FzZSBWRFVTRV9BQ0NFU1NfV086Cj4gKwkJZmxh Z3MgfD0gT19XUk9OTFk7Cj4gKwkJYnJlYWs7Cj4gKwljYXNlIFZEVVNFX0FDQ0VTU19STzoKPiAr CQlmbGFncyB8PSBPX1JET05MWTsKPiArCQlicmVhazsKPiArCWNhc2UgVkRVU0VfQUNDRVNTX1JX Ogo+ICsJCWZsYWdzIHw9IE9fUkRXUjsKPiArCQlicmVhazsKPiArCWRlZmF1bHQ6Cj4gKwkJV0FS TigxLCAiaW52YWxpZGF0ZSB2aG9zdCBJT1RMQiBwZXJtaXNzaW9uXG4iKTsKPiArCQlicmVhazsK PiArCX0KPiArCj4gKwlyZXR1cm4gZmxhZ3M7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgdmR1c2Vf a2lja2ZkX3NldHVwKHN0cnVjdCB2ZHVzZV9kZXYgKmRldiwKPiArCQkJc3RydWN0IHZkdXNlX3Zx X2V2ZW50ZmQgKmV2ZW50ZmQpCj4gK3sKPiArCXN0cnVjdCBldmVudGZkX2N0eCAqY3R4ID0gTlVM TDsKPiArCXN0cnVjdCB2ZHVzZV92aXJ0cXVldWUgKnZxOwo+ICsKPiArCWlmIChldmVudGZkLT5p bmRleCA+PSBkZXYtPnZxX251bSkKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCj4gKwl2cSA9ICZk ZXYtPnZxc1tldmVudGZkLT5pbmRleF07Cj4gKwlpZiAoZXZlbnRmZC0+ZmQgPiAwKSB7Cj4gKwkJ Y3R4ID0gZXZlbnRmZF9jdHhfZmRnZXQoZXZlbnRmZC0+ZmQpOwo+ICsJCWlmIChJU19FUlIoY3R4 KSkKPiArCQkJcmV0dXJuIFBUUl9FUlIoY3R4KTsKPiArCX0KPiArCXNwaW5fbG9jaygmdnEtPmtp Y2tfbG9jayk7Cj4gKwlpZiAodnEtPmtpY2tmZCkKPiArCQlldmVudGZkX2N0eF9wdXQodnEtPmtp Y2tmZCk7Cj4gKwl2cS0+a2lja2ZkID0gY3R4Owo+ICsJc3Bpbl91bmxvY2soJnZxLT5raWNrX2xv Y2spOwo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgbG9uZyB2ZHVzZV9kZXZf aW9jdGwoc3RydWN0IGZpbGUgKmZpbGUsIHVuc2lnbmVkIGludCBjbWQsCj4gKwkJCXVuc2lnbmVk IGxvbmcgYXJnKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSBmaWxlLT5wcml2YXRl X2RhdGE7Cj4gKwl2b2lkIF9fdXNlciAqYXJncCA9ICh2b2lkIF9fdXNlciAqKWFyZzsKPiArCWlu dCByZXQ7Cj4gKwo+ICsJc3dpdGNoIChjbWQpIHsKPiArCWNhc2UgVkRVU0VfSU9UTEJfR0VUX0ZE OiB7Cj4gKwkJc3RydWN0IHZkdXNlX2lvdGxiX2VudHJ5IGVudHJ5Owo+ICsJCXN0cnVjdCB2aG9z dF9pb3RsYl9tYXAgKm1hcDsKPiArCQlzdHJ1Y3QgdmRwYV9tYXBfZmlsZSAqbWFwX2ZpbGU7Cj4g KwkJc3RydWN0IGZpbGUgKmYgPSBOVUxMOwo+ICsKPiArCQlyZXQgPSAtRUZBVUxUOwo+ICsJCWlm IChjb3B5X2Zyb21fdXNlcigmZW50cnksIGFyZ3AsIHNpemVvZihlbnRyeSkpKQo+ICsJCQlicmVh azsKPiArCj4gKwkJc3Bpbl9sb2NrKCZkZXYtPmlvbW11X2xvY2spOwo+ICsJCW1hcCA9IHZob3N0 X2lvdGxiX2l0cmVlX2ZpcnN0KGRldi0+aW9tbXUsIGVudHJ5LnN0YXJ0LAo+ICsJCQkJCSAgICAg IGVudHJ5Lmxhc3QpOwo+ICsJCWlmIChtYXApIHsKPiArCQkJbWFwX2ZpbGUgPSAoc3RydWN0IHZk cGFfbWFwX2ZpbGUgKiltYXAtPm9wYXF1ZTsKPiArCQkJZiA9IGdldF9maWxlKG1hcF9maWxlLT5m aWxlKTsKPiArCQkJZW50cnkub2Zmc2V0ID0gbWFwX2ZpbGUtPm9mZnNldDsKPiArCQkJZW50cnku c3RhcnQgPSBtYXAtPnN0YXJ0Owo+ICsJCQllbnRyeS5sYXN0ID0gbWFwLT5sYXN0Owo+ICsJCQll bnRyeS5wZXJtID0gbWFwLT5wZXJtOwo+ICsJCX0KPiArCQlzcGluX3VubG9jaygmZGV2LT5pb21t dV9sb2NrKTsKPiArCQlpZiAoIWYpIHsKPiArCQkJcmV0ID0gLUVJTlZBTDsKPiArCQkJYnJlYWs7 Cj4gKwkJfQo+ICsJCWlmIChjb3B5X3RvX3VzZXIoYXJncCwgJmVudHJ5LCBzaXplb2YoZW50cnkp KSkgewo+ICsJCQlmcHV0KGYpOwo+ICsJCQlyZXQgPSAtRUZBVUxUOwo+ICsJCQlicmVhazsKPiAr CQl9Cj4gKwkJcmV0ID0gZ2V0X3VudXNlZF9mZF9mbGFncyhwZXJtX3RvX2ZpbGVfZmxhZ3MoZW50 cnkucGVybSkpOwo+ICsJCWlmIChyZXQgPCAwKSB7Cj4gKwkJCWZwdXQoZik7Cj4gKwkJCWJyZWFr Owo+ICsJCX0KPiArCQlmZF9pbnN0YWxsKHJldCwgZik7Cj4gKwkJYnJlYWs7Cj4gKwl9Cj4gKwlj YXNlIFZEVVNFX1ZRX1NFVFVQX0tJQ0tGRDogewo+ICsJCXN0cnVjdCB2ZHVzZV92cV9ldmVudGZk IGV2ZW50ZmQ7Cj4gKwo+ICsJCXJldCA9IC1FRkFVTFQ7Cj4gKwkJaWYgKGNvcHlfZnJvbV91c2Vy KCZldmVudGZkLCBhcmdwLCBzaXplb2YoZXZlbnRmZCkpKQo+ICsJCQlicmVhazsKPiArCj4gKwkJ cmV0ID0gdmR1c2Vfa2lja2ZkX3NldHVwKGRldiwgJmV2ZW50ZmQpOwo+ICsJCWJyZWFrOwo+ICsJ fQo+ICsJY2FzZSBWRFVTRV9JTkpFQ1RfVlFfSVJROiB7Cj4gKwkJc3RydWN0IHZkdXNlX3ZpcnRx dWV1ZSAqdnE7Cj4gKwo+ICsJCXJldCA9IC1FSU5WQUw7Cj4gKwkJaWYgKGFyZyA+PSBkZXYtPnZx X251bSkKPiArCQkJYnJlYWs7Cj4gKwo+ICsJCXZxID0gJmRldi0+dnFzW2FyZ107Cj4gKwkJc3Bp bl9sb2NrX2lycSgmdnEtPmlycV9sb2NrKTsKPiArCQlpZiAodnEtPnJlYWR5ICYmIHZxLT5jYi5j YWxsYmFjaykgewo+ICsJCQl2cS0+Y2IuY2FsbGJhY2sodnEtPmNiLnByaXZhdGUpOwo+ICsJCQly ZXQgPSAwOwo+ICsJCX0KPiArCQlzcGluX3VubG9ja19pcnEoJnZxLT5pcnFfbG9jayk7Cj4gKwkJ YnJlYWs7Cj4gKwl9Cj4gKwlkZWZhdWx0Ogo+ICsJCXJldCA9IC1FTk9JT0NUTENNRDsKPiArCQli cmVhazsKPiArCX0KPiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHZk dXNlX2Rldl9yZWxlYXNlKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQo+ ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSBmaWxlLT5wcml2YXRlX2RhdGE7Cj4gKwlz dHJ1Y3QgdmR1c2VfZGV2X21zZyAqbXNnOwo+ICsJaW50IGk7Cj4gKwo+ICsJZm9yIChpID0gMDsg aSA8IGRldi0+dnFfbnVtOyBpKyspIHsKPiArCQlzdHJ1Y3QgdmR1c2VfdmlydHF1ZXVlICp2cSA9 ICZkZXYtPnZxc1tpXTsKPiArCj4gKwkJc3Bpbl9sb2NrKCZ2cS0+a2lja19sb2NrKTsKPiArCQlp ZiAodnEtPmtpY2tmZCkKPiArCQkJZXZlbnRmZF9jdHhfcHV0KHZxLT5raWNrZmQpOwo+ICsJCXZx LT5raWNrZmQgPSBOVUxMOwo+ICsJCXNwaW5fdW5sb2NrKCZ2cS0+a2lja19sb2NrKTsKPiArCX0K PiArCj4gKwltdXRleF9sb2NrKCZkZXYtPm1zZ19sb2NrKTsKPiArCXdoaWxlICgobXNnID0gdmR1 c2VfZGVxdWV1ZV9tc2coJmRldi0+cmVjdl9saXN0KSkpCj4gKwkJdmR1c2VfZW5xdWV1ZV9tc2co JmRldi0+c2VuZF9saXN0LCBtc2cpOwo+ICsJbXV0ZXhfdW5sb2NrKCZkZXYtPm1zZ19sb2NrKTsK PiArCj4gKwlkZXYtPmNvbm5lY3RlZCA9IGZhbHNlOwo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4g Kwo+ICtzdGF0aWMgaW50IHZkdXNlX2Rldl9vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVj dCBmaWxlICpmaWxlKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPSBjb250YWluZXJf b2YoaW5vZGUtPmlfY2RldiwKPiArCQkJCQlzdHJ1Y3QgdmR1c2VfZGV2LCBjZGV2KTsKPiArCWlu dCByZXQgPSAtRUJVU1k7Cj4gKwo+ICsJbXV0ZXhfbG9jaygmdmR1c2VfbG9jayk7Cj4gKwlpZiAo ZGV2LT5jb25uZWN0ZWQpCj4gKwkJZ290byB1bmxvY2s7Cj4gKwo+ICsJcmV0ID0gMDsKPiArCWRl di0+Y29ubmVjdGVkID0gdHJ1ZTsKPiArCWZpbGUtPnByaXZhdGVfZGF0YSA9IGRldjsKPiArdW5s b2NrOgo+ICsJbXV0ZXhfdW5sb2NrKCZ2ZHVzZV9sb2NrKTsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ ICt9Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyB2ZHVzZV9kZXZf Zm9wcyA9IHsKPiArCS5vd25lcgkJPSBUSElTX01PRFVMRSwKPiArCS5vcGVuCQk9IHZkdXNlX2Rl dl9vcGVuLAo+ICsJLnJlbGVhc2UJPSB2ZHVzZV9kZXZfcmVsZWFzZSwKPiArCS5yZWFkX2l0ZXIJ PSB2ZHVzZV9kZXZfcmVhZF9pdGVyLAo+ICsJLndyaXRlX2l0ZXIJPSB2ZHVzZV9kZXZfd3JpdGVf aXRlciwKPiArCS5wb2xsCQk9IHZkdXNlX2Rldl9wb2xsLAo+ICsJLnVubG9ja2VkX2lvY3RsCT0g dmR1c2VfZGV2X2lvY3RsLAo+ICsJLmNvbXBhdF9pb2N0bAk9IGNvbXBhdF9wdHJfaW9jdGwsCj4g KwkubGxzZWVrCQk9IG5vb3BfbGxzZWVrLAo+ICt9Owo+ICsKPiArc3RhdGljIHN0cnVjdCB2ZHVz ZV9kZXYgKnZkdXNlX2Rldl9jcmVhdGUodm9pZCkKPiArewo+ICsJc3RydWN0IHZkdXNlX2RldiAq ZGV2ID0ga3phbGxvYyhzaXplb2YoKmRldiksIEdGUF9LRVJORUwpOwo+ICsKPiArCWlmICghZGV2 KQo+ICsJCXJldHVybiBOVUxMOwo+ICsKPiArCWRldi0+aW9tbXUgPSB2aG9zdF9pb3RsYl9hbGxv YygwLCAwKTsKPiArCWlmICghZGV2LT5pb21tdSkgewo+ICsJCWtmcmVlKGRldik7Cj4gKwkJcmV0 dXJuIE5VTEw7Cj4gKwl9Cj4gKwo+ICsJbXV0ZXhfaW5pdCgmZGV2LT5tc2dfbG9jayk7Cj4gKwlJ TklUX0xJU1RfSEVBRCgmZGV2LT5zZW5kX2xpc3QpOwo+ICsJSU5JVF9MSVNUX0hFQUQoJmRldi0+ cmVjdl9saXN0KTsKPiArCWF0b21pYzY0X3NldCgmZGV2LT5tc2dfdW5pcXVlLCAwKTsKPiArCXNw aW5fbG9ja19pbml0KCZkZXYtPmlvbW11X2xvY2spOwo+ICsJYXRvbWljX3NldCgmZGV2LT5ib3Vu Y2VfbWFwLCAwKTsKPiArCj4gKwlpbml0X3dhaXRxdWV1ZV9oZWFkKCZkZXYtPndhaXRxKTsKPiAr Cj4gKwlyZXR1cm4gZGV2Owo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCB2ZHVzZV9kZXZfZGVzdHJv eShzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYpCj4gK3sKPiArCXZob3N0X2lvdGxiX2ZyZWUoZGV2LT5p b21tdSk7Cj4gKwltdXRleF9kZXN0cm95KCZkZXYtPm1zZ19sb2NrKTsKPiArCWtmcmVlKGRldik7 Cj4gK30KPiArCj4gK3N0YXRpYyBzdHJ1Y3QgdmR1c2VfZGV2ICp2ZHVzZV9maW5kX2Rldihjb25z dCBjaGFyICpuYW1lKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICp0bXAsICpkZXYgPSBOVUxM Owo+ICsKPiArCWxpc3RfZm9yX2VhY2hfZW50cnkodG1wLCAmdmR1c2VfZGV2cywgbGlzdCkgewo+ ICsJCWlmICghc3RyY21wKGRldl9uYW1lKCZ0bXAtPmRldiksIG5hbWUpKSB7Cj4gKwkJCWRldiA9 IHRtcDsKPiArCQkJYnJlYWs7Cj4gKwkJfQo+ICsJfQo+ICsJcmV0dXJuIGRldjsKPiArfQo+ICsK PiArc3RhdGljIGludCB2ZHVzZV9kZXN0cm95X2RldihjaGFyICpuYW1lKQo+ICt7Cj4gKwlzdHJ1 Y3QgdmR1c2VfZGV2ICpkZXYgPSB2ZHVzZV9maW5kX2RldihuYW1lKTsKPiArCj4gKwlpZiAoIWRl dikKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCj4gKwlpZiAoZGV2LT52ZGV2IHx8IGRldi0+Y29u bmVjdGVkKQo+ICsJCXJldHVybiAtRUJVU1k7Cj4gKwo+ICsJZGV2LT5jb25uZWN0ZWQgPSB0cnVl Owo+ICsJbGlzdF9kZWwoJmRldi0+bGlzdCk7Cj4gKwljZGV2X2RldmljZV9kZWwoJmRldi0+Y2Rl diwgJmRldi0+ZGV2KTsKPiArCXB1dF9kZXZpY2UoJmRldi0+ZGV2KTsKPiArCj4gKwlyZXR1cm4g MDsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdmR1c2VfcmVsZWFzZV9kZXYoc3RydWN0IGRldmlj ZSAqZGV2aWNlKQo+ICt7Cj4gKwlzdHJ1Y3QgdmR1c2VfZGV2ICpkZXYgPQo+ICsJCWNvbnRhaW5l cl9vZihkZXZpY2UsIHN0cnVjdCB2ZHVzZV9kZXYsIGRldik7Cj4gKwo+ICsJaWRhX3NpbXBsZV9y ZW1vdmUoJnZkdXNlX2lkYSwgZGV2LT5taW5vcik7Cj4gKwlrZnJlZShkZXYtPnZxcyk7Cj4gKwl2 ZHVzZV9kb21haW5fZGVzdHJveShkZXYtPmRvbWFpbik7Cj4gKwl2ZHVzZV9kZXZfZGVzdHJveShk ZXYpOwo+ICsJbW9kdWxlX3B1dChUSElTX01PRFVMRSk7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQg dmR1c2VfY3JlYXRlX2RldihzdHJ1Y3QgdmR1c2VfZGV2X2NvbmZpZyAqY29uZmlnKQo+ICt7Cj4g KwlpbnQgaSwgcmV0ID0gLUVOT01FTTsKPiArCXN0cnVjdCB2ZHVzZV9kZXYgKmRldjsKPiArCj4g KwlpZiAoY29uZmlnLT5ib3VuY2Vfc2l6ZSA+IG1heF9ib3VuY2Vfc2l6ZSkKPiArCQlyZXR1cm4g LUVJTlZBTDsKPiArCj4gKwlpZiAoY29uZmlnLT5ib3VuY2Vfc2l6ZSA+IG1heF9pb3ZhX3NpemUp Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJaWYgKHZkdXNlX2ZpbmRfZGV2KGNvbmZpZy0+ bmFtZSkpCj4gKwkJcmV0dXJuIC1FRVhJU1Q7Cj4gKwo+ICsJZGV2ID0gdmR1c2VfZGV2X2NyZWF0 ZSgpOwo+ICsJaWYgKCFkZXYpCj4gKwkJcmV0dXJuIC1FTk9NRU07Cj4gKwo+ICsJZGV2LT5kZXZp Y2VfaWQgPSBjb25maWctPmRldmljZV9pZDsKPiArCWRldi0+dmVuZG9yX2lkID0gY29uZmlnLT52 ZW5kb3JfaWQ7Cj4gKwlkZXYtPmRvbWFpbiA9IHZkdXNlX2RvbWFpbl9jcmVhdGUobWF4X2lvdmFf c2l6ZSAtIDEsCj4gKwkJCQkJY29uZmlnLT5ib3VuY2Vfc2l6ZSk7Cj4gKwlpZiAoIWRldi0+ZG9t YWluKQo+ICsJCWdvdG8gZXJyX2RvbWFpbjsKPiArCj4gKwlkZXYtPnZxX2FsaWduID0gY29uZmln LT52cV9hbGlnbjsKPiArCWRldi0+dnFfc2l6ZV9tYXggPSBjb25maWctPnZxX3NpemVfbWF4Owo+ ICsJZGV2LT52cV9udW0gPSBjb25maWctPnZxX251bTsKPiArCWRldi0+dnFzID0ga2NhbGxvYyhk ZXYtPnZxX251bSwgc2l6ZW9mKCpkZXYtPnZxcyksIEdGUF9LRVJORUwpOwo+ICsJaWYgKCFkZXYt PnZxcykKPiArCQlnb3RvIGVycl92cXM7Cj4gKwo+ICsJZm9yIChpID0gMDsgaSA8IGRldi0+dnFf bnVtOyBpKyspIHsKPiArCQlkZXYtPnZxc1tpXS5pbmRleCA9IGk7Cj4gKwkJc3Bpbl9sb2NrX2lu aXQoJmRldi0+dnFzW2ldLmtpY2tfbG9jayk7Cj4gKwkJc3Bpbl9sb2NrX2luaXQoJmRldi0+dnFz W2ldLmlycV9sb2NrKTsKPiArCX0KPiArCj4gKwlyZXQgPSBpZGFfc2ltcGxlX2dldCgmdmR1c2Vf aWRhLCAwLCBWRFVTRV9ERVZfTUFYLCBHRlBfS0VSTkVMKTsKPiArCWlmIChyZXQgPCAwKQo+ICsJ CWdvdG8gZXJyX2lkYTsKPiArCj4gKwlkZXYtPm1pbm9yID0gcmV0Owo+ICsJZGV2aWNlX2luaXRp YWxpemUoJmRldi0+ZGV2KTsKPiArCWRldi0+ZGV2LnJlbGVhc2UgPSB2ZHVzZV9yZWxlYXNlX2Rl djsKPiArCWRldi0+ZGV2LmNsYXNzID0gdmR1c2VfY2xhc3M7Cj4gKwlkZXYtPmRldi5kZXZ0ID0g TUtERVYoTUFKT1IodmR1c2VfbWFqb3IpLCBkZXYtPm1pbm9yKTsKPiArCXJldCA9IGRldl9zZXRf bmFtZSgmZGV2LT5kZXYsICIlcyIsIGNvbmZpZy0+bmFtZSk7CgoKRG8gd2UgbmVlZCB0byBhZGQg YSBuYW1lc3BjZSBoZXJlPyBFLmcgInZkdXNlLSVzIiwgY29uZmlnLT5uYW1lLgoKCj4gKwlpZiAo cmV0KQo+ICsJCWdvdG8gZXJyX25hbWU7Cj4gKwo+ICsJY2Rldl9pbml0KCZkZXYtPmNkZXYsICZ2 ZHVzZV9kZXZfZm9wcyk7Cj4gKwlkZXYtPmNkZXYub3duZXIgPSBUSElTX01PRFVMRTsKPiArCj4g KwlyZXQgPSBjZGV2X2RldmljZV9hZGQoJmRldi0+Y2RldiwgJmRldi0+ZGV2KTsKPiArCWlmIChy ZXQpIHsKPiArCQlwdXRfZGV2aWNlKCZkZXYtPmRldik7Cj4gKwkJcmV0dXJuIHJldDsKPiArCX0K PiArCWxpc3RfYWRkKCZkZXYtPmxpc3QsICZ2ZHVzZV9kZXZzKTsKPiArCV9fbW9kdWxlX2dldChU SElTX01PRFVMRSk7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK2Vycl9uYW1lOgo+ICsJaWRhX3NpbXBs ZV9yZW1vdmUoJnZkdXNlX2lkYSwgZGV2LT5taW5vcik7Cj4gK2Vycl9pZGE6Cj4gKwlrZnJlZShk ZXYtPnZxcyk7Cj4gK2Vycl92cXM6Cj4gKwl2ZHVzZV9kb21haW5fZGVzdHJveShkZXYtPmRvbWFp bik7Cj4gK2Vycl9kb21haW46Cj4gKwl2ZHVzZV9kZXZfZGVzdHJveShkZXYpOwo+ICsJcmV0dXJu IHJldDsKPiArfQo+ICsKPiArc3RhdGljIGxvbmcgdmR1c2VfaW9jdGwoc3RydWN0IGZpbGUgKmZp bGUsIHVuc2lnbmVkIGludCBjbWQsCj4gKwkJCXVuc2lnbmVkIGxvbmcgYXJnKQo+ICt7Cj4gKwlp bnQgcmV0Owo+ICsJdm9pZCBfX3VzZXIgKmFyZ3AgPSAodm9pZCBfX3VzZXIgKilhcmc7Cj4gKwo+ ICsJbXV0ZXhfbG9jaygmdmR1c2VfbG9jayk7Cj4gKwlzd2l0Y2ggKGNtZCkgewo+ICsJY2FzZSBW RFVTRV9DUkVBVEVfREVWOiB7Cj4gKwkJc3RydWN0IHZkdXNlX2Rldl9jb25maWcgY29uZmlnOwo+ ICsKPiArCQlyZXQgPSAtRUZBVUxUOwo+ICsJCWlmIChjb3B5X2Zyb21fdXNlcigmY29uZmlnLCBh cmdwLCBzaXplb2YoY29uZmlnKSkpCj4gKwkJCWJyZWFrOwo+ICsKPiArCQlyZXQgPSB2ZHVzZV9j cmVhdGVfZGV2KCZjb25maWcpOwo+ICsJCWJyZWFrOwo+ICsJfQo+ICsJY2FzZSBWRFVTRV9ERVNU Uk9ZX0RFVjogewo+ICsJCWNoYXIgbmFtZVtWRFVTRV9OQU1FX01BWF07Cj4gKwo+ICsJCXJldCA9 IC1FRkFVTFQ7Cj4gKwkJaWYgKGNvcHlfZnJvbV91c2VyKG5hbWUsIGFyZ3AsIFZEVVNFX05BTUVf TUFYKSkKPiArCQkJYnJlYWs7Cj4gKwo+ICsJCXJldCA9IHZkdXNlX2Rlc3Ryb3lfZGV2KG5hbWUp Owo+ICsJCWJyZWFrOwo+ICsJfQo+ICsJZGVmYXVsdDoKPiArCQlyZXQgPSAtRUlOVkFMOwo+ICsJ CWJyZWFrOwo+ICsJfQo+ICsJbXV0ZXhfdW5sb2NrKCZ2ZHVzZV9sb2NrKTsKPiArCj4gKwlyZXR1 cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyB2 ZHVzZV9mb3BzID0gewo+ICsJLm93bmVyCQk9IFRISVNfTU9EVUxFLAo+ICsJLnVubG9ja2VkX2lv Y3RsCT0gdmR1c2VfaW9jdGwsCj4gKwkuY29tcGF0X2lvY3RsCT0gY29tcGF0X3B0cl9pb2N0bCwK PiArCS5sbHNlZWsJCT0gbm9vcF9sbHNlZWssCj4gK307Cj4gKwo+ICtzdGF0aWMgY2hhciAqdmR1 c2VfZGV2bm9kZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHVtb2RlX3QgKm1vZGUpCj4gK3sKPiArCXJl dHVybiBrYXNwcmludGYoR0ZQX0tFUk5FTCwgInZkdXNlLyVzIiwgZGV2X25hbWUoZGV2KSk7Cj4g K30KPiArCj4gK3N0YXRpYyBzdHJ1Y3QgbWlzY2RldmljZSB2ZHVzZV9taXNjID0gewo+ICsJLmZv cHMgPSAmdmR1c2VfZm9wcywKPiArCS5taW5vciA9IE1JU0NfRFlOQU1JQ19NSU5PUiwKPiArCS5u YW1lID0gInZkdXNlIiwKPiArCS5ub2RlbmFtZSA9ICJ2ZHVzZS9jb250cm9sIiwKPiArfTsKPiAr Cj4gK3N0YXRpYyB2b2lkIHZkdXNlX21nbXRkZXZfcmVsZWFzZShzdHJ1Y3QgZGV2aWNlICpkZXYp Cj4gK3sKPiArfQo+ICsKPiArc3RhdGljIHN0cnVjdCBkZXZpY2UgdmR1c2VfbWdtdGRldiA9IHsK PiArCS5pbml0X25hbWUgPSAidmR1c2UiLAo+ICsJLnJlbGVhc2UgPSB2ZHVzZV9tZ210ZGV2X3Jl bGVhc2UsCj4gK307Cj4gKwo+ICtzdGF0aWMgc3RydWN0IHZkcGFfbWdtdF9kZXYgbWdtdF9kZXY7 Cj4gKwo+ICtzdGF0aWMgaW50IHZkdXNlX2Rldl9hZGRfdmRwYShzdHJ1Y3QgdmR1c2VfZGV2ICpk ZXYsIGNvbnN0IGNoYXIgKm5hbWUpCj4gK3sKPiArCXN0cnVjdCB2ZHVzZV92ZHBhICp2ZGV2ID0g ZGV2LT52ZGV2Owo+ICsJaW50IHJldDsKPiArCj4gKwlpZiAodmRldikKPiArCQlyZXR1cm4gLUVF WElTVDsKPiArCj4gKwl2ZGV2ID0gdmRwYV9hbGxvY19kZXZpY2Uoc3RydWN0IHZkdXNlX3ZkcGEs IHZkcGEsIE5VTEwsCgoKSSB0aGluayB0aGUgY2hhciBkZXYgc2hvdWxkIGJlIHVzZWQgYXMgdGhl IHBhcmVudCBoZXJlLgoKCj4gKwkJCQkgJnZkdXNlX3ZkcGFfY29uZmlnX29wcywKPiArCQkJCSBk ZXYtPnZxX251bSwgbmFtZSwgdHJ1ZSk7Cj4gKwlpZiAoIXZkZXYpCj4gKwkJcmV0dXJuIC1FTk9N RU07Cj4gKwo+ICsJdmRldi0+ZGV2ID0gZGV2Owo+ICsJdmRldi0+dmRwYS5kZXYuZG1hX21hc2sg PSAmdmRldi0+dmRwYS5kZXYuY29oZXJlbnRfZG1hX21hc2s7Cj4gKwlyZXQgPSBkbWFfc2V0X21h c2tfYW5kX2NvaGVyZW50KCZ2ZGV2LT52ZHBhLmRldiwgRE1BX0JJVF9NQVNLKDY0KSk7Cj4gKwlp ZiAocmV0KQo+ICsJCWdvdG8gZXJyOwo+ICsKPiArCXNldF9kbWFfb3BzKCZ2ZGV2LT52ZHBhLmRl diwgJnZkdXNlX2Rldl9kbWFfb3BzKTsKPiArCXZkZXYtPnZkcGEuZG1hX2RldiA9ICZ2ZGV2LT52 ZHBhLmRldjsKPiArCXZkZXYtPnZkcGEubWRldiA9ICZtZ210X2RldjsKPiArCj4gKwlyZXQgPSBf dmRwYV9yZWdpc3Rlcl9kZXZpY2UoJnZkZXYtPnZkcGEpOwo+ICsJaWYgKHJldCkKPiArCQlnb3Rv IGVycjsKPiArCj4gKwlkZXYtPnZkZXYgPSB2ZGV2Owo+ICsKPiArCXJldHVybiAwOwo+ICtlcnI6 Cj4gKwlwdXRfZGV2aWNlKCZ2ZGV2LT52ZHBhLmRldik7Cj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4g Kwo+ICtzdGF0aWMgaW50IHZkcGFfZGV2X2FkZChzdHJ1Y3QgdmRwYV9tZ210X2RldiAqbWRldiwg Y29uc3QgY2hhciAqbmFtZSkKPiArewo+ICsJc3RydWN0IHZkdXNlX2RldiAqZGV2Owo+ICsJaW50 IHJldCA9IC1FSU5WQUw7Cj4gKwo+ICsJbXV0ZXhfbG9jaygmdmR1c2VfbG9jayk7Cj4gKwlkZXYg PSB2ZHVzZV9maW5kX2RldihuYW1lKTsKPiArCWlmICghZGV2KQo+ICsJCWdvdG8gdW5sb2NrOwoK CkFueSByZWFzb24gZm9yIHRoaXMgY2hlY2s/IEkgdGhpbmsgdmRwYSBjb3JlIGxheWVyIGhhcyBh bHJlYWR5IGRpZCBmb3IgCnRoZSBuYW1lIGNoZWNrIGZvciB1cy4KCgo+ICsKPiArCXJldCA9IHZk dXNlX2Rldl9hZGRfdmRwYShkZXYsIG5hbWUpOwo+ICt1bmxvY2s6Cj4gKwltdXRleF91bmxvY2so JnZkdXNlX2xvY2spOwo+ICsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lk IHZkcGFfZGV2X2RlbChzdHJ1Y3QgdmRwYV9tZ210X2RldiAqbWRldiwgc3RydWN0IHZkcGFfZGV2 aWNlICpkZXYpCj4gK3sKPiArCV92ZHBhX3VucmVnaXN0ZXJfZGV2aWNlKGRldik7Cj4gK30KPiAr Cj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdmRwYV9tZ210ZGV2X29wcyB2ZHBhX2Rldl9tZ210ZGV2 X29wcyA9IHsKPiArCS5kZXZfYWRkID0gdmRwYV9kZXZfYWRkLAo+ICsJLmRldl9kZWwgPSB2ZHBh X2Rldl9kZWwsCj4gK307Cj4gKwo+ICtzdGF0aWMgc3RydWN0IHZpcnRpb19kZXZpY2VfaWQgaWRf dGFibGVbXSA9IHsKPiArCXsgVklSVElPX0RFVl9BTllfSUQsIFZJUlRJT19ERVZfQU5ZX0lEIH0s Cj4gKwl7IDAgfSwKPiArfTsKPiArCj4gK3N0YXRpYyBzdHJ1Y3QgdmRwYV9tZ210X2RldiBtZ210 X2RldiA9IHsKPiArCS5kZXZpY2UgPSAmdmR1c2VfbWdtdGRldiwKPiArCS5pZF90YWJsZSA9IGlk X3RhYmxlLAo+ICsJLm9wcyA9ICZ2ZHBhX2Rldl9tZ210ZGV2X29wcywKPiArfTsKPiArCj4gK3N0 YXRpYyBpbnQgdmR1c2VfbWdtdGRldl9pbml0KHZvaWQpCj4gK3sKPiArCWludCByZXQ7Cj4gKwo+ ICsJcmV0ID0gZGV2aWNlX3JlZ2lzdGVyKCZ2ZHVzZV9tZ210ZGV2KTsKPiArCWlmIChyZXQpCj4g KwkJcmV0dXJuIHJldDsKPiArCj4gKwlyZXQgPSB2ZHBhX21nbXRkZXZfcmVnaXN0ZXIoJm1nbXRf ZGV2KTsKPiArCWlmIChyZXQpCj4gKwkJZ290byBlcnI7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK2Vy cjoKPiArCWRldmljZV91bnJlZ2lzdGVyKCZ2ZHVzZV9tZ210ZGV2KTsKPiArCXJldHVybiByZXQ7 Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHZkdXNlX21nbXRkZXZfZXhpdCh2b2lkKQo+ICt7Cj4g Kwl2ZHBhX21nbXRkZXZfdW5yZWdpc3RlcigmbWdtdF9kZXYpOwo+ICsJZGV2aWNlX3VucmVnaXN0 ZXIoJnZkdXNlX21nbXRkZXYpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHZkdXNlX2luaXQodm9p ZCkKPiArewo+ICsJaW50IHJldDsKPiArCj4gKwlyZXQgPSBtaXNjX3JlZ2lzdGVyKCZ2ZHVzZV9t aXNjKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiArCj4gKwl2ZHVzZV9jbGFzcyA9 IGNsYXNzX2NyZWF0ZShUSElTX01PRFVMRSwgInZkdXNlIik7Cj4gKwlpZiAoSVNfRVJSKHZkdXNl X2NsYXNzKSkgewo+ICsJCXJldCA9IFBUUl9FUlIodmR1c2VfY2xhc3MpOwo+ICsJCWdvdG8gZXJy X2NsYXNzOwo+ICsJfQo+ICsJdmR1c2VfY2xhc3MtPmRldm5vZGUgPSB2ZHVzZV9kZXZub2RlOwo+ ICsKPiArCXJldCA9IGFsbG9jX2NocmRldl9yZWdpb24oJnZkdXNlX21ham9yLCAwLCBWRFVTRV9E RVZfTUFYLCAidmR1c2UiKTsKPiArCWlmIChyZXQpCj4gKwkJZ290byBlcnJfY2hhcmRldjsKPiAr Cj4gKwlyZXQgPSB2ZHVzZV9kb21haW5faW5pdCgpOwo+ICsJaWYgKHJldCkKPiArCQlnb3RvIGVy cl9kb21haW47Cj4gKwo+ICsJcmV0ID0gdmR1c2VfbWdtdGRldl9pbml0KCk7Cj4gKwlpZiAocmV0 KQo+ICsJCWdvdG8gZXJyX21nbXRkZXY7CgoKU2hvdWxkIHdlIHZhbGlkYXRlIG1heF9ib3VuY2Vf c2l6ZSA8IG1heF9pb3ZhX3NpemUgaGVyZT8KClRoYW5rcwoKCj4gKwo+ICsJcmV0dXJuIDA7Cj4g K2Vycl9tZ210ZGV2Ogo+ICsJdmR1c2VfZG9tYWluX2V4aXQoKTsKPiArZXJyX2RvbWFpbjoKPiAr CXVucmVnaXN0ZXJfY2hyZGV2X3JlZ2lvbih2ZHVzZV9tYWpvciwgVkRVU0VfREVWX01BWCk7Cj4g K2Vycl9jaGFyZGV2Ogo+ICsJY2xhc3NfZGVzdHJveSh2ZHVzZV9jbGFzcyk7Cj4gK2Vycl9jbGFz czoKPiArCW1pc2NfZGVyZWdpc3RlcigmdmR1c2VfbWlzYyk7Cj4gKwlyZXR1cm4gcmV0Owo+ICt9 Cj4gK21vZHVsZV9pbml0KHZkdXNlX2luaXQpOwo+ICsKPiArc3RhdGljIHZvaWQgdmR1c2VfZXhp dCh2b2lkKQo+ICt7Cj4gKwltaXNjX2RlcmVnaXN0ZXIoJnZkdXNlX21pc2MpOwo+ICsJY2xhc3Nf ZGVzdHJveSh2ZHVzZV9jbGFzcyk7Cj4gKwl1bnJlZ2lzdGVyX2NocmRldl9yZWdpb24odmR1c2Vf bWFqb3IsIFZEVVNFX0RFVl9NQVgpOwo+ICsJdmR1c2VfZG9tYWluX2V4aXQoKTsKPiArCXZkdXNl X21nbXRkZXZfZXhpdCgpOwo+ICt9Cj4gK21vZHVsZV9leGl0KHZkdXNlX2V4aXQpOwo+ICsKPiAr TU9EVUxFX1ZFUlNJT04oRFJWX1ZFUlNJT04pOwo+ICtNT0RVTEVfTElDRU5TRShEUlZfTElDRU5T RSk7Cj4gK01PRFVMRV9BVVRIT1IoRFJWX0FVVEhPUik7Cj4gK01PRFVMRV9ERVNDUklQVElPTihE UlZfREVTQyk7Cj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvdWFwaS9saW51eC92ZHVzZS5oIGIvaW5j bHVkZS91YXBpL2xpbnV4L3ZkdXNlLmgKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAw MDAwMDAwMDAwMC4uOTM5MWM0YWNmYTUzCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2luY2x1ZGUv dWFwaS9saW51eC92ZHVzZS5oCj4gQEAgLTAsMCArMSwxMzYgQEAKPiArLyogU1BEWC1MaWNlbnNl LUlkZW50aWZpZXI6IEdQTC0yLjAgV0lUSCBMaW51eC1zeXNjYWxsLW5vdGUgKi8KPiArI2lmbmRl ZiBfVUFQSV9WRFVTRV9IXwo+ICsjZGVmaW5lIF9VQVBJX1ZEVVNFX0hfCj4gKwo+ICsjaW5jbHVk ZSA8bGludXgvdHlwZXMuaD4KPiArCj4gKyNkZWZpbmUgVkRVU0VfQ09ORklHX0RBVEFfTEVOCTI1 Ngo+ICsjZGVmaW5lIFZEVVNFX05BTUVfTUFYCTI1Ngo+ICsKPiArLyogdGhlIGNvbnRyb2wgbWVz c2FnZXMgZGVmaW5pdGlvbiBmb3IgcmVhZC93cml0ZSAqLwo+ICsKPiArZW51bSB2ZHVzZV9yZXFf dHlwZSB7Cj4gKwlWRFVTRV9TRVRfVlFfTlVNLAo+ICsJVkRVU0VfU0VUX1ZRX0FERFIsCj4gKwlW RFVTRV9TRVRfVlFfUkVBRFksCj4gKwlWRFVTRV9HRVRfVlFfUkVBRFksCj4gKwlWRFVTRV9TRVRf VlFfU1RBVEUsCj4gKwlWRFVTRV9HRVRfVlFfU1RBVEUsCj4gKwlWRFVTRV9TRVRfRkVBVFVSRVMs Cj4gKwlWRFVTRV9HRVRfRkVBVFVSRVMsCj4gKwlWRFVTRV9TRVRfU1RBVFVTLAo+ICsJVkRVU0Vf R0VUX1NUQVRVUywKPiArCVZEVVNFX1NFVF9DT05GSUcsCj4gKwlWRFVTRV9HRVRfQ09ORklHLAo+ ICsJVkRVU0VfVVBEQVRFX0lPVExCLAo+ICt9Owo+ICsKPiArc3RydWN0IHZkdXNlX3ZxX251bSB7 Cj4gKwlfX3UzMiBpbmRleDsKPiArCV9fdTMyIG51bTsKPiArfTsKPiArCj4gK3N0cnVjdCB2ZHVz ZV92cV9hZGRyIHsKPiArCV9fdTMyIGluZGV4Owo+ICsJX191NjQgZGVzY19hZGRyOwo+ICsJX191 NjQgZHJpdmVyX2FkZHI7Cj4gKwlfX3U2NCBkZXZpY2VfYWRkcjsKPiArfTsKPiArCj4gK3N0cnVj dCB2ZHVzZV92cV9yZWFkeSB7Cj4gKwlfX3UzMiBpbmRleDsKPiArCV9fdTggcmVhZHk7Cj4gK307 Cj4gKwo+ICtzdHJ1Y3QgdmR1c2VfdnFfc3RhdGUgewo+ICsJX191MzIgaW5kZXg7Cj4gKwlfX3Ux NiBhdmFpbF9pZHg7Cj4gK307Cj4gKwo+ICtzdHJ1Y3QgdmR1c2VfZGV2X2NvbmZpZ19kYXRhIHsK PiArCV9fdTMyIG9mZnNldDsKPiArCV9fdTMyIGxlbjsKPiArCV9fdTggZGF0YVtWRFVTRV9DT05G SUdfREFUQV9MRU5dOwo+ICt9Owo+ICsKPiArc3RydWN0IHZkdXNlX2lvdmFfcmFuZ2Ugewo+ICsJ X191NjQgc3RhcnQ7Cj4gKwlfX3U2NCBsYXN0Owo+ICt9Owo+ICsKPiArc3RydWN0IHZkdXNlX2Rl dl9yZXF1ZXN0IHsKPiArCV9fdTMyIHR5cGU7IC8qIHJlcXVlc3QgdHlwZSAqLwo+ICsJX191MzIg dW5pcXVlOyAvKiByZXF1ZXN0IGlkICovCgoKTGV0J3Mgc2ltcGx5IHVzZSAicmVxdWVzdF9pZCIg aGVyZS4KCgo+ICsJX191MzIgcmVzZXJ2ZWRbMl07IC8qIGZvciBmZWF0dXJlIHVzZSAqLwo+ICsJ dW5pb24gewo+ICsJCXN0cnVjdCB2ZHVzZV92cV9udW0gdnFfbnVtOyAvKiB2aXJ0cXVldWUgbnVt ICovCj4gKwkJc3RydWN0IHZkdXNlX3ZxX2FkZHIgdnFfYWRkcjsgLyogdmlydHF1ZXVlIGFkZHJl c3MgKi8KPiArCQlzdHJ1Y3QgdmR1c2VfdnFfcmVhZHkgdnFfcmVhZHk7IC8qIHZpcnRxdWV1ZSBy ZWFkeSBzdGF0dXMgKi8KPiArCQlzdHJ1Y3QgdmR1c2VfdnFfc3RhdGUgdnFfc3RhdGU7IC8qIHZp cnRxdWV1ZSBzdGF0ZSAqLwo+ICsJCXN0cnVjdCB2ZHVzZV9kZXZfY29uZmlnX2RhdGEgY29uZmln OyAvKiB2aXJ0aW8gZGV2aWNlIGNvbmZpZyBzcGFjZSAqLwo+ICsJCXN0cnVjdCB2ZHVzZV9pb3Zh X3JhbmdlIGlvdmE7IC8qIGlvdmEgcmFuZ2UgZm9yIHVwZGF0aW5nICovCj4gKwkJX191NjQgZmVh dHVyZXM7IC8qIHZpcnRpbyBmZWF0dXJlcyAqLwo+ICsJCV9fdTggc3RhdHVzOyAvKiBkZXZpY2Ug c3RhdHVzICovCgoKSXQgbWlnaHQgYmUgYmV0dGVyIHRvIHVzZSBzdHJ1Y3QgZm9yIGZlYXVyZXMg YW5kIHN0YXR1cyBhcyB3ZWxsIGZvciAKY29uc2lzdGVuY3kuCgpBbmQgdG8gYmUgc2FmZSwgbGV0 J3MgYWRkIGV4cGxpY2l0eSBwYWRkaW5nIGhlcmUuCgoKPiArCX07Cj4gK307Cj4gKwo+ICtzdHJ1 Y3QgdmR1c2VfZGV2X3Jlc3BvbnNlIHsKPiArCV9fdTMyIHJlcXVlc3RfaWQ7IC8qIGNvcnJlc3Bv bmRpbmcgcmVxdWVzdCBpZCAqLwo+ICsjZGVmaW5lIFZEVVNFX1JFUVVFU1RfT0sJMHgwMAo+ICsj ZGVmaW5lIFZEVVNFX1JFUVVFU1RfRkFJTEVECTB4MDEKPiArCV9fdTggcmVzdWx0OyAvKiB0aGUg cmVzdWx0IG9mIHJlcXVlc3QgKi8KPiArCV9fdTggcmVzZXJ2ZWRbMTFdOyAvKiBmb3IgZmVhdHVy ZSB1c2UgKi8KCgpMb29rcyBsaWtlIHRoaXMgd2lsbCBiZSBhIGhvbGUgd2hpY2ggaXMgc2ltaWxh ciB0byAKNDI5NzExYWVjMjgyYzRiNWZlNWJiZDdiMmYwYmJiZmY0MTEwZmZiMi4gTmVlZCB0byBt YWtlIHN1cmUgdGhlIHJlc2VydmVkIAplbmQgYXQgOCBieXRlIGJvdW5kYXJ5LgoKCj4gKwl1bmlv biB7Cj4gKwkJc3RydWN0IHZkdXNlX3ZxX3JlYWR5IHZxX3JlYWR5OyAvKiB2aXJ0cXVldWUgcmVh ZHkgc3RhdHVzICovCj4gKwkJc3RydWN0IHZkdXNlX3ZxX3N0YXRlIHZxX3N0YXRlOyAvKiB2aXJ0 cXVldWUgc3RhdGUgKi8KPiArCQlzdHJ1Y3QgdmR1c2VfZGV2X2NvbmZpZ19kYXRhIGNvbmZpZzsg LyogdmlydGlvIGRldmljZSBjb25maWcgc3BhY2UgKi8KPiArCQlfX3U2NCBmZWF0dXJlczsgLyog dmlydGlvIGZlYXR1cmVzICovCj4gKwkJX191OCBzdGF0dXM7IC8qIGRldmljZSBzdGF0dXMgKi8K PiArCX07Cj4gK307Cj4gKwo+ICsvKiBpb2N0bHMgKi8KPiArCj4gK3N0cnVjdCB2ZHVzZV9kZXZf Y29uZmlnIHsKPiArCWNoYXIgbmFtZVtWRFVTRV9OQU1FX01BWF07IC8qIHZkdXNlIGRldmljZSBu YW1lICovCj4gKwlfX3UzMiB2ZW5kb3JfaWQ7IC8qIHZpcnRpbyB2ZW5kb3IgaWQgKi8KPiArCV9f dTMyIGRldmljZV9pZDsgLyogdmlydGlvIGRldmljZSBpZCAqLwo+ICsJX191NjQgYm91bmNlX3Np emU7IC8qIGJvdW5jZSBidWZmZXIgc2l6ZSBmb3IgaW9tbXUgKi8KPiArCV9fdTE2IHZxX251bTsg LyogdGhlIG51bWJlciBvZiB2aXJ0cXVldWVzICovCj4gKwlfX3UxNiB2cV9zaXplX21heDsgLyog dGhlIG1heCBzaXplIG9mIHZpcnRxdWV1ZSAqLwo+ICsJX191MzIgdnFfYWxpZ247IC8qIHRoZSBh bGxvY2F0aW9uIGFsaWdubWVudCBvZiB2aXJ0cXVldWUncyBtZXRhZGF0YSAqLwo+ICt9Owo+ICsK PiArc3RydWN0IHZkdXNlX2lvdGxiX2VudHJ5IHsKPiArCV9fdTY0IG9mZnNldDsgLyogdGhlIG1t YXAgb2Zmc2V0IG9uIGZkICovCj4gKwlfX3U2NCBzdGFydDsgLyogc3RhcnQgb2YgdGhlIElPVkEg cmFuZ2UgKi8KPiArCV9fdTY0IGxhc3Q7IC8qIGxhc3Qgb2YgdGhlIElPVkEgcmFuZ2UgKi8KPiAr I2RlZmluZSBWRFVTRV9BQ0NFU1NfUk8gMHgxCj4gKyNkZWZpbmUgVkRVU0VfQUNDRVNTX1dPIDB4 Mgo+ICsjZGVmaW5lIFZEVVNFX0FDQ0VTU19SVyAweDMKPiArCV9fdTggcGVybTsgLyogYWNjZXNz IHBlcm1pc3Npb24gb2YgdGhpcyByYW5nZSAqLwo+ICt9Owo+ICsKPiArc3RydWN0IHZkdXNlX3Zx X2V2ZW50ZmQgewo+ICsJX191MzIgaW5kZXg7IC8qIHZpcnRxdWV1ZSBpbmRleCAqLwo+ICsJaW50 IGZkOyAvKiBldmVudGZkLCAtMSBtZWFucyBkZS1hc3NpZ25pbmcgdGhlIGV2ZW50ZmQgKi8KCgpM ZXQncyBkZWZpbmUgYSBtYWNybyBmb3IgdGhpcy4KCgo+ICt9Owo+ICsKPiArI2RlZmluZSBWRFVT RV9CQVNFCTB4ODEKPiArCj4gKy8qIENyZWF0ZSBhIHZkdXNlIGRldmljZSB3aGljaCBpcyByZXBy ZXNlbnRlZCBieSBhIGNoYXIgZGV2aWNlICgvZGV2L3ZkdXNlLzxuYW1lPikgKi8KPiArI2RlZmlu ZSBWRFVTRV9DUkVBVEVfREVWCV9JT1coVkRVU0VfQkFTRSwgMHgwMSwgc3RydWN0IHZkdXNlX2Rl dl9jb25maWcpCj4gKwo+ICsvKiBEZXN0cm95IGEgdmR1c2UgZGV2aWNlLiBNYWtlIHN1cmUgdGhl cmUgYXJlIG5vIHJlZmVyZW5jZXMgdG8gdGhlIGNoYXIgZGV2aWNlICovCj4gKyNkZWZpbmUgVkRV U0VfREVTVFJPWV9ERVYJX0lPVyhWRFVTRV9CQVNFLCAweDAyLCBjaGFyW1ZEVVNFX05BTUVfTUFY XSkKPiArCj4gKy8qIEdldCBhIGZpbGUgZGVzY3JpcHRvciBmb3IgdGhlIG1tYXAnYWJsZSBpb3Zh IHJlZ2lvbiAqLwo+ICsjZGVmaW5lIFZEVVNFX0lPVExCX0dFVF9GRAlfSU9XUihWRFVTRV9CQVNF LCAweDAzLCBzdHJ1Y3QgdmR1c2VfaW90bGJfZW50cnkpCj4gKwo+ICsvKiBTZXR1cCBhbiBldmVu dGZkIHRvIHJlY2VpdmUga2ljayBmb3IgdmlydHF1ZXVlICovCj4gKyNkZWZpbmUgVkRVU0VfVlFf U0VUVVBfS0lDS0ZECV9JT1coVkRVU0VfQkFTRSwgMHgwNCwgc3RydWN0IHZkdXNlX3ZxX2V2ZW50 ZmQpCj4gKwo+ICsvKiBJbmplY3QgYW4gaW50ZXJydXB0IGZvciBzcGVjaWZpYyB2aXJ0cXVldWUg Ki8KPiArI2RlZmluZSBWRFVTRV9JTkpFQ1RfVlFfSVJRCV9JTyhWRFVTRV9CQVNFLCAweDA1KQoK Ckkgd29uZGVyIGRvIHdlIG5lZWQgYSB2ZXJzaW9uL2ZlYXR1cmUgaGFuZHNoYWtlIHRoYXQgaXMg Zm9yIGZ1dHVyZSAKZXh0ZW5zaW9uIGluc3RlYWQgb2YganVzdCByZXNlcnZlIGJpdHMgaW4gdUFC ST8gRS5nIFZEVVNFX0dFVF9WRVJTSU9OIC4uLgoKVGhhbmtzCgoKPiArCj4gKyNlbmRpZiAvKiBf VUFQSV9WRFVTRV9IXyAqLwoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fClZpcnR1YWxpemF0aW9uIG1haWxpbmcgbGlzdApWaXJ0dWFsaXphdGlvbkBsaXN0 cy5saW51eC1mb3VuZGF0aW9uLm9yZwpodHRwczovL2xpc3RzLmxpbnV4Zm91bmRhdGlvbi5vcmcv bWFpbG1hbi9saXN0aW5mby92aXJ0dWFsaXphdGlvbg==