From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-1.mimecast.com (us-smtp-1.mimecast.com. [207.211.31.81]) by gmr-mx.google.com with ESMTPS id u25si1224628vkl.5.2020.09.15.20.11.12 for (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Tue, 15 Sep 2020 20:11:12 -0700 (PDT) Subject: Re: [RFC PATCH 00/22] Enhance VHOST to enable SoC-to-SoC communication References: <20200702082143.25259-1-kishon@ti.com> <20200702055026-mutt-send-email-mst@kernel.org> <603970f5-3289-cd53-82a9-aa62b292c552@redhat.com> <14c6cad7-9361-7fa4-e1c6-715ccc7e5f6b@ti.com> <59fd6a0b-8566-44b7-3dae-bb52b468219b@redhat.com> <45a8a97c-2061-13ee-5da8-9877a4a3b8aa@ti.com> <20200828123409.4cd2a812.cohuck@redhat.com> <9cd58cd1-0041-3d98-baf7-6e5bc2e7e317@redhat.com> <5733dbfc-76c1-45dc-6dce-ef5449eacc73@redhat.com> <181ae83d-edeb-9406-27cc-1195fe29ae95@ti.com> From: Jason Wang Message-ID: Date: Wed, 16 Sep 2020 11:10:50 +0800 MIME-Version: 1.0 In-Reply-To: <181ae83d-edeb-9406-27cc-1195fe29ae95@ti.com> Content-Type: text/plain; charset="utf-8"; format="flowed" Content-Transfer-Encoding: 8bit Content-Language: en-US To: Kishon Vijay Abraham I , Cornelia Huck Cc: "Michael S. Tsirkin" , Ohad Ben-Cohen , Bjorn Andersson , Jon Mason , Dave Jiang , Allen Hubbe , Lorenzo Pieralisi , Bjorn Helgaas , Paolo Bonzini , Stefan Hajnoczi , Stefano Garzarella , linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-remoteproc@vger.kernel.org, linux-ntb@googlegroups.com, linux-pci@vger.kernel.org, kvm@vger.kernel.org, virtualization@lists.linux-foundation.org, netdev@vger.kernel.org List-ID: On 2020/9/15 下午11:47, Kishon Vijay Abraham I wrote: > Hi Jason, > > On 15/09/20 1:48 pm, Jason Wang wrote: >> Hi Kishon: >> >> On 2020/9/14 下午3:23, Kishon Vijay Abraham I wrote: >>>> Then you need something that is functional equivalent to virtio PCI >>>> which is actually the concept of vDPA (e.g vDPA provides alternatives if >>>> the queue_sel is hard in the EP implementation). >>> Okay, I just tried to compare the 'struct vdpa_config_ops' and 'struct >>> vhost_config_ops' ( introduced in [RFC PATCH 03/22] vhost: Add ops for >>> the VHOST driver to configure VHOST device). >>> >>> struct vdpa_config_ops { >>>     /* Virtqueue ops */ >>>     int (*set_vq_address)(struct vdpa_device *vdev, >>>                   u16 idx, u64 desc_area, u64 driver_area, >>>                   u64 device_area); >>>     void (*set_vq_num)(struct vdpa_device *vdev, u16 idx, u32 num); >>>     void (*kick_vq)(struct vdpa_device *vdev, u16 idx); >>>     void (*set_vq_cb)(struct vdpa_device *vdev, u16 idx, >>>               struct vdpa_callback *cb); >>>     void (*set_vq_ready)(struct vdpa_device *vdev, u16 idx, bool ready); >>>     bool (*get_vq_ready)(struct vdpa_device *vdev, u16 idx); >>>     int (*set_vq_state)(struct vdpa_device *vdev, u16 idx, >>>                 const struct vdpa_vq_state *state); >>>     int (*get_vq_state)(struct vdpa_device *vdev, u16 idx, >>>                 struct vdpa_vq_state *state); >>>     struct vdpa_notification_area >>>     (*get_vq_notification)(struct vdpa_device *vdev, u16 idx); >>>     /* vq irq is not expected to be changed once DRIVER_OK is set */ >>>     int (*get_vq_irq)(struct vdpa_device *vdv, u16 idx); >>> >>>     /* Device ops */ >>>     u32 (*get_vq_align)(struct vdpa_device *vdev); >>>     u64 (*get_features)(struct vdpa_device *vdev); >>>     int (*set_features)(struct vdpa_device *vdev, u64 features); >>>     void (*set_config_cb)(struct vdpa_device *vdev, >>>                   struct vdpa_callback *cb); >>>     u16 (*get_vq_num_max)(struct vdpa_device *vdev); >>>     u32 (*get_device_id)(struct vdpa_device *vdev); >>>     u32 (*get_vendor_id)(struct vdpa_device *vdev); >>>     u8 (*get_status)(struct vdpa_device *vdev); >>>     void (*set_status)(struct vdpa_device *vdev, u8 status); >>>     void (*get_config)(struct vdpa_device *vdev, unsigned int offset, >>>                void *buf, unsigned int len); >>>     void (*set_config)(struct vdpa_device *vdev, unsigned int offset, >>>                const void *buf, unsigned int len); >>>     u32 (*get_generation)(struct vdpa_device *vdev); >>> >>>     /* DMA ops */ >>>     int (*set_map)(struct vdpa_device *vdev, struct vhost_iotlb *iotlb); >>>     int (*dma_map)(struct vdpa_device *vdev, u64 iova, u64 size, >>>                u64 pa, u32 perm); >>>     int (*dma_unmap)(struct vdpa_device *vdev, u64 iova, u64 size); >>> >>>     /* Free device resources */ >>>     void (*free)(struct vdpa_device *vdev); >>> }; >>> >>> +struct vhost_config_ops { >>> +    int (*create_vqs)(struct vhost_dev *vdev, unsigned int nvqs, >>> +              unsigned int num_bufs, struct vhost_virtqueue *vqs[], >>> +              vhost_vq_callback_t *callbacks[], >>> +              const char * const names[]); >>> +    void (*del_vqs)(struct vhost_dev *vdev); >>> +    int (*write)(struct vhost_dev *vdev, u64 vhost_dst, void *src, >>> int len); >>> +    int (*read)(struct vhost_dev *vdev, void *dst, u64 vhost_src, int >>> len); >>> +    int (*set_features)(struct vhost_dev *vdev, u64 device_features); >>> +    int (*set_status)(struct vhost_dev *vdev, u8 status); >>> +    u8 (*get_status)(struct vhost_dev *vdev); >>> +}; >>> + >>> struct virtio_config_ops >>> I think there's some overlap here and some of the ops tries to do the >>> same thing. >>> >>> I think it differs in (*set_vq_address)() and (*create_vqs)(). >>> [create_vqs() introduced in struct vhost_config_ops provides >>> complimentary functionality to (*find_vqs)() in struct >>> virtio_config_ops. It seemingly encapsulates the functionality of >>> (*set_vq_address)(), (*set_vq_num)(), (*set_vq_cb)(),..]. >>> >>> Back to the difference between (*set_vq_address)() and (*create_vqs)(), >>> set_vq_address() directly provides the virtqueue address to the vdpa >>> device but create_vqs() only provides the parameters of the virtqueue >>> (like the number of virtqueues, number of buffers) but does not directly >>> provide the address. IMO the backend client drivers (like net or vhost) >>> shouldn't/cannot by itself know how to access the vring created on >>> virtio front-end. The vdpa device/vhost device should have logic for >>> that. That will help the client drivers to work with different types of >>> vdpa device/vhost device and can access the vring created by virtio >>> irrespective of whether the vring can be accessed via mmio or kernel >>> space or user space. >>> >>> I think vdpa always works with client drivers in userspace and providing >>> userspace address for vring. >> >> Sorry for being unclear. What I meant is not replacing vDPA with the >> vhost(bus) you proposed but the possibility of replacing virtio-pci-epf >> with vDPA in: > Okay, so the virtio back-end still use vhost and front end should use > vDPA. I see. So the host side PCI driver for EPF should populate > vdpa_config_ops and invoke vdpa_register_device(). Yes. >> My question is basically for the part of virtio_pci_epf_send_command(), >> so it looks to me you have a vendor specific API to replace the >> virtio-pci layout of the BAR: > Even when we use vDPA, we have to use some sort of > virtio_pci_epf_send_command() to communicate with virtio backend right? Right. > > Right, the layout is slightly different from the standard layout. > > This is the layout > struct epf_vhost_reg_queue { > u8 cmd; > u8 cmd_status; > u16 status; > u16 num_buffers; > u16 msix_vector; > u64 queue_addr; What's the meaning of queue_addr here? Does not mean the device expects a contiguous memory for avail/desc/used ring? > } __packed; > > struct epf_vhost_reg { > u64 host_features; > u64 guest_features; > u16 msix_config; > u16 num_queues; > u8 device_status; > u8 config_generation; > u32 isr; > u8 cmd; > u8 cmd_status; > struct epf_vhost_reg_queue vq[MAX_VQS]; > } __packed; >> >> +static int virtio_pci_epf_send_command(struct virtio_pci_device *vp_dev, >> +                       u32 command) >> +{ >> +    struct virtio_pci_epf *pci_epf; >> +    void __iomem *ioaddr; >> +    ktime_t timeout; >> +    bool timedout; >> +    int ret = 0; >> +    u8 status; >> + >> +    pci_epf = to_virtio_pci_epf(vp_dev); >> +    ioaddr = vp_dev->ioaddr; >> + >> +    mutex_lock(&pci_epf->lock); >> +    writeb(command, ioaddr + HOST_CMD); >> +    timeout = ktime_add_ms(ktime_get(), COMMAND_TIMEOUT); >> +    while (1) { >> +        timedout = ktime_after(ktime_get(), timeout); >> +        status = readb(ioaddr + HOST_CMD_STATUS); >> + >> >> Several questions: >> >> - It's not clear to me how the synchronization is done between the RC >> and EP. E.g how and when the value of HOST_CMD_STATUS can be changed. > The HOST_CMD (commands sent to the EP) is serialized by using mutex. > Once the EP reads the command, it resets the value in HOST_CMD. So > HOST_CMD is less likely an issue. Here's my understanding of the protocol: 1) RC write to HOST_CMD 2) RC wait for HOST_CMD_STATUS to be HOST_CMD_STATUS_OKAY It looks to me what EP should do is 1) EP reset HOST_CMD after reading new command And it looks to me EP should also reset HOST_CMD_STATUS here? (I thought there should be patch to handle stuffs like this but I didn't find it in this series) > > A sufficiently large time is given for the EP to complete it's operation > (1 Sec) where the EP provides the status in HOST_CMD_STATUS. After it > expires, HOST_CMD_STATUS_NONE is written to HOST_CMD_STATUS. There could > be case where EP updates HOST_CMD_STATUS after RC writes > HOST_CMD_STATUS_NONE, but by then HOST has already detected this as > failure and error-ed out. > >> If you still want to introduce a new transport, a virtio spec patch >> would be helpful for us to understand the device API. > Okay, that should be on https://github.com/oasis-tcs/virtio-spec.git? Yes. >> - You have you vendor specific layout (according to >> virtio_pci_epb_table()), so I guess you it's better to have a vendor >> specific vDPA driver instead > Okay, with vDPA, we are free to define our own layouts. Right, but vDPA have other requirements. E.g it requires the device have the ability to save/restore the state (e.g the last_avail_idx). So it actually depends on what you want. If you don't care about userspace drivers and want to have a standard transport, you can still go virtio. >> - The advantage of vendor specific vDPA driver is that it can 1) have >> less codes 2) support userspace drivers through vhost-vDPA (instead of >> inventing new APIs since we can't use vfio-pci here). > I see there's an additional level of indirection from virtio to vDPA and > probably no need for spec update but don't exactly see how it'll reduce > code. AFAIK you don't need to implement your own setup_vq and del_vq. > > For 2, Isn't vhost-vdpa supposed to run on virtio backend? Not currently, vDPA is a superset of virtio (e.g it support virtqueue state save/restore). This it should be possible in the future probably. > > From a high level, I think I should be able to use vDPA for > virtio_pci_epf.c. Would you also suggest using vDPA for ntb_virtio.c? > ([RFC PATCH 20/22] NTB: Add a new NTB client driver to implement VIRTIO > functionality). I think it's your call. If you want 1) a well-defined standard virtio transport 2) willing to finalize d and maintain the spec 3) doesn't care about userspace drivers You can go with virtio, otherwise vDPA. Thanks > > Thanks > Kishon > 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=-10.1 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI, MENTIONS_GIT_HOSTING,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 25C01C43461 for ; Wed, 16 Sep 2020 03:11:19 +0000 (UTC) Received: from hemlock.osuosl.org (smtp2.osuosl.org [140.211.166.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 8F91C20770 for ; Wed, 16 Sep 2020 03:11:18 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="e2eSZZ5s" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8F91C20770 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 hemlock.osuosl.org (Postfix) with ESMTP id 0CC9F86F62; Wed, 16 Sep 2020 03:11:18 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from hemlock.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id BTyY-GHUSAdQ; Wed, 16 Sep 2020 03:11:16 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by hemlock.osuosl.org (Postfix) with ESMTP id E827686F3F; Wed, 16 Sep 2020 03:11:16 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id B6AAAC0859; Wed, 16 Sep 2020 03:11:16 +0000 (UTC) Received: from silver.osuosl.org (smtp3.osuosl.org [140.211.166.136]) by lists.linuxfoundation.org (Postfix) with ESMTP id 39755C0051 for ; Wed, 16 Sep 2020 03:11:15 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by silver.osuosl.org (Postfix) with ESMTP id 0F71D1FC71 for ; Wed, 16 Sep 2020 03:11:15 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from silver.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id t75Dc4yGtCjd for ; Wed, 16 Sep 2020 03:11:13 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.7.6 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [216.205.24.124]) by silver.osuosl.org (Postfix) with ESMTPS id 4FD3E1FE65 for ; Wed, 16 Sep 2020 03:11:13 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1600225872; 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=pUfKtm728JV5HfEPBrNg85FNcQ7Ve2VTddaezZoQ5WY=; b=e2eSZZ5sdsX3X3Ue95HizoenwROKqPzCs28HYypKHrD8NUFlYdxUqhlXpfDTy+Gq5ptHAt 8mC449O06FfPYBgrrOtcA7WZKtnW+hXmjAT2W5pVAt0ikwANq4kLG374EZbFcQRz7TW1L1 rO8YUjefFrwAxb+fwh/DmcTRIYJHPpM= 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-165-J5rmrvsYOhil88kP7owOHQ-1; Tue, 15 Sep 2020 23:11:09 -0400 X-MC-Unique: J5rmrvsYOhil88kP7owOHQ-1 Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.phx2.redhat.com [10.5.11.15]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 6EC658015FD; Wed, 16 Sep 2020 03:11:06 +0000 (UTC) Received: from [10.72.13.186] (ovpn-13-186.pek2.redhat.com [10.72.13.186]) by smtp.corp.redhat.com (Postfix) with ESMTP id C29ED75124; Wed, 16 Sep 2020 03:10:52 +0000 (UTC) Subject: Re: [RFC PATCH 00/22] Enhance VHOST to enable SoC-to-SoC communication To: Kishon Vijay Abraham I , Cornelia Huck References: <20200702082143.25259-1-kishon@ti.com> <20200702055026-mutt-send-email-mst@kernel.org> <603970f5-3289-cd53-82a9-aa62b292c552@redhat.com> <14c6cad7-9361-7fa4-e1c6-715ccc7e5f6b@ti.com> <59fd6a0b-8566-44b7-3dae-bb52b468219b@redhat.com> <45a8a97c-2061-13ee-5da8-9877a4a3b8aa@ti.com> <20200828123409.4cd2a812.cohuck@redhat.com> <9cd58cd1-0041-3d98-baf7-6e5bc2e7e317@redhat.com> <5733dbfc-76c1-45dc-6dce-ef5449eacc73@redhat.com> <181ae83d-edeb-9406-27cc-1195fe29ae95@ti.com> From: Jason Wang Message-ID: Date: Wed, 16 Sep 2020 11:10:50 +0800 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: <181ae83d-edeb-9406-27cc-1195fe29ae95@ti.com> Content-Language: en-US X-Scanned-By: MIMEDefang 2.79 on 10.5.11.15 Cc: Ohad Ben-Cohen , Allen Hubbe , Lorenzo Pieralisi , Dave Jiang , kvm@vger.kernel.org, linux-ntb@googlegroups.com, "Michael S. Tsirkin" , linux-pci@vger.kernel.org, linux-doc@vger.kernel.org, linux-remoteproc@vger.kernel.org, linux-kernel@vger.kernel.org, Bjorn Andersson , netdev@vger.kernel.org, Stefan Hajnoczi , Jon Mason , Bjorn Helgaas , Paolo Bonzini , 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" Ck9uIDIwMjAvOS8xNSDkuIvljYgxMTo0NywgS2lzaG9uIFZpamF5IEFicmFoYW0gSSB3cm90ZToK PiBIaSBKYXNvbiwKPgo+IE9uIDE1LzA5LzIwIDE6NDggcG0sIEphc29uIFdhbmcgd3JvdGU6Cj4+ IEhpIEtpc2hvbjoKPj4KPj4gT24gMjAyMC85LzE0IOS4i+WNiDM6MjMsIEtpc2hvbiBWaWpheSBB YnJhaGFtIEkgd3JvdGU6Cj4+Pj4gVGhlbiB5b3UgbmVlZCBzb21ldGhpbmcgdGhhdCBpcyBmdW5j dGlvbmFsIGVxdWl2YWxlbnQgdG8gdmlydGlvIFBDSQo+Pj4+IHdoaWNoIGlzIGFjdHVhbGx5IHRo ZSBjb25jZXB0IG9mIHZEUEEgKGUuZyB2RFBBIHByb3ZpZGVzIGFsdGVybmF0aXZlcyBpZgo+Pj4+ IHRoZSBxdWV1ZV9zZWwgaXMgaGFyZCBpbiB0aGUgRVAgaW1wbGVtZW50YXRpb24pLgo+Pj4gT2th eSwgSSBqdXN0IHRyaWVkIHRvIGNvbXBhcmUgdGhlICdzdHJ1Y3QgdmRwYV9jb25maWdfb3BzJyBh bmQgJ3N0cnVjdAo+Pj4gdmhvc3RfY29uZmlnX29wcycgKCBpbnRyb2R1Y2VkIGluIFtSRkMgUEFU Q0ggMDMvMjJdIHZob3N0OiBBZGQgb3BzIGZvcgo+Pj4gdGhlIFZIT1NUIGRyaXZlciB0byBjb25m aWd1cmUgVkhPU1QgZGV2aWNlKS4KPj4+Cj4+PiBzdHJ1Y3QgdmRwYV9jb25maWdfb3BzIHsKPj4+ ICDCoMKgwqDCoC8qIFZpcnRxdWV1ZSBvcHMgKi8KPj4+ICDCoMKgwqDCoGludCAoKnNldF92cV9h ZGRyZXNzKShzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkZXYsCj4+PiAgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoCB1MTYgaWR4LCB1NjQgZGVzY19hcmVhLCB1NjQgZHJpdmVyX2FyZWEs Cj4+PiAgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB1NjQgZGV2aWNlX2FyZWEp Owo+Pj4gIMKgwqDCoMKgdm9pZCAoKnNldF92cV9udW0pKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRl diwgdTE2IGlkeCwgdTMyIG51bSk7Cj4+PiAgwqDCoMKgwqB2b2lkICgqa2lja192cSkoc3RydWN0 IHZkcGFfZGV2aWNlICp2ZGV2LCB1MTYgaWR4KTsKPj4+ICDCoMKgwqDCoHZvaWQgKCpzZXRfdnFf Y2IpKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRldiwgdTE2IGlkeCwKPj4+ICDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoCBzdHJ1Y3QgdmRwYV9jYWxsYmFjayAqY2IpOwo+Pj4gIMKgwqDCoMKgdm9p ZCAoKnNldF92cV9yZWFkeSkoc3RydWN0IHZkcGFfZGV2aWNlICp2ZGV2LCB1MTYgaWR4LCBib29s IHJlYWR5KTsKPj4+ICDCoMKgwqDCoGJvb2wgKCpnZXRfdnFfcmVhZHkpKHN0cnVjdCB2ZHBhX2Rl dmljZSAqdmRldiwgdTE2IGlkeCk7Cj4+PiAgwqDCoMKgwqBpbnQgKCpzZXRfdnFfc3RhdGUpKHN0 cnVjdCB2ZHBhX2RldmljZSAqdmRldiwgdTE2IGlkeCwKPj4+ICDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqAgY29uc3Qgc3RydWN0IHZkcGFfdnFfc3RhdGUgKnN0YXRlKTsKPj4+ICDCoMKg wqDCoGludCAoKmdldF92cV9zdGF0ZSkoc3RydWN0IHZkcGFfZGV2aWNlICp2ZGV2LCB1MTYgaWR4 LAo+Pj4gIMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBzdHJ1Y3QgdmRwYV92cV9zdGF0 ZSAqc3RhdGUpOwo+Pj4gIMKgwqDCoMKgc3RydWN0IHZkcGFfbm90aWZpY2F0aW9uX2FyZWEKPj4+ ICDCoMKgwqDCoCgqZ2V0X3ZxX25vdGlmaWNhdGlvbikoc3RydWN0IHZkcGFfZGV2aWNlICp2ZGV2 LCB1MTYgaWR4KTsKPj4+ICDCoMKgwqDCoC8qIHZxIGlycSBpcyBub3QgZXhwZWN0ZWQgdG8gYmUg Y2hhbmdlZCBvbmNlIERSSVZFUl9PSyBpcyBzZXQgKi8KPj4+ICDCoMKgwqDCoGludCAoKmdldF92 cV9pcnEpKHN0cnVjdCB2ZHBhX2RldmljZSAqdmR2LCB1MTYgaWR4KTsKPj4+Cj4+PiAgwqDCoMKg wqAvKiBEZXZpY2Ugb3BzICovCj4+PiAgwqDCoMKgwqB1MzIgKCpnZXRfdnFfYWxpZ24pKHN0cnVj dCB2ZHBhX2RldmljZSAqdmRldik7Cj4+PiAgwqDCoMKgwqB1NjQgKCpnZXRfZmVhdHVyZXMpKHN0 cnVjdCB2ZHBhX2RldmljZSAqdmRldik7Cj4+PiAgwqDCoMKgwqBpbnQgKCpzZXRfZmVhdHVyZXMp KHN0cnVjdCB2ZHBhX2RldmljZSAqdmRldiwgdTY0IGZlYXR1cmVzKTsKPj4+ICDCoMKgwqDCoHZv aWQgKCpzZXRfY29uZmlnX2NiKShzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkZXYsCj4+PiAgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBzdHJ1Y3QgdmRwYV9jYWxsYmFjayAqY2IpOwo+ Pj4gIMKgwqDCoMKgdTE2ICgqZ2V0X3ZxX251bV9tYXgpKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRl dik7Cj4+PiAgwqDCoMKgwqB1MzIgKCpnZXRfZGV2aWNlX2lkKShzdHJ1Y3QgdmRwYV9kZXZpY2Ug KnZkZXYpOwo+Pj4gIMKgwqDCoMKgdTMyICgqZ2V0X3ZlbmRvcl9pZCkoc3RydWN0IHZkcGFfZGV2 aWNlICp2ZGV2KTsKPj4+ICDCoMKgwqDCoHU4ICgqZ2V0X3N0YXR1cykoc3RydWN0IHZkcGFfZGV2 aWNlICp2ZGV2KTsKPj4+ICDCoMKgwqDCoHZvaWQgKCpzZXRfc3RhdHVzKShzdHJ1Y3QgdmRwYV9k ZXZpY2UgKnZkZXYsIHU4IHN0YXR1cyk7Cj4+PiAgwqDCoMKgwqB2b2lkICgqZ2V0X2NvbmZpZyko c3RydWN0IHZkcGFfZGV2aWNlICp2ZGV2LCB1bnNpZ25lZCBpbnQgb2Zmc2V0LAo+Pj4gIMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgdm9pZCAqYnVmLCB1bnNpZ25lZCBpbnQgbGVuKTsKPj4+ ICDCoMKgwqDCoHZvaWQgKCpzZXRfY29uZmlnKShzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkZXYsIHVu c2lnbmVkIGludCBvZmZzZXQsCj4+PiAgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBjb25z dCB2b2lkICpidWYsIHVuc2lnbmVkIGludCBsZW4pOwo+Pj4gIMKgwqDCoMKgdTMyICgqZ2V0X2dl bmVyYXRpb24pKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRldik7Cj4+Pgo+Pj4gIMKgwqDCoMKgLyog RE1BIG9wcyAqLwo+Pj4gIMKgwqDCoMKgaW50ICgqc2V0X21hcCkoc3RydWN0IHZkcGFfZGV2aWNl ICp2ZGV2LCBzdHJ1Y3Qgdmhvc3RfaW90bGIgKmlvdGxiKTsKPj4+ICDCoMKgwqDCoGludCAoKmRt YV9tYXApKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRldiwgdTY0IGlvdmEsIHU2NCBzaXplLAo+Pj4g IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgdTY0IHBhLCB1MzIgcGVybSk7Cj4+PiAgwqDC oMKgwqBpbnQgKCpkbWFfdW5tYXApKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRldiwgdTY0IGlvdmEs IHU2NCBzaXplKTsKPj4+Cj4+PiAgwqDCoMKgwqAvKiBGcmVlIGRldmljZSByZXNvdXJjZXMgKi8K Pj4+ICDCoMKgwqDCoHZvaWQgKCpmcmVlKShzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkZXYpOwo+Pj4g fTsKPj4+Cj4+PiArc3RydWN0IHZob3N0X2NvbmZpZ19vcHMgewo+Pj4gK8KgwqDCoCBpbnQgKCpj cmVhdGVfdnFzKShzdHJ1Y3Qgdmhvc3RfZGV2ICp2ZGV2LCB1bnNpZ25lZCBpbnQgbnZxcywKPj4+ ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB1bnNpZ25lZCBpbnQgbnVtX2J1ZnMsIHN0cnVj dCB2aG9zdF92aXJ0cXVldWUgKnZxc1tdLAo+Pj4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg IHZob3N0X3ZxX2NhbGxiYWNrX3QgKmNhbGxiYWNrc1tdLAo+Pj4gK8KgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgIGNvbnN0IGNoYXIgKiBjb25zdCBuYW1lc1tdKTsKPj4+ICvCoMKgwqAgdm9pZCAo KmRlbF92cXMpKHN0cnVjdCB2aG9zdF9kZXYgKnZkZXYpOwo+Pj4gK8KgwqDCoCBpbnQgKCp3cml0 ZSkoc3RydWN0IHZob3N0X2RldiAqdmRldiwgdTY0IHZob3N0X2RzdCwgdm9pZCAqc3JjLAo+Pj4g aW50IGxlbik7Cj4+PiArwqDCoMKgIGludCAoKnJlYWQpKHN0cnVjdCB2aG9zdF9kZXYgKnZkZXYs IHZvaWQgKmRzdCwgdTY0IHZob3N0X3NyYywgaW50Cj4+PiBsZW4pOwo+Pj4gK8KgwqDCoCBpbnQg KCpzZXRfZmVhdHVyZXMpKHN0cnVjdCB2aG9zdF9kZXYgKnZkZXYsIHU2NCBkZXZpY2VfZmVhdHVy ZXMpOwo+Pj4gK8KgwqDCoCBpbnQgKCpzZXRfc3RhdHVzKShzdHJ1Y3Qgdmhvc3RfZGV2ICp2ZGV2 LCB1OCBzdGF0dXMpOwo+Pj4gK8KgwqDCoCB1OCAoKmdldF9zdGF0dXMpKHN0cnVjdCB2aG9zdF9k ZXYgKnZkZXYpOwo+Pj4gK307Cj4+PiArCj4+PiBzdHJ1Y3QgdmlydGlvX2NvbmZpZ19vcHMKPj4+ IEkgdGhpbmsgdGhlcmUncyBzb21lIG92ZXJsYXAgaGVyZSBhbmQgc29tZSBvZiB0aGUgb3BzIHRy aWVzIHRvIGRvIHRoZQo+Pj4gc2FtZSB0aGluZy4KPj4+Cj4+PiBJIHRoaW5rIGl0IGRpZmZlcnMg aW4gKCpzZXRfdnFfYWRkcmVzcykoKSBhbmQgKCpjcmVhdGVfdnFzKSgpLgo+Pj4gW2NyZWF0ZV92 cXMoKSBpbnRyb2R1Y2VkIGluIHN0cnVjdCB2aG9zdF9jb25maWdfb3BzIHByb3ZpZGVzCj4+PiBj b21wbGltZW50YXJ5IGZ1bmN0aW9uYWxpdHkgdG8gKCpmaW5kX3ZxcykoKSBpbiBzdHJ1Y3QKPj4+ IHZpcnRpb19jb25maWdfb3BzLiBJdCBzZWVtaW5nbHkgZW5jYXBzdWxhdGVzIHRoZSBmdW5jdGlv bmFsaXR5IG9mCj4+PiAoKnNldF92cV9hZGRyZXNzKSgpLCAoKnNldF92cV9udW0pKCksICgqc2V0 X3ZxX2NiKSgpLC4uXS4KPj4+Cj4+PiBCYWNrIHRvIHRoZSBkaWZmZXJlbmNlIGJldHdlZW4gKCpz ZXRfdnFfYWRkcmVzcykoKSBhbmQgKCpjcmVhdGVfdnFzKSgpLAo+Pj4gc2V0X3ZxX2FkZHJlc3Mo KSBkaXJlY3RseSBwcm92aWRlcyB0aGUgdmlydHF1ZXVlIGFkZHJlc3MgdG8gdGhlIHZkcGEKPj4+ IGRldmljZSBidXQgY3JlYXRlX3ZxcygpIG9ubHkgcHJvdmlkZXMgdGhlIHBhcmFtZXRlcnMgb2Yg dGhlIHZpcnRxdWV1ZQo+Pj4gKGxpa2UgdGhlIG51bWJlciBvZiB2aXJ0cXVldWVzLCBudW1iZXIg b2YgYnVmZmVycykgYnV0IGRvZXMgbm90IGRpcmVjdGx5Cj4+PiBwcm92aWRlIHRoZSBhZGRyZXNz LiBJTU8gdGhlIGJhY2tlbmQgY2xpZW50IGRyaXZlcnMgKGxpa2UgbmV0IG9yIHZob3N0KQo+Pj4g c2hvdWxkbid0L2Nhbm5vdCBieSBpdHNlbGYga25vdyBob3cgdG8gYWNjZXNzIHRoZSB2cmluZyBj cmVhdGVkIG9uCj4+PiB2aXJ0aW8gZnJvbnQtZW5kLiBUaGUgdmRwYSBkZXZpY2Uvdmhvc3QgZGV2 aWNlIHNob3VsZCBoYXZlIGxvZ2ljIGZvcgo+Pj4gdGhhdC4gVGhhdCB3aWxsIGhlbHAgdGhlIGNs aWVudCBkcml2ZXJzIHRvIHdvcmsgd2l0aCBkaWZmZXJlbnQgdHlwZXMgb2YKPj4+IHZkcGEgZGV2 aWNlL3Zob3N0IGRldmljZSBhbmQgY2FuIGFjY2VzcyB0aGUgdnJpbmcgY3JlYXRlZCBieSB2aXJ0 aW8KPj4+IGlycmVzcGVjdGl2ZSBvZiB3aGV0aGVyIHRoZSB2cmluZyBjYW4gYmUgYWNjZXNzZWQg dmlhIG1taW8gb3Iga2VybmVsCj4+PiBzcGFjZSBvciB1c2VyIHNwYWNlLgo+Pj4KPj4+IEkgdGhp bmsgdmRwYSBhbHdheXMgd29ya3Mgd2l0aCBjbGllbnQgZHJpdmVycyBpbiB1c2Vyc3BhY2UgYW5k IHByb3ZpZGluZwo+Pj4gdXNlcnNwYWNlIGFkZHJlc3MgZm9yIHZyaW5nLgo+Pgo+PiBTb3JyeSBm b3IgYmVpbmcgdW5jbGVhci4gV2hhdCBJIG1lYW50IGlzIG5vdCByZXBsYWNpbmcgdkRQQSB3aXRo IHRoZQo+PiB2aG9zdChidXMpIHlvdSBwcm9wb3NlZCBidXQgdGhlIHBvc3NpYmlsaXR5IG9mIHJl cGxhY2luZyB2aXJ0aW8tcGNpLWVwZgo+PiB3aXRoIHZEUEEgaW46Cj4gT2theSwgc28gdGhlIHZp cnRpbyBiYWNrLWVuZCBzdGlsbCB1c2Ugdmhvc3QgYW5kIGZyb250IGVuZCBzaG91bGQgdXNlCj4g dkRQQS4gSSBzZWUuIFNvIHRoZSBob3N0IHNpZGUgUENJIGRyaXZlciBmb3IgRVBGIHNob3VsZCBw b3B1bGF0ZQo+IHZkcGFfY29uZmlnX29wcyBhbmQgaW52b2tlIHZkcGFfcmVnaXN0ZXJfZGV2aWNl KCkuCgoKWWVzLgoKCj4+IE15IHF1ZXN0aW9uIGlzIGJhc2ljYWxseSBmb3IgdGhlIHBhcnQgb2Yg dmlydGlvX3BjaV9lcGZfc2VuZF9jb21tYW5kKCksCj4+IHNvIGl0IGxvb2tzIHRvIG1lIHlvdSBo YXZlIGEgdmVuZG9yIHNwZWNpZmljIEFQSSB0byByZXBsYWNlIHRoZQo+PiB2aXJ0aW8tcGNpIGxh eW91dCBvZiB0aGUgQkFSOgo+IEV2ZW4gd2hlbiB3ZSB1c2UgdkRQQSwgd2UgaGF2ZSB0byB1c2Ug c29tZSBzb3J0IG9mCj4gdmlydGlvX3BjaV9lcGZfc2VuZF9jb21tYW5kKCkgdG8gY29tbXVuaWNh dGUgd2l0aCB2aXJ0aW8gYmFja2VuZCByaWdodD8KCgpSaWdodC4KCgo+Cj4gUmlnaHQsIHRoZSBs YXlvdXQgaXMgc2xpZ2h0bHkgZGlmZmVyZW50IGZyb20gdGhlIHN0YW5kYXJkIGxheW91dC4KPgo+ IFRoaXMgaXMgdGhlIGxheW91dAo+IHN0cnVjdCBlcGZfdmhvc3RfcmVnX3F1ZXVlIHsKPiAgICAg ICAgICB1OCBjbWQ7Cj4gICAgICAgICAgdTggY21kX3N0YXR1czsKPiAgICAgICAgICB1MTYgc3Rh dHVzOwo+ICAgICAgICAgIHUxNiBudW1fYnVmZmVyczsKPiAgICAgICAgICB1MTYgbXNpeF92ZWN0 b3I7Cj4gICAgICAgICAgdTY0IHF1ZXVlX2FkZHI7CgoKV2hhdCdzIHRoZSBtZWFuaW5nIG9mIHF1 ZXVlX2FkZHIgaGVyZT8KCkRvZXMgbm90IG1lYW4gdGhlIGRldmljZSBleHBlY3RzIGEgY29udGln dW91cyBtZW1vcnkgZm9yIGF2YWlsL2Rlc2MvdXNlZCAKcmluZz8KCgo+IH0gX19wYWNrZWQ7Cj4K PiBzdHJ1Y3QgZXBmX3Zob3N0X3JlZyB7Cj4gICAgICAgICAgdTY0IGhvc3RfZmVhdHVyZXM7Cj4g ICAgICAgICAgdTY0IGd1ZXN0X2ZlYXR1cmVzOwo+ICAgICAgICAgIHUxNiBtc2l4X2NvbmZpZzsK PiAgICAgICAgICB1MTYgbnVtX3F1ZXVlczsKPiAgICAgICAgICB1OCBkZXZpY2Vfc3RhdHVzOwo+ ICAgICAgICAgIHU4IGNvbmZpZ19nZW5lcmF0aW9uOwo+ICAgICAgICAgIHUzMiBpc3I7Cj4gICAg ICAgICAgdTggY21kOwo+ICAgICAgICAgIHU4IGNtZF9zdGF0dXM7Cj4gICAgICAgICAgc3RydWN0 IGVwZl92aG9zdF9yZWdfcXVldWUgdnFbTUFYX1ZRU107Cj4gfSBfX3BhY2tlZDsKPj4KPj4gK3N0 YXRpYyBpbnQgdmlydGlvX3BjaV9lcGZfc2VuZF9jb21tYW5kKHN0cnVjdCB2aXJ0aW9fcGNpX2Rl dmljZSAqdnBfZGV2LAo+PiArwqDCoMKgIMKgwqDCoCDCoMKgwqAgwqDCoMKgIMKgwqDCoMKgwqDC oCB1MzIgY29tbWFuZCkKPj4gK3sKPj4gK8KgwqDCoCBzdHJ1Y3QgdmlydGlvX3BjaV9lcGYgKnBj aV9lcGY7Cj4+ICvCoMKgwqAgdm9pZCBfX2lvbWVtICppb2FkZHI7Cj4+ICvCoMKgwqAga3RpbWVf dCB0aW1lb3V0Owo+PiArwqDCoMKgIGJvb2wgdGltZWRvdXQ7Cj4+ICvCoMKgwqAgaW50IHJldCA9 IDA7Cj4+ICvCoMKgwqAgdTggc3RhdHVzOwo+PiArCj4+ICvCoMKgwqAgcGNpX2VwZiA9IHRvX3Zp cnRpb19wY2lfZXBmKHZwX2Rldik7Cj4+ICvCoMKgwqAgaW9hZGRyID0gdnBfZGV2LT5pb2FkZHI7 Cj4+ICsKPj4gK8KgwqDCoCBtdXRleF9sb2NrKCZwY2lfZXBmLT5sb2NrKTsKPj4gK8KgwqDCoCB3 cml0ZWIoY29tbWFuZCwgaW9hZGRyICsgSE9TVF9DTUQpOwo+PiArwqDCoMKgIHRpbWVvdXQgPSBr dGltZV9hZGRfbXMoa3RpbWVfZ2V0KCksIENPTU1BTkRfVElNRU9VVCk7Cj4+ICvCoMKgwqAgd2hp bGUgKDEpIHsKPj4gK8KgwqDCoCDCoMKgwqAgdGltZWRvdXQgPSBrdGltZV9hZnRlcihrdGltZV9n ZXQoKSwgdGltZW91dCk7Cj4+ICvCoMKgwqAgwqDCoMKgIHN0YXR1cyA9IHJlYWRiKGlvYWRkciAr IEhPU1RfQ01EX1NUQVRVUyk7Cj4+ICsKPj4KPj4gU2V2ZXJhbCBxdWVzdGlvbnM6Cj4+Cj4+IC0g SXQncyBub3QgY2xlYXIgdG8gbWUgaG93IHRoZSBzeW5jaHJvbml6YXRpb24gaXMgZG9uZSBiZXR3 ZWVuIHRoZSBSQwo+PiBhbmQgRVAuIEUuZyBob3cgYW5kIHdoZW4gdGhlIHZhbHVlIG9mIEhPU1Rf Q01EX1NUQVRVUyBjYW4gYmUgY2hhbmdlZC4KPiBUaGUgSE9TVF9DTUQgKGNvbW1hbmRzIHNlbnQg dG8gdGhlIEVQKSBpcyBzZXJpYWxpemVkIGJ5IHVzaW5nIG11dGV4Lgo+IE9uY2UgdGhlIEVQIHJl YWRzIHRoZSBjb21tYW5kLCBpdCByZXNldHMgdGhlIHZhbHVlIGluIEhPU1RfQ01ELiBTbwo+IEhP U1RfQ01EIGlzIGxlc3MgbGlrZWx5IGFuIGlzc3VlLgoKCkhlcmUncyBteSB1bmRlcnN0YW5kaW5n IG9mIHRoZSBwcm90b2NvbDoKCjEpIFJDIHdyaXRlIHRvIEhPU1RfQ01ECjIpIFJDIHdhaXQgZm9y IEhPU1RfQ01EX1NUQVRVUyB0byBiZSBIT1NUX0NNRF9TVEFUVVNfT0tBWQoKSXQgbG9va3MgdG8g bWUgd2hhdCBFUCBzaG91bGQgZG8gaXMKCjEpIEVQIHJlc2V0IEhPU1RfQ01EIGFmdGVyIHJlYWRp bmcgbmV3IGNvbW1hbmQKCkFuZCBpdCBsb29rcyB0byBtZSBFUCBzaG91bGQgYWxzbyByZXNldCBI T1NUX0NNRF9TVEFUVVMgaGVyZT8KCihJIHRob3VnaHQgdGhlcmUgc2hvdWxkIGJlIHBhdGNoIHRv IGhhbmRsZSBzdHVmZnMgbGlrZSB0aGlzIGJ1dCBJIGRpZG4ndCAKZmluZCBpdCBpbiB0aGlzIHNl cmllcykKCgo+Cj4gQSBzdWZmaWNpZW50bHkgbGFyZ2UgdGltZSBpcyBnaXZlbiBmb3IgdGhlIEVQ IHRvIGNvbXBsZXRlIGl0J3Mgb3BlcmF0aW9uCj4gKDEgU2VjKSB3aGVyZSB0aGUgRVAgcHJvdmlk ZXMgdGhlIHN0YXR1cyBpbiBIT1NUX0NNRF9TVEFUVVMuIEFmdGVyIGl0Cj4gZXhwaXJlcywgSE9T VF9DTURfU1RBVFVTX05PTkUgaXMgd3JpdHRlbiB0byBIT1NUX0NNRF9TVEFUVVMuIFRoZXJlIGNv dWxkCj4gYmUgY2FzZSB3aGVyZSBFUCB1cGRhdGVzIEhPU1RfQ01EX1NUQVRVUyBhZnRlciBSQyB3 cml0ZXMKPiBIT1NUX0NNRF9TVEFUVVNfTk9ORSwgYnV0IGJ5IHRoZW4gSE9TVCBoYXMgYWxyZWFk eSBkZXRlY3RlZCB0aGlzIGFzCj4gZmFpbHVyZSBhbmQgZXJyb3ItZWQgb3V0Lgo+ICAgCj4+IElm IHlvdSBzdGlsbCB3YW50IHRvIGludHJvZHVjZSBhIG5ldyB0cmFuc3BvcnQsIGEgdmlydGlvIHNw ZWMgcGF0Y2gKPj4gd291bGQgYmUgaGVscGZ1bCBmb3IgdXMgdG8gdW5kZXJzdGFuZCB0aGUgZGV2 aWNlIEFQSS4KPiBPa2F5LCB0aGF0IHNob3VsZCBiZSBvbiBodHRwczovL2dpdGh1Yi5jb20vb2Fz aXMtdGNzL3ZpcnRpby1zcGVjLmdpdD8KCgpZZXMuCgoKPj4gLSBZb3UgaGF2ZSB5b3UgdmVuZG9y IHNwZWNpZmljIGxheW91dCAoYWNjb3JkaW5nIHRvCj4+IHZpcnRpb19wY2lfZXBiX3RhYmxlKCkp LCBzbyBJIGd1ZXNzIHlvdSBpdCdzIGJldHRlciB0byBoYXZlIGEgdmVuZG9yCj4+IHNwZWNpZmlj IHZEUEEgZHJpdmVyIGluc3RlYWQKPiBPa2F5LCB3aXRoIHZEUEEsIHdlIGFyZSBmcmVlIHRvIGRl ZmluZSBvdXIgb3duIGxheW91dHMuCgoKUmlnaHQsIGJ1dCB2RFBBIGhhdmUgb3RoZXIgcmVxdWly ZW1lbnRzLiBFLmcgaXQgcmVxdWlyZXMgdGhlIGRldmljZSBoYXZlIAp0aGUgYWJpbGl0eSB0byBz YXZlL3Jlc3RvcmUgdGhlIHN0YXRlIChlLmcgdGhlIGxhc3RfYXZhaWxfaWR4KS4KClNvIGl0IGFj dHVhbGx5IGRlcGVuZHMgb24gd2hhdCB5b3Ugd2FudC4gSWYgeW91IGRvbid0IGNhcmUgYWJvdXQg CnVzZXJzcGFjZSBkcml2ZXJzIGFuZCB3YW50IHRvIGhhdmUgYSBzdGFuZGFyZCB0cmFuc3BvcnQs IHlvdSBjYW4gc3RpbGwgCmdvIHZpcnRpby4KCgo+PiAtIFRoZSBhZHZhbnRhZ2Ugb2YgdmVuZG9y IHNwZWNpZmljIHZEUEEgZHJpdmVyIGlzIHRoYXQgaXQgY2FuIDEpIGhhdmUKPj4gbGVzcyBjb2Rl cyAyKSBzdXBwb3J0IHVzZXJzcGFjZSBkcml2ZXJzIHRocm91Z2ggdmhvc3QtdkRQQSAoaW5zdGVh ZCBvZgo+PiBpbnZlbnRpbmcgbmV3IEFQSXMgc2luY2Ugd2UgY2FuJ3QgdXNlIHZmaW8tcGNpIGhl cmUpLgo+IEkgc2VlIHRoZXJlJ3MgYW4gYWRkaXRpb25hbCBsZXZlbCBvZiBpbmRpcmVjdGlvbiBm cm9tIHZpcnRpbyB0byB2RFBBIGFuZAo+IHByb2JhYmx5IG5vIG5lZWQgZm9yIHNwZWMgdXBkYXRl IGJ1dCBkb24ndCBleGFjdGx5IHNlZSBob3cgaXQnbGwgcmVkdWNlCj4gY29kZS4KCgpBRkFJSyB5 b3UgZG9uJ3QgbmVlZCB0byBpbXBsZW1lbnQgeW91ciBvd24gc2V0dXBfdnEgYW5kIGRlbF92cS4K Cgo+Cj4gRm9yIDIsIElzbid0IHZob3N0LXZkcGEgc3VwcG9zZWQgdG8gcnVuIG9uIHZpcnRpbyBi YWNrZW5kPwoKCk5vdCBjdXJyZW50bHksIHZEUEEgaXMgYSBzdXBlcnNldCBvZiB2aXJ0aW8gKGUu ZyBpdCBzdXBwb3J0IHZpcnRxdWV1ZSAKc3RhdGUgc2F2ZS9yZXN0b3JlKS4gVGhpcyBpdCBzaG91 bGQgYmUgcG9zc2libGUgaW4gdGhlIGZ1dHVyZSBwcm9iYWJseS4KCgo+Cj4gIEZyb20gYSBoaWdo IGxldmVsLCBJIHRoaW5rIEkgc2hvdWxkIGJlIGFibGUgdG8gdXNlIHZEUEEgZm9yCj4gdmlydGlv X3BjaV9lcGYuYy4gV291bGQgeW91IGFsc28gc3VnZ2VzdCB1c2luZyB2RFBBIGZvciBudGJfdmly dGlvLmM/Cj4gKFtSRkMgUEFUQ0ggMjAvMjJdIE5UQjogQWRkIGEgbmV3IE5UQiBjbGllbnQgZHJp dmVyIHRvIGltcGxlbWVudCBWSVJUSU8KPiBmdW5jdGlvbmFsaXR5KS4KCgpJIHRoaW5rIGl0J3Mg eW91ciBjYWxsLiBJZiB5b3Ugd2FudAoKMSkgYSB3ZWxsLWRlZmluZWQgc3RhbmRhcmQgdmlydGlv IHRyYW5zcG9ydAoyKSB3aWxsaW5nIHRvIGZpbmFsaXplIGQgYW5kIG1haW50YWluIHRoZSBzcGVj CjMpIGRvZXNuJ3QgY2FyZSBhYm91dCB1c2Vyc3BhY2UgZHJpdmVycwoKWW91IGNhbiBnbyB3aXRo IHZpcnRpbywgb3RoZXJ3aXNlIHZEUEEuCgpUaGFua3MKCgo+Cj4gVGhhbmtzCj4gS2lzaG9uCj4K Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClZpcnR1YWxp emF0aW9uIG1haWxpbmcgbGlzdApWaXJ0dWFsaXphdGlvbkBsaXN0cy5saW51eC1mb3VuZGF0aW9u Lm9yZwpodHRwczovL2xpc3RzLmxpbnV4Zm91bmRhdGlvbi5vcmcvbWFpbG1hbi9saXN0aW5mby92 aXJ0dWFsaXphdGlvbg==