From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from aer-iport-3.cisco.com ([173.38.203.53]:62038 "EHLO aer-iport-3.cisco.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2389264AbeIUOMO (ORCPT ); Fri, 21 Sep 2018 10:12:14 -0400 Subject: Re: [PATCH 04/18] video/hdmi: Constify infoframe passed to the pack functions To: Ville Syrjala , dri-devel@lists.freedesktop.org Cc: intel-gfx@lists.freedesktop.org, Thierry Reding , Hans Verkuil , linux-media@vger.kernel.org References: <20180920185145.1912-1-ville.syrjala@linux.intel.com> <20180920185145.1912-5-ville.syrjala@linux.intel.com> From: Hans Verkuil Message-ID: Date: Fri, 21 Sep 2018 10:24:25 +0200 MIME-Version: 1.0 In-Reply-To: <20180920185145.1912-5-ville.syrjala@linux.intel.com> Content-Type: text/plain; charset=utf-8 Content-Language: en-US Content-Transfer-Encoding: 8bit Sender: linux-media-owner@vger.kernel.org List-ID: On 09/20/18 20:51, Ville Syrjala wrote: > From: Ville Syrjälä > > Let's make the infoframe pack functions usable with a const infoframe > structure. This allows us to precompute the infoframe earlier, and still > pack it later when we're no longer allowed to modify the structure. > So now we end up with a _check()+_pack_only() or _pack() functions > depending on whether you want to precompute the infoframes or not. > The names aren't greate but I was lazy and didn't want to change all the greate -> great > drivers. > > v2: Deal with exynos churn > Actually export the new funcs > > Cc: Thierry Reding > Cc: Hans Verkuil > Cc: linux-media@vger.kernel.org > Signed-off-by: Ville Syrjälä > --- > drivers/video/hdmi.c | 425 +++++++++++++++++++++++++++++++++++++++++++++++---- > include/linux/hdmi.h | 19 ++- > 2 files changed, 416 insertions(+), 28 deletions(-) > > diff --git a/drivers/video/hdmi.c b/drivers/video/hdmi.c > index 53e7ee2c83fc..9507f668a569 100644 > --- a/drivers/video/hdmi.c > +++ b/drivers/video/hdmi.c > @@ -68,8 +68,36 @@ int hdmi_avi_infoframe_init(struct hdmi_avi_infoframe *frame) > } > EXPORT_SYMBOL(hdmi_avi_infoframe_init); > > +static int hdmi_avi_infoframe_check_only(const struct hdmi_avi_infoframe *frame) > +{ > + if (frame->type != HDMI_INFOFRAME_TYPE_AVI || > + frame->version != 2 || > + frame->length != HDMI_AVI_INFOFRAME_SIZE) > + return -EINVAL; > + > + if (frame->picture_aspect > HDMI_PICTURE_ASPECT_16_9) > + return -EINVAL; > + > + return 0; > +} > + > /** > - * hdmi_avi_infoframe_pack() - write HDMI AVI infoframe to binary buffer > + * hdmi_avi_infoframe_check() - Check and check a HDMI AVI infoframe "Check and check"? This is repeated elsewhere as well (clearly copy-and-paste). > + * @frame: HDMI AVI infoframe > + * > + * Validates that the infoframe is consistent and updates derived fields > + * (eg. length) based on other fields. > + * > + * Returns 0 on success or a negative error code on failure. > + */ > +int hdmi_avi_infoframe_check(struct hdmi_avi_infoframe *frame) > +{ > + return hdmi_avi_infoframe_check_only(frame); > +} > +EXPORT_SYMBOL(hdmi_avi_infoframe_check); > + > +/** > + * hdmi_avi_infoframe_pack_only() - write HDMI AVI infoframe to binary buffer > * @frame: HDMI AVI infoframe > * @buffer: destination buffer > * @size: size of buffer > @@ -82,20 +110,22 @@ EXPORT_SYMBOL(hdmi_avi_infoframe_init); > * Returns the number of bytes packed into the binary buffer or a negative > * error code on failure. > */ > -ssize_t hdmi_avi_infoframe_pack(struct hdmi_avi_infoframe *frame, void *buffer, > - size_t size) > +ssize_t hdmi_avi_infoframe_pack_only(const struct hdmi_avi_infoframe *frame, > + void *buffer, size_t size) > { > u8 *ptr = buffer; > size_t length; > + int ret; > + > + ret = hdmi_avi_infoframe_check_only(frame); > + if (ret) > + return ret; > > length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; > > if (size < length) > return -ENOSPC; > > - if (frame->picture_aspect > HDMI_PICTURE_ASPECT_16_9) > - return -EINVAL; > - > memset(buffer, 0, size); > > ptr[0] = frame->type; > @@ -152,6 +182,36 @@ ssize_t hdmi_avi_infoframe_pack(struct hdmi_avi_infoframe *frame, void *buffer, > > return length; > } > +EXPORT_SYMBOL(hdmi_avi_infoframe_pack_only); > + > +/** > + * hdmi_avi_infoframe_pack() - Check and check a HDMI AVI infoframe, > + * and write it to binary buffer > + * @frame: HDMI AVI infoframe > + * @buffer: destination buffer > + * @size: size of buffer > + * > + * Validates that the infoframe is consistent and updates derived fields > + * (eg. length) based on other fields, after which packs the information which packs -> which it packs Ditto elsewhere. > + * contained in the @frame structure into a binary representation that > + * can be written into the corresponding controller registers. Also Also -> This function also Ditto elsewhere. > + * computes the checksum as required by section 5.3.5 of the HDMI 1.4 > + * specification. > + * > + * Returns the number of bytes packed into the binary buffer or a negative > + * error code on failure. > + */ > +ssize_t hdmi_avi_infoframe_pack(struct hdmi_avi_infoframe *frame, > + void *buffer, size_t size) > +{ > + int ret; > + > + ret = hdmi_avi_infoframe_check(frame); > + if (ret) > + return ret; > + > + return hdmi_avi_infoframe_pack_only(frame, buffer, size); > +} > EXPORT_SYMBOL(hdmi_avi_infoframe_pack); > > /** > @@ -178,8 +238,33 @@ int hdmi_spd_infoframe_init(struct hdmi_spd_infoframe *frame, > } > EXPORT_SYMBOL(hdmi_spd_infoframe_init); > > +static int hdmi_spd_infoframe_check_only(const struct hdmi_spd_infoframe *frame) > +{ > + if (frame->type != HDMI_INFOFRAME_TYPE_SPD || > + frame->version != 1 || > + frame->length != HDMI_SPD_INFOFRAME_SIZE) > + return -EINVAL; > + > + return 0; > +} > + > /** > - * hdmi_spd_infoframe_pack() - write HDMI SPD infoframe to binary buffer > + * hdmi_spd_infoframe_check() - Check and check a HDMI SPD infoframe > + * @frame: HDMI SPD infoframe > + * > + * Validates that the infoframe is consistent and updates derived fields > + * (eg. length) based on other fields. > + * > + * Returns 0 on success or a negative error code on failure. > + */ > +int hdmi_spd_infoframe_check(struct hdmi_spd_infoframe *frame) > +{ > + return hdmi_spd_infoframe_check_only(frame); > +} > +EXPORT_SYMBOL(hdmi_spd_infoframe_check); > + > +/** > + * hdmi_spd_infoframe_pack_only() - write HDMI SPD infoframe to binary buffer > * @frame: HDMI SPD infoframe > * @buffer: destination buffer > * @size: size of buffer > @@ -192,11 +277,16 @@ EXPORT_SYMBOL(hdmi_spd_infoframe_init); > * Returns the number of bytes packed into the binary buffer or a negative > * error code on failure. > */ > -ssize_t hdmi_spd_infoframe_pack(struct hdmi_spd_infoframe *frame, void *buffer, > - size_t size) > +ssize_t hdmi_spd_infoframe_pack_only(const struct hdmi_spd_infoframe *frame, > + void *buffer, size_t size) > { > u8 *ptr = buffer; > size_t length; > + int ret; > + > + ret = hdmi_spd_infoframe_check_only(frame); > + if (ret) > + return ret; > > length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; > > @@ -222,6 +312,36 @@ ssize_t hdmi_spd_infoframe_pack(struct hdmi_spd_infoframe *frame, void *buffer, > > return length; > } > +EXPORT_SYMBOL(hdmi_spd_infoframe_pack_only); > + > +/** > + * hdmi_spd_infoframe_pack() - Check and check a HDMI SPD infoframe, > + * and write it to binary buffer > + * @frame: HDMI SPD infoframe > + * @buffer: destination buffer > + * @size: size of buffer > + * > + * Validates that the infoframe is consistent and updates derived fields > + * (eg. length) based on other fields, after which packs the information > + * contained in the @frame structure into a binary representation that > + * can be written into the corresponding controller registers. Also > + * computes the checksum as required by section 5.3.5 of the HDMI 1.4 > + * specification. > + * > + * Returns the number of bytes packed into the binary buffer or a negative > + * error code on failure. > + */ > +ssize_t hdmi_spd_infoframe_pack(struct hdmi_spd_infoframe *frame, > + void *buffer, size_t size) > +{ > + int ret; > + > + ret = hdmi_spd_infoframe_check(frame); > + if (ret) > + return ret; > + > + return hdmi_spd_infoframe_pack_only(frame, buffer, size); > +} > EXPORT_SYMBOL(hdmi_spd_infoframe_pack); > > /** > @@ -242,8 +362,33 @@ int hdmi_audio_infoframe_init(struct hdmi_audio_infoframe *frame) > } > EXPORT_SYMBOL(hdmi_audio_infoframe_init); > > +static int hdmi_audio_infoframe_check_only(const struct hdmi_audio_infoframe *frame) > +{ > + if (frame->type != HDMI_INFOFRAME_TYPE_AUDIO || > + frame->version != 1 || > + frame->length != HDMI_AUDIO_INFOFRAME_SIZE) > + return -EINVAL; > + > + return 0; > +} > + > +/** > + * hdmi_audio_infoframe_check() - Check and check a HDMI audio infoframe > + * @frame: HDMI audio infoframe > + * > + * Validates that the infoframe is consistent and updates derived fields > + * (eg. length) based on other fields. > + * > + * Returns 0 on success or a negative error code on failure. > + */ > +int hdmi_audio_infoframe_check(struct hdmi_audio_infoframe *frame) > +{ > + return hdmi_audio_infoframe_check_only(frame); > +} > +EXPORT_SYMBOL(hdmi_audio_infoframe_check); > + > /** > - * hdmi_audio_infoframe_pack() - write HDMI audio infoframe to binary buffer > + * hdmi_audio_infoframe_pack_only() - write HDMI audio infoframe to binary buffer > * @frame: HDMI audio infoframe > * @buffer: destination buffer > * @size: size of buffer > @@ -256,12 +401,17 @@ EXPORT_SYMBOL(hdmi_audio_infoframe_init); > * Returns the number of bytes packed into the binary buffer or a negative > * error code on failure. > */ > -ssize_t hdmi_audio_infoframe_pack(struct hdmi_audio_infoframe *frame, > - void *buffer, size_t size) > +ssize_t hdmi_audio_infoframe_pack_only(const struct hdmi_audio_infoframe *frame, > + void *buffer, size_t size) > { > unsigned char channels; > u8 *ptr = buffer; > size_t length; > + int ret; > + > + ret = hdmi_audio_infoframe_check_only(frame); > + if (ret) > + return ret; > > length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; > > @@ -297,6 +447,36 @@ ssize_t hdmi_audio_infoframe_pack(struct hdmi_audio_infoframe *frame, > > return length; > } > +EXPORT_SYMBOL(hdmi_audio_infoframe_pack_only); > + > +/** > + * hdmi_audio_infoframe_pack() - Check and check a HDMI Audio infoframe, > + * and write it to binary buffer > + * @frame: HDMI Audio infoframe > + * @buffer: destination buffer > + * @size: size of buffer > + * > + * Validates that the infoframe is consistent and updates derived fields > + * (eg. length) based on other fields, after which packs the information > + * contained in the @frame structure into a binary representation that > + * can be written into the corresponding controller registers. Also > + * computes the checksum as required by section 5.3.5 of the HDMI 1.4 > + * specification. > + * > + * Returns the number of bytes packed into the binary buffer or a negative > + * error code on failure. > + */ > +ssize_t hdmi_audio_infoframe_pack(struct hdmi_audio_infoframe *frame, > + void *buffer, size_t size) > +{ > + int ret; > + > + ret = hdmi_audio_infoframe_check(frame); > + if (ret) > + return ret; > + > + return hdmi_audio_infoframe_pack_only(frame, buffer, size); > +} > EXPORT_SYMBOL(hdmi_audio_infoframe_pack); > > /** > @@ -319,6 +499,7 @@ int hdmi_vendor_infoframe_init(struct hdmi_vendor_infoframe *frame) > * value > */ > frame->s3d_struct = HDMI_3D_STRUCTURE_INVALID; > + frame->length = 4; > > return 0; > } > @@ -335,8 +516,42 @@ static int hdmi_vendor_infoframe_length(const struct hdmi_vendor_infoframe *fram > return 4; > } > > +static int hdmi_vendor_infoframe_check_only(const struct hdmi_vendor_infoframe *frame) > +{ > + if (frame->type != HDMI_INFOFRAME_TYPE_VENDOR || > + frame->version != 1 || > + frame->oui != HDMI_IEEE_OUI) > + return -EINVAL; > + > + /* only one of those can be supplied */ > + if (frame->vic != 0 && frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID) > + return -EINVAL; > + > + if (frame->length != hdmi_vendor_infoframe_length(frame)) > + return -EINVAL; > + > + return 0; > +} > + > /** > - * hdmi_vendor_infoframe_pack() - write a HDMI vendor infoframe to binary buffer > + * hdmi_vendor_infoframe_check() - Check and check a HDMI vendor infoframe > + * @frame: HDMI infoframe > + * > + * Validates that the infoframe is consistent and updates derived fields > + * (eg. length) based on other fields. > + * > + * Returns 0 on success or a negative error code on failure. > + */ > +int hdmi_vendor_infoframe_check(struct hdmi_vendor_infoframe *frame) > +{ > + frame->length = hdmi_vendor_infoframe_length(frame); > + > + return hdmi_vendor_infoframe_check_only(frame); > +} > +EXPORT_SYMBOL(hdmi_vendor_infoframe_check); > + > +/** > + * hdmi_vendor_infoframe_pack_only() - write a HDMI vendor infoframe to binary buffer > * @frame: HDMI infoframe > * @buffer: destination buffer > * @size: size of buffer > @@ -349,17 +564,16 @@ static int hdmi_vendor_infoframe_length(const struct hdmi_vendor_infoframe *fram > * Returns the number of bytes packed into the binary buffer or a negative > * error code on failure. > */ > -ssize_t hdmi_vendor_infoframe_pack(struct hdmi_vendor_infoframe *frame, > - void *buffer, size_t size) > +ssize_t hdmi_vendor_infoframe_pack_only(const struct hdmi_vendor_infoframe *frame, > + void *buffer, size_t size) > { > u8 *ptr = buffer; > size_t length; > + int ret; > > - /* only one of those can be supplied */ > - if (frame->vic != 0 && frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID) > - return -EINVAL; > - > - frame->length = hdmi_vendor_infoframe_length(frame); > + ret = hdmi_vendor_infoframe_check_only(frame); > + if (ret) > + return ret; > > length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; > > @@ -394,24 +608,134 @@ ssize_t hdmi_vendor_infoframe_pack(struct hdmi_vendor_infoframe *frame, > > return length; > } > +EXPORT_SYMBOL(hdmi_vendor_infoframe_pack_only); > + > +/** > + * hdmi_vendor_infoframe_pack() - Check and check a HDMI Vendor infoframe, > + * and write it to binary buffer > + * @frame: HDMI Vendor infoframe > + * @buffer: destination buffer > + * @size: size of buffer > + * > + * Validates that the infoframe is consistent and updates derived fields > + * (eg. length) based on other fields, after which packs the information > + * contained in the @frame structure into a binary representation that > + * can be written into the corresponding controller registers. Also > + * computes the checksum as required by section 5.3.5 of the HDMI 1.4 > + * specification. > + * > + * Returns the number of bytes packed into the binary buffer or a negative > + * error code on failure. > + */ > +ssize_t hdmi_vendor_infoframe_pack(struct hdmi_vendor_infoframe *frame, > + void *buffer, size_t size) > +{ > + int ret; > + > + ret = hdmi_vendor_infoframe_check(frame); > + if (ret) > + return ret; > + > + return hdmi_vendor_infoframe_pack_only(frame, buffer, size); > +} > EXPORT_SYMBOL(hdmi_vendor_infoframe_pack); > > +static int > +hdmi_vendor_any_infoframe_check_only(const union hdmi_vendor_any_infoframe *frame) > +{ > + if (frame->any.type != HDMI_INFOFRAME_TYPE_VENDOR || > + frame->any.version != 1) > + return -EINVAL; > + > + return 0; > +} > + > /* > - * hdmi_vendor_any_infoframe_pack() - write a vendor infoframe to binary buffer > + * hdmi_vendor_any_infoframe_check() - check and check a vendor infoframe > + */ > +static int > +hdmi_vendor_any_infoframe_check(union hdmi_vendor_any_infoframe *frame) > +{ > + int ret; > + > + ret = hdmi_vendor_any_infoframe_check_only(frame); > + if (ret) > + return ret; > + > + /* we only know about HDMI vendor infoframes */ > + if (frame->any.oui != HDMI_IEEE_OUI) > + return -EINVAL; > + > + return hdmi_vendor_infoframe_check(&frame->hdmi); > +} > + > +/* > + * hdmi_vendor_any_infoframe_pack_only() - write a vendor infoframe to binary buffer > */ > static ssize_t > -hdmi_vendor_any_infoframe_pack(union hdmi_vendor_any_infoframe *frame, > - void *buffer, size_t size) > +hdmi_vendor_any_infoframe_pack_only(const union hdmi_vendor_any_infoframe *frame, > + void *buffer, size_t size) > { > + int ret; > + > + ret = hdmi_vendor_any_infoframe_check_only(frame); > + if (ret) > + return ret; > + > /* we only know about HDMI vendor infoframes */ > if (frame->any.oui != HDMI_IEEE_OUI) > return -EINVAL; > > - return hdmi_vendor_infoframe_pack(&frame->hdmi, buffer, size); > + return hdmi_vendor_infoframe_pack_only(&frame->hdmi, buffer, size); > +} > + > +/* > + * hdmi_vendor_any_infoframe_pack() - check and check a vendor infoframe, > + * and write it to binary buffer > + */ > +static ssize_t > +hdmi_vendor_any_infoframe_pack(union hdmi_vendor_any_infoframe *frame, > + void *buffer, size_t size) > +{ > + int ret; > + > + ret = hdmi_vendor_any_infoframe_check(frame); > + if (ret) > + return ret; > + > + return hdmi_vendor_any_infoframe_pack_only(frame, buffer, size); > +} > + > +/** > + * hdmi_infoframe_check() - Check check a HDMI infoframe > + * @frame: HDMI infoframe > + * > + * Validates that the infoframe is consistent and updates derived fields > + * (eg. length) based on other fields. > + * > + * Returns 0 on success or a negative error code on failure. > + */ > +int > +hdmi_infoframe_check(union hdmi_infoframe *frame) > +{ > + switch (frame->any.type) { > + case HDMI_INFOFRAME_TYPE_AVI: > + return hdmi_avi_infoframe_check(&frame->avi); > + case HDMI_INFOFRAME_TYPE_SPD: > + return hdmi_spd_infoframe_check(&frame->spd); > + case HDMI_INFOFRAME_TYPE_AUDIO: > + return hdmi_audio_infoframe_check(&frame->audio); > + case HDMI_INFOFRAME_TYPE_VENDOR: > + return hdmi_vendor_any_infoframe_check(&frame->vendor); > + default: > + WARN(1, "Bad infoframe type %d\n", frame->any.type); > + return -EINVAL; > + } > } > +EXPORT_SYMBOL(hdmi_infoframe_check); > > /** > - * hdmi_infoframe_pack() - write a HDMI infoframe to binary buffer > + * hdmi_infoframe_pack_only() - write a HDMI infoframe to binary buffer > * @frame: HDMI infoframe > * @buffer: destination buffer > * @size: size of buffer > @@ -425,7 +749,56 @@ hdmi_vendor_any_infoframe_pack(union hdmi_vendor_any_infoframe *frame, > * error code on failure. > */ > ssize_t > -hdmi_infoframe_pack(union hdmi_infoframe *frame, void *buffer, size_t size) > +hdmi_infoframe_pack_only(const union hdmi_infoframe *frame, void *buffer, size_t size) > +{ > + ssize_t length; > + > + switch (frame->any.type) { > + case HDMI_INFOFRAME_TYPE_AVI: > + length = hdmi_avi_infoframe_pack_only(&frame->avi, > + buffer, size); > + break; > + case HDMI_INFOFRAME_TYPE_SPD: > + length = hdmi_spd_infoframe_pack_only(&frame->spd, > + buffer, size); > + break; > + case HDMI_INFOFRAME_TYPE_AUDIO: > + length = hdmi_audio_infoframe_pack_only(&frame->audio, > + buffer, size); > + break; > + case HDMI_INFOFRAME_TYPE_VENDOR: > + length = hdmi_vendor_any_infoframe_pack_only(&frame->vendor, > + buffer, size); > + break; > + default: > + WARN(1, "Bad infoframe type %d\n", frame->any.type); > + length = -EINVAL; > + } > + > + return length; > +} > +EXPORT_SYMBOL(hdmi_infoframe_pack_only); > + > +/** > + * hdmi_infoframe_pack() - Check check a HDMI infoframe, Check check? > + * and write it to binary buffer > + * @frame: HDMI infoframe > + * @buffer: destination buffer > + * @size: size of buffer > + * > + * Validates that the infoframe is consistent and updates derived fields > + * (eg. length) based on other fields, after which packs the information > + * contained in the @frame structure into a binary representation that > + * can be written into the corresponding controller registers. Also > + * computes the checksum as required by section 5.3.5 of the HDMI 1.4 > + * specification. > + * > + * Returns the number of bytes packed into the binary buffer or a negative > + * error code on failure. > + */ > +ssize_t > +hdmi_infoframe_pack(union hdmi_infoframe *frame, > + void *buffer, size_t size) > { > ssize_t length; > > diff --git a/include/linux/hdmi.h b/include/linux/hdmi.h > index bce1abb1fe57..c76b50a48e48 100644 > --- a/include/linux/hdmi.h > +++ b/include/linux/hdmi.h > @@ -163,6 +163,9 @@ struct hdmi_avi_infoframe { > int hdmi_avi_infoframe_init(struct hdmi_avi_infoframe *frame); > ssize_t hdmi_avi_infoframe_pack(struct hdmi_avi_infoframe *frame, void *buffer, > size_t size); > +ssize_t hdmi_avi_infoframe_pack_only(const struct hdmi_avi_infoframe *frame, > + void *buffer, size_t size); > +int hdmi_avi_infoframe_check(struct hdmi_avi_infoframe *frame); > > enum hdmi_spd_sdi { > HDMI_SPD_SDI_UNKNOWN, > @@ -194,6 +197,9 @@ int hdmi_spd_infoframe_init(struct hdmi_spd_infoframe *frame, > const char *vendor, const char *product); > ssize_t hdmi_spd_infoframe_pack(struct hdmi_spd_infoframe *frame, void *buffer, > size_t size); > +ssize_t hdmi_spd_infoframe_pack_only(const struct hdmi_spd_infoframe *frame, > + void *buffer, size_t size); > +int hdmi_spd_infoframe_check(struct hdmi_spd_infoframe *frame); > > enum hdmi_audio_coding_type { > HDMI_AUDIO_CODING_TYPE_STREAM, > @@ -272,6 +278,9 @@ struct hdmi_audio_infoframe { > int hdmi_audio_infoframe_init(struct hdmi_audio_infoframe *frame); > ssize_t hdmi_audio_infoframe_pack(struct hdmi_audio_infoframe *frame, > void *buffer, size_t size); > +ssize_t hdmi_audio_infoframe_pack_only(const struct hdmi_audio_infoframe *frame, > + void *buffer, size_t size); > +int hdmi_audio_infoframe_check(struct hdmi_audio_infoframe *frame); > > enum hdmi_3d_structure { > HDMI_3D_STRUCTURE_INVALID = -1, > @@ -299,6 +308,9 @@ struct hdmi_vendor_infoframe { > int hdmi_vendor_infoframe_init(struct hdmi_vendor_infoframe *frame); > ssize_t hdmi_vendor_infoframe_pack(struct hdmi_vendor_infoframe *frame, > void *buffer, size_t size); > +ssize_t hdmi_vendor_infoframe_pack_only(const struct hdmi_vendor_infoframe *frame, > + void *buffer, size_t size); > +int hdmi_vendor_infoframe_check(struct hdmi_vendor_infoframe *frame); > > union hdmi_vendor_any_infoframe { > struct { > @@ -330,8 +342,11 @@ union hdmi_infoframe { > struct hdmi_audio_infoframe audio; > }; > > -ssize_t > -hdmi_infoframe_pack(union hdmi_infoframe *frame, void *buffer, size_t size); > +ssize_t hdmi_infoframe_pack(union hdmi_infoframe *frame, void *buffer, > + size_t size); > +ssize_t hdmi_infoframe_pack_only(const union hdmi_infoframe *frame, > + void *buffer, size_t size); > +int hdmi_infoframe_check(union hdmi_infoframe *frame); > int hdmi_infoframe_unpack(union hdmi_infoframe *frame, > const void *buffer, size_t size); > void hdmi_infoframe_log(const char *level, struct device *dev, > Regards, Hans From mboxrd@z Thu Jan 1 00:00:00 1970 From: Hans Verkuil Subject: Re: [PATCH 04/18] video/hdmi: Constify infoframe passed to the pack functions Date: Fri, 21 Sep 2018 10:24:25 +0200 Message-ID: References: <20180920185145.1912-1-ville.syrjala@linux.intel.com> <20180920185145.1912-5-ville.syrjala@linux.intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180920185145.1912-5-ville.syrjala@linux.intel.com> Content-Language: en-US List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Ville Syrjala , dri-devel@lists.freedesktop.org Cc: intel-gfx@lists.freedesktop.org, Thierry Reding , Hans Verkuil , linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org T24gMDkvMjAvMTggMjA6NTEsIFZpbGxlIFN5cmphbGEgd3JvdGU6Cj4gRnJvbTogVmlsbGUgU3ly asOkbMOkIDx2aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNvbT4KPiAKPiBMZXQncyBtYWtlIHRo ZSBpbmZvZnJhbWUgcGFjayBmdW5jdGlvbnMgdXNhYmxlIHdpdGggYSBjb25zdCBpbmZvZnJhbWUK PiBzdHJ1Y3R1cmUuIFRoaXMgYWxsb3dzIHVzIHRvIHByZWNvbXB1dGUgdGhlIGluZm9mcmFtZSBl YXJsaWVyLCBhbmQgc3RpbGwKPiBwYWNrIGl0IGxhdGVyIHdoZW4gd2UncmUgbm8gbG9uZ2VyIGFs bG93ZWQgdG8gbW9kaWZ5IHRoZSBzdHJ1Y3R1cmUuCj4gU28gbm93IHdlIGVuZCB1cCB3aXRoIGEg X2NoZWNrKCkrX3BhY2tfb25seSgpIG9yIF9wYWNrKCkgZnVuY3Rpb25zCj4gZGVwZW5kaW5nIG9u IHdoZXRoZXIgeW91IHdhbnQgdG8gcHJlY29tcHV0ZSB0aGUgaW5mb2ZyYW1lcyBvciBub3QuCj4g VGhlIG5hbWVzIGFyZW4ndCBncmVhdGUgYnV0IEkgd2FzIGxhenkgYW5kIGRpZG4ndCB3YW50IHRv IGNoYW5nZSBhbGwgdGhlCgpncmVhdGUgLT4gZ3JlYXQKCj4gZHJpdmVycy4KPiAKPiB2MjogRGVh bCB3aXRoIGV4eW5vcyBjaHVybgo+ICAgICBBY3R1YWxseSBleHBvcnQgdGhlIG5ldyBmdW5jcwo+ IAo+IENjOiBUaGllcnJ5IFJlZGluZyA8dGhpZXJyeS5yZWRpbmdAZ21haWwuY29tPgo+IENjOiBI YW5zIFZlcmt1aWwgPGhhbnMudmVya3VpbEBjaXNjby5jb20+Cj4gQ2M6IGxpbnV4LW1lZGlhQHZn ZXIua2VybmVsLm9yZwo+IFNpZ25lZC1vZmYtYnk6IFZpbGxlIFN5cmrDpGzDpCA8dmlsbGUuc3ly amFsYUBsaW51eC5pbnRlbC5jb20+Cj4gLS0tCj4gIGRyaXZlcnMvdmlkZW8vaGRtaS5jIHwgNDI1 ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tLQo+ICBp bmNsdWRlL2xpbnV4L2hkbWkuaCB8ICAxOSArKy0KPiAgMiBmaWxlcyBjaGFuZ2VkLCA0MTYgaW5z ZXJ0aW9ucygrKSwgMjggZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlk ZW8vaGRtaS5jIGIvZHJpdmVycy92aWRlby9oZG1pLmMKPiBpbmRleCA1M2U3ZWUyYzgzZmMuLjk1 MDdmNjY4YTU2OSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3ZpZGVvL2hkbWkuYwo+ICsrKyBiL2Ry aXZlcnMvdmlkZW8vaGRtaS5jCj4gQEAgLTY4LDggKzY4LDM2IEBAIGludCBoZG1pX2F2aV9pbmZv ZnJhbWVfaW5pdChzdHJ1Y3QgaGRtaV9hdmlfaW5mb2ZyYW1lICpmcmFtZSkKPiAgfQo+ICBFWFBP UlRfU1lNQk9MKGhkbWlfYXZpX2luZm9mcmFtZV9pbml0KTsKPiAgCj4gK3N0YXRpYyBpbnQgaGRt aV9hdmlfaW5mb2ZyYW1lX2NoZWNrX29ubHkoY29uc3Qgc3RydWN0IGhkbWlfYXZpX2luZm9mcmFt ZSAqZnJhbWUpCj4gK3sKPiArCWlmIChmcmFtZS0+dHlwZSAhPSBIRE1JX0lORk9GUkFNRV9UWVBF X0FWSSB8fAo+ICsJICAgIGZyYW1lLT52ZXJzaW9uICE9IDIgfHwKPiArCSAgICBmcmFtZS0+bGVu Z3RoICE9IEhETUlfQVZJX0lORk9GUkFNRV9TSVpFKQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsK PiArCWlmIChmcmFtZS0+cGljdHVyZV9hc3BlY3QgPiBIRE1JX1BJQ1RVUkVfQVNQRUNUXzE2Xzkp Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gIC8qKgo+ IC0gKiBoZG1pX2F2aV9pbmZvZnJhbWVfcGFjaygpIC0gd3JpdGUgSERNSSBBVkkgaW5mb2ZyYW1l IHRvIGJpbmFyeSBidWZmZXIKPiArICogaGRtaV9hdmlfaW5mb2ZyYW1lX2NoZWNrKCkgLSBDaGVj ayBhbmQgY2hlY2sgYSBIRE1JIEFWSSBpbmZvZnJhbWUKCiJDaGVjayBhbmQgY2hlY2siPyBUaGlz IGlzIHJlcGVhdGVkIGVsc2V3aGVyZSBhcyB3ZWxsIChjbGVhcmx5IGNvcHktYW5kLXBhc3RlKS4K Cj4gKyAqIEBmcmFtZTogSERNSSBBVkkgaW5mb2ZyYW1lCj4gKyAqCj4gKyAqIFZhbGlkYXRlcyB0 aGF0IHRoZSBpbmZvZnJhbWUgaXMgY29uc2lzdGVudCBhbmQgdXBkYXRlcyBkZXJpdmVkIGZpZWxk cwo+ICsgKiAoZWcuIGxlbmd0aCkgYmFzZWQgb24gb3RoZXIgZmllbGRzLgo+ICsgKgo+ICsgKiBS ZXR1cm5zIDAgb24gc3VjY2VzcyBvciBhIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24gZmFpbHVyZS4K PiArICovCj4gK2ludCBoZG1pX2F2aV9pbmZvZnJhbWVfY2hlY2soc3RydWN0IGhkbWlfYXZpX2lu Zm9mcmFtZSAqZnJhbWUpCj4gK3sKPiArCXJldHVybiBoZG1pX2F2aV9pbmZvZnJhbWVfY2hlY2tf b25seShmcmFtZSk7Cj4gK30KPiArRVhQT1JUX1NZTUJPTChoZG1pX2F2aV9pbmZvZnJhbWVfY2hl Y2spOwo+ICsKPiArLyoqCj4gKyAqIGhkbWlfYXZpX2luZm9mcmFtZV9wYWNrX29ubHkoKSAtIHdy aXRlIEhETUkgQVZJIGluZm9mcmFtZSB0byBiaW5hcnkgYnVmZmVyCj4gICAqIEBmcmFtZTogSERN SSBBVkkgaW5mb2ZyYW1lCj4gICAqIEBidWZmZXI6IGRlc3RpbmF0aW9uIGJ1ZmZlcgo+ICAgKiBA c2l6ZTogc2l6ZSBvZiBidWZmZXIKPiBAQCAtODIsMjAgKzExMCwyMiBAQCBFWFBPUlRfU1lNQk9M KGhkbWlfYXZpX2luZm9mcmFtZV9pbml0KTsKPiAgICogUmV0dXJucyB0aGUgbnVtYmVyIG9mIGJ5 dGVzIHBhY2tlZCBpbnRvIHRoZSBiaW5hcnkgYnVmZmVyIG9yIGEgbmVnYXRpdmUKPiAgICogZXJy b3IgY29kZSBvbiBmYWlsdXJlLgo+ICAgKi8KPiAtc3NpemVfdCBoZG1pX2F2aV9pbmZvZnJhbWVf cGFjayhzdHJ1Y3QgaGRtaV9hdmlfaW5mb2ZyYW1lICpmcmFtZSwgdm9pZCAqYnVmZmVyLAo+IC0J CQkJc2l6ZV90IHNpemUpCj4gK3NzaXplX3QgaGRtaV9hdmlfaW5mb2ZyYW1lX3BhY2tfb25seShj b25zdCBzdHJ1Y3QgaGRtaV9hdmlfaW5mb2ZyYW1lICpmcmFtZSwKPiArCQkJCSAgICAgdm9pZCAq YnVmZmVyLCBzaXplX3Qgc2l6ZSkKPiAgewo+ICAJdTggKnB0ciA9IGJ1ZmZlcjsKPiAgCXNpemVf dCBsZW5ndGg7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXJldCA9IGhkbWlfYXZpX2luZm9mcmFtZV9j aGVja19vbmx5KGZyYW1lKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiAgCj4gIAls ZW5ndGggPSBIRE1JX0lORk9GUkFNRV9IRUFERVJfU0laRSArIGZyYW1lLT5sZW5ndGg7Cj4gIAo+ ICAJaWYgKHNpemUgPCBsZW5ndGgpCj4gIAkJcmV0dXJuIC1FTk9TUEM7Cj4gIAo+IC0JaWYgKGZy YW1lLT5waWN0dXJlX2FzcGVjdCA+IEhETUlfUElDVFVSRV9BU1BFQ1RfMTZfOSkKPiAtCQlyZXR1 cm4gLUVJTlZBTDsKPiAtCj4gIAltZW1zZXQoYnVmZmVyLCAwLCBzaXplKTsKPiAgCj4gIAlwdHJb MF0gPSBmcmFtZS0+dHlwZTsKPiBAQCAtMTUyLDYgKzE4MiwzNiBAQCBzc2l6ZV90IGhkbWlfYXZp X2luZm9mcmFtZV9wYWNrKHN0cnVjdCBoZG1pX2F2aV9pbmZvZnJhbWUgKmZyYW1lLCB2b2lkICpi dWZmZXIsCj4gIAo+ICAJcmV0dXJuIGxlbmd0aDsKPiAgfQo+ICtFWFBPUlRfU1lNQk9MKGhkbWlf YXZpX2luZm9mcmFtZV9wYWNrX29ubHkpOwo+ICsKPiArLyoqCj4gKyAqIGhkbWlfYXZpX2luZm9m cmFtZV9wYWNrKCkgLSBDaGVjayBhbmQgY2hlY2sgYSBIRE1JIEFWSSBpbmZvZnJhbWUsCj4gKyAq ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBhbmQgd3JpdGUgaXQgdG8gYmluYXJ5IGJ1ZmZl cgo+ICsgKiBAZnJhbWU6IEhETUkgQVZJIGluZm9mcmFtZQo+ICsgKiBAYnVmZmVyOiBkZXN0aW5h dGlvbiBidWZmZXIKPiArICogQHNpemU6IHNpemUgb2YgYnVmZmVyCj4gKyAqCj4gKyAqIFZhbGlk YXRlcyB0aGF0IHRoZSBpbmZvZnJhbWUgaXMgY29uc2lzdGVudCBhbmQgdXBkYXRlcyBkZXJpdmVk IGZpZWxkcwo+ICsgKiAoZWcuIGxlbmd0aCkgYmFzZWQgb24gb3RoZXIgZmllbGRzLCBhZnRlciB3 aGljaCBwYWNrcyB0aGUgaW5mb3JtYXRpb24KCndoaWNoIHBhY2tzIC0+IHdoaWNoIGl0IHBhY2tz CgpEaXR0byBlbHNld2hlcmUuCgo+ICsgKiBjb250YWluZWQgaW4gdGhlIEBmcmFtZSBzdHJ1Y3R1 cmUgaW50byBhIGJpbmFyeSByZXByZXNlbnRhdGlvbiB0aGF0Cj4gKyAqIGNhbiBiZSB3cml0dGVu IGludG8gdGhlIGNvcnJlc3BvbmRpbmcgY29udHJvbGxlciByZWdpc3RlcnMuIEFsc28KCkFsc28g LT4gVGhpcyBmdW5jdGlvbiBhbHNvCgpEaXR0byBlbHNld2hlcmUuCgo+ICsgKiBjb21wdXRlcyB0 aGUgY2hlY2tzdW0gYXMgcmVxdWlyZWQgYnkgc2VjdGlvbiA1LjMuNSBvZiB0aGUgSERNSSAxLjQK PiArICogc3BlY2lmaWNhdGlvbi4KPiArICoKPiArICogUmV0dXJucyB0aGUgbnVtYmVyIG9mIGJ5 dGVzIHBhY2tlZCBpbnRvIHRoZSBiaW5hcnkgYnVmZmVyIG9yIGEgbmVnYXRpdmUKPiArICogZXJy b3IgY29kZSBvbiBmYWlsdXJlLgo+ICsgKi8KPiArc3NpemVfdCBoZG1pX2F2aV9pbmZvZnJhbWVf cGFjayhzdHJ1Y3QgaGRtaV9hdmlfaW5mb2ZyYW1lICpmcmFtZSwKPiArCQkJCXZvaWQgKmJ1ZmZl ciwgc2l6ZV90IHNpemUpCj4gK3sKPiArCWludCByZXQ7Cj4gKwo+ICsJcmV0ID0gaGRtaV9hdmlf aW5mb2ZyYW1lX2NoZWNrKGZyYW1lKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiAr Cj4gKwlyZXR1cm4gaGRtaV9hdmlfaW5mb2ZyYW1lX3BhY2tfb25seShmcmFtZSwgYnVmZmVyLCBz aXplKTsKPiArfQo+ICBFWFBPUlRfU1lNQk9MKGhkbWlfYXZpX2luZm9mcmFtZV9wYWNrKTsKPiAg Cj4gIC8qKgo+IEBAIC0xNzgsOCArMjM4LDMzIEBAIGludCBoZG1pX3NwZF9pbmZvZnJhbWVfaW5p dChzdHJ1Y3QgaGRtaV9zcGRfaW5mb2ZyYW1lICpmcmFtZSwKPiAgfQo+ICBFWFBPUlRfU1lNQk9M KGhkbWlfc3BkX2luZm9mcmFtZV9pbml0KTsKPiAgCj4gK3N0YXRpYyBpbnQgaGRtaV9zcGRfaW5m b2ZyYW1lX2NoZWNrX29ubHkoY29uc3Qgc3RydWN0IGhkbWlfc3BkX2luZm9mcmFtZSAqZnJhbWUp Cj4gK3sKPiArCWlmIChmcmFtZS0+dHlwZSAhPSBIRE1JX0lORk9GUkFNRV9UWVBFX1NQRCB8fAo+ ICsJICAgIGZyYW1lLT52ZXJzaW9uICE9IDEgfHwKPiArCSAgICBmcmFtZS0+bGVuZ3RoICE9IEhE TUlfU1BEX0lORk9GUkFNRV9TSVpFKQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsKPiArCXJldHVy biAwOwo+ICt9Cj4gKwo+ICAvKioKPiAtICogaGRtaV9zcGRfaW5mb2ZyYW1lX3BhY2soKSAtIHdy aXRlIEhETUkgU1BEIGluZm9mcmFtZSB0byBiaW5hcnkgYnVmZmVyCj4gKyAqIGhkbWlfc3BkX2lu Zm9mcmFtZV9jaGVjaygpIC0gQ2hlY2sgYW5kIGNoZWNrIGEgSERNSSBTUEQgaW5mb2ZyYW1lCj4g KyAqIEBmcmFtZTogSERNSSBTUEQgaW5mb2ZyYW1lCj4gKyAqCj4gKyAqIFZhbGlkYXRlcyB0aGF0 IHRoZSBpbmZvZnJhbWUgaXMgY29uc2lzdGVudCBhbmQgdXBkYXRlcyBkZXJpdmVkIGZpZWxkcwo+ ICsgKiAoZWcuIGxlbmd0aCkgYmFzZWQgb24gb3RoZXIgZmllbGRzLgo+ICsgKgo+ICsgKiBSZXR1 cm5zIDAgb24gc3VjY2VzcyBvciBhIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KPiAr ICovCj4gK2ludCBoZG1pX3NwZF9pbmZvZnJhbWVfY2hlY2soc3RydWN0IGhkbWlfc3BkX2luZm9m cmFtZSAqZnJhbWUpCj4gK3sKPiArCXJldHVybiBoZG1pX3NwZF9pbmZvZnJhbWVfY2hlY2tfb25s eShmcmFtZSk7Cj4gK30KPiArRVhQT1JUX1NZTUJPTChoZG1pX3NwZF9pbmZvZnJhbWVfY2hlY2sp Owo+ICsKPiArLyoqCj4gKyAqIGhkbWlfc3BkX2luZm9mcmFtZV9wYWNrX29ubHkoKSAtIHdyaXRl IEhETUkgU1BEIGluZm9mcmFtZSB0byBiaW5hcnkgYnVmZmVyCj4gICAqIEBmcmFtZTogSERNSSBT UEQgaW5mb2ZyYW1lCj4gICAqIEBidWZmZXI6IGRlc3RpbmF0aW9uIGJ1ZmZlcgo+ICAgKiBAc2l6 ZTogc2l6ZSBvZiBidWZmZXIKPiBAQCAtMTkyLDExICsyNzcsMTYgQEAgRVhQT1JUX1NZTUJPTCho ZG1pX3NwZF9pbmZvZnJhbWVfaW5pdCk7Cj4gICAqIFJldHVybnMgdGhlIG51bWJlciBvZiBieXRl cyBwYWNrZWQgaW50byB0aGUgYmluYXJ5IGJ1ZmZlciBvciBhIG5lZ2F0aXZlCj4gICAqIGVycm9y IGNvZGUgb24gZmFpbHVyZS4KPiAgICovCj4gLXNzaXplX3QgaGRtaV9zcGRfaW5mb2ZyYW1lX3Bh Y2soc3RydWN0IGhkbWlfc3BkX2luZm9mcmFtZSAqZnJhbWUsIHZvaWQgKmJ1ZmZlciwKPiAtCQkJ CXNpemVfdCBzaXplKQo+ICtzc2l6ZV90IGhkbWlfc3BkX2luZm9mcmFtZV9wYWNrX29ubHkoY29u c3Qgc3RydWN0IGhkbWlfc3BkX2luZm9mcmFtZSAqZnJhbWUsCj4gKwkJCQkgICAgIHZvaWQgKmJ1 ZmZlciwgc2l6ZV90IHNpemUpCj4gIHsKPiAgCXU4ICpwdHIgPSBidWZmZXI7Cj4gIAlzaXplX3Qg bGVuZ3RoOwo+ICsJaW50IHJldDsKPiArCj4gKwlyZXQgPSBoZG1pX3NwZF9pbmZvZnJhbWVfY2hl Y2tfb25seShmcmFtZSk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gIAo+ICAJbGVu Z3RoID0gSERNSV9JTkZPRlJBTUVfSEVBREVSX1NJWkUgKyBmcmFtZS0+bGVuZ3RoOwo+ICAKPiBA QCAtMjIyLDYgKzMxMiwzNiBAQCBzc2l6ZV90IGhkbWlfc3BkX2luZm9mcmFtZV9wYWNrKHN0cnVj dCBoZG1pX3NwZF9pbmZvZnJhbWUgKmZyYW1lLCB2b2lkICpidWZmZXIsCj4gIAo+ICAJcmV0dXJu IGxlbmd0aDsKPiAgfQo+ICtFWFBPUlRfU1lNQk9MKGhkbWlfc3BkX2luZm9mcmFtZV9wYWNrX29u bHkpOwo+ICsKPiArLyoqCj4gKyAqIGhkbWlfc3BkX2luZm9mcmFtZV9wYWNrKCkgLSBDaGVjayBh bmQgY2hlY2sgYSBIRE1JIFNQRCBpbmZvZnJhbWUsCj4gKyAqICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBhbmQgd3JpdGUgaXQgdG8gYmluYXJ5IGJ1ZmZlcgo+ICsgKiBAZnJhbWU6IEhETUkg U1BEIGluZm9mcmFtZQo+ICsgKiBAYnVmZmVyOiBkZXN0aW5hdGlvbiBidWZmZXIKPiArICogQHNp emU6IHNpemUgb2YgYnVmZmVyCj4gKyAqCj4gKyAqIFZhbGlkYXRlcyB0aGF0IHRoZSBpbmZvZnJh bWUgaXMgY29uc2lzdGVudCBhbmQgdXBkYXRlcyBkZXJpdmVkIGZpZWxkcwo+ICsgKiAoZWcuIGxl bmd0aCkgYmFzZWQgb24gb3RoZXIgZmllbGRzLCBhZnRlciB3aGljaCBwYWNrcyB0aGUgaW5mb3Jt YXRpb24KPiArICogY29udGFpbmVkIGluIHRoZSBAZnJhbWUgc3RydWN0dXJlIGludG8gYSBiaW5h cnkgcmVwcmVzZW50YXRpb24gdGhhdAo+ICsgKiBjYW4gYmUgd3JpdHRlbiBpbnRvIHRoZSBjb3Jy ZXNwb25kaW5nIGNvbnRyb2xsZXIgcmVnaXN0ZXJzLiBBbHNvCj4gKyAqIGNvbXB1dGVzIHRoZSBj aGVja3N1bSBhcyByZXF1aXJlZCBieSBzZWN0aW9uIDUuMy41IG9mIHRoZSBIRE1JIDEuNAo+ICsg KiBzcGVjaWZpY2F0aW9uLgo+ICsgKgo+ICsgKiBSZXR1cm5zIHRoZSBudW1iZXIgb2YgYnl0ZXMg cGFja2VkIGludG8gdGhlIGJpbmFyeSBidWZmZXIgb3IgYSBuZWdhdGl2ZQo+ICsgKiBlcnJvciBj b2RlIG9uIGZhaWx1cmUuCj4gKyAqLwo+ICtzc2l6ZV90IGhkbWlfc3BkX2luZm9mcmFtZV9wYWNr KHN0cnVjdCBoZG1pX3NwZF9pbmZvZnJhbWUgKmZyYW1lLAo+ICsJCQkJdm9pZCAqYnVmZmVyLCBz aXplX3Qgc2l6ZSkKPiArewo+ICsJaW50IHJldDsKPiArCj4gKwlyZXQgPSBoZG1pX3NwZF9pbmZv ZnJhbWVfY2hlY2soZnJhbWUpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiAr CXJldHVybiBoZG1pX3NwZF9pbmZvZnJhbWVfcGFja19vbmx5KGZyYW1lLCBidWZmZXIsIHNpemUp Owo+ICt9Cj4gIEVYUE9SVF9TWU1CT0woaGRtaV9zcGRfaW5mb2ZyYW1lX3BhY2spOwo+ICAKPiAg LyoqCj4gQEAgLTI0Miw4ICszNjIsMzMgQEAgaW50IGhkbWlfYXVkaW9faW5mb2ZyYW1lX2luaXQo c3RydWN0IGhkbWlfYXVkaW9faW5mb2ZyYW1lICpmcmFtZSkKPiAgfQo+ICBFWFBPUlRfU1lNQk9M KGhkbWlfYXVkaW9faW5mb2ZyYW1lX2luaXQpOwo+ICAKPiArc3RhdGljIGludCBoZG1pX2F1ZGlv X2luZm9mcmFtZV9jaGVja19vbmx5KGNvbnN0IHN0cnVjdCBoZG1pX2F1ZGlvX2luZm9mcmFtZSAq ZnJhbWUpCj4gK3sKPiArCWlmIChmcmFtZS0+dHlwZSAhPSBIRE1JX0lORk9GUkFNRV9UWVBFX0FV RElPIHx8Cj4gKwkgICAgZnJhbWUtPnZlcnNpb24gIT0gMSB8fAo+ICsJICAgIGZyYW1lLT5sZW5n dGggIT0gSERNSV9BVURJT19JTkZPRlJBTUVfU0laRSkKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiAr Cj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArLyoqCj4gKyAqIGhkbWlfYXVkaW9faW5mb2ZyYW1l X2NoZWNrKCkgLSBDaGVjayBhbmQgY2hlY2sgYSBIRE1JIGF1ZGlvIGluZm9mcmFtZQo+ICsgKiBA ZnJhbWU6IEhETUkgYXVkaW8gaW5mb2ZyYW1lCj4gKyAqCj4gKyAqIFZhbGlkYXRlcyB0aGF0IHRo ZSBpbmZvZnJhbWUgaXMgY29uc2lzdGVudCBhbmQgdXBkYXRlcyBkZXJpdmVkIGZpZWxkcwo+ICsg KiAoZWcuIGxlbmd0aCkgYmFzZWQgb24gb3RoZXIgZmllbGRzLgo+ICsgKgo+ICsgKiBSZXR1cm5z IDAgb24gc3VjY2VzcyBvciBhIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KPiArICov Cj4gK2ludCBoZG1pX2F1ZGlvX2luZm9mcmFtZV9jaGVjayhzdHJ1Y3QgaGRtaV9hdWRpb19pbmZv ZnJhbWUgKmZyYW1lKQo+ICt7Cj4gKwlyZXR1cm4gaGRtaV9hdWRpb19pbmZvZnJhbWVfY2hlY2tf b25seShmcmFtZSk7Cj4gK30KPiArRVhQT1JUX1NZTUJPTChoZG1pX2F1ZGlvX2luZm9mcmFtZV9j aGVjayk7Cj4gKwo+ICAvKioKPiAtICogaGRtaV9hdWRpb19pbmZvZnJhbWVfcGFjaygpIC0gd3Jp dGUgSERNSSBhdWRpbyBpbmZvZnJhbWUgdG8gYmluYXJ5IGJ1ZmZlcgo+ICsgKiBoZG1pX2F1ZGlv X2luZm9mcmFtZV9wYWNrX29ubHkoKSAtIHdyaXRlIEhETUkgYXVkaW8gaW5mb2ZyYW1lIHRvIGJp bmFyeSBidWZmZXIKPiAgICogQGZyYW1lOiBIRE1JIGF1ZGlvIGluZm9mcmFtZQo+ICAgKiBAYnVm ZmVyOiBkZXN0aW5hdGlvbiBidWZmZXIKPiAgICogQHNpemU6IHNpemUgb2YgYnVmZmVyCj4gQEAg LTI1NiwxMiArNDAxLDE3IEBAIEVYUE9SVF9TWU1CT0woaGRtaV9hdWRpb19pbmZvZnJhbWVfaW5p dCk7Cj4gICAqIFJldHVybnMgdGhlIG51bWJlciBvZiBieXRlcyBwYWNrZWQgaW50byB0aGUgYmlu YXJ5IGJ1ZmZlciBvciBhIG5lZ2F0aXZlCj4gICAqIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KPiAg ICovCj4gLXNzaXplX3QgaGRtaV9hdWRpb19pbmZvZnJhbWVfcGFjayhzdHJ1Y3QgaGRtaV9hdWRp b19pbmZvZnJhbWUgKmZyYW1lLAo+IC0JCQkJICB2b2lkICpidWZmZXIsIHNpemVfdCBzaXplKQo+ ICtzc2l6ZV90IGhkbWlfYXVkaW9faW5mb2ZyYW1lX3BhY2tfb25seShjb25zdCBzdHJ1Y3QgaGRt aV9hdWRpb19pbmZvZnJhbWUgKmZyYW1lLAo+ICsJCQkJICAgICAgIHZvaWQgKmJ1ZmZlciwgc2l6 ZV90IHNpemUpCj4gIHsKPiAgCXVuc2lnbmVkIGNoYXIgY2hhbm5lbHM7Cj4gIAl1OCAqcHRyID0g YnVmZmVyOwo+ICAJc2l6ZV90IGxlbmd0aDsKPiArCWludCByZXQ7Cj4gKwo+ICsJcmV0ID0gaGRt aV9hdWRpb19pbmZvZnJhbWVfY2hlY2tfb25seShmcmFtZSk7Cj4gKwlpZiAocmV0KQo+ICsJCXJl dHVybiByZXQ7Cj4gIAo+ICAJbGVuZ3RoID0gSERNSV9JTkZPRlJBTUVfSEVBREVSX1NJWkUgKyBm cmFtZS0+bGVuZ3RoOwo+ICAKPiBAQCAtMjk3LDYgKzQ0NywzNiBAQCBzc2l6ZV90IGhkbWlfYXVk aW9faW5mb2ZyYW1lX3BhY2soc3RydWN0IGhkbWlfYXVkaW9faW5mb2ZyYW1lICpmcmFtZSwKPiAg Cj4gIAlyZXR1cm4gbGVuZ3RoOwo+ICB9Cj4gK0VYUE9SVF9TWU1CT0woaGRtaV9hdWRpb19pbmZv ZnJhbWVfcGFja19vbmx5KTsKPiArCj4gKy8qKgo+ICsgKiBoZG1pX2F1ZGlvX2luZm9mcmFtZV9w YWNrKCkgLSBDaGVjayBhbmQgY2hlY2sgYSBIRE1JIEF1ZGlvIGluZm9mcmFtZSwKPiArICogICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgYW5kIHdyaXRlIGl0IHRvIGJpbmFyeSBidWZmZXIK PiArICogQGZyYW1lOiBIRE1JIEF1ZGlvIGluZm9mcmFtZQo+ICsgKiBAYnVmZmVyOiBkZXN0aW5h dGlvbiBidWZmZXIKPiArICogQHNpemU6IHNpemUgb2YgYnVmZmVyCj4gKyAqCj4gKyAqIFZhbGlk YXRlcyB0aGF0IHRoZSBpbmZvZnJhbWUgaXMgY29uc2lzdGVudCBhbmQgdXBkYXRlcyBkZXJpdmVk IGZpZWxkcwo+ICsgKiAoZWcuIGxlbmd0aCkgYmFzZWQgb24gb3RoZXIgZmllbGRzLCBhZnRlciB3 aGljaCBwYWNrcyB0aGUgaW5mb3JtYXRpb24KPiArICogY29udGFpbmVkIGluIHRoZSBAZnJhbWUg c3RydWN0dXJlIGludG8gYSBiaW5hcnkgcmVwcmVzZW50YXRpb24gdGhhdAo+ICsgKiBjYW4gYmUg d3JpdHRlbiBpbnRvIHRoZSBjb3JyZXNwb25kaW5nIGNvbnRyb2xsZXIgcmVnaXN0ZXJzLiBBbHNv Cj4gKyAqIGNvbXB1dGVzIHRoZSBjaGVja3N1bSBhcyByZXF1aXJlZCBieSBzZWN0aW9uIDUuMy41 IG9mIHRoZSBIRE1JIDEuNAo+ICsgKiBzcGVjaWZpY2F0aW9uLgo+ICsgKgo+ICsgKiBSZXR1cm5z IHRoZSBudW1iZXIgb2YgYnl0ZXMgcGFja2VkIGludG8gdGhlIGJpbmFyeSBidWZmZXIgb3IgYSBu ZWdhdGl2ZQo+ICsgKiBlcnJvciBjb2RlIG9uIGZhaWx1cmUuCj4gKyAqLwo+ICtzc2l6ZV90IGhk bWlfYXVkaW9faW5mb2ZyYW1lX3BhY2soc3RydWN0IGhkbWlfYXVkaW9faW5mb2ZyYW1lICpmcmFt ZSwKPiArCQkJCSAgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSkKPiArewo+ICsJaW50IHJldDsK PiArCj4gKwlyZXQgPSBoZG1pX2F1ZGlvX2luZm9mcmFtZV9jaGVjayhmcmFtZSk7Cj4gKwlpZiAo cmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJcmV0dXJuIGhkbWlfYXVkaW9faW5mb2ZyYW1l X3BhY2tfb25seShmcmFtZSwgYnVmZmVyLCBzaXplKTsKPiArfQo+ICBFWFBPUlRfU1lNQk9MKGhk bWlfYXVkaW9faW5mb2ZyYW1lX3BhY2spOwo+ICAKPiAgLyoqCj4gQEAgLTMxOSw2ICs0OTksNyBA QCBpbnQgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX2luaXQoc3RydWN0IGhkbWlfdmVuZG9yX2luZm9m cmFtZSAqZnJhbWUpCj4gIAkgKiB2YWx1ZQo+ICAJICovCj4gIAlmcmFtZS0+czNkX3N0cnVjdCA9 IEhETUlfM0RfU1RSVUNUVVJFX0lOVkFMSUQ7Cj4gKwlmcmFtZS0+bGVuZ3RoID0gNDsKPiAgCj4g IAlyZXR1cm4gMDsKPiAgfQo+IEBAIC0zMzUsOCArNTE2LDQyIEBAIHN0YXRpYyBpbnQgaGRtaV92 ZW5kb3JfaW5mb2ZyYW1lX2xlbmd0aChjb25zdCBzdHJ1Y3QgaGRtaV92ZW5kb3JfaW5mb2ZyYW1l ICpmcmFtCj4gIAkJcmV0dXJuIDQ7Cj4gIH0KPiAgCj4gK3N0YXRpYyBpbnQgaGRtaV92ZW5kb3Jf aW5mb2ZyYW1lX2NoZWNrX29ubHkoY29uc3Qgc3RydWN0IGhkbWlfdmVuZG9yX2luZm9mcmFtZSAq ZnJhbWUpCj4gK3sKPiArCWlmIChmcmFtZS0+dHlwZSAhPSBIRE1JX0lORk9GUkFNRV9UWVBFX1ZF TkRPUiB8fAo+ICsJICAgIGZyYW1lLT52ZXJzaW9uICE9IDEgfHwKPiArCSAgICBmcmFtZS0+b3Vp ICE9IEhETUlfSUVFRV9PVUkpCj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJLyogb25seSBv bmUgb2YgdGhvc2UgY2FuIGJlIHN1cHBsaWVkICovCj4gKwlpZiAoZnJhbWUtPnZpYyAhPSAwICYm IGZyYW1lLT5zM2Rfc3RydWN0ICE9IEhETUlfM0RfU1RSVUNUVVJFX0lOVkFMSUQpCj4gKwkJcmV0 dXJuIC1FSU5WQUw7Cj4gKwo+ICsJaWYgKGZyYW1lLT5sZW5ndGggIT0gaGRtaV92ZW5kb3JfaW5m b2ZyYW1lX2xlbmd0aChmcmFtZSkpCj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJcmV0dXJu IDA7Cj4gK30KPiArCj4gIC8qKgo+IC0gKiBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfcGFjaygpIC0g d3JpdGUgYSBIRE1JIHZlbmRvciBpbmZvZnJhbWUgdG8gYmluYXJ5IGJ1ZmZlcgo+ICsgKiBoZG1p X3ZlbmRvcl9pbmZvZnJhbWVfY2hlY2soKSAtIENoZWNrIGFuZCBjaGVjayBhIEhETUkgdmVuZG9y IGluZm9mcmFtZQo+ICsgKiBAZnJhbWU6IEhETUkgaW5mb2ZyYW1lCj4gKyAqCj4gKyAqIFZhbGlk YXRlcyB0aGF0IHRoZSBpbmZvZnJhbWUgaXMgY29uc2lzdGVudCBhbmQgdXBkYXRlcyBkZXJpdmVk IGZpZWxkcwo+ICsgKiAoZWcuIGxlbmd0aCkgYmFzZWQgb24gb3RoZXIgZmllbGRzLgo+ICsgKgo+ ICsgKiBSZXR1cm5zIDAgb24gc3VjY2VzcyBvciBhIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24gZmFp bHVyZS4KPiArICovCj4gK2ludCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfY2hlY2soc3RydWN0IGhk bWlfdmVuZG9yX2luZm9mcmFtZSAqZnJhbWUpCj4gK3sKPiArCWZyYW1lLT5sZW5ndGggPSBoZG1p X3ZlbmRvcl9pbmZvZnJhbWVfbGVuZ3RoKGZyYW1lKTsKPiArCj4gKwlyZXR1cm4gaGRtaV92ZW5k b3JfaW5mb2ZyYW1lX2NoZWNrX29ubHkoZnJhbWUpOwo+ICt9Cj4gK0VYUE9SVF9TWU1CT0woaGRt aV92ZW5kb3JfaW5mb2ZyYW1lX2NoZWNrKTsKPiArCj4gKy8qKgo+ICsgKiBoZG1pX3ZlbmRvcl9p bmZvZnJhbWVfcGFja19vbmx5KCkgLSB3cml0ZSBhIEhETUkgdmVuZG9yIGluZm9mcmFtZSB0byBi aW5hcnkgYnVmZmVyCj4gICAqIEBmcmFtZTogSERNSSBpbmZvZnJhbWUKPiAgICogQGJ1ZmZlcjog ZGVzdGluYXRpb24gYnVmZmVyCj4gICAqIEBzaXplOiBzaXplIG9mIGJ1ZmZlcgo+IEBAIC0zNDks MTcgKzU2NCwxNiBAQCBzdGF0aWMgaW50IGhkbWlfdmVuZG9yX2luZm9mcmFtZV9sZW5ndGgoY29u c3Qgc3RydWN0IGhkbWlfdmVuZG9yX2luZm9mcmFtZSAqZnJhbQo+ICAgKiBSZXR1cm5zIHRoZSBu dW1iZXIgb2YgYnl0ZXMgcGFja2VkIGludG8gdGhlIGJpbmFyeSBidWZmZXIgb3IgYSBuZWdhdGl2 ZQo+ICAgKiBlcnJvciBjb2RlIG9uIGZhaWx1cmUuCj4gICAqLwo+IC1zc2l6ZV90IGhkbWlfdmVu ZG9yX2luZm9mcmFtZV9wYWNrKHN0cnVjdCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWUgKmZyYW1lLAo+ IC0JCQkJIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpCj4gK3NzaXplX3QgaGRtaV92ZW5kb3Jf aW5mb2ZyYW1lX3BhY2tfb25seShjb25zdCBzdHJ1Y3QgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lICpm cmFtZSwKPiArCQkJCQl2b2lkICpidWZmZXIsIHNpemVfdCBzaXplKQo+ICB7Cj4gIAl1OCAqcHRy ID0gYnVmZmVyOwo+ICAJc2l6ZV90IGxlbmd0aDsKPiArCWludCByZXQ7Cj4gIAo+IC0JLyogb25s eSBvbmUgb2YgdGhvc2UgY2FuIGJlIHN1cHBsaWVkICovCj4gLQlpZiAoZnJhbWUtPnZpYyAhPSAw ICYmIGZyYW1lLT5zM2Rfc3RydWN0ICE9IEhETUlfM0RfU1RSVUNUVVJFX0lOVkFMSUQpCj4gLQkJ cmV0dXJuIC1FSU5WQUw7Cj4gLQo+IC0JZnJhbWUtPmxlbmd0aCA9IGhkbWlfdmVuZG9yX2luZm9m cmFtZV9sZW5ndGgoZnJhbWUpOwo+ICsJcmV0ID0gaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX2NoZWNr X29ubHkoZnJhbWUpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICAKPiAgCWxlbmd0 aCA9IEhETUlfSU5GT0ZSQU1FX0hFQURFUl9TSVpFICsgZnJhbWUtPmxlbmd0aDsKPiAgCj4gQEAg LTM5NCwyNCArNjA4LDEzNCBAQCBzc2l6ZV90IGhkbWlfdmVuZG9yX2luZm9mcmFtZV9wYWNrKHN0 cnVjdCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWUgKmZyYW1lLAo+ICAKPiAgCXJldHVybiBsZW5ndGg7 Cj4gIH0KPiArRVhQT1JUX1NZTUJPTChoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfcGFja19vbmx5KTsK PiArCj4gKy8qKgo+ICsgKiBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfcGFjaygpIC0gQ2hlY2sgYW5k IGNoZWNrIGEgSERNSSBWZW5kb3IgaW5mb2ZyYW1lLAo+ICsgKiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgYW5kIHdyaXRlIGl0IHRvIGJpbmFyeSBidWZmZXIKPiArICogQGZyYW1lOiBI RE1JIFZlbmRvciBpbmZvZnJhbWUKPiArICogQGJ1ZmZlcjogZGVzdGluYXRpb24gYnVmZmVyCj4g KyAqIEBzaXplOiBzaXplIG9mIGJ1ZmZlcgo+ICsgKgo+ICsgKiBWYWxpZGF0ZXMgdGhhdCB0aGUg aW5mb2ZyYW1lIGlzIGNvbnNpc3RlbnQgYW5kIHVwZGF0ZXMgZGVyaXZlZCBmaWVsZHMKPiArICog KGVnLiBsZW5ndGgpIGJhc2VkIG9uIG90aGVyIGZpZWxkcywgYWZ0ZXIgd2hpY2ggcGFja3MgdGhl IGluZm9ybWF0aW9uCj4gKyAqIGNvbnRhaW5lZCBpbiB0aGUgQGZyYW1lIHN0cnVjdHVyZSBpbnRv IGEgYmluYXJ5IHJlcHJlc2VudGF0aW9uIHRoYXQKPiArICogY2FuIGJlIHdyaXR0ZW4gaW50byB0 aGUgY29ycmVzcG9uZGluZyBjb250cm9sbGVyIHJlZ2lzdGVycy4gQWxzbwo+ICsgKiBjb21wdXRl cyB0aGUgY2hlY2tzdW0gYXMgcmVxdWlyZWQgYnkgc2VjdGlvbiA1LjMuNSBvZiB0aGUgSERNSSAx LjQKPiArICogc3BlY2lmaWNhdGlvbi4KPiArICoKPiArICogUmV0dXJucyB0aGUgbnVtYmVyIG9m IGJ5dGVzIHBhY2tlZCBpbnRvIHRoZSBiaW5hcnkgYnVmZmVyIG9yIGEgbmVnYXRpdmUKPiArICog ZXJyb3IgY29kZSBvbiBmYWlsdXJlLgo+ICsgKi8KPiArc3NpemVfdCBoZG1pX3ZlbmRvcl9pbmZv ZnJhbWVfcGFjayhzdHJ1Y3QgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lICpmcmFtZSwKPiArCQkJCSAg IHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpCj4gK3sKPiArCWludCByZXQ7Cj4gKwo+ICsJcmV0 ID0gaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX2NoZWNrKGZyYW1lKTsKPiArCWlmIChyZXQpCj4gKwkJ cmV0dXJuIHJldDsKPiArCj4gKwlyZXR1cm4gaGRtaV92ZW5kb3JfaW5mb2ZyYW1lX3BhY2tfb25s eShmcmFtZSwgYnVmZmVyLCBzaXplKTsKPiArfQo+ICBFWFBPUlRfU1lNQk9MKGhkbWlfdmVuZG9y X2luZm9mcmFtZV9wYWNrKTsKPiAgCj4gK3N0YXRpYyBpbnQKPiAraGRtaV92ZW5kb3JfYW55X2lu Zm9mcmFtZV9jaGVja19vbmx5KGNvbnN0IHVuaW9uIGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWUg KmZyYW1lKQo+ICt7Cj4gKwlpZiAoZnJhbWUtPmFueS50eXBlICE9IEhETUlfSU5GT0ZSQU1FX1RZ UEVfVkVORE9SIHx8Cj4gKwkgICAgZnJhbWUtPmFueS52ZXJzaW9uICE9IDEpCj4gKwkJcmV0dXJu IC1FSU5WQUw7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gIC8qCj4gLSAqIGhkbWlfdmVu ZG9yX2FueV9pbmZvZnJhbWVfcGFjaygpIC0gd3JpdGUgYSB2ZW5kb3IgaW5mb2ZyYW1lIHRvIGJp bmFyeSBidWZmZXIKPiArICogaGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZV9jaGVjaygpIC0gY2hl Y2sgYW5kIGNoZWNrIGEgdmVuZG9yIGluZm9mcmFtZQo+ICsgKi8KPiArc3RhdGljIGludAo+ICto ZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1lX2NoZWNrKHVuaW9uIGhkbWlfdmVuZG9yX2FueV9pbmZv ZnJhbWUgKmZyYW1lKQo+ICt7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXJldCA9IGhkbWlfdmVuZG9y X2FueV9pbmZvZnJhbWVfY2hlY2tfb25seShmcmFtZSk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVy biByZXQ7Cj4gKwo+ICsJLyogd2Ugb25seSBrbm93IGFib3V0IEhETUkgdmVuZG9yIGluZm9mcmFt ZXMgKi8KPiArCWlmIChmcmFtZS0+YW55Lm91aSAhPSBIRE1JX0lFRUVfT1VJKQo+ICsJCXJldHVy biAtRUlOVkFMOwo+ICsKPiArCXJldHVybiBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVfY2hlY2soJmZy YW1lLT5oZG1pKTsKPiArfQo+ICsKPiArLyoKPiArICogaGRtaV92ZW5kb3JfYW55X2luZm9mcmFt ZV9wYWNrX29ubHkoKSAtIHdyaXRlIGEgdmVuZG9yIGluZm9mcmFtZSB0byBiaW5hcnkgYnVmZmVy Cj4gICAqLwo+ICBzdGF0aWMgc3NpemVfdAo+IC1oZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1lX3Bh Y2sodW5pb24gaGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZSAqZnJhbWUsCj4gLQkJCSAgIHZvaWQg KmJ1ZmZlciwgc2l6ZV90IHNpemUpCj4gK2hkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWVfcGFja19v bmx5KGNvbnN0IHVuaW9uIGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWUgKmZyYW1lLAo+ICsJCQkJ ICAgIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpCj4gIHsKPiArCWludCByZXQ7Cj4gKwo+ICsJ cmV0ID0gaGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZV9jaGVja19vbmx5KGZyYW1lKTsKPiArCWlm IChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiArCj4gIAkvKiB3ZSBvbmx5IGtub3cgYWJvdXQgSERN SSB2ZW5kb3IgaW5mb2ZyYW1lcyAqLwo+ICAJaWYgKGZyYW1lLT5hbnkub3VpICE9IEhETUlfSUVF RV9PVUkpCj4gIAkJcmV0dXJuIC1FSU5WQUw7Cj4gIAo+IC0JcmV0dXJuIGhkbWlfdmVuZG9yX2lu Zm9mcmFtZV9wYWNrKCZmcmFtZS0+aGRtaSwgYnVmZmVyLCBzaXplKTsKPiArCXJldHVybiBoZG1p X3ZlbmRvcl9pbmZvZnJhbWVfcGFja19vbmx5KCZmcmFtZS0+aGRtaSwgYnVmZmVyLCBzaXplKTsK PiArfQo+ICsKPiArLyoKPiArICogaGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZV9wYWNrKCkgLSBj aGVjayBhbmQgY2hlY2sgYSB2ZW5kb3IgaW5mb2ZyYW1lLAo+ICsgKiAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBhbmQgd3JpdGUgaXQgdG8gYmluYXJ5IGJ1ZmZl cgo+ICsgKi8KPiArc3RhdGljIHNzaXplX3QKPiAraGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZV9w YWNrKHVuaW9uIGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWUgKmZyYW1lLAo+ICsJCQkgICAgICAg dm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSkKPiArewo+ICsJaW50IHJldDsKPiArCj4gKwlyZXQg PSBoZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1lX2NoZWNrKGZyYW1lKTsKPiArCWlmIChyZXQpCj4g KwkJcmV0dXJuIHJldDsKPiArCj4gKwlyZXR1cm4gaGRtaV92ZW5kb3JfYW55X2luZm9mcmFtZV9w YWNrX29ubHkoZnJhbWUsIGJ1ZmZlciwgc2l6ZSk7Cj4gK30KPiArCj4gKy8qKgo+ICsgKiBoZG1p X2luZm9mcmFtZV9jaGVjaygpIC0gQ2hlY2sgY2hlY2sgYSBIRE1JIGluZm9mcmFtZQo+ICsgKiBA ZnJhbWU6IEhETUkgaW5mb2ZyYW1lCj4gKyAqCj4gKyAqIFZhbGlkYXRlcyB0aGF0IHRoZSBpbmZv ZnJhbWUgaXMgY29uc2lzdGVudCBhbmQgdXBkYXRlcyBkZXJpdmVkIGZpZWxkcwo+ICsgKiAoZWcu IGxlbmd0aCkgYmFzZWQgb24gb3RoZXIgZmllbGRzLgo+ICsgKgo+ICsgKiBSZXR1cm5zIDAgb24g c3VjY2VzcyBvciBhIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KPiArICovCj4gK2lu dAo+ICtoZG1pX2luZm9mcmFtZV9jaGVjayh1bmlvbiBoZG1pX2luZm9mcmFtZSAqZnJhbWUpCj4g K3sKPiArCXN3aXRjaCAoZnJhbWUtPmFueS50eXBlKSB7Cj4gKwljYXNlIEhETUlfSU5GT0ZSQU1F X1RZUEVfQVZJOgo+ICsJCXJldHVybiBoZG1pX2F2aV9pbmZvZnJhbWVfY2hlY2soJmZyYW1lLT5h dmkpOwo+ICsJY2FzZSBIRE1JX0lORk9GUkFNRV9UWVBFX1NQRDoKPiArCQlyZXR1cm4gaGRtaV9z cGRfaW5mb2ZyYW1lX2NoZWNrKCZmcmFtZS0+c3BkKTsKPiArCWNhc2UgSERNSV9JTkZPRlJBTUVf VFlQRV9BVURJTzoKPiArCQlyZXR1cm4gaGRtaV9hdWRpb19pbmZvZnJhbWVfY2hlY2soJmZyYW1l LT5hdWRpbyk7Cj4gKwljYXNlIEhETUlfSU5GT0ZSQU1FX1RZUEVfVkVORE9SOgo+ICsJCXJldHVy biBoZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1lX2NoZWNrKCZmcmFtZS0+dmVuZG9yKTsKPiArCWRl ZmF1bHQ6Cj4gKwkJV0FSTigxLCAiQmFkIGluZm9mcmFtZSB0eXBlICVkXG4iLCBmcmFtZS0+YW55 LnR5cGUpOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsJfQo+ICB9Cj4gK0VYUE9SVF9TWU1CT0wo aGRtaV9pbmZvZnJhbWVfY2hlY2spOwo+ICAKPiAgLyoqCj4gLSAqIGhkbWlfaW5mb2ZyYW1lX3Bh Y2soKSAtIHdyaXRlIGEgSERNSSBpbmZvZnJhbWUgdG8gYmluYXJ5IGJ1ZmZlcgo+ICsgKiBoZG1p X2luZm9mcmFtZV9wYWNrX29ubHkoKSAtIHdyaXRlIGEgSERNSSBpbmZvZnJhbWUgdG8gYmluYXJ5 IGJ1ZmZlcgo+ICAgKiBAZnJhbWU6IEhETUkgaW5mb2ZyYW1lCj4gICAqIEBidWZmZXI6IGRlc3Rp bmF0aW9uIGJ1ZmZlcgo+ICAgKiBAc2l6ZTogc2l6ZSBvZiBidWZmZXIKPiBAQCAtNDI1LDcgKzc0 OSw1NiBAQCBoZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1lX3BhY2sodW5pb24gaGRtaV92ZW5kb3Jf YW55X2luZm9mcmFtZSAqZnJhbWUsCj4gICAqIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KPiAgICov Cj4gIHNzaXplX3QKPiAtaGRtaV9pbmZvZnJhbWVfcGFjayh1bmlvbiBoZG1pX2luZm9mcmFtZSAq ZnJhbWUsIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpCj4gK2hkbWlfaW5mb2ZyYW1lX3BhY2tf b25seShjb25zdCB1bmlvbiBoZG1pX2luZm9mcmFtZSAqZnJhbWUsIHZvaWQgKmJ1ZmZlciwgc2l6 ZV90IHNpemUpCj4gK3sKPiArCXNzaXplX3QgbGVuZ3RoOwo+ICsKPiArCXN3aXRjaCAoZnJhbWUt PmFueS50eXBlKSB7Cj4gKwljYXNlIEhETUlfSU5GT0ZSQU1FX1RZUEVfQVZJOgo+ICsJCWxlbmd0 aCA9IGhkbWlfYXZpX2luZm9mcmFtZV9wYWNrX29ubHkoJmZyYW1lLT5hdmksCj4gKwkJCQkJCSAg ICAgIGJ1ZmZlciwgc2l6ZSk7Cj4gKwkJYnJlYWs7Cj4gKwljYXNlIEhETUlfSU5GT0ZSQU1FX1RZ UEVfU1BEOgo+ICsJCWxlbmd0aCA9IGhkbWlfc3BkX2luZm9mcmFtZV9wYWNrX29ubHkoJmZyYW1l LT5zcGQsCj4gKwkJCQkJCSAgICAgIGJ1ZmZlciwgc2l6ZSk7Cj4gKwkJYnJlYWs7Cj4gKwljYXNl IEhETUlfSU5GT0ZSQU1FX1RZUEVfQVVESU86Cj4gKwkJbGVuZ3RoID0gaGRtaV9hdWRpb19pbmZv ZnJhbWVfcGFja19vbmx5KCZmcmFtZS0+YXVkaW8sCj4gKwkJCQkJCQlidWZmZXIsIHNpemUpOwo+ ICsJCWJyZWFrOwo+ICsJY2FzZSBIRE1JX0lORk9GUkFNRV9UWVBFX1ZFTkRPUjoKPiArCQlsZW5n dGggPSBoZG1pX3ZlbmRvcl9hbnlfaW5mb2ZyYW1lX3BhY2tfb25seSgmZnJhbWUtPnZlbmRvciwK PiArCQkJCQkJCSAgICAgYnVmZmVyLCBzaXplKTsKPiArCQlicmVhazsKPiArCWRlZmF1bHQ6Cj4g KwkJV0FSTigxLCAiQmFkIGluZm9mcmFtZSB0eXBlICVkXG4iLCBmcmFtZS0+YW55LnR5cGUpOwo+ ICsJCWxlbmd0aCA9IC1FSU5WQUw7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIGxlbmd0aDsKPiArfQo+ ICtFWFBPUlRfU1lNQk9MKGhkbWlfaW5mb2ZyYW1lX3BhY2tfb25seSk7Cj4gKwo+ICsvKioKPiAr ICogaGRtaV9pbmZvZnJhbWVfcGFjaygpIC0gQ2hlY2sgY2hlY2sgYSBIRE1JIGluZm9mcmFtZSwK CkNoZWNrIGNoZWNrPwoKPiArICogICAgICAgICAgICAgICAgICAgICAgICAgYW5kIHdyaXRlIGl0 IHRvIGJpbmFyeSBidWZmZXIKPiArICogQGZyYW1lOiBIRE1JIGluZm9mcmFtZQo+ICsgKiBAYnVm ZmVyOiBkZXN0aW5hdGlvbiBidWZmZXIKPiArICogQHNpemU6IHNpemUgb2YgYnVmZmVyCj4gKyAq Cj4gKyAqIFZhbGlkYXRlcyB0aGF0IHRoZSBpbmZvZnJhbWUgaXMgY29uc2lzdGVudCBhbmQgdXBk YXRlcyBkZXJpdmVkIGZpZWxkcwo+ICsgKiAoZWcuIGxlbmd0aCkgYmFzZWQgb24gb3RoZXIgZmll bGRzLCBhZnRlciB3aGljaCBwYWNrcyB0aGUgaW5mb3JtYXRpb24KPiArICogY29udGFpbmVkIGlu IHRoZSBAZnJhbWUgc3RydWN0dXJlIGludG8gYSBiaW5hcnkgcmVwcmVzZW50YXRpb24gdGhhdAo+ ICsgKiBjYW4gYmUgd3JpdHRlbiBpbnRvIHRoZSBjb3JyZXNwb25kaW5nIGNvbnRyb2xsZXIgcmVn aXN0ZXJzLiBBbHNvCj4gKyAqIGNvbXB1dGVzIHRoZSBjaGVja3N1bSBhcyByZXF1aXJlZCBieSBz ZWN0aW9uIDUuMy41IG9mIHRoZSBIRE1JIDEuNAo+ICsgKiBzcGVjaWZpY2F0aW9uLgo+ICsgKgo+ ICsgKiBSZXR1cm5zIHRoZSBudW1iZXIgb2YgYnl0ZXMgcGFja2VkIGludG8gdGhlIGJpbmFyeSBi dWZmZXIgb3IgYSBuZWdhdGl2ZQo+ICsgKiBlcnJvciBjb2RlIG9uIGZhaWx1cmUuCj4gKyAqLwo+ ICtzc2l6ZV90Cj4gK2hkbWlfaW5mb2ZyYW1lX3BhY2sodW5pb24gaGRtaV9pbmZvZnJhbWUgKmZy YW1lLAo+ICsJCSAgICB2b2lkICpidWZmZXIsIHNpemVfdCBzaXplKQo+ICB7Cj4gIAlzc2l6ZV90 IGxlbmd0aDsKPiAgCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvaGRtaS5oIGIvaW5jbHVk ZS9saW51eC9oZG1pLmgKPiBpbmRleCBiY2UxYWJiMWZlNTcuLmM3NmI1MGE0OGU0OCAxMDA2NDQK PiAtLS0gYS9pbmNsdWRlL2xpbnV4L2hkbWkuaAo+ICsrKyBiL2luY2x1ZGUvbGludXgvaGRtaS5o Cj4gQEAgLTE2Myw2ICsxNjMsOSBAQCBzdHJ1Y3QgaGRtaV9hdmlfaW5mb2ZyYW1lIHsKPiAgaW50 IGhkbWlfYXZpX2luZm9mcmFtZV9pbml0KHN0cnVjdCBoZG1pX2F2aV9pbmZvZnJhbWUgKmZyYW1l KTsKPiAgc3NpemVfdCBoZG1pX2F2aV9pbmZvZnJhbWVfcGFjayhzdHJ1Y3QgaGRtaV9hdmlfaW5m b2ZyYW1lICpmcmFtZSwgdm9pZCAqYnVmZmVyLAo+ICAJCQkJc2l6ZV90IHNpemUpOwo+ICtzc2l6 ZV90IGhkbWlfYXZpX2luZm9mcmFtZV9wYWNrX29ubHkoY29uc3Qgc3RydWN0IGhkbWlfYXZpX2lu Zm9mcmFtZSAqZnJhbWUsCj4gKwkJCQkgICAgIHZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpOwo+ ICtpbnQgaGRtaV9hdmlfaW5mb2ZyYW1lX2NoZWNrKHN0cnVjdCBoZG1pX2F2aV9pbmZvZnJhbWUg KmZyYW1lKTsKPiAgCj4gIGVudW0gaGRtaV9zcGRfc2RpIHsKPiAgCUhETUlfU1BEX1NESV9VTktO T1dOLAo+IEBAIC0xOTQsNiArMTk3LDkgQEAgaW50IGhkbWlfc3BkX2luZm9mcmFtZV9pbml0KHN0 cnVjdCBoZG1pX3NwZF9pbmZvZnJhbWUgKmZyYW1lLAo+ICAJCQkgICAgY29uc3QgY2hhciAqdmVu ZG9yLCBjb25zdCBjaGFyICpwcm9kdWN0KTsKPiAgc3NpemVfdCBoZG1pX3NwZF9pbmZvZnJhbWVf cGFjayhzdHJ1Y3QgaGRtaV9zcGRfaW5mb2ZyYW1lICpmcmFtZSwgdm9pZCAqYnVmZmVyLAo+ICAJ CQkJc2l6ZV90IHNpemUpOwo+ICtzc2l6ZV90IGhkbWlfc3BkX2luZm9mcmFtZV9wYWNrX29ubHko Y29uc3Qgc3RydWN0IGhkbWlfc3BkX2luZm9mcmFtZSAqZnJhbWUsCj4gKwkJCQkgICAgIHZvaWQg KmJ1ZmZlciwgc2l6ZV90IHNpemUpOwo+ICtpbnQgaGRtaV9zcGRfaW5mb2ZyYW1lX2NoZWNrKHN0 cnVjdCBoZG1pX3NwZF9pbmZvZnJhbWUgKmZyYW1lKTsKPiAgCj4gIGVudW0gaGRtaV9hdWRpb19j b2RpbmdfdHlwZSB7Cj4gIAlIRE1JX0FVRElPX0NPRElOR19UWVBFX1NUUkVBTSwKPiBAQCAtMjcy LDYgKzI3OCw5IEBAIHN0cnVjdCBoZG1pX2F1ZGlvX2luZm9mcmFtZSB7Cj4gIGludCBoZG1pX2F1 ZGlvX2luZm9mcmFtZV9pbml0KHN0cnVjdCBoZG1pX2F1ZGlvX2luZm9mcmFtZSAqZnJhbWUpOwo+ ICBzc2l6ZV90IGhkbWlfYXVkaW9faW5mb2ZyYW1lX3BhY2soc3RydWN0IGhkbWlfYXVkaW9faW5m b2ZyYW1lICpmcmFtZSwKPiAgCQkJCSAgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSk7Cj4gK3Nz aXplX3QgaGRtaV9hdWRpb19pbmZvZnJhbWVfcGFja19vbmx5KGNvbnN0IHN0cnVjdCBoZG1pX2F1 ZGlvX2luZm9mcmFtZSAqZnJhbWUsCj4gKwkJCQkgICAgICAgdm9pZCAqYnVmZmVyLCBzaXplX3Qg c2l6ZSk7Cj4gK2ludCBoZG1pX2F1ZGlvX2luZm9mcmFtZV9jaGVjayhzdHJ1Y3QgaGRtaV9hdWRp b19pbmZvZnJhbWUgKmZyYW1lKTsKPiAgCj4gIGVudW0gaGRtaV8zZF9zdHJ1Y3R1cmUgewo+ICAJ SERNSV8zRF9TVFJVQ1RVUkVfSU5WQUxJRCA9IC0xLAo+IEBAIC0yOTksNiArMzA4LDkgQEAgc3Ry dWN0IGhkbWlfdmVuZG9yX2luZm9mcmFtZSB7Cj4gIGludCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWVf aW5pdChzdHJ1Y3QgaGRtaV92ZW5kb3JfaW5mb2ZyYW1lICpmcmFtZSk7Cj4gIHNzaXplX3QgaGRt aV92ZW5kb3JfaW5mb2ZyYW1lX3BhY2soc3RydWN0IGhkbWlfdmVuZG9yX2luZm9mcmFtZSAqZnJh bWUsCj4gIAkJCQkgICB2b2lkICpidWZmZXIsIHNpemVfdCBzaXplKTsKPiArc3NpemVfdCBoZG1p X3ZlbmRvcl9pbmZvZnJhbWVfcGFja19vbmx5KGNvbnN0IHN0cnVjdCBoZG1pX3ZlbmRvcl9pbmZv ZnJhbWUgKmZyYW1lLAo+ICsJCQkJCXZvaWQgKmJ1ZmZlciwgc2l6ZV90IHNpemUpOwo+ICtpbnQg aGRtaV92ZW5kb3JfaW5mb2ZyYW1lX2NoZWNrKHN0cnVjdCBoZG1pX3ZlbmRvcl9pbmZvZnJhbWUg KmZyYW1lKTsKPiAgCj4gIHVuaW9uIGhkbWlfdmVuZG9yX2FueV9pbmZvZnJhbWUgewo+ICAJc3Ry dWN0IHsKPiBAQCAtMzMwLDggKzM0MiwxMSBAQCB1bmlvbiBoZG1pX2luZm9mcmFtZSB7Cj4gIAlz dHJ1Y3QgaGRtaV9hdWRpb19pbmZvZnJhbWUgYXVkaW87Cj4gIH07Cj4gIAo+IC1zc2l6ZV90Cj4g LWhkbWlfaW5mb2ZyYW1lX3BhY2sodW5pb24gaGRtaV9pbmZvZnJhbWUgKmZyYW1lLCB2b2lkICpi dWZmZXIsIHNpemVfdCBzaXplKTsKPiArc3NpemVfdCBoZG1pX2luZm9mcmFtZV9wYWNrKHVuaW9u IGhkbWlfaW5mb2ZyYW1lICpmcmFtZSwgdm9pZCAqYnVmZmVyLAo+ICsJCQkgICAgc2l6ZV90IHNp emUpOwo+ICtzc2l6ZV90IGhkbWlfaW5mb2ZyYW1lX3BhY2tfb25seShjb25zdCB1bmlvbiBoZG1p X2luZm9mcmFtZSAqZnJhbWUsCj4gKwkJCQkgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSk7Cj4g K2ludCBoZG1pX2luZm9mcmFtZV9jaGVjayh1bmlvbiBoZG1pX2luZm9mcmFtZSAqZnJhbWUpOwo+ ICBpbnQgaGRtaV9pbmZvZnJhbWVfdW5wYWNrKHVuaW9uIGhkbWlfaW5mb2ZyYW1lICpmcmFtZSwK PiAgCQkJICBjb25zdCB2b2lkICpidWZmZXIsIHNpemVfdCBzaXplKTsKPiAgdm9pZCBoZG1pX2lu Zm9mcmFtZV9sb2coY29uc3QgY2hhciAqbGV2ZWwsIHN0cnVjdCBkZXZpY2UgKmRldiwKPiAKClJl Z2FyZHMsCgoJSGFucwpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5v cmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2 ZWwK