From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jason Wang Subject: [PATCH V10 1/6] mdev: class id support Date: Wed, 6 Nov 2019 21:35:26 +0800 Message-ID: <20191106133531.693-2-jasowang@redhat.com> References: <20191106133531.693-1-jasowang@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset=WINDOWS-1252 Content-Transfer-Encoding: quoted-printable Return-path: In-Reply-To: <20191106133531.693-1-jasowang@redhat.com> Sender: linux-kernel-owner@vger.kernel.org To: kvm@vger.kernel.org, linux-s390@vger.kernel.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, intel-gfx@lists.freedesktop.org, intel-gvt-dev@lists.freedesktop.org, kwankhede@nvidia.com, alex.williamson@redhat.com, mst@redhat.com, tiwei.bie@intel.com Cc: virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, cohuck@redhat.com, maxime.coquelin@redhat.com, cunming.liang@intel.com, zhihong.wang@intel.com, rob.miller@broadcom.com, xiao.w.wang@intel.com, haotian.wang@sifive.com, zhenyuw@linux.intel.com, zhi.a.wang@intel.com, jani.nikula@linux.intel.com, joonas.lahtinen@linux.intel.com, rodrigo.vivi@intel.com, airlied@linux.ie, daniel@ffwll.ch, farman@linux.ibm.com, pasic@linux.ibm.com, sebott@linux.ibm.com, oberpar@linux.ibm.com, heiko.carstens@de.ibm.com, gor@linux.ibm.com, borntraeger@de.ibm.com, akrowiak@linux.ibm.com, freude@linux.ibm.com, lingshan.zhu@intel.com, idos@mellanox.com, eperezma@redhat.com, lulu@redhat.com, parav@mellanox.com, christophe.de.dinechin@gmail.com, kevin.tian@intel.com, stefanha@redhat.com List-Id: intel-gfx@lists.freedesktop.org Mdev bus only supports vfio driver right now, so it doesn't implement match method. But in the future, we may add drivers other than vfio, the first driver could be virtio-mdev. This means we need to add device class id support in bus match method to pair the mdev device and mdev driver correctly. So this patch adds id_table to mdev_driver and class_id for mdev device with the match method for mdev bus. Reviewed-by: Parav Pandit Reviewed-by: Cornelia Huck Signed-off-by: Jason Wang --- .../driver-api/vfio-mediated-device.rst | 5 ++++ drivers/gpu/drm/i915/gvt/kvmgt.c | 1 + drivers/s390/cio/vfio_ccw_ops.c | 1 + drivers/s390/crypto/vfio_ap_ops.c | 1 + drivers/vfio/mdev/mdev_core.c | 17 +++++++++++++ drivers/vfio/mdev/mdev_driver.c | 25 +++++++++++++++++++ drivers/vfio/mdev/mdev_private.h | 1 + drivers/vfio/mdev/vfio_mdev.c | 6 +++++ include/linux/mdev.h | 8 ++++++ include/linux/mod_devicetable.h | 8 ++++++ samples/vfio-mdev/mbochs.c | 1 + samples/vfio-mdev/mdpy.c | 1 + samples/vfio-mdev/mtty.c | 1 + 13 files changed, 76 insertions(+) diff --git a/Documentation/driver-api/vfio-mediated-device.rst b/Documentat= ion/driver-api/vfio-mediated-device.rst index 25eb7d5b834b..6709413bee29 100644 --- a/Documentation/driver-api/vfio-mediated-device.rst +++ b/Documentation/driver-api/vfio-mediated-device.rst @@ -102,12 +102,14 @@ structure to represent a mediated device's driver:: * @probe: called when new device created * @remove: called when device removed * @driver: device driver structure + * @id_table: the ids serviced by this driver */ struct mdev_driver { =09 const char *name; =09 int (*probe) (struct device *dev); =09 void (*remove) (struct device *dev); =09 struct device_driver driver; +=09 const struct mdev_class_id *id_table; }; =20 A mediated bus driver for mdev should use this structure in the function c= alls @@ -170,6 +172,9 @@ that a driver should use to unregister itself with the = mdev core driver:: =20 =09extern void mdev_unregister_device(struct device *dev); =20 +It is also required to specify the class_id in create() callback through:: + +=09int mdev_set_class(struct mdev_device *mdev, u16 id); =20 Mediated Device Management Interface Through sysfs =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D diff --git a/drivers/gpu/drm/i915/gvt/kvmgt.c b/drivers/gpu/drm/i915/gvt/kv= mgt.c index 343d79c1cb7e..6420f0dbd31b 100644 --- a/drivers/gpu/drm/i915/gvt/kvmgt.c +++ b/drivers/gpu/drm/i915/gvt/kvmgt.c @@ -678,6 +678,7 @@ static int intel_vgpu_create(struct kobject *kobj, stru= ct mdev_device *mdev) =09=09 dev_name(mdev_dev(mdev))); =09ret =3D 0; =20 +=09mdev_set_class(mdev, MDEV_CLASS_ID_VFIO); out: =09return ret; } diff --git a/drivers/s390/cio/vfio_ccw_ops.c b/drivers/s390/cio/vfio_ccw_op= s.c index f0d71ab77c50..cf2c013ae32f 100644 --- a/drivers/s390/cio/vfio_ccw_ops.c +++ b/drivers/s390/cio/vfio_ccw_ops.c @@ -129,6 +129,7 @@ static int vfio_ccw_mdev_create(struct kobject *kobj, s= truct mdev_device *mdev) =09=09=09 private->sch->schid.ssid, =09=09=09 private->sch->schid.sch_no); =20 +=09mdev_set_class(mdev, MDEV_CLASS_ID_VFIO); =09return 0; } =20 diff --git a/drivers/s390/crypto/vfio_ap_ops.c b/drivers/s390/crypto/vfio_a= p_ops.c index 5c0f53c6dde7..07c31070afeb 100644 --- a/drivers/s390/crypto/vfio_ap_ops.c +++ b/drivers/s390/crypto/vfio_ap_ops.c @@ -343,6 +343,7 @@ static int vfio_ap_mdev_create(struct kobject *kobj, st= ruct mdev_device *mdev) =09list_add(&matrix_mdev->node, &matrix_dev->mdev_list); =09mutex_unlock(&matrix_dev->lock); =20 +=09mdev_set_class(mdev, MDEV_CLASS_ID_VFIO); =09return 0; } =20 diff --git a/drivers/vfio/mdev/mdev_core.c b/drivers/vfio/mdev/mdev_core.c index b558d4cfd082..7bfa2e46e829 100644 --- a/drivers/vfio/mdev/mdev_core.c +++ b/drivers/vfio/mdev/mdev_core.c @@ -45,6 +45,17 @@ void mdev_set_drvdata(struct mdev_device *mdev, void *da= ta) } EXPORT_SYMBOL(mdev_set_drvdata); =20 +/* + * Specify the class for the mdev device, this must be called during + * create() callback. + */ +void mdev_set_class(struct mdev_device *mdev, u16 id) +{ +=09WARN_ON(mdev->class_id); +=09mdev->class_id =3D id; +} +EXPORT_SYMBOL(mdev_set_class); + struct device *mdev_dev(struct mdev_device *mdev) { =09return &mdev->dev; @@ -324,6 +335,12 @@ int mdev_device_create(struct kobject *kobj, =09if (ret) =09=09goto ops_create_fail; =20 +=09if (!mdev->class_id) { +=09=09ret =3D -EINVAL; +=09=09dev_warn(dev, "mdev vendor driver failed to specify device class\n")= ; +=09=09goto add_fail; +=09} + =09ret =3D device_add(&mdev->dev); =09if (ret) =09=09goto add_fail; diff --git a/drivers/vfio/mdev/mdev_driver.c b/drivers/vfio/mdev/mdev_drive= r.c index 0d3223aee20b..ed06433693e8 100644 --- a/drivers/vfio/mdev/mdev_driver.c +++ b/drivers/vfio/mdev/mdev_driver.c @@ -69,8 +69,33 @@ static int mdev_remove(struct device *dev) =09return 0; } =20 +static int mdev_match(struct device *dev, struct device_driver *drv) +{ +=09unsigned int i; +=09struct mdev_device *mdev =3D to_mdev_device(dev); +=09struct mdev_driver *mdrv =3D to_mdev_driver(drv); +=09const struct mdev_class_id *ids =3D mdrv->id_table; + +=09if (!ids) +=09=09return 0; + +=09for (i =3D 0; ids[i].id; i++) +=09=09if (ids[i].id =3D=3D mdev->class_id) +=09=09=09return 1; +=09return 0; +} + +static int mdev_uevent(struct device *dev, struct kobj_uevent_env *env) +{ +=09struct mdev_device *mdev =3D to_mdev_device(dev); + +=09return add_uevent_var(env, "MODALIAS=3Dmdev:c%02X", mdev->class_id); +} + struct bus_type mdev_bus_type =3D { =09.name=09=09=3D "mdev", +=09.match=09=09=3D mdev_match, +=09.uevent=09=09=3D mdev_uevent, =09.probe=09=09=3D mdev_probe, =09.remove=09=09=3D mdev_remove, }; diff --git a/drivers/vfio/mdev/mdev_private.h b/drivers/vfio/mdev/mdev_priv= ate.h index 7d922950caaf..c65f436c1869 100644 --- a/drivers/vfio/mdev/mdev_private.h +++ b/drivers/vfio/mdev/mdev_private.h @@ -33,6 +33,7 @@ struct mdev_device { =09struct kobject *type_kobj; =09struct device *iommu_device; =09bool active; +=09u16 class_id; }; =20 #define to_mdev_device(dev)=09container_of(dev, struct mdev_device, dev) diff --git a/drivers/vfio/mdev/vfio_mdev.c b/drivers/vfio/mdev/vfio_mdev.c index 30964a4e0a28..38431e9ef7f5 100644 --- a/drivers/vfio/mdev/vfio_mdev.c +++ b/drivers/vfio/mdev/vfio_mdev.c @@ -120,10 +120,16 @@ static void vfio_mdev_remove(struct device *dev) =09vfio_del_group_dev(dev); } =20 +static const struct mdev_class_id vfio_id_table[] =3D { +=09{ MDEV_CLASS_ID_VFIO }, +=09{ 0 }, +}; + static struct mdev_driver vfio_mdev_driver =3D { =09.name=09=3D "vfio_mdev", =09.probe=09=3D vfio_mdev_probe, =09.remove=09=3D vfio_mdev_remove, +=09.id_table =3D vfio_id_table, }; =20 static int __init vfio_mdev_init(void) diff --git a/include/linux/mdev.h b/include/linux/mdev.h index 0ce30ca78db0..78b69d09eb54 100644 --- a/include/linux/mdev.h +++ b/include/linux/mdev.h @@ -118,6 +118,7 @@ struct mdev_type_attribute mdev_type_attr_##_name =3D= =09=09\ * @probe: called when new device created * @remove: called when device removed * @driver: device driver structure + * @id_table: the ids serviced by this driver * **/ struct mdev_driver { @@ -125,6 +126,7 @@ struct mdev_driver { =09int (*probe)(struct device *dev); =09void (*remove)(struct device *dev); =09struct device_driver driver; +=09const struct mdev_class_id *id_table; }; =20 #define to_mdev_driver(drv)=09container_of(drv, struct mdev_driver, driver= ) @@ -132,6 +134,7 @@ struct mdev_driver { void *mdev_get_drvdata(struct mdev_device *mdev); void mdev_set_drvdata(struct mdev_device *mdev, void *data); const guid_t *mdev_uuid(struct mdev_device *mdev); +void mdev_set_class(struct mdev_device *mdev, u16 id); =20 extern struct bus_type mdev_bus_type; =20 @@ -145,4 +148,9 @@ struct device *mdev_parent_dev(struct mdev_device *mdev= ); struct device *mdev_dev(struct mdev_device *mdev); struct mdev_device *mdev_from_dev(struct device *dev); =20 +enum { +=09MDEV_CLASS_ID_VFIO =3D 1, +=09/* New entries must be added here */ +}; + #endif /* MDEV_H */ diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetabl= e.h index 5714fd35a83c..f32c6e44fb1a 100644 --- a/include/linux/mod_devicetable.h +++ b/include/linux/mod_devicetable.h @@ -821,4 +821,12 @@ struct wmi_device_id { =09const void *context; }; =20 +/** + * struct mdev_class_id - MDEV device class identifier + * @id: Used to identify a specific class of device, e.g vfio-mdev device. + */ +struct mdev_class_id { +=09__u16 id; +}; + #endif /* LINUX_MOD_DEVICETABLE_H */ diff --git a/samples/vfio-mdev/mbochs.c b/samples/vfio-mdev/mbochs.c index ac5c8c17b1ff..115bc5074656 100644 --- a/samples/vfio-mdev/mbochs.c +++ b/samples/vfio-mdev/mbochs.c @@ -561,6 +561,7 @@ static int mbochs_create(struct kobject *kobj, struct m= dev_device *mdev) =09mbochs_reset(mdev); =20 =09mbochs_used_mbytes +=3D type->mbytes; +=09mdev_set_class(mdev, MDEV_CLASS_ID_VFIO); =09return 0; =20 err_mem: diff --git a/samples/vfio-mdev/mdpy.c b/samples/vfio-mdev/mdpy.c index cc86bf6566e4..665614574d50 100644 --- a/samples/vfio-mdev/mdpy.c +++ b/samples/vfio-mdev/mdpy.c @@ -269,6 +269,7 @@ static int mdpy_create(struct kobject *kobj, struct mde= v_device *mdev) =09mdpy_reset(mdev); =20 =09mdpy_count++; +=09mdev_set_class(mdev, MDEV_CLASS_ID_VFIO); =09return 0; } =20 diff --git a/samples/vfio-mdev/mtty.c b/samples/vfio-mdev/mtty.c index ce84a300a4da..90da12ff7fd9 100644 --- a/samples/vfio-mdev/mtty.c +++ b/samples/vfio-mdev/mtty.c @@ -755,6 +755,7 @@ static int mtty_create(struct kobject *kobj, struct mde= v_device *mdev) =09list_add(&mdev_state->next, &mdev_devices_list); =09mutex_unlock(&mdev_list_lock); =20 +=09mdev_set_class(mdev, MDEV_CLASS_ID_VFIO); =09return 0; } =20 --=20 2.19.1 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS 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 3621BC5DF62 for ; Wed, 6 Nov 2019 13:38:32 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (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 0DABE2166E for ; Wed, 6 Nov 2019 13:38:32 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 0DABE2166E Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=intel-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id B3C396E1ED; Wed, 6 Nov 2019 13:38:31 +0000 (UTC) Received: from us-smtp-1.mimecast.com (us-smtp-delivery-1.mimecast.com [205.139.110.120]) by gabe.freedesktop.org (Postfix) with ESMTPS id 851866E23B for ; Wed, 6 Nov 2019 13:38:30 +0000 (UTC) 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-50-aftLk9sJMIW6mxYuK06UeQ-1; Wed, 06 Nov 2019 08:38:26 -0500 Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 1CEB81005500; Wed, 6 Nov 2019 13:38:22 +0000 (UTC) Received: from jason-ThinkPad-X1-Carbon-6th.redhat.com (ovpn-12-193.pek2.redhat.com [10.72.12.193]) by smtp.corp.redhat.com (Postfix) with ESMTP id A3E6E393B; Wed, 6 Nov 2019 13:37:23 +0000 (UTC) From: Jason Wang To: kvm@vger.kernel.org, linux-s390@vger.kernel.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, intel-gfx@lists.freedesktop.org, intel-gvt-dev@lists.freedesktop.org, kwankhede@nvidia.com, alex.williamson@redhat.com, mst@redhat.com, tiwei.bie@intel.com Date: Wed, 6 Nov 2019 21:35:26 +0800 Message-Id: <20191106133531.693-2-jasowang@redhat.com> In-Reply-To: <20191106133531.693-1-jasowang@redhat.com> References: <20191106133531.693-1-jasowang@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-MC-Unique: aftLk9sJMIW6mxYuK06UeQ-1 X-Mimecast-Spam-Score: 0 X-Mailman-Original-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1573047509; 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=ZjglcjJdfJ+rYNda606bWPhtmSxvctdSzvRhdUvjVro=; b=aLI3n57wLFJ7tLZvLD4ie3gqiwpkM7BX3O+hWxen4jPeLGLFhGIJABJJriA4wBmdwfJDZC h2tIiKpHdAqCZ0bemXNCr/nt2XWsEUFmGVGMKXp2LTa+cussOCdjg6ZNVf7/r51QM+hTRF QF48/MBLNkI5U4pSBnCRLO84CXf4Hmk= Subject: [Intel-gfx] [PATCH V10 1/6] mdev: class id support X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: christophe.de.dinechin@gmail.com, sebott@linux.ibm.com, airlied@linux.ie, Jason Wang , heiko.carstens@de.ibm.com, virtualization@lists.linux-foundation.org, rob.miller@broadcom.com, lulu@redhat.com, eperezma@redhat.com, pasic@linux.ibm.com, borntraeger@de.ibm.com, haotian.wang@sifive.com, farman@linux.ibm.com, idos@mellanox.com, gor@linux.ibm.com, cunming.liang@intel.com, xiao.w.wang@intel.com, freude@linux.ibm.com, parav@mellanox.com, zhihong.wang@intel.com, stefanha@redhat.com, akrowiak@linux.ibm.com, netdev@vger.kernel.org, cohuck@redhat.com, oberpar@linux.ibm.com, maxime.coquelin@redhat.com, lingshan.zhu@intel.com Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" Message-ID: <20191106133526.MaQbR8h4I1us5JWMTE60UqjdRy8Q6G2z7uJcibFvWoI@z> TWRldiBidXMgb25seSBzdXBwb3J0cyB2ZmlvIGRyaXZlciByaWdodCBub3csIHNvIGl0IGRvZXNu J3QgaW1wbGVtZW50Cm1hdGNoIG1ldGhvZC4gQnV0IGluIHRoZSBmdXR1cmUsIHdlIG1heSBhZGQg ZHJpdmVycyBvdGhlciB0aGFuIHZmaW8sCnRoZSBmaXJzdCBkcml2ZXIgY291bGQgYmUgdmlydGlv LW1kZXYuIFRoaXMgbWVhbnMgd2UgbmVlZCB0byBhZGQKZGV2aWNlIGNsYXNzIGlkIHN1cHBvcnQg aW4gYnVzIG1hdGNoIG1ldGhvZCB0byBwYWlyIHRoZSBtZGV2IGRldmljZQphbmQgbWRldiBkcml2 ZXIgY29ycmVjdGx5LgoKU28gdGhpcyBwYXRjaCBhZGRzIGlkX3RhYmxlIHRvIG1kZXZfZHJpdmVy IGFuZCBjbGFzc19pZCBmb3IgbWRldgpkZXZpY2Ugd2l0aCB0aGUgbWF0Y2ggbWV0aG9kIGZvciBt ZGV2IGJ1cy4KClJldmlld2VkLWJ5OiBQYXJhdiBQYW5kaXQgPHBhcmF2QG1lbGxhbm94LmNvbT4K UmV2aWV3ZWQtYnk6IENvcm5lbGlhIEh1Y2sgPGNvaHVja0ByZWRoYXQuY29tPgpTaWduZWQtb2Zm LWJ5OiBKYXNvbiBXYW5nIDxqYXNvd2FuZ0ByZWRoYXQuY29tPgotLS0KIC4uLi9kcml2ZXItYXBp L3ZmaW8tbWVkaWF0ZWQtZGV2aWNlLnJzdCAgICAgICB8ICA1ICsrKysKIGRyaXZlcnMvZ3B1L2Ry bS9pOTE1L2d2dC9rdm1ndC5jICAgICAgICAgICAgICB8ICAxICsKIGRyaXZlcnMvczM5MC9jaW8v dmZpb19jY3dfb3BzLmMgICAgICAgICAgICAgICB8ICAxICsKIGRyaXZlcnMvczM5MC9jcnlwdG8v dmZpb19hcF9vcHMuYyAgICAgICAgICAgICB8ICAxICsKIGRyaXZlcnMvdmZpby9tZGV2L21kZXZf Y29yZS5jICAgICAgICAgICAgICAgICB8IDE3ICsrKysrKysrKysrKysKIGRyaXZlcnMvdmZpby9t ZGV2L21kZXZfZHJpdmVyLmMgICAgICAgICAgICAgICB8IDI1ICsrKysrKysrKysrKysrKysrKysK IGRyaXZlcnMvdmZpby9tZGV2L21kZXZfcHJpdmF0ZS5oICAgICAgICAgICAgICB8ICAxICsKIGRy aXZlcnMvdmZpby9tZGV2L3ZmaW9fbWRldi5jICAgICAgICAgICAgICAgICB8ICA2ICsrKysrCiBp bmNsdWRlL2xpbnV4L21kZXYuaCAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgOCArKysrKysK IGluY2x1ZGUvbGludXgvbW9kX2RldmljZXRhYmxlLmggICAgICAgICAgICAgICB8ICA4ICsrKysr Kwogc2FtcGxlcy92ZmlvLW1kZXYvbWJvY2hzLmMgICAgICAgICAgICAgICAgICAgIHwgIDEgKwog c2FtcGxlcy92ZmlvLW1kZXYvbWRweS5jICAgICAgICAgICAgICAgICAgICAgIHwgIDEgKwogc2Ft cGxlcy92ZmlvLW1kZXYvbXR0eS5jICAgICAgICAgICAgICAgICAgICAgIHwgIDEgKwogMTMgZmls ZXMgY2hhbmdlZCwgNzYgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24v ZHJpdmVyLWFwaS92ZmlvLW1lZGlhdGVkLWRldmljZS5yc3QgYi9Eb2N1bWVudGF0aW9uL2RyaXZl ci1hcGkvdmZpby1tZWRpYXRlZC1kZXZpY2UucnN0CmluZGV4IDI1ZWI3ZDViODM0Yi4uNjcwOTQx M2JlZTI5IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvdmZpby1tZWRpYXRl ZC1kZXZpY2UucnN0CisrKyBiL0RvY3VtZW50YXRpb24vZHJpdmVyLWFwaS92ZmlvLW1lZGlhdGVk LWRldmljZS5yc3QKQEAgLTEwMiwxMiArMTAyLDE0IEBAIHN0cnVjdHVyZSB0byByZXByZXNlbnQg YSBtZWRpYXRlZCBkZXZpY2UncyBkcml2ZXI6OgogICAgICAgKiBAcHJvYmU6IGNhbGxlZCB3aGVu IG5ldyBkZXZpY2UgY3JlYXRlZAogICAgICAgKiBAcmVtb3ZlOiBjYWxsZWQgd2hlbiBkZXZpY2Ug cmVtb3ZlZAogICAgICAgKiBAZHJpdmVyOiBkZXZpY2UgZHJpdmVyIHN0cnVjdHVyZQorICAgICAg KiBAaWRfdGFibGU6IHRoZSBpZHMgc2VydmljZWQgYnkgdGhpcyBkcml2ZXIKICAgICAgICovCiAg ICAgIHN0cnVjdCBtZGV2X2RyaXZlciB7CiAJICAgICBjb25zdCBjaGFyICpuYW1lOwogCSAgICAg aW50ICAoKnByb2JlKSAgKHN0cnVjdCBkZXZpY2UgKmRldik7CiAJICAgICB2b2lkICgqcmVtb3Zl KSAoc3RydWN0IGRldmljZSAqZGV2KTsKIAkgICAgIHN0cnVjdCBkZXZpY2VfZHJpdmVyICAgIGRy aXZlcjsKKwkgICAgIGNvbnN0IHN0cnVjdCBtZGV2X2NsYXNzX2lkICppZF90YWJsZTsKICAgICAg fTsKIAogQSBtZWRpYXRlZCBidXMgZHJpdmVyIGZvciBtZGV2IHNob3VsZCB1c2UgdGhpcyBzdHJ1 Y3R1cmUgaW4gdGhlIGZ1bmN0aW9uIGNhbGxzCkBAIC0xNzAsNiArMTcyLDkgQEAgdGhhdCBhIGRy aXZlciBzaG91bGQgdXNlIHRvIHVucmVnaXN0ZXIgaXRzZWxmIHdpdGggdGhlIG1kZXYgY29yZSBk cml2ZXI6OgogCiAJZXh0ZXJuIHZvaWQgbWRldl91bnJlZ2lzdGVyX2RldmljZShzdHJ1Y3QgZGV2 aWNlICpkZXYpOwogCitJdCBpcyBhbHNvIHJlcXVpcmVkIHRvIHNwZWNpZnkgdGhlIGNsYXNzX2lk IGluIGNyZWF0ZSgpIGNhbGxiYWNrIHRocm91Z2g6OgorCisJaW50IG1kZXZfc2V0X2NsYXNzKHN0 cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdTE2IGlkKTsKIAogTWVkaWF0ZWQgRGV2aWNlIE1hbmFn ZW1lbnQgSW50ZXJmYWNlIFRocm91Z2ggc3lzZnMKID09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkx NS9ndnQva3ZtZ3QuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d2dC9rdm1ndC5jCmluZGV4IDM0 M2Q3OWMxY2I3ZS4uNjQyMGYwZGJkMzFiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkx NS9ndnQva3ZtZ3QuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndnQva3ZtZ3QuYwpAQCAt Njc4LDYgKzY3OCw3IEBAIHN0YXRpYyBpbnQgaW50ZWxfdmdwdV9jcmVhdGUoc3RydWN0IGtvYmpl Y3QgKmtvYmosIHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKIAkJICAgICBkZXZfbmFtZShtZGV2 X2RldihtZGV2KSkpOwogCXJldCA9IDA7CiAKKwltZGV2X3NldF9jbGFzcyhtZGV2LCBNREVWX0NM QVNTX0lEX1ZGSU8pOwogb3V0OgogCXJldHVybiByZXQ7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJz L3MzOTAvY2lvL3ZmaW9fY2N3X29wcy5jIGIvZHJpdmVycy9zMzkwL2Npby92ZmlvX2Njd19vcHMu YwppbmRleCBmMGQ3MWFiNzdjNTAuLmNmMmMwMTNhZTMyZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9z MzkwL2Npby92ZmlvX2Njd19vcHMuYworKysgYi9kcml2ZXJzL3MzOTAvY2lvL3ZmaW9fY2N3X29w cy5jCkBAIC0xMjksNiArMTI5LDcgQEAgc3RhdGljIGludCB2ZmlvX2Njd19tZGV2X2NyZWF0ZShz dHJ1Y3Qga29iamVjdCAqa29iaiwgc3RydWN0IG1kZXZfZGV2aWNlICptZGV2KQogCQkJICAgcHJp dmF0ZS0+c2NoLT5zY2hpZC5zc2lkLAogCQkJICAgcHJpdmF0ZS0+c2NoLT5zY2hpZC5zY2hfbm8p OwogCisJbWRldl9zZXRfY2xhc3MobWRldiwgTURFVl9DTEFTU19JRF9WRklPKTsKIAlyZXR1cm4g MDsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zMzkwL2NyeXB0by92ZmlvX2FwX29wcy5jIGIv ZHJpdmVycy9zMzkwL2NyeXB0by92ZmlvX2FwX29wcy5jCmluZGV4IDVjMGY1M2M2ZGRlNy4uMDdj MzEwNzBhZmViIDEwMDY0NAotLS0gYS9kcml2ZXJzL3MzOTAvY3J5cHRvL3ZmaW9fYXBfb3BzLmMK KysrIGIvZHJpdmVycy9zMzkwL2NyeXB0by92ZmlvX2FwX29wcy5jCkBAIC0zNDMsNiArMzQzLDcg QEAgc3RhdGljIGludCB2ZmlvX2FwX21kZXZfY3JlYXRlKHN0cnVjdCBrb2JqZWN0ICprb2JqLCBz dHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYpCiAJbGlzdF9hZGQoJm1hdHJpeF9tZGV2LT5ub2RlLCAm bWF0cml4X2Rldi0+bWRldl9saXN0KTsKIAltdXRleF91bmxvY2soJm1hdHJpeF9kZXYtPmxvY2sp OwogCisJbWRldl9zZXRfY2xhc3MobWRldiwgTURFVl9DTEFTU19JRF9WRklPKTsKIAlyZXR1cm4g MDsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy92ZmlvL21kZXYvbWRldl9jb3JlLmMgYi9kcml2 ZXJzL3ZmaW8vbWRldi9tZGV2X2NvcmUuYwppbmRleCBiNTU4ZDRjZmQwODIuLjdiZmEyZTQ2ZTgy OSAxMDA2NDQKLS0tIGEvZHJpdmVycy92ZmlvL21kZXYvbWRldl9jb3JlLmMKKysrIGIvZHJpdmVy cy92ZmlvL21kZXYvbWRldl9jb3JlLmMKQEAgLTQ1LDYgKzQ1LDE3IEBAIHZvaWQgbWRldl9zZXRf ZHJ2ZGF0YShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsIHZvaWQgKmRhdGEpCiB9CiBFWFBPUlRf U1lNQk9MKG1kZXZfc2V0X2RydmRhdGEpOwogCisvKgorICogU3BlY2lmeSB0aGUgY2xhc3MgZm9y IHRoZSBtZGV2IGRldmljZSwgdGhpcyBtdXN0IGJlIGNhbGxlZCBkdXJpbmcKKyAqIGNyZWF0ZSgp IGNhbGxiYWNrLgorICovCit2b2lkIG1kZXZfc2V0X2NsYXNzKHN0cnVjdCBtZGV2X2RldmljZSAq bWRldiwgdTE2IGlkKQoreworCVdBUk5fT04obWRldi0+Y2xhc3NfaWQpOworCW1kZXYtPmNsYXNz X2lkID0gaWQ7Cit9CitFWFBPUlRfU1lNQk9MKG1kZXZfc2V0X2NsYXNzKTsKKwogc3RydWN0IGRl dmljZSAqbWRldl9kZXYoc3RydWN0IG1kZXZfZGV2aWNlICptZGV2KQogewogCXJldHVybiAmbWRl di0+ZGV2OwpAQCAtMzI0LDYgKzMzNSwxMiBAQCBpbnQgbWRldl9kZXZpY2VfY3JlYXRlKHN0cnVj dCBrb2JqZWN0ICprb2JqLAogCWlmIChyZXQpCiAJCWdvdG8gb3BzX2NyZWF0ZV9mYWlsOwogCisJ aWYgKCFtZGV2LT5jbGFzc19pZCkgeworCQlyZXQgPSAtRUlOVkFMOworCQlkZXZfd2FybihkZXYs ICJtZGV2IHZlbmRvciBkcml2ZXIgZmFpbGVkIHRvIHNwZWNpZnkgZGV2aWNlIGNsYXNzXG4iKTsK KwkJZ290byBhZGRfZmFpbDsKKwl9CisKIAlyZXQgPSBkZXZpY2VfYWRkKCZtZGV2LT5kZXYpOwog CWlmIChyZXQpCiAJCWdvdG8gYWRkX2ZhaWw7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZmaW8vbWRl di9tZGV2X2RyaXZlci5jIGIvZHJpdmVycy92ZmlvL21kZXYvbWRldl9kcml2ZXIuYwppbmRleCAw ZDMyMjNhZWUyMGIuLmVkMDY0MzM2OTNlOCAxMDA2NDQKLS0tIGEvZHJpdmVycy92ZmlvL21kZXYv bWRldl9kcml2ZXIuYworKysgYi9kcml2ZXJzL3ZmaW8vbWRldi9tZGV2X2RyaXZlci5jCkBAIC02 OSw4ICs2OSwzMyBAQCBzdGF0aWMgaW50IG1kZXZfcmVtb3ZlKHN0cnVjdCBkZXZpY2UgKmRldikK IAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIGludCBtZGV2X21hdGNoKHN0cnVjdCBkZXZpY2UgKmRl diwgc3RydWN0IGRldmljZV9kcml2ZXIgKmRydikKK3sKKwl1bnNpZ25lZCBpbnQgaTsKKwlzdHJ1 Y3QgbWRldl9kZXZpY2UgKm1kZXYgPSB0b19tZGV2X2RldmljZShkZXYpOworCXN0cnVjdCBtZGV2 X2RyaXZlciAqbWRydiA9IHRvX21kZXZfZHJpdmVyKGRydik7CisJY29uc3Qgc3RydWN0IG1kZXZf Y2xhc3NfaWQgKmlkcyA9IG1kcnYtPmlkX3RhYmxlOworCisJaWYgKCFpZHMpCisJCXJldHVybiAw OworCisJZm9yIChpID0gMDsgaWRzW2ldLmlkOyBpKyspCisJCWlmIChpZHNbaV0uaWQgPT0gbWRl di0+Y2xhc3NfaWQpCisJCQlyZXR1cm4gMTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBt ZGV2X3VldmVudChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBrb2JqX3VldmVudF9lbnYgKmVu dikKK3sKKwlzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYgPSB0b19tZGV2X2RldmljZShkZXYpOwor CisJcmV0dXJuIGFkZF91ZXZlbnRfdmFyKGVudiwgIk1PREFMSUFTPW1kZXY6YyUwMlgiLCBtZGV2 LT5jbGFzc19pZCk7Cit9CisKIHN0cnVjdCBidXNfdHlwZSBtZGV2X2J1c190eXBlID0gewogCS5u YW1lCQk9ICJtZGV2IiwKKwkubWF0Y2gJCT0gbWRldl9tYXRjaCwKKwkudWV2ZW50CQk9IG1kZXZf dWV2ZW50LAogCS5wcm9iZQkJPSBtZGV2X3Byb2JlLAogCS5yZW1vdmUJCT0gbWRldl9yZW1vdmUs CiB9OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy92ZmlvL21kZXYvbWRldl9wcml2YXRlLmggYi9kcml2 ZXJzL3ZmaW8vbWRldi9tZGV2X3ByaXZhdGUuaAppbmRleCA3ZDkyMjk1MGNhYWYuLmM2NWY0MzZj MTg2OSAxMDA2NDQKLS0tIGEvZHJpdmVycy92ZmlvL21kZXYvbWRldl9wcml2YXRlLmgKKysrIGIv ZHJpdmVycy92ZmlvL21kZXYvbWRldl9wcml2YXRlLmgKQEAgLTMzLDYgKzMzLDcgQEAgc3RydWN0 IG1kZXZfZGV2aWNlIHsKIAlzdHJ1Y3Qga29iamVjdCAqdHlwZV9rb2JqOwogCXN0cnVjdCBkZXZp Y2UgKmlvbW11X2RldmljZTsKIAlib29sIGFjdGl2ZTsKKwl1MTYgY2xhc3NfaWQ7CiB9OwogCiAj ZGVmaW5lIHRvX21kZXZfZGV2aWNlKGRldikJY29udGFpbmVyX29mKGRldiwgc3RydWN0IG1kZXZf ZGV2aWNlLCBkZXYpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZmaW8vbWRldi92ZmlvX21kZXYuYyBi L2RyaXZlcnMvdmZpby9tZGV2L3ZmaW9fbWRldi5jCmluZGV4IDMwOTY0YTRlMGEyOC4uMzg0MzFl OWVmN2Y1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZmaW8vbWRldi92ZmlvX21kZXYuYworKysgYi9k cml2ZXJzL3ZmaW8vbWRldi92ZmlvX21kZXYuYwpAQCAtMTIwLDEwICsxMjAsMTYgQEAgc3RhdGlj IHZvaWQgdmZpb19tZGV2X3JlbW92ZShzdHJ1Y3QgZGV2aWNlICpkZXYpCiAJdmZpb19kZWxfZ3Jv dXBfZGV2KGRldik7CiB9CiAKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgbWRldl9jbGFzc19pZCB2Zmlv X2lkX3RhYmxlW10gPSB7CisJeyBNREVWX0NMQVNTX0lEX1ZGSU8gfSwKKwl7IDAgfSwKK307CisK IHN0YXRpYyBzdHJ1Y3QgbWRldl9kcml2ZXIgdmZpb19tZGV2X2RyaXZlciA9IHsKIAkubmFtZQk9 ICJ2ZmlvX21kZXYiLAogCS5wcm9iZQk9IHZmaW9fbWRldl9wcm9iZSwKIAkucmVtb3ZlCT0gdmZp b19tZGV2X3JlbW92ZSwKKwkuaWRfdGFibGUgPSB2ZmlvX2lkX3RhYmxlLAogfTsKIAogc3RhdGlj IGludCBfX2luaXQgdmZpb19tZGV2X2luaXQodm9pZCkKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGlu dXgvbWRldi5oIGIvaW5jbHVkZS9saW51eC9tZGV2LmgKaW5kZXggMGNlMzBjYTc4ZGIwLi43OGI2 OWQwOWViNTQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbWRldi5oCisrKyBiL2luY2x1ZGUv bGludXgvbWRldi5oCkBAIC0xMTgsNiArMTE4LDcgQEAgc3RydWN0IG1kZXZfdHlwZV9hdHRyaWJ1 dGUgbWRldl90eXBlX2F0dHJfIyNfbmFtZSA9CQlcCiAgKiBAcHJvYmU6IGNhbGxlZCB3aGVuIG5l dyBkZXZpY2UgY3JlYXRlZAogICogQHJlbW92ZTogY2FsbGVkIHdoZW4gZGV2aWNlIHJlbW92ZWQK ICAqIEBkcml2ZXI6IGRldmljZSBkcml2ZXIgc3RydWN0dXJlCisgKiBAaWRfdGFibGU6IHRoZSBp ZHMgc2VydmljZWQgYnkgdGhpcyBkcml2ZXIKICAqCiAgKiovCiBzdHJ1Y3QgbWRldl9kcml2ZXIg ewpAQCAtMTI1LDYgKzEyNiw3IEBAIHN0cnVjdCBtZGV2X2RyaXZlciB7CiAJaW50ICAoKnByb2Jl KShzdHJ1Y3QgZGV2aWNlICpkZXYpOwogCXZvaWQgKCpyZW1vdmUpKHN0cnVjdCBkZXZpY2UgKmRl dik7CiAJc3RydWN0IGRldmljZV9kcml2ZXIgZHJpdmVyOworCWNvbnN0IHN0cnVjdCBtZGV2X2Ns YXNzX2lkICppZF90YWJsZTsKIH07CiAKICNkZWZpbmUgdG9fbWRldl9kcml2ZXIoZHJ2KQljb250 YWluZXJfb2YoZHJ2LCBzdHJ1Y3QgbWRldl9kcml2ZXIsIGRyaXZlcikKQEAgLTEzMiw2ICsxMzQs NyBAQCBzdHJ1Y3QgbWRldl9kcml2ZXIgewogdm9pZCAqbWRldl9nZXRfZHJ2ZGF0YShzdHJ1Y3Qg bWRldl9kZXZpY2UgKm1kZXYpOwogdm9pZCBtZGV2X3NldF9kcnZkYXRhKHN0cnVjdCBtZGV2X2Rl dmljZSAqbWRldiwgdm9pZCAqZGF0YSk7CiBjb25zdCBndWlkX3QgKm1kZXZfdXVpZChzdHJ1Y3Qg bWRldl9kZXZpY2UgKm1kZXYpOwordm9pZCBtZGV2X3NldF9jbGFzcyhzdHJ1Y3QgbWRldl9kZXZp Y2UgKm1kZXYsIHUxNiBpZCk7CiAKIGV4dGVybiBzdHJ1Y3QgYnVzX3R5cGUgbWRldl9idXNfdHlw ZTsKIApAQCAtMTQ1LDQgKzE0OCw5IEBAIHN0cnVjdCBkZXZpY2UgKm1kZXZfcGFyZW50X2Rldihz dHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYpOwogc3RydWN0IGRldmljZSAqbWRldl9kZXYoc3RydWN0 IG1kZXZfZGV2aWNlICptZGV2KTsKIHN0cnVjdCBtZGV2X2RldmljZSAqbWRldl9mcm9tX2Rldihz dHJ1Y3QgZGV2aWNlICpkZXYpOwogCitlbnVtIHsKKwlNREVWX0NMQVNTX0lEX1ZGSU8gPSAxLAor CS8qIE5ldyBlbnRyaWVzIG11c3QgYmUgYWRkZWQgaGVyZSAqLworfTsKKwogI2VuZGlmIC8qIE1E RVZfSCAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tb2RfZGV2aWNldGFibGUuaCBiL2lu Y2x1ZGUvbGludXgvbW9kX2RldmljZXRhYmxlLmgKaW5kZXggNTcxNGZkMzVhODNjLi5mMzJjNmU0 NGZiMWEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbW9kX2RldmljZXRhYmxlLmgKKysrIGIv aW5jbHVkZS9saW51eC9tb2RfZGV2aWNldGFibGUuaApAQCAtODIxLDQgKzgyMSwxMiBAQCBzdHJ1 Y3Qgd21pX2RldmljZV9pZCB7CiAJY29uc3Qgdm9pZCAqY29udGV4dDsKIH07CiAKKy8qKgorICog c3RydWN0IG1kZXZfY2xhc3NfaWQgLSBNREVWIGRldmljZSBjbGFzcyBpZGVudGlmaWVyCisgKiBA aWQ6IFVzZWQgdG8gaWRlbnRpZnkgYSBzcGVjaWZpYyBjbGFzcyBvZiBkZXZpY2UsIGUuZyB2Zmlv LW1kZXYgZGV2aWNlLgorICovCitzdHJ1Y3QgbWRldl9jbGFzc19pZCB7CisJX191MTYgaWQ7Cit9 OworCiAjZW5kaWYgLyogTElOVVhfTU9EX0RFVklDRVRBQkxFX0ggKi8KZGlmZiAtLWdpdCBhL3Nh bXBsZXMvdmZpby1tZGV2L21ib2Nocy5jIGIvc2FtcGxlcy92ZmlvLW1kZXYvbWJvY2hzLmMKaW5k ZXggYWM1YzhjMTdiMWZmLi4xMTViYzUwNzQ2NTYgMTAwNjQ0Ci0tLSBhL3NhbXBsZXMvdmZpby1t ZGV2L21ib2Nocy5jCisrKyBiL3NhbXBsZXMvdmZpby1tZGV2L21ib2Nocy5jCkBAIC01NjEsNiAr NTYxLDcgQEAgc3RhdGljIGludCBtYm9jaHNfY3JlYXRlKHN0cnVjdCBrb2JqZWN0ICprb2JqLCBz dHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYpCiAJbWJvY2hzX3Jlc2V0KG1kZXYpOwogCiAJbWJvY2hz X3VzZWRfbWJ5dGVzICs9IHR5cGUtPm1ieXRlczsKKwltZGV2X3NldF9jbGFzcyhtZGV2LCBNREVW X0NMQVNTX0lEX1ZGSU8pOwogCXJldHVybiAwOwogCiBlcnJfbWVtOgpkaWZmIC0tZ2l0IGEvc2Ft cGxlcy92ZmlvLW1kZXYvbWRweS5jIGIvc2FtcGxlcy92ZmlvLW1kZXYvbWRweS5jCmluZGV4IGNj ODZiZjY1NjZlNC4uNjY1NjE0NTc0ZDUwIDEwMDY0NAotLS0gYS9zYW1wbGVzL3ZmaW8tbWRldi9t ZHB5LmMKKysrIGIvc2FtcGxlcy92ZmlvLW1kZXYvbWRweS5jCkBAIC0yNjksNiArMjY5LDcgQEAg c3RhdGljIGludCBtZHB5X2NyZWF0ZShzdHJ1Y3Qga29iamVjdCAqa29iaiwgc3RydWN0IG1kZXZf ZGV2aWNlICptZGV2KQogCW1kcHlfcmVzZXQobWRldik7CiAKIAltZHB5X2NvdW50Kys7CisJbWRl dl9zZXRfY2xhc3MobWRldiwgTURFVl9DTEFTU19JRF9WRklPKTsKIAlyZXR1cm4gMDsKIH0KIApk aWZmIC0tZ2l0IGEvc2FtcGxlcy92ZmlvLW1kZXYvbXR0eS5jIGIvc2FtcGxlcy92ZmlvLW1kZXYv bXR0eS5jCmluZGV4IGNlODRhMzAwYTRkYS4uOTBkYTEyZmY3ZmQ5IDEwMDY0NAotLS0gYS9zYW1w bGVzL3ZmaW8tbWRldi9tdHR5LmMKKysrIGIvc2FtcGxlcy92ZmlvLW1kZXYvbXR0eS5jCkBAIC03 NTUsNiArNzU1LDcgQEAgc3RhdGljIGludCBtdHR5X2NyZWF0ZShzdHJ1Y3Qga29iamVjdCAqa29i aiwgc3RydWN0IG1kZXZfZGV2aWNlICptZGV2KQogCWxpc3RfYWRkKCZtZGV2X3N0YXRlLT5uZXh0 LCAmbWRldl9kZXZpY2VzX2xpc3QpOwogCW11dGV4X3VubG9jaygmbWRldl9saXN0X2xvY2spOwog CisJbWRldl9zZXRfY2xhc3MobWRldiwgTURFVl9DTEFTU19JRF9WRklPKTsKIAlyZXR1cm4gMDsK IH0KIAotLSAKMi4xOS4xCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fXwpJbnRlbC1nZnggbWFpbGluZyBsaXN0CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3Rv cC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9pbnRl bC1nZng=