From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from lb1-smtp-cloud9.xs4all.net ([194.109.24.22]:33274 "EHLO lb1-smtp-cloud9.xs4all.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727958AbeJEUgh (ORCPT ); Fri, 5 Oct 2018 16:36:37 -0400 From: Hans Verkuil To: linux-media@vger.kernel.org Cc: dri-devel@lists.freedesktop.org, Hans Verkuil Subject: [PATCHv2 2/6] cec: add new tx/rx status bits to detect aborts/timeouts Date: Fri, 5 Oct 2018 15:37:41 +0200 Message-Id: <20181005133745.8593-3-hverkuil@xs4all.nl> In-Reply-To: <20181005133745.8593-1-hverkuil@xs4all.nl> References: <20181005133745.8593-1-hverkuil@xs4all.nl> Sender: linux-media-owner@vger.kernel.org List-ID: From: Hans Verkuil If the HDMI cable is disconnected or the CEC adapter is manually unconfigured, then all pending transmits and wait-for-replies are aborted. Signal this with new status bits (CEC_RX/TX_STATUS_ABORTED). If due to (usually) a driver bug a transmit never ends (i.e. the transmit_done was never called by the driver), then when this times out the message is marked with CEC_TX_STATUS_TIMEOUT. This should not happen and is an indication of a driver bug. Without a separate status bit for this it was impossible to detect this from userspace. The 'transmit timed out' kernel message is now a warning, so this should be more prominent in the kernel log as well. Signed-off-by: Hans Verkuil --- .../media/uapi/cec/cec-ioc-receive.rst | 25 ++++++- drivers/media/cec/cec-adap.c | 66 +++++-------------- include/uapi/linux/cec.h | 3 + 3 files changed, 44 insertions(+), 50 deletions(-) diff --git a/Documentation/media/uapi/cec/cec-ioc-receive.rst b/Documentation/media/uapi/cec/cec-ioc-receive.rst index e964074cd15b..b25e48afaa08 100644 --- a/Documentation/media/uapi/cec/cec-ioc-receive.rst +++ b/Documentation/media/uapi/cec/cec-ioc-receive.rst @@ -16,10 +16,10 @@ CEC_RECEIVE, CEC_TRANSMIT - Receive or transmit a CEC message Synopsis ======== -.. c:function:: int ioctl( int fd, CEC_RECEIVE, struct cec_msg *argp ) +.. c:function:: int ioctl( int fd, CEC_RECEIVE, struct cec_msg \*argp ) :name: CEC_RECEIVE -.. c:function:: int ioctl( int fd, CEC_TRANSMIT, struct cec_msg *argp ) +.. c:function:: int ioctl( int fd, CEC_TRANSMIT, struct cec_msg \*argp ) :name: CEC_TRANSMIT Arguments @@ -272,6 +272,19 @@ View On' messages from initiator 0xf ('Unregistered') to destination 0 ('TV'). - The transmit failed after one or more retries. This status bit is mutually exclusive with :ref:`CEC_TX_STATUS_OK `. Other bits can still be set to explain which failures were seen. + * .. _`CEC-TX-STATUS-ABORTED`: + + - ``CEC_TX_STATUS_ABORTED`` + - 0x40 + - The transmit was aborted due to an HDMI disconnect, or the adapter + was unconfigured, or a transmit was interrupted, or the driver + returned an error when attempting to start a transmit. + * .. _`CEC-TX-STATUS-TIMEOUT`: + + - ``CEC_TX_STATUS_TIMEOUT`` + - 0x80 + - The transmit timed out. This should not normally happen and this + indicates a driver problem. .. tabularcolumns:: |p{5.6cm}|p{0.9cm}|p{11.0cm}| @@ -300,6 +313,14 @@ View On' messages from initiator 0xf ('Unregistered') to destination 0 ('TV'). - The message was received successfully but the reply was ``CEC_MSG_FEATURE_ABORT``. This status is only set if this message was the reply to an earlier transmitted message. + * .. _`CEC-RX-STATUS-ABORTED`: + + - ``CEC_RX_STATUS_ABORTED`` + - 0x08 + - The wait for a reply to an earlier transmitted message was aborted + because the HDMI cable was disconnected, the adapter was unconfigured + or the :ref:`CEC_TRANSMIT ` that waited for a + reply was interrupted. diff --git a/drivers/media/cec/cec-adap.c b/drivers/media/cec/cec-adap.c index 829878356e1e..e6e82b504e56 100644 --- a/drivers/media/cec/cec-adap.c +++ b/drivers/media/cec/cec-adap.c @@ -354,7 +354,7 @@ static void cec_data_completed(struct cec_data *data) * * This function is called with adap->lock held. */ -static void cec_data_cancel(struct cec_data *data) +static void cec_data_cancel(struct cec_data *data, u8 tx_status) { /* * It's either the current transmit, or it is a pending @@ -369,13 +369,11 @@ static void cec_data_cancel(struct cec_data *data) } if (data->msg.tx_status & CEC_TX_STATUS_OK) { - /* Mark the canceled RX as a timeout */ data->msg.rx_ts = ktime_get_ns(); - data->msg.rx_status = CEC_RX_STATUS_TIMEOUT; + data->msg.rx_status = CEC_RX_STATUS_ABORTED; } else { - /* Mark the canceled TX as an error */ data->msg.tx_ts = ktime_get_ns(); - data->msg.tx_status |= CEC_TX_STATUS_ERROR | + data->msg.tx_status |= tx_status | CEC_TX_STATUS_MAX_RETRIES; data->msg.tx_error_cnt++; data->attempts = 0; @@ -403,15 +401,15 @@ static void cec_flush(struct cec_adapter *adap) while (!list_empty(&adap->transmit_queue)) { data = list_first_entry(&adap->transmit_queue, struct cec_data, list); - cec_data_cancel(data); + cec_data_cancel(data, CEC_TX_STATUS_ABORTED); } if (adap->transmitting) - cec_data_cancel(adap->transmitting); + cec_data_cancel(adap->transmitting, CEC_TX_STATUS_ABORTED); /* Cancel the pending timeout work. */ list_for_each_entry_safe(data, n, &adap->wait_queue, list) { if (cancel_delayed_work(&data->work)) - cec_data_cancel(data); + cec_data_cancel(data, CEC_TX_STATUS_OK); /* * If cancel_delayed_work returned false, then * the cec_wait_timeout function is running, @@ -487,12 +485,13 @@ int cec_thread_func(void *_adap) * so much traffic on the bus that the adapter was * unable to transmit for CEC_XFER_TIMEOUT_MS (2.1s). */ - dprintk(1, "%s: message %*ph timed out\n", __func__, + pr_warn("cec-%s: message %*ph timed out\n", adap->name, adap->transmitting->msg.len, adap->transmitting->msg.msg); adap->tx_timeouts++; /* Just give up on this. */ - cec_data_cancel(adap->transmitting); + cec_data_cancel(adap->transmitting, + CEC_TX_STATUS_TIMEOUT); goto unlock; } @@ -543,7 +542,7 @@ int cec_thread_func(void *_adap) /* Tell the adapter to transmit, cancel on error */ if (adap->ops->adap_transmit(adap, data->attempts, signal_free_time, &data->msg)) - cec_data_cancel(data); + cec_data_cancel(data, CEC_TX_STATUS_ABORTED); unlock: mutex_unlock(&adap->lock); @@ -715,8 +714,6 @@ int cec_transmit_msg_fh(struct cec_adapter *adap, struct cec_msg *msg, { struct cec_data *data; u8 last_initiator = 0xff; - unsigned int timeout; - int res = 0; msg->rx_ts = 0; msg->tx_ts = 0; @@ -858,48 +855,21 @@ int cec_transmit_msg_fh(struct cec_adapter *adap, struct cec_msg *msg, if (!block) return 0; - /* - * If we don't get a completion before this time something is really - * wrong and we time out. - */ - timeout = CEC_XFER_TIMEOUT_MS; - /* Add the requested timeout if we have to wait for a reply as well */ - if (msg->timeout) - timeout += msg->timeout; - /* * Release the lock and wait, retake the lock afterwards. */ mutex_unlock(&adap->lock); - res = wait_for_completion_killable_timeout(&data->c, - msecs_to_jiffies(timeout)); + wait_for_completion_killable(&data->c); mutex_lock(&adap->lock); - if (data->completed) { - /* The transmit completed (possibly with an error) */ - *msg = data->msg; - kfree(data); - return 0; - } - /* - * The wait for completion timed out or was interrupted, so mark this - * as non-blocking and disconnect from the filehandle since it is - * still 'in flight'. When it finally completes it will just drop the - * result silently. - */ - data->blocking = false; - if (data->fh) - list_del(&data->xfer_list); - data->fh = NULL; + /* Cancel the transmit if it was interrupted */ + if (!data->completed) + cec_data_cancel(data, CEC_TX_STATUS_ABORTED); - if (res == 0) { /* timed out */ - /* Check if the reply or the transmit failed */ - if (msg->timeout && (msg->tx_status & CEC_TX_STATUS_OK)) - msg->rx_status = CEC_RX_STATUS_TIMEOUT; - else - msg->tx_status = CEC_TX_STATUS_MAX_RETRIES; - } - return res > 0 ? 0 : res; + /* The transmit completed (possibly with an error) */ + *msg = data->msg; + kfree(data); + return 0; } /* Helper function to be used by drivers and this framework. */ diff --git a/include/uapi/linux/cec.h b/include/uapi/linux/cec.h index 097fcd812471..3094af68b6e7 100644 --- a/include/uapi/linux/cec.h +++ b/include/uapi/linux/cec.h @@ -152,10 +152,13 @@ static inline void cec_msg_set_reply_to(struct cec_msg *msg, #define CEC_TX_STATUS_LOW_DRIVE (1 << 3) #define CEC_TX_STATUS_ERROR (1 << 4) #define CEC_TX_STATUS_MAX_RETRIES (1 << 5) +#define CEC_TX_STATUS_ABORTED (1 << 6) +#define CEC_TX_STATUS_TIMEOUT (1 << 7) #define CEC_RX_STATUS_OK (1 << 0) #define CEC_RX_STATUS_TIMEOUT (1 << 1) #define CEC_RX_STATUS_FEATURE_ABORT (1 << 2) +#define CEC_RX_STATUS_ABORTED (1 << 3) static inline int cec_msg_status_is_ok(const struct cec_msg *msg) { -- 2.18.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Hans Verkuil Subject: [PATCHv2 2/6] cec: add new tx/rx status bits to detect aborts/timeouts Date: Fri, 5 Oct 2018 15:37:41 +0200 Message-ID: <20181005133745.8593-3-hverkuil@xs4all.nl> References: <20181005133745.8593-1-hverkuil@xs4all.nl> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from lb2-smtp-cloud9.xs4all.net (lb2-smtp-cloud9.xs4all.net [194.109.24.26]) by gabe.freedesktop.org (Postfix) with ESMTPS id 01E016E7D0 for ; Fri, 5 Oct 2018 13:37:51 +0000 (UTC) In-Reply-To: <20181005133745.8593-1-hverkuil@xs4all.nl> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: linux-media@vger.kernel.org Cc: Hans Verkuil , dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org RnJvbTogSGFucyBWZXJrdWlsIDxoYW5zLnZlcmt1aWxAY2lzY28uY29tPgoKSWYgdGhlIEhETUkg Y2FibGUgaXMgZGlzY29ubmVjdGVkIG9yIHRoZSBDRUMgYWRhcHRlciBpcyBtYW51YWxseQp1bmNv bmZpZ3VyZWQsIHRoZW4gYWxsIHBlbmRpbmcgdHJhbnNtaXRzIGFuZCB3YWl0LWZvci1yZXBsaWVz IGFyZQphYm9ydGVkLiBTaWduYWwgdGhpcyB3aXRoIG5ldyBzdGF0dXMgYml0cyAoQ0VDX1JYL1RY X1NUQVRVU19BQk9SVEVEKS4KCklmIGR1ZSB0byAodXN1YWxseSkgYSBkcml2ZXIgYnVnIGEgdHJh bnNtaXQgbmV2ZXIgZW5kcyAoaS5lLiB0aGUKdHJhbnNtaXRfZG9uZSB3YXMgbmV2ZXIgY2FsbGVk IGJ5IHRoZSBkcml2ZXIpLCB0aGVuIHdoZW4gdGhpcyB0aW1lcwpvdXQgdGhlIG1lc3NhZ2UgaXMg bWFya2VkIHdpdGggQ0VDX1RYX1NUQVRVU19USU1FT1VULgoKVGhpcyBzaG91bGQgbm90IGhhcHBl biBhbmQgaXMgYW4gaW5kaWNhdGlvbiBvZiBhIGRyaXZlciBidWcuCgpXaXRob3V0IGEgc2VwYXJh dGUgc3RhdHVzIGJpdCBmb3IgdGhpcyBpdCB3YXMgaW1wb3NzaWJsZSB0byBkZXRlY3QKdGhpcyBm cm9tIHVzZXJzcGFjZS4KClRoZSAndHJhbnNtaXQgdGltZWQgb3V0JyBrZXJuZWwgbWVzc2FnZSBp cyBub3cgYSB3YXJuaW5nLCBzbyB0aGlzCnNob3VsZCBiZSBtb3JlIHByb21pbmVudCBpbiB0aGUg a2VybmVsIGxvZyBhcyB3ZWxsLgoKU2lnbmVkLW9mZi1ieTogSGFucyBWZXJrdWlsIDxoYW5zLnZl cmt1aWxAY2lzY28uY29tPgotLS0KIC4uLi9tZWRpYS91YXBpL2NlYy9jZWMtaW9jLXJlY2VpdmUu cnN0ICAgICAgICB8IDI1ICsrKysrKy0KIGRyaXZlcnMvbWVkaWEvY2VjL2NlYy1hZGFwLmMgICAg ICAgICAgICAgICAgICB8IDY2ICsrKysrLS0tLS0tLS0tLS0tLS0KIGluY2x1ZGUvdWFwaS9saW51 eC9jZWMuaCAgICAgICAgICAgICAgICAgICAgICB8ICAzICsKIDMgZmlsZXMgY2hhbmdlZCwgNDQg aW5zZXJ0aW9ucygrKSwgNTAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlv bi9tZWRpYS91YXBpL2NlYy9jZWMtaW9jLXJlY2VpdmUucnN0IGIvRG9jdW1lbnRhdGlvbi9tZWRp YS91YXBpL2NlYy9jZWMtaW9jLXJlY2VpdmUucnN0CmluZGV4IGU5NjQwNzRjZDE1Yi4uYjI1ZTQ4 YWZhYTA4IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL21lZGlhL3VhcGkvY2VjL2NlYy1pb2Mt cmVjZWl2ZS5yc3QKKysrIGIvRG9jdW1lbnRhdGlvbi9tZWRpYS91YXBpL2NlYy9jZWMtaW9jLXJl Y2VpdmUucnN0CkBAIC0xNiwxMCArMTYsMTAgQEAgQ0VDX1JFQ0VJVkUsIENFQ19UUkFOU01JVCAt IFJlY2VpdmUgb3IgdHJhbnNtaXQgYSBDRUMgbWVzc2FnZQogU3lub3BzaXMKID09PT09PT09CiAK LS4uIGM6ZnVuY3Rpb246OiBpbnQgaW9jdGwoIGludCBmZCwgQ0VDX1JFQ0VJVkUsIHN0cnVjdCBj ZWNfbXNnICphcmdwICkKKy4uIGM6ZnVuY3Rpb246OiBpbnQgaW9jdGwoIGludCBmZCwgQ0VDX1JF Q0VJVkUsIHN0cnVjdCBjZWNfbXNnIFwqYXJncCApCiAgICAgOm5hbWU6IENFQ19SRUNFSVZFCiAK LS4uIGM6ZnVuY3Rpb246OiBpbnQgaW9jdGwoIGludCBmZCwgQ0VDX1RSQU5TTUlULCBzdHJ1Y3Qg Y2VjX21zZyAqYXJncCApCisuLiBjOmZ1bmN0aW9uOjogaW50IGlvY3RsKCBpbnQgZmQsIENFQ19U UkFOU01JVCwgc3RydWN0IGNlY19tc2cgXCphcmdwICkKICAgICA6bmFtZTogQ0VDX1RSQU5TTUlU CiAKIEFyZ3VtZW50cwpAQCAtMjcyLDYgKzI3MiwxOSBAQCBWaWV3IE9uJyBtZXNzYWdlcyBmcm9t IGluaXRpYXRvciAweGYgKCdVbnJlZ2lzdGVyZWQnKSB0byBkZXN0aW5hdGlvbiAwICgnVFYnKS4K ICAgICAgIC0gVGhlIHRyYW5zbWl0IGZhaWxlZCBhZnRlciBvbmUgb3IgbW9yZSByZXRyaWVzLiBU aGlzIHN0YXR1cyBiaXQgaXMKIAltdXR1YWxseSBleGNsdXNpdmUgd2l0aCA6cmVmOmBDRUNfVFhf U1RBVFVTX09LIDxDRUMtVFgtU1RBVFVTLU9LPmAuCiAJT3RoZXIgYml0cyBjYW4gc3RpbGwgYmUg c2V0IHRvIGV4cGxhaW4gd2hpY2ggZmFpbHVyZXMgd2VyZSBzZWVuLgorICAgICogLi4gX2BDRUMt VFgtU1RBVFVTLUFCT1JURURgOgorCisgICAgICAtIGBgQ0VDX1RYX1NUQVRVU19BQk9SVEVEYGAK KyAgICAgIC0gMHg0MAorICAgICAgLSBUaGUgdHJhbnNtaXQgd2FzIGFib3J0ZWQgZHVlIHRvIGFu IEhETUkgZGlzY29ubmVjdCwgb3IgdGhlIGFkYXB0ZXIKKyAgICAgICAgd2FzIHVuY29uZmlndXJl ZCwgb3IgYSB0cmFuc21pdCB3YXMgaW50ZXJydXB0ZWQsIG9yIHRoZSBkcml2ZXIKKwlyZXR1cm5l ZCBhbiBlcnJvciB3aGVuIGF0dGVtcHRpbmcgdG8gc3RhcnQgYSB0cmFuc21pdC4KKyAgICAqIC4u IF9gQ0VDLVRYLVNUQVRVUy1USU1FT1VUYDoKKworICAgICAgLSBgYENFQ19UWF9TVEFUVVNfVElN RU9VVGBgCisgICAgICAtIDB4ODAKKyAgICAgIC0gVGhlIHRyYW5zbWl0IHRpbWVkIG91dC4gVGhp cyBzaG91bGQgbm90IG5vcm1hbGx5IGhhcHBlbiBhbmQgdGhpcworCWluZGljYXRlcyBhIGRyaXZl ciBwcm9ibGVtLgogCiAKIC4uIHRhYnVsYXJjb2x1bW5zOjogfHB7NS42Y219fHB7MC45Y219fHB7 MTEuMGNtfXwKQEAgLTMwMCw2ICszMTMsMTQgQEAgVmlldyBPbicgbWVzc2FnZXMgZnJvbSBpbml0 aWF0b3IgMHhmICgnVW5yZWdpc3RlcmVkJykgdG8gZGVzdGluYXRpb24gMCAoJ1RWJykuCiAgICAg ICAtIFRoZSBtZXNzYWdlIHdhcyByZWNlaXZlZCBzdWNjZXNzZnVsbHkgYnV0IHRoZSByZXBseSB3 YXMKIAlgYENFQ19NU0dfRkVBVFVSRV9BQk9SVGBgLiBUaGlzIHN0YXR1cyBpcyBvbmx5IHNldCBp ZiB0aGlzIG1lc3NhZ2UKIAl3YXMgdGhlIHJlcGx5IHRvIGFuIGVhcmxpZXIgdHJhbnNtaXR0ZWQg bWVzc2FnZS4KKyAgICAqIC4uIF9gQ0VDLVJYLVNUQVRVUy1BQk9SVEVEYDoKKworICAgICAgLSBg YENFQ19SWF9TVEFUVVNfQUJPUlRFRGBgCisgICAgICAtIDB4MDgKKyAgICAgIC0gVGhlIHdhaXQg Zm9yIGEgcmVwbHkgdG8gYW4gZWFybGllciB0cmFuc21pdHRlZCBtZXNzYWdlIHdhcyBhYm9ydGVk CisgICAgICAgIGJlY2F1c2UgdGhlIEhETUkgY2FibGUgd2FzIGRpc2Nvbm5lY3RlZCwgdGhlIGFk YXB0ZXIgd2FzIHVuY29uZmlndXJlZAorCW9yIHRoZSA6cmVmOmBDRUNfVFJBTlNNSVQgPENFQ19S RUNFSVZFPmAgdGhhdCB3YWl0ZWQgZm9yIGEKKwlyZXBseSB3YXMgaW50ZXJydXB0ZWQuCiAKIAog CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL2NlYy9jZWMtYWRhcC5jIGIvZHJpdmVycy9tZWRp YS9jZWMvY2VjLWFkYXAuYwppbmRleCA4Mjk4NzgzNTZlMWUuLmU2ZTgyYjUwNGU1NiAxMDA2NDQK LS0tIGEvZHJpdmVycy9tZWRpYS9jZWMvY2VjLWFkYXAuYworKysgYi9kcml2ZXJzL21lZGlhL2Nl Yy9jZWMtYWRhcC5jCkBAIC0zNTQsNyArMzU0LDcgQEAgc3RhdGljIHZvaWQgY2VjX2RhdGFfY29t cGxldGVkKHN0cnVjdCBjZWNfZGF0YSAqZGF0YSkKICAqCiAgKiBUaGlzIGZ1bmN0aW9uIGlzIGNh bGxlZCB3aXRoIGFkYXAtPmxvY2sgaGVsZC4KICAqLwotc3RhdGljIHZvaWQgY2VjX2RhdGFfY2Fu Y2VsKHN0cnVjdCBjZWNfZGF0YSAqZGF0YSkKK3N0YXRpYyB2b2lkIGNlY19kYXRhX2NhbmNlbChz dHJ1Y3QgY2VjX2RhdGEgKmRhdGEsIHU4IHR4X3N0YXR1cykKIHsKIAkvKgogCSAqIEl0J3MgZWl0 aGVyIHRoZSBjdXJyZW50IHRyYW5zbWl0LCBvciBpdCBpcyBhIHBlbmRpbmcKQEAgLTM2OSwxMyAr MzY5LDExIEBAIHN0YXRpYyB2b2lkIGNlY19kYXRhX2NhbmNlbChzdHJ1Y3QgY2VjX2RhdGEgKmRh dGEpCiAJfQogCiAJaWYgKGRhdGEtPm1zZy50eF9zdGF0dXMgJiBDRUNfVFhfU1RBVFVTX09LKSB7 Ci0JCS8qIE1hcmsgdGhlIGNhbmNlbGVkIFJYIGFzIGEgdGltZW91dCAqLwogCQlkYXRhLT5tc2cu cnhfdHMgPSBrdGltZV9nZXRfbnMoKTsKLQkJZGF0YS0+bXNnLnJ4X3N0YXR1cyA9IENFQ19SWF9T VEFUVVNfVElNRU9VVDsKKwkJZGF0YS0+bXNnLnJ4X3N0YXR1cyA9IENFQ19SWF9TVEFUVVNfQUJP UlRFRDsKIAl9IGVsc2UgewotCQkvKiBNYXJrIHRoZSBjYW5jZWxlZCBUWCBhcyBhbiBlcnJvciAq LwogCQlkYXRhLT5tc2cudHhfdHMgPSBrdGltZV9nZXRfbnMoKTsKLQkJZGF0YS0+bXNnLnR4X3N0 YXR1cyB8PSBDRUNfVFhfU1RBVFVTX0VSUk9SIHwKKwkJZGF0YS0+bXNnLnR4X3N0YXR1cyB8PSB0 eF9zdGF0dXMgfAogCQkJCSAgICAgICBDRUNfVFhfU1RBVFVTX01BWF9SRVRSSUVTOwogCQlkYXRh LT5tc2cudHhfZXJyb3JfY250Kys7CiAJCWRhdGEtPmF0dGVtcHRzID0gMDsKQEAgLTQwMywxNSAr NDAxLDE1IEBAIHN0YXRpYyB2b2lkIGNlY19mbHVzaChzdHJ1Y3QgY2VjX2FkYXB0ZXIgKmFkYXAp CiAJd2hpbGUgKCFsaXN0X2VtcHR5KCZhZGFwLT50cmFuc21pdF9xdWV1ZSkpIHsKIAkJZGF0YSA9 IGxpc3RfZmlyc3RfZW50cnkoJmFkYXAtPnRyYW5zbWl0X3F1ZXVlLAogCQkJCQlzdHJ1Y3QgY2Vj X2RhdGEsIGxpc3QpOwotCQljZWNfZGF0YV9jYW5jZWwoZGF0YSk7CisJCWNlY19kYXRhX2NhbmNl bChkYXRhLCBDRUNfVFhfU1RBVFVTX0FCT1JURUQpOwogCX0KIAlpZiAoYWRhcC0+dHJhbnNtaXR0 aW5nKQotCQljZWNfZGF0YV9jYW5jZWwoYWRhcC0+dHJhbnNtaXR0aW5nKTsKKwkJY2VjX2RhdGFf Y2FuY2VsKGFkYXAtPnRyYW5zbWl0dGluZywgQ0VDX1RYX1NUQVRVU19BQk9SVEVEKTsKIAogCS8q IENhbmNlbCB0aGUgcGVuZGluZyB0aW1lb3V0IHdvcmsuICovCiAJbGlzdF9mb3JfZWFjaF9lbnRy eV9zYWZlKGRhdGEsIG4sICZhZGFwLT53YWl0X3F1ZXVlLCBsaXN0KSB7CiAJCWlmIChjYW5jZWxf ZGVsYXllZF93b3JrKCZkYXRhLT53b3JrKSkKLQkJCWNlY19kYXRhX2NhbmNlbChkYXRhKTsKKwkJ CWNlY19kYXRhX2NhbmNlbChkYXRhLCBDRUNfVFhfU1RBVFVTX09LKTsKIAkJLyoKIAkJICogSWYg Y2FuY2VsX2RlbGF5ZWRfd29yayByZXR1cm5lZCBmYWxzZSwgdGhlbgogCQkgKiB0aGUgY2VjX3dh aXRfdGltZW91dCBmdW5jdGlvbiBpcyBydW5uaW5nLApAQCAtNDg3LDEyICs0ODUsMTMgQEAgaW50 IGNlY190aHJlYWRfZnVuYyh2b2lkICpfYWRhcCkKIAkJCSAqIHNvIG11Y2ggdHJhZmZpYyBvbiB0 aGUgYnVzIHRoYXQgdGhlIGFkYXB0ZXIgd2FzCiAJCQkgKiB1bmFibGUgdG8gdHJhbnNtaXQgZm9y IENFQ19YRkVSX1RJTUVPVVRfTVMgKDIuMXMpLgogCQkJICovCi0JCQlkcHJpbnRrKDEsICIlczog bWVzc2FnZSAlKnBoIHRpbWVkIG91dFxuIiwgX19mdW5jX18sCisJCQlwcl93YXJuKCJjZWMtJXM6 IG1lc3NhZ2UgJSpwaCB0aW1lZCBvdXRcbiIsIGFkYXAtPm5hbWUsCiAJCQkJYWRhcC0+dHJhbnNt aXR0aW5nLT5tc2cubGVuLAogCQkJCWFkYXAtPnRyYW5zbWl0dGluZy0+bXNnLm1zZyk7CiAJCQlh ZGFwLT50eF90aW1lb3V0cysrOwogCQkJLyogSnVzdCBnaXZlIHVwIG9uIHRoaXMuICovCi0JCQlj ZWNfZGF0YV9jYW5jZWwoYWRhcC0+dHJhbnNtaXR0aW5nKTsKKwkJCWNlY19kYXRhX2NhbmNlbChh ZGFwLT50cmFuc21pdHRpbmcsCisJCQkJCUNFQ19UWF9TVEFUVVNfVElNRU9VVCk7CiAJCQlnb3Rv IHVubG9jazsKIAkJfQogCkBAIC01NDMsNyArNTQyLDcgQEAgaW50IGNlY190aHJlYWRfZnVuYyh2 b2lkICpfYWRhcCkKIAkJLyogVGVsbCB0aGUgYWRhcHRlciB0byB0cmFuc21pdCwgY2FuY2VsIG9u IGVycm9yICovCiAJCWlmIChhZGFwLT5vcHMtPmFkYXBfdHJhbnNtaXQoYWRhcCwgZGF0YS0+YXR0 ZW1wdHMsCiAJCQkJCSAgICAgc2lnbmFsX2ZyZWVfdGltZSwgJmRhdGEtPm1zZykpCi0JCQljZWNf ZGF0YV9jYW5jZWwoZGF0YSk7CisJCQljZWNfZGF0YV9jYW5jZWwoZGF0YSwgQ0VDX1RYX1NUQVRV U19BQk9SVEVEKTsKIAogdW5sb2NrOgogCQltdXRleF91bmxvY2soJmFkYXAtPmxvY2spOwpAQCAt NzE1LDggKzcxNCw2IEBAIGludCBjZWNfdHJhbnNtaXRfbXNnX2ZoKHN0cnVjdCBjZWNfYWRhcHRl ciAqYWRhcCwgc3RydWN0IGNlY19tc2cgKm1zZywKIHsKIAlzdHJ1Y3QgY2VjX2RhdGEgKmRhdGE7 CiAJdTggbGFzdF9pbml0aWF0b3IgPSAweGZmOwotCXVuc2lnbmVkIGludCB0aW1lb3V0OwotCWlu dCByZXMgPSAwOwogCiAJbXNnLT5yeF90cyA9IDA7CiAJbXNnLT50eF90cyA9IDA7CkBAIC04NTgs NDggKzg1NSwyMSBAQCBpbnQgY2VjX3RyYW5zbWl0X21zZ19maChzdHJ1Y3QgY2VjX2FkYXB0ZXIg KmFkYXAsIHN0cnVjdCBjZWNfbXNnICptc2csCiAJaWYgKCFibG9jaykKIAkJcmV0dXJuIDA7CiAK LQkvKgotCSAqIElmIHdlIGRvbid0IGdldCBhIGNvbXBsZXRpb24gYmVmb3JlIHRoaXMgdGltZSBz b21ldGhpbmcgaXMgcmVhbGx5Ci0JICogd3JvbmcgYW5kIHdlIHRpbWUgb3V0LgotCSAqLwotCXRp bWVvdXQgPSBDRUNfWEZFUl9USU1FT1VUX01TOwotCS8qIEFkZCB0aGUgcmVxdWVzdGVkIHRpbWVv dXQgaWYgd2UgaGF2ZSB0byB3YWl0IGZvciBhIHJlcGx5IGFzIHdlbGwgKi8KLQlpZiAobXNnLT50 aW1lb3V0KQotCQl0aW1lb3V0ICs9IG1zZy0+dGltZW91dDsKLQogCS8qCiAJICogUmVsZWFzZSB0 aGUgbG9jayBhbmQgd2FpdCwgcmV0YWtlIHRoZSBsb2NrIGFmdGVyd2FyZHMuCiAJICovCiAJbXV0 ZXhfdW5sb2NrKCZhZGFwLT5sb2NrKTsKLQlyZXMgPSB3YWl0X2Zvcl9jb21wbGV0aW9uX2tpbGxh YmxlX3RpbWVvdXQoJmRhdGEtPmMsCi0JCQkJCQkgICBtc2Vjc190b19qaWZmaWVzKHRpbWVvdXQp KTsKKwl3YWl0X2Zvcl9jb21wbGV0aW9uX2tpbGxhYmxlKCZkYXRhLT5jKTsKIAltdXRleF9sb2Nr KCZhZGFwLT5sb2NrKTsKIAotCWlmIChkYXRhLT5jb21wbGV0ZWQpIHsKLQkJLyogVGhlIHRyYW5z bWl0IGNvbXBsZXRlZCAocG9zc2libHkgd2l0aCBhbiBlcnJvcikgKi8KLQkJKm1zZyA9IGRhdGEt Pm1zZzsKLQkJa2ZyZWUoZGF0YSk7Ci0JCXJldHVybiAwOwotCX0KLQkvKgotCSAqIFRoZSB3YWl0 IGZvciBjb21wbGV0aW9uIHRpbWVkIG91dCBvciB3YXMgaW50ZXJydXB0ZWQsIHNvIG1hcmsgdGhp cwotCSAqIGFzIG5vbi1ibG9ja2luZyBhbmQgZGlzY29ubmVjdCBmcm9tIHRoZSBmaWxlaGFuZGxl IHNpbmNlIGl0IGlzCi0JICogc3RpbGwgJ2luIGZsaWdodCcuIFdoZW4gaXQgZmluYWxseSBjb21w bGV0ZXMgaXQgd2lsbCBqdXN0IGRyb3AgdGhlCi0JICogcmVzdWx0IHNpbGVudGx5LgotCSAqLwot CWRhdGEtPmJsb2NraW5nID0gZmFsc2U7Ci0JaWYgKGRhdGEtPmZoKQotCQlsaXN0X2RlbCgmZGF0 YS0+eGZlcl9saXN0KTsKLQlkYXRhLT5maCA9IE5VTEw7CisJLyogQ2FuY2VsIHRoZSB0cmFuc21p dCBpZiBpdCB3YXMgaW50ZXJydXB0ZWQgKi8KKwlpZiAoIWRhdGEtPmNvbXBsZXRlZCkKKwkJY2Vj X2RhdGFfY2FuY2VsKGRhdGEsIENFQ19UWF9TVEFUVVNfQUJPUlRFRCk7CiAKLQlpZiAocmVzID09 IDApIHsgLyogdGltZWQgb3V0ICovCi0JCS8qIENoZWNrIGlmIHRoZSByZXBseSBvciB0aGUgdHJh bnNtaXQgZmFpbGVkICovCi0JCWlmIChtc2ctPnRpbWVvdXQgJiYgKG1zZy0+dHhfc3RhdHVzICYg Q0VDX1RYX1NUQVRVU19PSykpCi0JCQltc2ctPnJ4X3N0YXR1cyA9IENFQ19SWF9TVEFUVVNfVElN RU9VVDsKLQkJZWxzZQotCQkJbXNnLT50eF9zdGF0dXMgPSBDRUNfVFhfU1RBVFVTX01BWF9SRVRS SUVTOwotCX0KLQlyZXR1cm4gcmVzID4gMCA/IDAgOiByZXM7CisJLyogVGhlIHRyYW5zbWl0IGNv bXBsZXRlZCAocG9zc2libHkgd2l0aCBhbiBlcnJvcikgKi8KKwkqbXNnID0gZGF0YS0+bXNnOwor CWtmcmVlKGRhdGEpOworCXJldHVybiAwOwogfQogCiAvKiBIZWxwZXIgZnVuY3Rpb24gdG8gYmUg dXNlZCBieSBkcml2ZXJzIGFuZCB0aGlzIGZyYW1ld29yay4gKi8KZGlmZiAtLWdpdCBhL2luY2x1 ZGUvdWFwaS9saW51eC9jZWMuaCBiL2luY2x1ZGUvdWFwaS9saW51eC9jZWMuaAppbmRleCAwOTdm Y2Q4MTI0NzEuLjMwOTRhZjY4YjZlNyAxMDA2NDQKLS0tIGEvaW5jbHVkZS91YXBpL2xpbnV4L2Nl Yy5oCisrKyBiL2luY2x1ZGUvdWFwaS9saW51eC9jZWMuaApAQCAtMTUyLDEwICsxNTIsMTMgQEAg c3RhdGljIGlubGluZSB2b2lkIGNlY19tc2dfc2V0X3JlcGx5X3RvKHN0cnVjdCBjZWNfbXNnICpt c2csCiAjZGVmaW5lIENFQ19UWF9TVEFUVVNfTE9XX0RSSVZFCQkoMSA8PCAzKQogI2RlZmluZSBD RUNfVFhfU1RBVFVTX0VSUk9SCQkoMSA8PCA0KQogI2RlZmluZSBDRUNfVFhfU1RBVFVTX01BWF9S RVRSSUVTCSgxIDw8IDUpCisjZGVmaW5lIENFQ19UWF9TVEFUVVNfQUJPUlRFRAkJKDEgPDwgNikK KyNkZWZpbmUgQ0VDX1RYX1NUQVRVU19USU1FT1VUCQkoMSA8PCA3KQogCiAjZGVmaW5lIENFQ19S WF9TVEFUVVNfT0sJCSgxIDw8IDApCiAjZGVmaW5lIENFQ19SWF9TVEFUVVNfVElNRU9VVAkJKDEg PDwgMSkKICNkZWZpbmUgQ0VDX1JYX1NUQVRVU19GRUFUVVJFX0FCT1JUCSgxIDw8IDIpCisjZGVm aW5lIENFQ19SWF9TVEFUVVNfQUJPUlRFRAkJKDEgPDwgMykKIAogc3RhdGljIGlubGluZSBpbnQg Y2VjX21zZ19zdGF0dXNfaXNfb2soY29uc3Qgc3RydWN0IGNlY19tc2cgKm1zZykKIHsKLS0gCjIu MTguMAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJp LWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBz Oi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==