From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alex Williamson Subject: Re: [PATCH V7 4/6] mdev: introduce virtio device and its device ops Date: Mon, 4 Nov 2019 21:39:20 -0700 Message-ID: <20191104213920.59d356a3@x1.home> References: <20191104123952.17276-1-jasowang@redhat.com> <20191104123952.17276-5-jasowang@redhat.com> <20191104145024.5e437765@x1.home> <1faf4f36-3f79-2e15-3f61-c406d68240ab@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable Return-path: In-Reply-To: <1faf4f36-3f79-2e15-3f61-c406d68240ab@redhat.com> Sender: linux-kernel-owner@vger.kernel.org To: Jason Wang Cc: 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, mst@redhat.com, tiwei.bie@intel.com, 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 List-Id: dri-devel@lists.freedesktop.org On Tue, 5 Nov 2019 11:52:41 +0800 Jason Wang wrote: > On 2019/11/5 =E4=B8=8A=E5=8D=885:50, Alex Williamson wrote: > > On Mon, 4 Nov 2019 20:39:50 +0800 > > Jason Wang wrote: > > =20 > >> This patch implements basic support for mdev driver that supports > >> virtio transport for kernel virtio driver. > >> > >> Signed-off-by: Jason Wang > >> --- > >> drivers/vfio/mdev/mdev_core.c | 20 ++++ > >> drivers/vfio/mdev/mdev_private.h | 2 + > >> include/linux/mdev.h | 6 ++ > >> include/linux/mdev_virtio_ops.h | 166 +++++++++++++++++++++++++++++= ++ > >> 4 files changed, 194 insertions(+) > >> create mode 100644 include/linux/mdev_virtio_ops.h > >> > >> diff --git a/drivers/vfio/mdev/mdev_core.c b/drivers/vfio/mdev/mdev_co= re.c > >> index 8d579d7ed82f..95ee4126ff9c 100644 > >> --- a/drivers/vfio/mdev/mdev_core.c > >> +++ b/drivers/vfio/mdev/mdev_core.c > >> @@ -76,6 +76,26 @@ const struct mdev_vfio_device_ops *mdev_get_vfio_op= s(struct mdev_device *mdev) > >> } > >> EXPORT_SYMBOL(mdev_get_vfio_ops); > >> =20 > >> +/* Specify the virtio device ops for the mdev device, this > >> + * must be called during create() callback for virtio mdev device. > >> + */ =20 > > Comment style. =20 >=20 >=20 > Will fix. >=20 >=20 > > =20 > >> +void mdev_set_virtio_ops(struct mdev_device *mdev, > >> +=09=09=09 const struct mdev_virtio_device_ops *virtio_ops) > >> +{ > >> +=09mdev_set_class(mdev, MDEV_CLASS_ID_VIRTIO); > >> +=09mdev->virtio_ops =3D virtio_ops; > >> +} > >> +EXPORT_SYMBOL(mdev_set_virtio_ops); > >> + > >> +/* Get the virtio device ops for the mdev device. */ > >> +const struct mdev_virtio_device_ops * > >> +mdev_get_virtio_ops(struct mdev_device *mdev) > >> +{ > >> +=09WARN_ON(mdev->class_id !=3D MDEV_CLASS_ID_VIRTIO); > >> +=09return mdev->virtio_ops; > >> +} > >> +EXPORT_SYMBOL(mdev_get_virtio_ops); > >> + > >> struct device *mdev_dev(struct mdev_device *mdev) > >> { > >> =09return &mdev->dev; > >> diff --git a/drivers/vfio/mdev/mdev_private.h b/drivers/vfio/mdev/mdev= _private.h > >> index 411227373625..2c74dd032409 100644 > >> --- a/drivers/vfio/mdev/mdev_private.h > >> +++ b/drivers/vfio/mdev/mdev_private.h > >> @@ -11,6 +11,7 @@ > >> #define MDEV_PRIVATE_H > >> =20 > >> #include > >> +#include > >> =20 > >> int mdev_bus_register(void); > >> void mdev_bus_unregister(void); > >> @@ -38,6 +39,7 @@ struct mdev_device { > >> =09u16 class_id; > >> =09union { > >> =09=09const struct mdev_vfio_device_ops *vfio_ops; > >> +=09=09const struct mdev_virtio_device_ops *virtio_ops; > >> =09}; > >> }; > >> =20 > >> diff --git a/include/linux/mdev.h b/include/linux/mdev.h > >> index 9e37506d1987..f3d75a60c2b5 100644 > >> --- a/include/linux/mdev.h > >> +++ b/include/linux/mdev.h > >> @@ -17,6 +17,7 @@ > >> =20 > >> struct mdev_device; > >> struct mdev_vfio_device_ops; > >> +struct mdev_virtio_device_ops; > >> =20 > >> /* > >> * Called by the parent device driver to set the device which repres= ents > >> @@ -112,6 +113,10 @@ void mdev_set_class(struct mdev_device *mdev, u16= id); > >> void mdev_set_vfio_ops(struct mdev_device *mdev, > >> =09=09 const struct mdev_vfio_device_ops *vfio_ops); > >> const struct mdev_vfio_device_ops *mdev_get_vfio_ops(struct mdev_dev= ice *mdev); > >> +void mdev_set_virtio_ops(struct mdev_device *mdev, > >> +=09=09=09 const struct mdev_virtio_device_ops *virtio_ops); > >> +const struct mdev_virtio_device_ops * > >> +mdev_get_virtio_ops(struct mdev_device *mdev); > >> =20 > >> extern struct bus_type mdev_bus_type; > >> =20 > >> @@ -127,6 +132,7 @@ struct mdev_device *mdev_from_dev(struct device *d= ev); > >> =20 > >> enum { > >> =09MDEV_CLASS_ID_VFIO =3D 1, > >> +=09MDEV_CLASS_ID_VIRTIO =3D 2, > >> =09/* New entries must be added here */ > >> }; > >> =20 > >> diff --git a/include/linux/mdev_virtio_ops.h b/include/linux/mdev_virt= io_ops.h > >> new file mode 100644 > >> index 000000000000..0dcae7fa31e5 > >> --- /dev/null > >> +++ b/include/linux/mdev_virtio_ops.h > >> @@ -0,0 +1,166 @@ > >> +/* SPDX-License-Identifier: GPL-2.0-only */ > >> +/* > >> + * Virtio mediated device driver > >> + * > >> + * Copyright 2019, Red Hat Corp. > >> + * Author: Jason Wang > >> + */ > >> +#ifndef MDEV_VIRTIO_OPS_H > >> +#define MDEV_VIRTIO_OPS_H > >> + > >> +#include > >> +#include > >> +#include > >> + > >> +#define VIRTIO_MDEV_DEVICE_API_STRING=09=09"virtio-mdev" > >> +#define VIRTIO_MDEV_F_VERSION_1 0x1 > >> + > >> +struct virtio_mdev_callback { > >> +=09irqreturn_t (*callback)(void *data); > >> +=09void *private; > >> +}; > >> + > >> +/** > >> + * struct mdev_virtio_device_ops - Structure to be registered for eac= h > >> + * mdev device to register the device for virtio/vhost drivers. > >> + * > >> + * The device ops that is supported by VIRTIO_MDEV_F_VERSION_1, the > >> + * callbacks are mandatory unless explicity mentioned. > >> + * > >> + * @get_mdev_features:=09=09Get a set of bits that demonstrate > >> + *=09=09=09=09the capability of the mdev device. New > >> + *=09=09=09=09feature bits must be added when > >> + *=09=09=09=09introducing new device ops. This > >> + *=09=09=09=09allows the device ops to be extended > >> + *=09=09=09=09(one feature could have N new ops). > >> + *=09=09=09=09@mdev: mediated device > >> + *=09=09=09=09Returns the mdev features (API) support by > >> + *=09=09=09=09the device. =20 > > I still don't see the point of VIRTIO_MDEV_F_VERSION_1. In what case > > would it not be set? =20 >=20 >=20 > It's a must for current driver implementation. >=20 >=20 > > What would it indicate to the caller if it were > > not set? The existence of this interface seems to indicate version 1. = =20 >=20 >=20 > The idea is when VIRTIO_MDE_F_VERSION_1 is advertised, driver will=20 > assume all the mandatory callbacks for this feature were implemented.=20 > Then there's no need to check the existence of each callback. But this is redundant to MDEV_CLASS_ID_VIRTIO, which must imply the struct mdev_virtio_device_ops or else we have no handshake between the mdev device and the mdev bus driver. Essentially this creates a flag that says there are no flags, which is useless. I can't see why checking feature bits here is preferable to checking callbacks. > > I'm also still unclear how device ops gets extended, can you give some > > examples? Particularly, if feature A and feature B both add device ops > > callbacks, is the vendor allowed to support B but not A, and does that > > imply their device ops structure includes callbacks for A but they're > > unused? =20 >=20 >=20 > For current API, the answer is yes. So if vendor only support feature B,= =20 > it needs to set the device_ops that support feature A to NULL. Which is exactly what we expect to happen with get_generation() but we can't be bothered to add a feature flag for it? The interface is already self inconsistent. > > Why doesn't the previous patch take any of this into account > > for struct mdev_vfio_device_ops? I think this is an internal API, > > therefore is it worthwhile to include feature and extension support? = =20 >=20 >=20 > I'm not sure if VFIO has the request. In that case new features could be= =20 > extended simply through transport/bus specific way (e.g PCIE capability= =20 > list). But in the case of virtio-mdev, we need invent something on our=20 > own. If the simple mapping between features and device ops is proved to= =20 > be not sufficient or sub-optimal, we can introduce a more sophisticated= =20 > API. I think the key is that device ops is not an ABI, if we add new callbacks we can extend the structures of all the vendor drivers and the mdev bus driver can either choose to test the callback at runtime or probe time. I really don't see what we're accomplishing with this callback. > >> + * @get_mdev_features:=09=09Set a set of features that will be =20 > > s/get/set/ =20 >=20 >=20 > Will fix. >=20 >=20 > > =20 > >> + *=09=09=09=09used by the driver. > >> + *=09=09=09=09@features: features used by the driver > >> + *=09=09=09=09Returns bollean: whether the features =20 > > s/bollean/boolean/ > > > > How does one provide a set of features to set given this prototype? > > > > bool (*set_mdev_feature)(struct mdev_device *mdev); > > > > This is starting to look like a grab bag of callbacks, what sort of > > mdev features would the driver have the ability to set on a device? =20 >=20 >=20 > Yes, e.g device support A,B,C, but driver will only use B and C. Can you give a _concrete_ example of such features where the device needs to be informed of what features the driver will use rather than simply not using them? There appears to be no use case for this currently, so I'd suggest dropping it. If such a feature becomes necessary it can be added as needed since this is an internal interface. Also not sure my point above was well conveyed, the prototype doesn't provide a feature arg in order to set features. The comment also indicates we can set a set of features (ie. multiple), but it's not well specified what a failure indicates or why we'd use a boolean to indicate a failure versus an errno where we could interpret the return code. Both these callbacks seem like placeholders, which should be unnecessary as this is simply an internal API between virtio-mdev vendor drivers and the bus driver. Thanks, Alex > > Note that this is not listed as optional, but the sample driver doesn't > > implement it :-\ =20 >=20 >=20 > My bad, will fix this. >=20 > Thanks >=20 >=20 > > Thanks, > > > > Alex > > =20 > >> + *=09=09=09=09is accepted by the device. > >> + * @set_vq_address:=09=09Set the address of virtqueue > >> + *=09=09=09=09@mdev: mediated device > >> + *=09=09=09=09@idx: virtqueue index > >> + *=09=09=09=09@desc_area: address of desc area > >> + *=09=09=09=09@driver_area: address of driver area > >> + *=09=09=09=09@device_area: address of device area > >> + *=09=09=09=09Returns integer: success (0) or error (< 0) > >> + * @set_vq_num:=09=09=09Set the size of virtqueue > >> + *=09=09=09=09@mdev: mediated device > >> + *=09=09=09=09@idx: virtqueue index > >> + *=09=09=09=09@num: the size of virtqueue > >> + * @kick_vq:=09=09=09Kick the virtqueue > >> + *=09=09=09=09@mdev: mediated device > >> + *=09=09=09=09@idx: virtqueue index > >> + * @set_vq_cb:=09=09=09Set the interrupt callback function for > >> + *=09=09=09=09a virtqueue > >> + *=09=09=09=09@mdev: mediated device > >> + *=09=09=09=09@idx: virtqueue index > >> + *=09=09=09=09@cb: virtio-mdev interrupt callback structure > >> + * @set_vq_ready:=09=09Set ready status for a virtqueue > >> + *=09=09=09=09@mdev: mediated device > >> + *=09=09=09=09@idx: virtqueue index > >> + *=09=09=09=09@ready: ready (true) not ready(false) > >> + * @get_vq_ready:=09=09Get ready status for a virtqueue > >> + *=09=09=09=09@mdev: mediated device > >> + *=09=09=09=09@idx: virtqueue index > >> + *=09=09=09=09Returns boolean: ready (true) or not (false) > >> + * @set_vq_state:=09=09Set the state for a virtqueue > >> + *=09=09=09=09@mdev: mediated device > >> + *=09=09=09=09@idx: virtqueue index > >> + *=09=09=09=09@state: virtqueue state (last_avail_idx) > >> + *=09=09=09=09Returns integer: success (0) or error (< 0) > >> + * @get_vq_state:=09=09Get the state for a virtqueue > >> + *=09=09=09=09@mdev: mediated device > >> + *=09=09=09=09@idx: virtqueue index > >> + *=09=09=09=09Returns virtqueue state (last_avail_idx) > >> + * @get_vq_align:=09=09Get the virtqueue align requirement > >> + *=09=09=09=09for the device > >> + *=09=09=09=09@mdev: mediated device > >> + *=09=09=09=09Returns virtqueue algin requirement > >> + * @get_features:=09=09Get virtio features supported by the device > >> + *=09=09=09=09@mdev: mediated device > >> + *=09=09=09=09Returns the virtio features support by the > >> + *=09=09=09=09device > >> + * @set_features:=09=09Set virtio features supported by the driver > >> + *=09=09=09=09@mdev: mediated device > >> + *=09=09=09=09@features: feature support by the driver > >> + *=09=09=09=09Returns integer: success (0) or error (< 0) > >> + * @set_config_cb:=09=09Set the config interrupt callback > >> + *=09=09=09=09@mdev: mediated device > >> + *=09=09=09=09@cb: virtio-mdev interrupt callback structure > >> + * @get_vq_num_max:=09=09Get the max size of virtqueue > >> + *=09=09=09=09@mdev: mediated device > >> + *=09=09=09=09Returns u16: max size of virtqueue > >> + * @get_device_id:=09=09Get virtio device id > >> + *=09=09=09=09@mdev: mediated device > >> + *=09=09=09=09Returns u32: virtio device id > >> + * @get_vendor_id:=09=09Get id for the vendor that provides this devi= ce > >> + *=09=09=09=09@mdev: mediated device > >> + *=09=09=09=09Returns u32: virtio vendor id > >> + * @get_status:=09=09=09Get the device status > >> + *=09=09=09=09@mdev: mediated device > >> + *=09=09=09=09Returns u8: virtio device status > >> + * @set_status:=09=09=09Set the device status > >> + *=09=09=09=09@mdev: mediated device > >> + *=09=09=09=09@status: virtio device status > >> + * @get_config:=09=09=09Read from device specific configuration space > >> + *=09=09=09=09@mdev: mediated device > >> + *=09=09=09=09@offset: offset from the beginning of > >> + *=09=09=09=09configuration space > >> + *=09=09=09=09@buf: buffer used to read to > >> + *=09=09=09=09@len: the length to read from > >> + *=09=09=09=09configration space > >> + * @set_config:=09=09=09Write to device specific configuration space > >> + *=09=09=09=09@mdev: mediated device > >> + *=09=09=09=09@offset: offset from the beginning of > >> + *=09=09=09=09configuration space > >> + *=09=09=09=09@buf: buffer used to write from > >> + *=09=09=09=09@len: the length to write to > >> + *=09=09=09=09configration space > >> + * @get_generation:=09=09Get device config generaton (optional) > >> + *=09=09=09=09@mdev: mediated device > >> + *=09=09=09=09Returns u32: device generation > >> + */ > >> +struct mdev_virtio_device_ops { > >> +=09/* Mdev device ops */ > >> +=09u64 (*get_mdev_features)(struct mdev_device *mdev); > >> +=09bool (*set_mdev_feature)(struct mdev_device *mdev); > >> +=09/* Virtqueue ops */ > >> +=09int (*set_vq_address)(struct mdev_device *mdev, > >> +=09=09=09 u16 idx, u64 desc_area, u64 driver_area, > >> +=09=09=09 u64 device_area); > >> +=09void (*set_vq_num)(struct mdev_device *mdev, u16 idx, u32 num); > >> +=09void (*kick_vq)(struct mdev_device *mdev, u16 idx); > >> +=09void (*set_vq_cb)(struct mdev_device *mdev, u16 idx, > >> +=09=09=09 struct virtio_mdev_callback *cb); > >> +=09void (*set_vq_ready)(struct mdev_device *mdev, u16 idx, bool ready= ); > >> +=09bool (*get_vq_ready)(struct mdev_device *mdev, u16 idx); > >> +=09int (*set_vq_state)(struct mdev_device *mdev, u16 idx, u64 state); > >> +=09u64 (*get_vq_state)(struct mdev_device *mdev, u16 idx); > >> + > >> +=09/* Virtio device ops */ > >> +=09u16 (*get_vq_align)(struct mdev_device *mdev); > >> +=09u64 (*get_features)(struct mdev_device *mdev); > >> +=09int (*set_features)(struct mdev_device *mdev, u64 features); > >> +=09void (*set_config_cb)(struct mdev_device *mdev, > >> +=09=09=09 struct virtio_mdev_callback *cb); > >> +=09u16 (*get_vq_num_max)(struct mdev_device *mdev); > >> +=09u32 (*get_device_id)(struct mdev_device *mdev); > >> +=09u32 (*get_vendor_id)(struct mdev_device *mdev); > >> +=09u8 (*get_status)(struct mdev_device *mdev); > >> +=09void (*set_status)(struct mdev_device *mdev, u8 status); > >> +=09void (*get_config)(struct mdev_device *mdev, unsigned int offset, > >> +=09=09=09 void *buf, unsigned int len); > >> +=09void (*set_config)(struct mdev_device *mdev, unsigned int offset, > >> +=09=09=09 const void *buf, unsigned int len); > >> +=09u32 (*get_generation)(struct mdev_device *mdev); > >> +}; > >> + > >> +void mdev_set_virtio_ops(struct mdev_device *mdev, > >> +=09=09=09 const struct mdev_virtio_device_ops *virtio_ops); > >> + > >> +#endif =20 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=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 3FDEBCA9ED5 for ; Tue, 5 Nov 2019 04:39:47 +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 20430217F4 for ; Tue, 5 Nov 2019 04:39:47 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 20430217F4 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id AC5526E8F3; Tue, 5 Nov 2019 04:39:45 +0000 (UTC) Received: from us-smtp-delivery-1.mimecast.com (us-smtp-1.mimecast.com [207.211.31.81]) by gabe.freedesktop.org (Postfix) with ESMTPS id E2BE86E8EE for ; Tue, 5 Nov 2019 04:39:43 +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-37-lmTJ02eAPJyyRYfLKnro3w-1; Mon, 04 Nov 2019 23:39:35 -0500 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 E14F61005500; Tue, 5 Nov 2019 04:39:31 +0000 (UTC) Received: from x1.home (ovpn-116-110.phx2.redhat.com [10.3.116.110]) by smtp.corp.redhat.com (Postfix) with ESMTP id 04FDD5D6D0; Tue, 5 Nov 2019 04:39:20 +0000 (UTC) Date: Mon, 4 Nov 2019 21:39:20 -0700 From: Alex Williamson To: Jason Wang Subject: Re: [PATCH V7 4/6] mdev: introduce virtio device and its device ops Message-ID: <20191104213920.59d356a3@x1.home> In-Reply-To: <1faf4f36-3f79-2e15-3f61-c406d68240ab@redhat.com> References: <20191104123952.17276-1-jasowang@redhat.com> <20191104123952.17276-5-jasowang@redhat.com> <20191104145024.5e437765@x1.home> <1faf4f36-3f79-2e15-3f61-c406d68240ab@redhat.com> Organization: Red Hat MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.15 X-MC-Unique: lmTJ02eAPJyyRYfLKnro3w-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=1572928783; 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=6iUNF5ryRs+VrcXV1qZ5sQXw8eDYoy6IQjeUm6xVBv4=; b=UqWtumzBUHugBxFP0UFDXo6wASvhxPrJz9kJIr6ybCYBFSw/x0tJWTPIBEGSjjeZB7tR82 ig13JnTCUFPNXNtWpX7buUO0lLRbtAQ5LRdtXPgtm3GpOs4ecnJUubFFAkTXbkwCmj/avn TzMxdrUmIXKHpzReoUkz/LZZuR0Y8JY= X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: stefanha@redhat.com, christophe.de.dinechin@gmail.com, kvm@vger.kernel.org, mst@redhat.com, airlied@linux.ie, heiko.carstens@de.ibm.com, kevin.tian@intel.com, dri-devel@lists.freedesktop.org, virtualization@lists.linux-foundation.org, kwankhede@nvidia.com, rob.miller@broadcom.com, linux-s390@vger.kernel.org, sebott@linux.ibm.com, lulu@redhat.com, eperezma@redhat.com, pasic@linux.ibm.com, borntraeger@de.ibm.com, haotian.wang@sifive.com, cunming.liang@intel.com, zhi.a.wang@intel.com, farman@linux.ibm.com, idos@mellanox.com, gor@linux.ibm.com, intel-gfx@lists.freedesktop.org, rodrigo.vivi@intel.com, xiao.w.wang@intel.com, freude@linux.ibm.com, parav@mellanox.com, zhihong.wang@intel.com, intel-gvt-dev@lists.freedesktop.org, akrowiak@linux.ibm.com, oberpar@linux.ibm.com, tiwei.bie@intel.com, netdev@vger.kernel.org, cohuck@redhat.com, linux-kernel@vger.kernel.org, maxime.coquelin@redhat.com, lingshan.zhu@intel.com Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Message-ID: <20191105043920.eEdDwOZXMdd3gfNDl89Lzx2auSKlOcW-56dkO3spEpY@z> T24gVHVlLCA1IE5vdiAyMDE5IDExOjUyOjQxICswODAwCkphc29uIFdhbmcgPGphc293YW5nQHJl ZGhhdC5jb20+IHdyb3RlOgoKPiBPbiAyMDE5LzExLzUg5LiK5Y2INTo1MCwgQWxleCBXaWxsaWFt c29uIHdyb3RlOgo+ID4gT24gTW9uLCAgNCBOb3YgMjAxOSAyMDozOTo1MCArMDgwMAo+ID4gSmFz b24gV2FuZyA8amFzb3dhbmdAcmVkaGF0LmNvbT4gd3JvdGU6Cj4gPiAgCj4gPj4gVGhpcyBwYXRj aCBpbXBsZW1lbnRzIGJhc2ljIHN1cHBvcnQgZm9yIG1kZXYgZHJpdmVyIHRoYXQgc3VwcG9ydHMK PiA+PiB2aXJ0aW8gdHJhbnNwb3J0IGZvciBrZXJuZWwgdmlydGlvIGRyaXZlci4KPiA+Pgo+ID4+ IFNpZ25lZC1vZmYtYnk6IEphc29uIFdhbmcgPGphc293YW5nQHJlZGhhdC5jb20+Cj4gPj4gLS0t Cj4gPj4gICBkcml2ZXJzL3ZmaW8vbWRldi9tZGV2X2NvcmUuYyAgICB8ICAyMCArKysrCj4gPj4g ICBkcml2ZXJzL3ZmaW8vbWRldi9tZGV2X3ByaXZhdGUuaCB8ICAgMiArCj4gPj4gICBpbmNsdWRl L2xpbnV4L21kZXYuaCAgICAgICAgICAgICB8ICAgNiArKwo+ID4+ICAgaW5jbHVkZS9saW51eC9t ZGV2X3ZpcnRpb19vcHMuaCAgfCAxNjYgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ ID4+ICAgNCBmaWxlcyBjaGFuZ2VkLCAxOTQgaW5zZXJ0aW9ucygrKQo+ID4+ICAgY3JlYXRlIG1v ZGUgMTAwNjQ0IGluY2x1ZGUvbGludXgvbWRldl92aXJ0aW9fb3BzLmgKPiA+Pgo+ID4+IGRpZmYg LS1naXQgYS9kcml2ZXJzL3ZmaW8vbWRldi9tZGV2X2NvcmUuYyBiL2RyaXZlcnMvdmZpby9tZGV2 L21kZXZfY29yZS5jCj4gPj4gaW5kZXggOGQ1NzlkN2VkODJmLi45NWVlNDEyNmZmOWMgMTAwNjQ0 Cj4gPj4gLS0tIGEvZHJpdmVycy92ZmlvL21kZXYvbWRldl9jb3JlLmMKPiA+PiArKysgYi9kcml2 ZXJzL3ZmaW8vbWRldi9tZGV2X2NvcmUuYwo+ID4+IEBAIC03Niw2ICs3NiwyNiBAQCBjb25zdCBz dHJ1Y3QgbWRldl92ZmlvX2RldmljZV9vcHMgKm1kZXZfZ2V0X3ZmaW9fb3BzKHN0cnVjdCBtZGV2 X2RldmljZSAqbWRldikKPiA+PiAgIH0KPiA+PiAgIEVYUE9SVF9TWU1CT0wobWRldl9nZXRfdmZp b19vcHMpOwo+ID4+ICAgCj4gPj4gKy8qIFNwZWNpZnkgdGhlIHZpcnRpbyBkZXZpY2Ugb3BzIGZv ciB0aGUgbWRldiBkZXZpY2UsIHRoaXMKPiA+PiArICogbXVzdCBiZSBjYWxsZWQgZHVyaW5nIGNy ZWF0ZSgpIGNhbGxiYWNrIGZvciB2aXJ0aW8gbWRldiBkZXZpY2UuCj4gPj4gKyAqLyAgCj4gPiBD b21tZW50IHN0eWxlLiAgCj4gCj4gCj4gV2lsbCBmaXguCj4gCj4gCj4gPiAgCj4gPj4gK3ZvaWQg bWRldl9zZXRfdmlydGlvX29wcyhzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsCj4gPj4gKwkJCSBj b25zdCBzdHJ1Y3QgbWRldl92aXJ0aW9fZGV2aWNlX29wcyAqdmlydGlvX29wcykKPiA+PiArewo+ ID4+ICsJbWRldl9zZXRfY2xhc3MobWRldiwgTURFVl9DTEFTU19JRF9WSVJUSU8pOwo+ID4+ICsJ bWRldi0+dmlydGlvX29wcyA9IHZpcnRpb19vcHM7Cj4gPj4gK30KPiA+PiArRVhQT1JUX1NZTUJP TChtZGV2X3NldF92aXJ0aW9fb3BzKTsKPiA+PiArCj4gPj4gKy8qIEdldCB0aGUgdmlydGlvIGRl dmljZSBvcHMgZm9yIHRoZSBtZGV2IGRldmljZS4gKi8KPiA+PiArY29uc3Qgc3RydWN0IG1kZXZf dmlydGlvX2RldmljZV9vcHMgKgo+ID4+ICttZGV2X2dldF92aXJ0aW9fb3BzKHN0cnVjdCBtZGV2 X2RldmljZSAqbWRldikKPiA+PiArewo+ID4+ICsJV0FSTl9PTihtZGV2LT5jbGFzc19pZCAhPSBN REVWX0NMQVNTX0lEX1ZJUlRJTyk7Cj4gPj4gKwlyZXR1cm4gbWRldi0+dmlydGlvX29wczsKPiA+ PiArfQo+ID4+ICtFWFBPUlRfU1lNQk9MKG1kZXZfZ2V0X3ZpcnRpb19vcHMpOwo+ID4+ICsKPiA+ PiAgIHN0cnVjdCBkZXZpY2UgKm1kZXZfZGV2KHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKPiA+ PiAgIHsKPiA+PiAgIAlyZXR1cm4gJm1kZXYtPmRldjsKPiA+PiBkaWZmIC0tZ2l0IGEvZHJpdmVy cy92ZmlvL21kZXYvbWRldl9wcml2YXRlLmggYi9kcml2ZXJzL3ZmaW8vbWRldi9tZGV2X3ByaXZh dGUuaAo+ID4+IGluZGV4IDQxMTIyNzM3MzYyNS4uMmM3NGRkMDMyNDA5IDEwMDY0NAo+ID4+IC0t LSBhL2RyaXZlcnMvdmZpby9tZGV2L21kZXZfcHJpdmF0ZS5oCj4gPj4gKysrIGIvZHJpdmVycy92 ZmlvL21kZXYvbWRldl9wcml2YXRlLmgKPiA+PiBAQCAtMTEsNiArMTEsNyBAQAo+ID4+ICAgI2Rl ZmluZSBNREVWX1BSSVZBVEVfSAo+ID4+ICAgCj4gPj4gICAjaW5jbHVkZSA8bGludXgvbWRldl92 ZmlvX29wcy5oPgo+ID4+ICsjaW5jbHVkZSA8bGludXgvbWRldl92aXJ0aW9fb3BzLmg+Cj4gPj4g ICAKPiA+PiAgIGludCAgbWRldl9idXNfcmVnaXN0ZXIodm9pZCk7Cj4gPj4gICB2b2lkIG1kZXZf YnVzX3VucmVnaXN0ZXIodm9pZCk7Cj4gPj4gQEAgLTM4LDYgKzM5LDcgQEAgc3RydWN0IG1kZXZf ZGV2aWNlIHsKPiA+PiAgIAl1MTYgY2xhc3NfaWQ7Cj4gPj4gICAJdW5pb24gewo+ID4+ICAgCQlj b25zdCBzdHJ1Y3QgbWRldl92ZmlvX2RldmljZV9vcHMgKnZmaW9fb3BzOwo+ID4+ICsJCWNvbnN0 IHN0cnVjdCBtZGV2X3ZpcnRpb19kZXZpY2Vfb3BzICp2aXJ0aW9fb3BzOwo+ID4+ICAgCX07Cj4g Pj4gICB9Owo+ID4+ICAgCj4gPj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbWRldi5oIGIv aW5jbHVkZS9saW51eC9tZGV2LmgKPiA+PiBpbmRleCA5ZTM3NTA2ZDE5ODcuLmYzZDc1YTYwYzJi NSAxMDA2NDQKPiA+PiAtLS0gYS9pbmNsdWRlL2xpbnV4L21kZXYuaAo+ID4+ICsrKyBiL2luY2x1 ZGUvbGludXgvbWRldi5oCj4gPj4gQEAgLTE3LDYgKzE3LDcgQEAKPiA+PiAgIAo+ID4+ICAgc3Ry dWN0IG1kZXZfZGV2aWNlOwo+ID4+ICAgc3RydWN0IG1kZXZfdmZpb19kZXZpY2Vfb3BzOwo+ID4+ ICtzdHJ1Y3QgbWRldl92aXJ0aW9fZGV2aWNlX29wczsKPiA+PiAgIAo+ID4+ICAgLyoKPiA+PiAg ICAqIENhbGxlZCBieSB0aGUgcGFyZW50IGRldmljZSBkcml2ZXIgdG8gc2V0IHRoZSBkZXZpY2Ug d2hpY2ggcmVwcmVzZW50cwo+ID4+IEBAIC0xMTIsNiArMTEzLDEwIEBAIHZvaWQgbWRldl9zZXRf Y2xhc3Moc3RydWN0IG1kZXZfZGV2aWNlICptZGV2LCB1MTYgaWQpOwo+ID4+ICAgdm9pZCBtZGV2 X3NldF92ZmlvX29wcyhzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsCj4gPj4gICAJCSAgICAgICBj b25zdCBzdHJ1Y3QgbWRldl92ZmlvX2RldmljZV9vcHMgKnZmaW9fb3BzKTsKPiA+PiAgIGNvbnN0 IHN0cnVjdCBtZGV2X3ZmaW9fZGV2aWNlX29wcyAqbWRldl9nZXRfdmZpb19vcHMoc3RydWN0IG1k ZXZfZGV2aWNlICptZGV2KTsKPiA+PiArdm9pZCBtZGV2X3NldF92aXJ0aW9fb3BzKHN0cnVjdCBt ZGV2X2RldmljZSAqbWRldiwKPiA+PiArCQkJIGNvbnN0IHN0cnVjdCBtZGV2X3ZpcnRpb19kZXZp Y2Vfb3BzICp2aXJ0aW9fb3BzKTsKPiA+PiArY29uc3Qgc3RydWN0IG1kZXZfdmlydGlvX2Rldmlj ZV9vcHMgKgo+ID4+ICttZGV2X2dldF92aXJ0aW9fb3BzKHN0cnVjdCBtZGV2X2RldmljZSAqbWRl dik7Cj4gPj4gICAKPiA+PiAgIGV4dGVybiBzdHJ1Y3QgYnVzX3R5cGUgbWRldl9idXNfdHlwZTsK PiA+PiAgIAo+ID4+IEBAIC0xMjcsNiArMTMyLDcgQEAgc3RydWN0IG1kZXZfZGV2aWNlICptZGV2 X2Zyb21fZGV2KHN0cnVjdCBkZXZpY2UgKmRldik7Cj4gPj4gICAKPiA+PiAgIGVudW0gewo+ID4+ ICAgCU1ERVZfQ0xBU1NfSURfVkZJTyA9IDEsCj4gPj4gKwlNREVWX0NMQVNTX0lEX1ZJUlRJTyA9 IDIsCj4gPj4gICAJLyogTmV3IGVudHJpZXMgbXVzdCBiZSBhZGRlZCBoZXJlICovCj4gPj4gICB9 Owo+ID4+ICAgCj4gPj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbWRldl92aXJ0aW9fb3Bz LmggYi9pbmNsdWRlL2xpbnV4L21kZXZfdmlydGlvX29wcy5oCj4gPj4gbmV3IGZpbGUgbW9kZSAx MDA2NDQKPiA+PiBpbmRleCAwMDAwMDAwMDAwMDAuLjBkY2FlN2ZhMzFlNQo+ID4+IC0tLSAvZGV2 L251bGwKPiA+PiArKysgYi9pbmNsdWRlL2xpbnV4L21kZXZfdmlydGlvX29wcy5oCj4gPj4gQEAg LTAsMCArMSwxNjYgQEAKPiA+PiArLyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAt b25seSAqLwo+ID4+ICsvKgo+ID4+ICsgKiBWaXJ0aW8gbWVkaWF0ZWQgZGV2aWNlIGRyaXZlcgo+ ID4+ICsgKgo+ID4+ICsgKiBDb3B5cmlnaHQgMjAxOSwgUmVkIEhhdCBDb3JwLgo+ID4+ICsgKiAg ICAgQXV0aG9yOiBKYXNvbiBXYW5nIDxqYXNvd2FuZ0ByZWRoYXQuY29tPgo+ID4+ICsgKi8KPiA+ PiArI2lmbmRlZiBNREVWX1ZJUlRJT19PUFNfSAo+ID4+ICsjZGVmaW5lIE1ERVZfVklSVElPX09Q U19ICj4gPj4gKwo+ID4+ICsjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+Cj4gPj4gKyNpbmNs dWRlIDxsaW51eC9tZGV2Lmg+Cj4gPj4gKyNpbmNsdWRlIDx1YXBpL2xpbnV4L3Zob3N0Lmg+Cj4g Pj4gKwo+ID4+ICsjZGVmaW5lIFZJUlRJT19NREVWX0RFVklDRV9BUElfU1RSSU5HCQkidmlydGlv LW1kZXYiCj4gPj4gKyNkZWZpbmUgVklSVElPX01ERVZfRl9WRVJTSU9OXzEgMHgxCj4gPj4gKwo+ ID4+ICtzdHJ1Y3QgdmlydGlvX21kZXZfY2FsbGJhY2sgewo+ID4+ICsJaXJxcmV0dXJuX3QgKCpj YWxsYmFjaykodm9pZCAqZGF0YSk7Cj4gPj4gKwl2b2lkICpwcml2YXRlOwo+ID4+ICt9Owo+ID4+ ICsKPiA+PiArLyoqCj4gPj4gKyAqIHN0cnVjdCBtZGV2X3ZpcnRpb19kZXZpY2Vfb3BzIC0gU3Ry dWN0dXJlIHRvIGJlIHJlZ2lzdGVyZWQgZm9yIGVhY2gKPiA+PiArICogbWRldiBkZXZpY2UgdG8g cmVnaXN0ZXIgdGhlIGRldmljZSBmb3IgdmlydGlvL3Zob3N0IGRyaXZlcnMuCj4gPj4gKyAqCj4g Pj4gKyAqIFRoZSBkZXZpY2Ugb3BzIHRoYXQgaXMgc3VwcG9ydGVkIGJ5IFZJUlRJT19NREVWX0Zf VkVSU0lPTl8xLCB0aGUKPiA+PiArICogY2FsbGJhY2tzIGFyZSBtYW5kYXRvcnkgdW5sZXNzIGV4 cGxpY2l0eSBtZW50aW9uZWQuCj4gPj4gKyAqCj4gPj4gKyAqIEBnZXRfbWRldl9mZWF0dXJlczoJ CUdldCBhIHNldCBvZiBiaXRzIHRoYXQgZGVtb25zdHJhdGUKPiA+PiArICoJCQkJdGhlIGNhcGFi aWxpdHkgb2YgdGhlIG1kZXYgZGV2aWNlLiBOZXcKPiA+PiArICoJCQkJZmVhdHVyZSBiaXRzIG11 c3QgYmUgYWRkZWQgd2hlbgo+ID4+ICsgKgkJCQlpbnRyb2R1Y2luZyBuZXcgZGV2aWNlIG9wcy4g VGhpcwo+ID4+ICsgKgkJCQlhbGxvd3MgdGhlIGRldmljZSBvcHMgdG8gYmUgZXh0ZW5kZWQKPiA+ PiArICoJCQkJKG9uZSBmZWF0dXJlIGNvdWxkIGhhdmUgTiBuZXcgb3BzKS4KPiA+PiArICoJCQkJ QG1kZXY6IG1lZGlhdGVkIGRldmljZQo+ID4+ICsgKgkJCQlSZXR1cm5zIHRoZSBtZGV2IGZlYXR1 cmVzIChBUEkpIHN1cHBvcnQgYnkKPiA+PiArICoJCQkJdGhlIGRldmljZS4gIAo+ID4gSSBzdGls bCBkb24ndCBzZWUgdGhlIHBvaW50IG9mIFZJUlRJT19NREVWX0ZfVkVSU0lPTl8xLiAgSW4gd2hh dCBjYXNlCj4gPiB3b3VsZCBpdCBub3QgYmUgc2V0PyAgCj4gCj4gCj4gSXQncyBhIG11c3QgZm9y IGN1cnJlbnQgZHJpdmVyIGltcGxlbWVudGF0aW9uLgo+IAo+IAo+ID4gV2hhdCB3b3VsZCBpdCBp bmRpY2F0ZSB0byB0aGUgY2FsbGVyIGlmIGl0IHdlcmUKPiA+IG5vdCBzZXQ/ICBUaGUgZXhpc3Rl bmNlIG9mIHRoaXMgaW50ZXJmYWNlIHNlZW1zIHRvIGluZGljYXRlIHZlcnNpb24gMS4gIAo+IAo+ IAo+IFRoZSBpZGVhIGlzIHdoZW4gVklSVElPX01ERV9GX1ZFUlNJT05fMSBpcyBhZHZlcnRpc2Vk LCBkcml2ZXIgd2lsbCAKPiBhc3N1bWUgYWxsIHRoZSBtYW5kYXRvcnkgY2FsbGJhY2tzIGZvciB0 aGlzIGZlYXR1cmUgd2VyZSBpbXBsZW1lbnRlZC4gCj4gVGhlbiB0aGVyZSdzIG5vIG5lZWQgdG8g Y2hlY2sgdGhlIGV4aXN0ZW5jZSBvZiBlYWNoIGNhbGxiYWNrLgoKQnV0IHRoaXMgaXMgcmVkdW5k YW50IHRvIE1ERVZfQ0xBU1NfSURfVklSVElPLCB3aGljaCBtdXN0IGltcGx5IHRoZQpzdHJ1Y3Qg bWRldl92aXJ0aW9fZGV2aWNlX29wcyBvciBlbHNlIHdlIGhhdmUgbm8gaGFuZHNoYWtlIGJldHdl ZW4gdGhlCm1kZXYgZGV2aWNlIGFuZCB0aGUgbWRldiBidXMgZHJpdmVyLiAgRXNzZW50aWFsbHkg dGhpcyBjcmVhdGVzIGEgZmxhZwp0aGF0IHNheXMgdGhlcmUgYXJlIG5vIGZsYWdzLCB3aGljaCBp cyB1c2VsZXNzLiAgSSBjYW4ndCBzZWUgd2h5CmNoZWNraW5nIGZlYXR1cmUgYml0cyBoZXJlIGlz IHByZWZlcmFibGUgdG8gY2hlY2tpbmcgY2FsbGJhY2tzLgoKPiA+IEknbSBhbHNvIHN0aWxsIHVu Y2xlYXIgaG93IGRldmljZSBvcHMgZ2V0cyBleHRlbmRlZCwgY2FuIHlvdSBnaXZlIHNvbWUKPiA+ IGV4YW1wbGVzPyAgUGFydGljdWxhcmx5LCBpZiBmZWF0dXJlIEEgYW5kIGZlYXR1cmUgQiBib3Ro IGFkZCBkZXZpY2Ugb3BzCj4gPiBjYWxsYmFja3MsIGlzIHRoZSB2ZW5kb3IgYWxsb3dlZCB0byBz dXBwb3J0IEIgYnV0IG5vdCBBLCBhbmQgZG9lcyB0aGF0Cj4gPiBpbXBseSB0aGVpciBkZXZpY2Ug b3BzIHN0cnVjdHVyZSBpbmNsdWRlcyBjYWxsYmFja3MgZm9yIEEgYnV0IHRoZXkncmUKPiA+IHVu dXNlZD8gIAo+IAo+IAo+IEZvciBjdXJyZW50IEFQSSwgdGhlIGFuc3dlciBpcyB5ZXMuIFNvIGlm IHZlbmRvciBvbmx5IHN1cHBvcnQgZmVhdHVyZSBCLCAKPiBpdCBuZWVkcyB0byBzZXQgdGhlIGRl dmljZV9vcHMgdGhhdCBzdXBwb3J0IGZlYXR1cmUgQSB0byBOVUxMLgoKV2hpY2ggaXMgZXhhY3Rs eSB3aGF0IHdlIGV4cGVjdCB0byBoYXBwZW4gd2l0aCBnZXRfZ2VuZXJhdGlvbigpIGJ1dCB3ZQpj YW4ndCBiZSBib3RoZXJlZCB0byBhZGQgYSBmZWF0dXJlIGZsYWcgZm9yIGl0PyAgVGhlIGludGVy ZmFjZSBpcwphbHJlYWR5IHNlbGYgaW5jb25zaXN0ZW50LgoKPiA+IFdoeSBkb2Vzbid0IHRoZSBw cmV2aW91cyBwYXRjaCB0YWtlIGFueSBvZiB0aGlzIGludG8gYWNjb3VudAo+ID4gZm9yIHN0cnVj dCBtZGV2X3ZmaW9fZGV2aWNlX29wcz8gIEkgdGhpbmsgdGhpcyBpcyBhbiBpbnRlcm5hbCBBUEks Cj4gPiB0aGVyZWZvcmUgaXMgaXQgd29ydGh3aGlsZSB0byBpbmNsdWRlIGZlYXR1cmUgYW5kIGV4 dGVuc2lvbiBzdXBwb3J0PyAgCj4gCj4gCj4gSSdtIG5vdCBzdXJlIGlmIFZGSU8gaGFzIHRoZSBy ZXF1ZXN0LiBJbiB0aGF0IGNhc2UgbmV3IGZlYXR1cmVzIGNvdWxkIGJlIAo+IGV4dGVuZGVkIHNp bXBseSB0aHJvdWdoIHRyYW5zcG9ydC9idXMgc3BlY2lmaWMgd2F5IChlLmcgUENJRSBjYXBhYmls aXR5IAo+IGxpc3QpLiBCdXQgaW4gdGhlIGNhc2Ugb2YgdmlydGlvLW1kZXYsIHdlIG5lZWQgaW52 ZW50IHNvbWV0aGluZyBvbiBvdXIgCj4gb3duLiBJZiB0aGUgc2ltcGxlIG1hcHBpbmcgYmV0d2Vl biBmZWF0dXJlcyBhbmQgZGV2aWNlIG9wcyBpcyBwcm92ZWQgdG8gCj4gYmUgbm90IHN1ZmZpY2ll bnQgb3Igc3ViLW9wdGltYWwsIHdlIGNhbiBpbnRyb2R1Y2UgYSBtb3JlIHNvcGhpc3RpY2F0ZWQg Cj4gQVBJLgoKSSB0aGluayB0aGUga2V5IGlzIHRoYXQgZGV2aWNlIG9wcyBpcyBub3QgYW4gQUJJ LCBpZiB3ZSBhZGQgbmV3CmNhbGxiYWNrcyB3ZSBjYW4gZXh0ZW5kIHRoZSBzdHJ1Y3R1cmVzIG9m IGFsbCB0aGUgdmVuZG9yIGRyaXZlcnMgYW5kCnRoZSBtZGV2IGJ1cyBkcml2ZXIgY2FuIGVpdGhl ciBjaG9vc2UgdG8gdGVzdCB0aGUgY2FsbGJhY2sgYXQgcnVudGltZQpvciBwcm9iZSB0aW1lLiAg SSByZWFsbHkgZG9uJ3Qgc2VlIHdoYXQgd2UncmUgYWNjb21wbGlzaGluZyB3aXRoIHRoaXMKY2Fs bGJhY2suCgo+ID4+ICsgKiBAZ2V0X21kZXZfZmVhdHVyZXM6CQlTZXQgYSBzZXQgb2YgZmVhdHVy ZXMgdGhhdCB3aWxsIGJlICAKPiA+IHMvZ2V0L3NldC8gIAo+IAo+IAo+IFdpbGwgZml4Lgo+IAo+ IAo+ID4gIAo+ID4+ICsgKgkJCQl1c2VkIGJ5IHRoZSBkcml2ZXIuCj4gPj4gKyAqCQkJCUBmZWF0 dXJlczogZmVhdHVyZXMgdXNlZCBieSB0aGUgZHJpdmVyCj4gPj4gKyAqCQkJCVJldHVybnMgYm9s bGVhbjogd2hldGhlciB0aGUgZmVhdHVyZXMgIAo+ID4gcy9ib2xsZWFuL2Jvb2xlYW4vCj4gPgo+ ID4gSG93IGRvZXMgb25lIHByb3ZpZGUgYSBzZXQgb2YgZmVhdHVyZXMgdG8gc2V0IGdpdmVuIHRo aXMgcHJvdG90eXBlPwo+ID4KPiA+IGJvb2wgKCpzZXRfbWRldl9mZWF0dXJlKShzdHJ1Y3QgbWRl dl9kZXZpY2UgKm1kZXYpOwo+ID4KPiA+IFRoaXMgaXMgc3RhcnRpbmcgdG8gbG9vayBsaWtlIGEg Z3JhYiBiYWcgb2YgY2FsbGJhY2tzLCB3aGF0IHNvcnQgb2YKPiA+IG1kZXYgZmVhdHVyZXMgd291 bGQgdGhlIGRyaXZlciBoYXZlIHRoZSBhYmlsaXR5IHRvIHNldCBvbiBhIGRldmljZT8gIAo+IAo+ IAo+IFllcywgZS5nIGRldmljZSBzdXBwb3J0IEEsQixDLCBidXQgZHJpdmVyIHdpbGwgb25seSB1 c2UgQiBhbmQgQy4KCkNhbiB5b3UgZ2l2ZSBhIF9jb25jcmV0ZV8gZXhhbXBsZSBvZiBzdWNoIGZl YXR1cmVzIHdoZXJlIHRoZSBkZXZpY2UKbmVlZHMgdG8gYmUgaW5mb3JtZWQgb2Ygd2hhdCBmZWF0 dXJlcyB0aGUgZHJpdmVyIHdpbGwgdXNlIHJhdGhlciB0aGFuCnNpbXBseSBub3QgdXNpbmcgdGhl bT8gIFRoZXJlIGFwcGVhcnMgdG8gYmUgbm8gdXNlIGNhc2UgZm9yIHRoaXMKY3VycmVudGx5LCBz byBJJ2Qgc3VnZ2VzdCBkcm9wcGluZyBpdC4gIElmIHN1Y2ggYSBmZWF0dXJlIGJlY29tZXMKbmVj ZXNzYXJ5IGl0IGNhbiBiZSBhZGRlZCBhcyBuZWVkZWQgc2luY2UgdGhpcyBpcyBhbiBpbnRlcm5h bAppbnRlcmZhY2UuICBBbHNvIG5vdCBzdXJlIG15IHBvaW50IGFib3ZlIHdhcyB3ZWxsIGNvbnZl eWVkLCB0aGUKcHJvdG90eXBlIGRvZXNuJ3QgcHJvdmlkZSBhIGZlYXR1cmUgYXJnIGluIG9yZGVy IHRvIHNldCBmZWF0dXJlcy4gIFRoZQpjb21tZW50IGFsc28gaW5kaWNhdGVzIHdlIGNhbiBzZXQg YSBzZXQgb2YgZmVhdHVyZXMgKGllLiBtdWx0aXBsZSksIGJ1dAppdCdzIG5vdCB3ZWxsIHNwZWNp ZmllZCB3aGF0IGEgZmFpbHVyZSBpbmRpY2F0ZXMgb3Igd2h5IHdlJ2QgdXNlIGEKYm9vbGVhbiB0 byBpbmRpY2F0ZSBhIGZhaWx1cmUgdmVyc3VzIGFuIGVycm5vIHdoZXJlIHdlIGNvdWxkIGludGVy cHJldAp0aGUgcmV0dXJuIGNvZGUuICBCb3RoIHRoZXNlIGNhbGxiYWNrcyBzZWVtIGxpa2UgcGxh Y2Vob2xkZXJzLCB3aGljaApzaG91bGQgYmUgdW5uZWNlc3NhcnkgYXMgdGhpcyBpcyBzaW1wbHkg YW4gaW50ZXJuYWwgQVBJIGJldHdlZW4KdmlydGlvLW1kZXYgdmVuZG9yIGRyaXZlcnMgYW5kIHRo ZSBidXMgZHJpdmVyLiAgVGhhbmtzLAoKQWxleAoKPiA+IE5vdGUgdGhhdCB0aGlzIGlzIG5vdCBs aXN0ZWQgYXMgb3B0aW9uYWwsIGJ1dCB0aGUgc2FtcGxlIGRyaXZlciBkb2Vzbid0Cj4gPiBpbXBs ZW1lbnQgaXQgOi1cICAKPiAKPiAKPiBNeSBiYWQsIHdpbGwgZml4IHRoaXMuCj4gCj4gVGhhbmtz Cj4gCj4gCj4gPiBUaGFua3MsCj4gPgo+ID4gQWxleAo+ID4gIAo+ID4+ICsgKgkJCQlpcyBhY2Nl cHRlZCBieSB0aGUgZGV2aWNlLgo+ID4+ICsgKiBAc2V0X3ZxX2FkZHJlc3M6CQlTZXQgdGhlIGFk ZHJlc3Mgb2YgdmlydHF1ZXVlCj4gPj4gKyAqCQkJCUBtZGV2OiBtZWRpYXRlZCBkZXZpY2UKPiA+ PiArICoJCQkJQGlkeDogdmlydHF1ZXVlIGluZGV4Cj4gPj4gKyAqCQkJCUBkZXNjX2FyZWE6IGFk ZHJlc3Mgb2YgZGVzYyBhcmVhCj4gPj4gKyAqCQkJCUBkcml2ZXJfYXJlYTogYWRkcmVzcyBvZiBk cml2ZXIgYXJlYQo+ID4+ICsgKgkJCQlAZGV2aWNlX2FyZWE6IGFkZHJlc3Mgb2YgZGV2aWNlIGFy ZWEKPiA+PiArICoJCQkJUmV0dXJucyBpbnRlZ2VyOiBzdWNjZXNzICgwKSBvciBlcnJvciAoPCAw KQo+ID4+ICsgKiBAc2V0X3ZxX251bToJCQlTZXQgdGhlIHNpemUgb2YgdmlydHF1ZXVlCj4gPj4g KyAqCQkJCUBtZGV2OiBtZWRpYXRlZCBkZXZpY2UKPiA+PiArICoJCQkJQGlkeDogdmlydHF1ZXVl IGluZGV4Cj4gPj4gKyAqCQkJCUBudW06IHRoZSBzaXplIG9mIHZpcnRxdWV1ZQo+ID4+ICsgKiBA a2lja192cToJCQlLaWNrIHRoZSB2aXJ0cXVldWUKPiA+PiArICoJCQkJQG1kZXY6IG1lZGlhdGVk IGRldmljZQo+ID4+ICsgKgkJCQlAaWR4OiB2aXJ0cXVldWUgaW5kZXgKPiA+PiArICogQHNldF92 cV9jYjoJCQlTZXQgdGhlIGludGVycnVwdCBjYWxsYmFjayBmdW5jdGlvbiBmb3IKPiA+PiArICoJ CQkJYSB2aXJ0cXVldWUKPiA+PiArICoJCQkJQG1kZXY6IG1lZGlhdGVkIGRldmljZQo+ID4+ICsg KgkJCQlAaWR4OiB2aXJ0cXVldWUgaW5kZXgKPiA+PiArICoJCQkJQGNiOiB2aXJ0aW8tbWRldiBp bnRlcnJ1cHQgY2FsbGJhY2sgc3RydWN0dXJlCj4gPj4gKyAqIEBzZXRfdnFfcmVhZHk6CQlTZXQg cmVhZHkgc3RhdHVzIGZvciBhIHZpcnRxdWV1ZQo+ID4+ICsgKgkJCQlAbWRldjogbWVkaWF0ZWQg ZGV2aWNlCj4gPj4gKyAqCQkJCUBpZHg6IHZpcnRxdWV1ZSBpbmRleAo+ID4+ICsgKgkJCQlAcmVh ZHk6IHJlYWR5ICh0cnVlKSBub3QgcmVhZHkoZmFsc2UpCj4gPj4gKyAqIEBnZXRfdnFfcmVhZHk6 CQlHZXQgcmVhZHkgc3RhdHVzIGZvciBhIHZpcnRxdWV1ZQo+ID4+ICsgKgkJCQlAbWRldjogbWVk aWF0ZWQgZGV2aWNlCj4gPj4gKyAqCQkJCUBpZHg6IHZpcnRxdWV1ZSBpbmRleAo+ID4+ICsgKgkJ CQlSZXR1cm5zIGJvb2xlYW46IHJlYWR5ICh0cnVlKSBvciBub3QgKGZhbHNlKQo+ID4+ICsgKiBA c2V0X3ZxX3N0YXRlOgkJU2V0IHRoZSBzdGF0ZSBmb3IgYSB2aXJ0cXVldWUKPiA+PiArICoJCQkJ QG1kZXY6IG1lZGlhdGVkIGRldmljZQo+ID4+ICsgKgkJCQlAaWR4OiB2aXJ0cXVldWUgaW5kZXgK PiA+PiArICoJCQkJQHN0YXRlOiB2aXJ0cXVldWUgc3RhdGUgKGxhc3RfYXZhaWxfaWR4KQo+ID4+ ICsgKgkJCQlSZXR1cm5zIGludGVnZXI6IHN1Y2Nlc3MgKDApIG9yIGVycm9yICg8IDApCj4gPj4g KyAqIEBnZXRfdnFfc3RhdGU6CQlHZXQgdGhlIHN0YXRlIGZvciBhIHZpcnRxdWV1ZQo+ID4+ICsg KgkJCQlAbWRldjogbWVkaWF0ZWQgZGV2aWNlCj4gPj4gKyAqCQkJCUBpZHg6IHZpcnRxdWV1ZSBp bmRleAo+ID4+ICsgKgkJCQlSZXR1cm5zIHZpcnRxdWV1ZSBzdGF0ZSAobGFzdF9hdmFpbF9pZHgp Cj4gPj4gKyAqIEBnZXRfdnFfYWxpZ246CQlHZXQgdGhlIHZpcnRxdWV1ZSBhbGlnbiByZXF1aXJl bWVudAo+ID4+ICsgKgkJCQlmb3IgdGhlIGRldmljZQo+ID4+ICsgKgkJCQlAbWRldjogbWVkaWF0 ZWQgZGV2aWNlCj4gPj4gKyAqCQkJCVJldHVybnMgdmlydHF1ZXVlIGFsZ2luIHJlcXVpcmVtZW50 Cj4gPj4gKyAqIEBnZXRfZmVhdHVyZXM6CQlHZXQgdmlydGlvIGZlYXR1cmVzIHN1cHBvcnRlZCBi eSB0aGUgZGV2aWNlCj4gPj4gKyAqCQkJCUBtZGV2OiBtZWRpYXRlZCBkZXZpY2UKPiA+PiArICoJ CQkJUmV0dXJucyB0aGUgdmlydGlvIGZlYXR1cmVzIHN1cHBvcnQgYnkgdGhlCj4gPj4gKyAqCQkJ CWRldmljZQo+ID4+ICsgKiBAc2V0X2ZlYXR1cmVzOgkJU2V0IHZpcnRpbyBmZWF0dXJlcyBzdXBw b3J0ZWQgYnkgdGhlIGRyaXZlcgo+ID4+ICsgKgkJCQlAbWRldjogbWVkaWF0ZWQgZGV2aWNlCj4g Pj4gKyAqCQkJCUBmZWF0dXJlczogZmVhdHVyZSBzdXBwb3J0IGJ5IHRoZSBkcml2ZXIKPiA+PiAr ICoJCQkJUmV0dXJucyBpbnRlZ2VyOiBzdWNjZXNzICgwKSBvciBlcnJvciAoPCAwKQo+ID4+ICsg KiBAc2V0X2NvbmZpZ19jYjoJCVNldCB0aGUgY29uZmlnIGludGVycnVwdCBjYWxsYmFjawo+ID4+ ICsgKgkJCQlAbWRldjogbWVkaWF0ZWQgZGV2aWNlCj4gPj4gKyAqCQkJCUBjYjogdmlydGlvLW1k ZXYgaW50ZXJydXB0IGNhbGxiYWNrIHN0cnVjdHVyZQo+ID4+ICsgKiBAZ2V0X3ZxX251bV9tYXg6 CQlHZXQgdGhlIG1heCBzaXplIG9mIHZpcnRxdWV1ZQo+ID4+ICsgKgkJCQlAbWRldjogbWVkaWF0 ZWQgZGV2aWNlCj4gPj4gKyAqCQkJCVJldHVybnMgdTE2OiBtYXggc2l6ZSBvZiB2aXJ0cXVldWUK PiA+PiArICogQGdldF9kZXZpY2VfaWQ6CQlHZXQgdmlydGlvIGRldmljZSBpZAo+ID4+ICsgKgkJ CQlAbWRldjogbWVkaWF0ZWQgZGV2aWNlCj4gPj4gKyAqCQkJCVJldHVybnMgdTMyOiB2aXJ0aW8g ZGV2aWNlIGlkCj4gPj4gKyAqIEBnZXRfdmVuZG9yX2lkOgkJR2V0IGlkIGZvciB0aGUgdmVuZG9y IHRoYXQgcHJvdmlkZXMgdGhpcyBkZXZpY2UKPiA+PiArICoJCQkJQG1kZXY6IG1lZGlhdGVkIGRl dmljZQo+ID4+ICsgKgkJCQlSZXR1cm5zIHUzMjogdmlydGlvIHZlbmRvciBpZAo+ID4+ICsgKiBA Z2V0X3N0YXR1czoJCQlHZXQgdGhlIGRldmljZSBzdGF0dXMKPiA+PiArICoJCQkJQG1kZXY6IG1l ZGlhdGVkIGRldmljZQo+ID4+ICsgKgkJCQlSZXR1cm5zIHU4OiB2aXJ0aW8gZGV2aWNlIHN0YXR1 cwo+ID4+ICsgKiBAc2V0X3N0YXR1czoJCQlTZXQgdGhlIGRldmljZSBzdGF0dXMKPiA+PiArICoJ CQkJQG1kZXY6IG1lZGlhdGVkIGRldmljZQo+ID4+ICsgKgkJCQlAc3RhdHVzOiB2aXJ0aW8gZGV2 aWNlIHN0YXR1cwo+ID4+ICsgKiBAZ2V0X2NvbmZpZzoJCQlSZWFkIGZyb20gZGV2aWNlIHNwZWNp ZmljIGNvbmZpZ3VyYXRpb24gc3BhY2UKPiA+PiArICoJCQkJQG1kZXY6IG1lZGlhdGVkIGRldmlj ZQo+ID4+ICsgKgkJCQlAb2Zmc2V0OiBvZmZzZXQgZnJvbSB0aGUgYmVnaW5uaW5nIG9mCj4gPj4g KyAqCQkJCWNvbmZpZ3VyYXRpb24gc3BhY2UKPiA+PiArICoJCQkJQGJ1ZjogYnVmZmVyIHVzZWQg dG8gcmVhZCB0bwo+ID4+ICsgKgkJCQlAbGVuOiB0aGUgbGVuZ3RoIHRvIHJlYWQgZnJvbQo+ID4+ ICsgKgkJCQljb25maWdyYXRpb24gc3BhY2UKPiA+PiArICogQHNldF9jb25maWc6CQkJV3JpdGUg dG8gZGV2aWNlIHNwZWNpZmljIGNvbmZpZ3VyYXRpb24gc3BhY2UKPiA+PiArICoJCQkJQG1kZXY6 IG1lZGlhdGVkIGRldmljZQo+ID4+ICsgKgkJCQlAb2Zmc2V0OiBvZmZzZXQgZnJvbSB0aGUgYmVn aW5uaW5nIG9mCj4gPj4gKyAqCQkJCWNvbmZpZ3VyYXRpb24gc3BhY2UKPiA+PiArICoJCQkJQGJ1 ZjogYnVmZmVyIHVzZWQgdG8gd3JpdGUgZnJvbQo+ID4+ICsgKgkJCQlAbGVuOiB0aGUgbGVuZ3Ro IHRvIHdyaXRlIHRvCj4gPj4gKyAqCQkJCWNvbmZpZ3JhdGlvbiBzcGFjZQo+ID4+ICsgKiBAZ2V0 X2dlbmVyYXRpb246CQlHZXQgZGV2aWNlIGNvbmZpZyBnZW5lcmF0b24gKG9wdGlvbmFsKQo+ID4+ ICsgKgkJCQlAbWRldjogbWVkaWF0ZWQgZGV2aWNlCj4gPj4gKyAqCQkJCVJldHVybnMgdTMyOiBk ZXZpY2UgZ2VuZXJhdGlvbgo+ID4+ICsgKi8KPiA+PiArc3RydWN0IG1kZXZfdmlydGlvX2Rldmlj ZV9vcHMgewo+ID4+ICsJLyogTWRldiBkZXZpY2Ugb3BzICovCj4gPj4gKwl1NjQgKCpnZXRfbWRl dl9mZWF0dXJlcykoc3RydWN0IG1kZXZfZGV2aWNlICptZGV2KTsKPiA+PiArCWJvb2wgKCpzZXRf bWRldl9mZWF0dXJlKShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYpOwo+ID4+ICsJLyogVmlydHF1 ZXVlIG9wcyAqLwo+ID4+ICsJaW50ICgqc2V0X3ZxX2FkZHJlc3MpKHN0cnVjdCBtZGV2X2Rldmlj ZSAqbWRldiwKPiA+PiArCQkJICAgICAgdTE2IGlkeCwgdTY0IGRlc2NfYXJlYSwgdTY0IGRyaXZl cl9hcmVhLAo+ID4+ICsJCQkgICAgICB1NjQgZGV2aWNlX2FyZWEpOwo+ID4+ICsJdm9pZCAoKnNl dF92cV9udW0pKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdTE2IGlkeCwgdTMyIG51bSk7Cj4g Pj4gKwl2b2lkICgqa2lja192cSkoc3RydWN0IG1kZXZfZGV2aWNlICptZGV2LCB1MTYgaWR4KTsK PiA+PiArCXZvaWQgKCpzZXRfdnFfY2IpKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdTE2IGlk eCwKPiA+PiArCQkJICBzdHJ1Y3QgdmlydGlvX21kZXZfY2FsbGJhY2sgKmNiKTsKPiA+PiArCXZv aWQgKCpzZXRfdnFfcmVhZHkpKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdTE2IGlkeCwgYm9v bCByZWFkeSk7Cj4gPj4gKwlib29sICgqZ2V0X3ZxX3JlYWR5KShzdHJ1Y3QgbWRldl9kZXZpY2Ug Km1kZXYsIHUxNiBpZHgpOwo+ID4+ICsJaW50ICgqc2V0X3ZxX3N0YXRlKShzdHJ1Y3QgbWRldl9k ZXZpY2UgKm1kZXYsIHUxNiBpZHgsIHU2NCBzdGF0ZSk7Cj4gPj4gKwl1NjQgKCpnZXRfdnFfc3Rh dGUpKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdTE2IGlkeCk7Cj4gPj4gKwo+ID4+ICsJLyog VmlydGlvIGRldmljZSBvcHMgKi8KPiA+PiArCXUxNiAoKmdldF92cV9hbGlnbikoc3RydWN0IG1k ZXZfZGV2aWNlICptZGV2KTsKPiA+PiArCXU2NCAoKmdldF9mZWF0dXJlcykoc3RydWN0IG1kZXZf ZGV2aWNlICptZGV2KTsKPiA+PiArCWludCAoKnNldF9mZWF0dXJlcykoc3RydWN0IG1kZXZfZGV2 aWNlICptZGV2LCB1NjQgZmVhdHVyZXMpOwo+ID4+ICsJdm9pZCAoKnNldF9jb25maWdfY2IpKHN0 cnVjdCBtZGV2X2RldmljZSAqbWRldiwKPiA+PiArCQkJICAgICAgc3RydWN0IHZpcnRpb19tZGV2 X2NhbGxiYWNrICpjYik7Cj4gPj4gKwl1MTYgKCpnZXRfdnFfbnVtX21heCkoc3RydWN0IG1kZXZf ZGV2aWNlICptZGV2KTsKPiA+PiArCXUzMiAoKmdldF9kZXZpY2VfaWQpKHN0cnVjdCBtZGV2X2Rl dmljZSAqbWRldik7Cj4gPj4gKwl1MzIgKCpnZXRfdmVuZG9yX2lkKShzdHJ1Y3QgbWRldl9kZXZp Y2UgKm1kZXYpOwo+ID4+ICsJdTggKCpnZXRfc3RhdHVzKShzdHJ1Y3QgbWRldl9kZXZpY2UgKm1k ZXYpOwo+ID4+ICsJdm9pZCAoKnNldF9zdGF0dXMpKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwg dTggc3RhdHVzKTsKPiA+PiArCXZvaWQgKCpnZXRfY29uZmlnKShzdHJ1Y3QgbWRldl9kZXZpY2Ug Km1kZXYsIHVuc2lnbmVkIGludCBvZmZzZXQsCj4gPj4gKwkJCSAgIHZvaWQgKmJ1ZiwgdW5zaWdu ZWQgaW50IGxlbik7Cj4gPj4gKwl2b2lkICgqc2V0X2NvbmZpZykoc3RydWN0IG1kZXZfZGV2aWNl ICptZGV2LCB1bnNpZ25lZCBpbnQgb2Zmc2V0LAo+ID4+ICsJCQkgICBjb25zdCB2b2lkICpidWYs IHVuc2lnbmVkIGludCBsZW4pOwo+ID4+ICsJdTMyICgqZ2V0X2dlbmVyYXRpb24pKHN0cnVjdCBt ZGV2X2RldmljZSAqbWRldik7Cj4gPj4gK307Cj4gPj4gKwo+ID4+ICt2b2lkIG1kZXZfc2V0X3Zp cnRpb19vcHMoc3RydWN0IG1kZXZfZGV2aWNlICptZGV2LAo+ID4+ICsJCQkgY29uc3Qgc3RydWN0 IG1kZXZfdmlydGlvX2RldmljZV9vcHMgKnZpcnRpb19vcHMpOwo+ID4+ICsKPiA+PiArI2VuZGlm ICAKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1k ZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczov L2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbA==