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=-9.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED, USER_AGENT_GIT 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 41495C282CB for ; Tue, 5 Feb 2019 19:57:09 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 175D12083B for ; Tue, 5 Feb 2019 19:57:09 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1730061AbfBET5H (ORCPT ); Tue, 5 Feb 2019 14:57:07 -0500 Received: from mx2.suse.de ([195.135.220.15]:53764 "EHLO mx1.suse.de" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1726927AbfBET5H (ORCPT ); Tue, 5 Feb 2019 14:57:07 -0500 X-Virus-Scanned: by amavisd-new at test-mx.suse.de Received: from relay2.suse.de (unknown [195.135.220.254]) by mx1.suse.de (Postfix) with ESMTP id 13FEDAC17; Tue, 5 Feb 2019 19:57:05 +0000 (UTC) From: Nicolas Saenz Julienne To: felipe.balbi@linux.intel.com, oneukum@suse.com, Mathias Nyman Cc: Nicolas Saenz Julienne , Greg Kroah-Hartman , linux-usb@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [RFC v2] usb: xhci: add Immediate Data Transfer support Date: Tue, 5 Feb 2019 20:56:47 +0100 Message-Id: <20190205195647.29258-1-nsaenzjulienne@suse.de> X-Mailer: git-send-email 2.20.1 MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Immediate data transfers (IDT) allow the HCD to copy small chunks of data (up to 8bytes) directly into its output transfer TRBs. This avoids the somewhat expensive DMA mappings that are performed by default on most URBs submissions. In the case an URB was suitable for IDT. The data is directly copied into the "Data Buffer Pointer" region of the TRB and the IDT flag is set. Instead of triggering memory accesses the HC will use the data directly. The implementation covers all kind of output endpoints. All have been tested successfully with multiple devices except for isochronous ones. I can't seem to find a device that'll perform transfers with such small packet sizes. The implementation takes into account that the 8 byte buffers provided by the URB will never cross a 64KB boundary. Signed-off-by: Nicolas Saenz Julienne --- Chages since first RFC: - Got rid of URB flag - Implement feature for Control transfers - Implement feature for Isoc transfers drivers/usb/host/xhci-ring.c | 20 ++++++++++++++++++++ drivers/usb/host/xhci.c | 16 ++++++++++++++++ drivers/usb/host/xhci.h | 12 ++++++++++++ 3 files changed, 48 insertions(+) diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c index 40fa25c4d041..a4efbe62a1a3 100644 --- a/drivers/usb/host/xhci-ring.c +++ b/drivers/usb/host/xhci-ring.c @@ -3272,8 +3272,15 @@ int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags, field |= TRB_IOC; more_trbs_coming = false; td->last_trb = ring->enqueue; + + if (xhci_urb_suitable_for_idt(urb)) { + memcpy(&send_addr, urb->transfer_buffer, + trb_buff_len); + field |= TRB_IDT; + } } + /* Only set interrupt on short packet for IN endpoints */ if (usb_urb_dir_in(urb)) field |= TRB_ISP; @@ -3411,6 +3418,12 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags, if (urb->transfer_buffer_length > 0) { u32 length_field, remainder; + if (xhci_urb_suitable_for_idt(urb)) { + memcpy(&urb->transfer_dma, urb->transfer_buffer, + urb->transfer_buffer_length); + field |= TRB_IDT; + } + remainder = xhci_td_remainder(xhci, 0, urb->transfer_buffer_length, urb->transfer_buffer_length, @@ -3420,6 +3433,7 @@ int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags, TRB_INTR_TARGET(0); if (setup->bRequestType & USB_DIR_IN) field |= TRB_DIR_IN; + queue_trb(xhci, ep_ring, true, lower_32_bits(urb->transfer_dma), upper_32_bits(urb->transfer_dma), @@ -3710,6 +3724,12 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags, if (trb_buff_len > td_remain_len) trb_buff_len = td_remain_len; + if (xhci_urb_suitable_for_idt(urb)) { + memcpy(&addr, urb->transfer_buffer, + trb_buff_len); + field |= TRB_IDT; + } + /* Set the TRB length, TD size, & interrupter fields. */ remainder = xhci_td_remainder(xhci, running_total, trb_buff_len, td_len, diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c index 005e65922608..dec62f7f5dc8 100644 --- a/drivers/usb/host/xhci.c +++ b/drivers/usb/host/xhci.c @@ -1238,6 +1238,21 @@ EXPORT_SYMBOL_GPL(xhci_resume); /*-------------------------------------------------------------------------*/ +/* + * Bypass the DMA mapping if URB is suitable for Immediate Transfer (IDT), + * we'll copy the actual data into the TRB address register. This is limited to + * transfers up to 8 bytes on output endpoints of any kind with wMaxPacketSize + * >= 8 bytes. + */ +static int xhci_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb, + gfp_t mem_flags) +{ + if (xhci_urb_suitable_for_idt(urb)) + return 0; + + return usb_hcd_map_urb_for_dma(hcd, urb, mem_flags); +} + /** * xhci_get_endpoint_index - Used for passing endpoint bitmasks between the core and * HCDs. Find the index for an endpoint given its descriptor. Use the return @@ -5155,6 +5170,7 @@ static const struct hc_driver xhci_hc_driver = { /* * managing i/o requests and associated device resources */ + .map_urb_for_dma = xhci_map_urb_for_dma, .urb_enqueue = xhci_urb_enqueue, .urb_dequeue = xhci_urb_dequeue, .alloc_dev = xhci_alloc_dev, diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h index 652dc36e3012..9d77b0901ab7 100644 --- a/drivers/usb/host/xhci.h +++ b/drivers/usb/host/xhci.h @@ -1295,6 +1295,8 @@ enum xhci_setup_dev { #define TRB_IOC (1<<5) /* The buffer pointer contains immediate data */ #define TRB_IDT (1<<6) +/* TDs smaller than this might use IDT */ +#define TRB_IDT_MAX_SIZE 8 /* Block Event Interrupt */ #define TRB_BEI (1<<9) @@ -2141,6 +2143,16 @@ static inline struct xhci_ring *xhci_urb_to_transfer_ring(struct xhci_hcd *xhci, urb->stream_id); } +static inline bool xhci_urb_suitable_for_idt(struct urb *urb) +{ + if (usb_endpoint_maxp(&urb->ep->desc) >= TRB_IDT_MAX_SIZE && + urb->transfer_buffer_length <= TRB_IDT_MAX_SIZE && + usb_urb_dir_out(urb)) + return true; + + return false; +} + static inline char *xhci_slot_state_string(u32 state) { switch (state) { -- 2.20.1 From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [RFC,v2] usb: xhci: add Immediate Data Transfer support From: Nicolas Saenz Julienne Message-Id: <20190205195647.29258-1-nsaenzjulienne@suse.de> Date: Tue, 5 Feb 2019 20:56:47 +0100 To: felipe.balbi@linux.intel.com, oneukum@suse.com, Mathias Nyman Cc: Nicolas Saenz Julienne , Greg Kroah-Hartman , linux-usb@vger.kernel.org, linux-kernel@vger.kernel.org List-ID: SW1tZWRpYXRlIGRhdGEgdHJhbnNmZXJzIChJRFQpIGFsbG93IHRoZSBIQ0QgdG8gY29weSBzbWFs bCBjaHVua3Mgb2YKZGF0YSAodXAgdG8gOGJ5dGVzKSBkaXJlY3RseSBpbnRvIGl0cyBvdXRwdXQg dHJhbnNmZXIgVFJCcy4gVGhpcyBhdm9pZHMKdGhlIHNvbWV3aGF0IGV4cGVuc2l2ZSBETUEgbWFw cGluZ3MgdGhhdCBhcmUgcGVyZm9ybWVkIGJ5IGRlZmF1bHQgb24KbW9zdCBVUkJzIHN1Ym1pc3Np b25zLgoKSW4gdGhlIGNhc2UgYW4gVVJCIHdhcyBzdWl0YWJsZSBmb3IgSURULiBUaGUgZGF0YSBp cyBkaXJlY3RseSBjb3BpZWQKaW50byB0aGUgIkRhdGEgQnVmZmVyIFBvaW50ZXIiIHJlZ2lvbiBv ZiB0aGUgVFJCIGFuZCB0aGUgSURUIGZsYWcgaXMKc2V0LiBJbnN0ZWFkIG9mIHRyaWdnZXJpbmcg bWVtb3J5IGFjY2Vzc2VzIHRoZSBIQyB3aWxsIHVzZSB0aGUgZGF0YQpkaXJlY3RseS4KClRoZSBp bXBsZW1lbnRhdGlvbiBjb3ZlcnMgYWxsIGtpbmQgb2Ygb3V0cHV0IGVuZHBvaW50cy4gQWxsIGhh dmUgYmVlbgp0ZXN0ZWQgc3VjY2Vzc2Z1bGx5IHdpdGggbXVsdGlwbGUgZGV2aWNlcyBleGNlcHQg Zm9yIGlzb2Nocm9ub3VzIG9uZXMuIEkKY2FuJ3Qgc2VlbSB0byBmaW5kIGEgZGV2aWNlIHRoYXQn bGwgcGVyZm9ybSB0cmFuc2ZlcnMgd2l0aCBzdWNoIHNtYWxsCnBhY2tldCBzaXplcy4KClRoZSBp bXBsZW1lbnRhdGlvbiB0YWtlcyBpbnRvIGFjY291bnQgdGhhdCB0aGUgOCBieXRlIGJ1ZmZlcnMg cHJvdmlkZWQKYnkgdGhlIFVSQiB3aWxsIG5ldmVyIGNyb3NzIGEgNjRLQiBib3VuZGFyeS4KClNp Z25lZC1vZmYtYnk6IE5pY29sYXMgU2FlbnogSnVsaWVubmUgPG5zYWVuemp1bGllbm5lQHN1c2Uu ZGU+Ci0tLQpDaGFnZXMgc2luY2UgZmlyc3QgUkZDOgogIC0gR290IHJpZCBvZiBVUkIgZmxhZwog IC0gSW1wbGVtZW50IGZlYXR1cmUgZm9yIENvbnRyb2wgdHJhbnNmZXJzCiAgLSBJbXBsZW1lbnQg ZmVhdHVyZSBmb3IgSXNvYyB0cmFuc2ZlcnMKCiBkcml2ZXJzL3VzYi9ob3N0L3hoY2ktcmluZy5j IHwgMjAgKysrKysrKysrKysrKysrKysrKysKIGRyaXZlcnMvdXNiL2hvc3QveGhjaS5jICAgICAg fCAxNiArKysrKysrKysrKysrKysrCiBkcml2ZXJzL3VzYi9ob3N0L3hoY2kuaCAgICAgIHwgMTIg KysrKysrKysrKysrCiAzIGZpbGVzIGNoYW5nZWQsIDQ4IGluc2VydGlvbnMoKykKCmRpZmYgLS1n aXQgYS9kcml2ZXJzL3VzYi9ob3N0L3hoY2ktcmluZy5jIGIvZHJpdmVycy91c2IvaG9zdC94aGNp LXJpbmcuYwppbmRleCA0MGZhMjVjNGQwNDEuLmE0ZWZiZTYyYTFhMyAxMDA2NDQKLS0tIGEvZHJp dmVycy91c2IvaG9zdC94aGNpLXJpbmcuYworKysgYi9kcml2ZXJzL3VzYi9ob3N0L3hoY2ktcmlu Zy5jCkBAIC0zMjcyLDggKzMyNzIsMTUgQEAgaW50IHhoY2lfcXVldWVfYnVsa190eChzdHJ1Y3Qg eGhjaV9oY2QgKnhoY2ksIGdmcF90IG1lbV9mbGFncywKIAkJCWZpZWxkIHw9IFRSQl9JT0M7CiAJ CQltb3JlX3RyYnNfY29taW5nID0gZmFsc2U7CiAJCQl0ZC0+bGFzdF90cmIgPSByaW5nLT5lbnF1 ZXVlOworCisJCQlpZiAoeGhjaV91cmJfc3VpdGFibGVfZm9yX2lkdCh1cmIpKSB7CisJCQkJbWVt Y3B5KCZzZW5kX2FkZHIsIHVyYi0+dHJhbnNmZXJfYnVmZmVyLAorCQkJCSAgICAgICB0cmJfYnVm Zl9sZW4pOworCQkJCWZpZWxkIHw9IFRSQl9JRFQ7CisJCQl9CiAJCX0KIAorCiAJCS8qIE9ubHkg c2V0IGludGVycnVwdCBvbiBzaG9ydCBwYWNrZXQgZm9yIElOIGVuZHBvaW50cyAqLwogCQlpZiAo dXNiX3VyYl9kaXJfaW4odXJiKSkKIAkJCWZpZWxkIHw9IFRSQl9JU1A7CkBAIC0zNDExLDYgKzM0 MTgsMTIgQEAgaW50IHhoY2lfcXVldWVfY3RybF90eChzdHJ1Y3QgeGhjaV9oY2QgKnhoY2ksIGdm cF90IG1lbV9mbGFncywKIAlpZiAodXJiLT50cmFuc2Zlcl9idWZmZXJfbGVuZ3RoID4gMCkgewog CQl1MzIgbGVuZ3RoX2ZpZWxkLCByZW1haW5kZXI7CiAKKwkJaWYgKHhoY2lfdXJiX3N1aXRhYmxl X2Zvcl9pZHQodXJiKSkgeworCQkJbWVtY3B5KCZ1cmItPnRyYW5zZmVyX2RtYSwgdXJiLT50cmFu c2Zlcl9idWZmZXIsCisJCQkgICAgICAgdXJiLT50cmFuc2Zlcl9idWZmZXJfbGVuZ3RoKTsKKwkJ CWZpZWxkIHw9IFRSQl9JRFQ7CisJCX0KKwogCQlyZW1haW5kZXIgPSB4aGNpX3RkX3JlbWFpbmRl cih4aGNpLCAwLAogCQkJCXVyYi0+dHJhbnNmZXJfYnVmZmVyX2xlbmd0aCwKIAkJCQl1cmItPnRy YW5zZmVyX2J1ZmZlcl9sZW5ndGgsCkBAIC0zNDIwLDYgKzM0MzMsNyBAQCBpbnQgeGhjaV9xdWV1 ZV9jdHJsX3R4KHN0cnVjdCB4aGNpX2hjZCAqeGhjaSwgZ2ZwX3QgbWVtX2ZsYWdzLAogCQkJCVRS Ql9JTlRSX1RBUkdFVCgwKTsKIAkJaWYgKHNldHVwLT5iUmVxdWVzdFR5cGUgJiBVU0JfRElSX0lO KQogCQkJZmllbGQgfD0gVFJCX0RJUl9JTjsKKwogCQlxdWV1ZV90cmIoeGhjaSwgZXBfcmluZywg dHJ1ZSwKIAkJCQlsb3dlcl8zMl9iaXRzKHVyYi0+dHJhbnNmZXJfZG1hKSwKIAkJCQl1cHBlcl8z Ml9iaXRzKHVyYi0+dHJhbnNmZXJfZG1hKSwKQEAgLTM3MTAsNiArMzcyNCwxMiBAQCBzdGF0aWMg aW50IHhoY2lfcXVldWVfaXNvY190eChzdHJ1Y3QgeGhjaV9oY2QgKnhoY2ksIGdmcF90IG1lbV9m bGFncywKIAkJCWlmICh0cmJfYnVmZl9sZW4gPiB0ZF9yZW1haW5fbGVuKQogCQkJCXRyYl9idWZm X2xlbiA9IHRkX3JlbWFpbl9sZW47CiAKKwkJCWlmICh4aGNpX3VyYl9zdWl0YWJsZV9mb3JfaWR0 KHVyYikpIHsKKwkJCQltZW1jcHkoJmFkZHIsIHVyYi0+dHJhbnNmZXJfYnVmZmVyLAorCQkJCSAg ICAgICB0cmJfYnVmZl9sZW4pOworCQkJCWZpZWxkIHw9IFRSQl9JRFQ7CisJCQl9CisKIAkJCS8q IFNldCB0aGUgVFJCIGxlbmd0aCwgVEQgc2l6ZSwgJiBpbnRlcnJ1cHRlciBmaWVsZHMuICovCiAJ CQlyZW1haW5kZXIgPSB4aGNpX3RkX3JlbWFpbmRlcih4aGNpLCBydW5uaW5nX3RvdGFsLAogCQkJ CQkJICAgdHJiX2J1ZmZfbGVuLCB0ZF9sZW4sCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9ob3N0 L3hoY2kuYyBiL2RyaXZlcnMvdXNiL2hvc3QveGhjaS5jCmluZGV4IDAwNWU2NTkyMjYwOC4uZGVj NjJmN2Y1ZGM4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9ob3N0L3hoY2kuYworKysgYi9kcml2 ZXJzL3VzYi9ob3N0L3hoY2kuYwpAQCAtMTIzOCw2ICsxMjM4LDIxIEBAIEVYUE9SVF9TWU1CT0xf R1BMKHhoY2lfcmVzdW1lKTsKIAogLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KIAorLyoKKyAqIEJ5cGFz cyB0aGUgRE1BIG1hcHBpbmcgaWYgVVJCIGlzIHN1aXRhYmxlIGZvciBJbW1lZGlhdGUgVHJhbnNm ZXIgKElEVCksCisgKiB3ZSdsbCBjb3B5IHRoZSBhY3R1YWwgZGF0YSBpbnRvIHRoZSBUUkIgYWRk cmVzcyByZWdpc3Rlci4gVGhpcyBpcyBsaW1pdGVkIHRvCisgKiB0cmFuc2ZlcnMgdXAgdG8gOCBi eXRlcyBvbiBvdXRwdXQgZW5kcG9pbnRzIG9mIGFueSBraW5kIHdpdGggd01heFBhY2tldFNpemUK KyAqID49IDggYnl0ZXMuCisgKi8KK3N0YXRpYyBpbnQgeGhjaV9tYXBfdXJiX2Zvcl9kbWEoc3Ry dWN0IHVzYl9oY2QgKmhjZCwgc3RydWN0IHVyYiAqdXJiLAorCQkJCWdmcF90IG1lbV9mbGFncykK K3sKKwlpZiAoeGhjaV91cmJfc3VpdGFibGVfZm9yX2lkdCh1cmIpKQorCQlyZXR1cm4gMDsKKwor CXJldHVybiB1c2JfaGNkX21hcF91cmJfZm9yX2RtYShoY2QsIHVyYiwgbWVtX2ZsYWdzKTsKK30K KwogLyoqCiAgKiB4aGNpX2dldF9lbmRwb2ludF9pbmRleCAtIFVzZWQgZm9yIHBhc3NpbmcgZW5k cG9pbnQgYml0bWFza3MgYmV0d2VlbiB0aGUgY29yZSBhbmQKICAqIEhDRHMuICBGaW5kIHRoZSBp bmRleCBmb3IgYW4gZW5kcG9pbnQgZ2l2ZW4gaXRzIGRlc2NyaXB0b3IuICBVc2UgdGhlIHJldHVy bgpAQCAtNTE1NSw2ICs1MTcwLDcgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBoY19kcml2ZXIgeGhj aV9oY19kcml2ZXIgPSB7CiAJLyoKIAkgKiBtYW5hZ2luZyBpL28gcmVxdWVzdHMgYW5kIGFzc29j aWF0ZWQgZGV2aWNlIHJlc291cmNlcwogCSAqLworCS5tYXBfdXJiX2Zvcl9kbWEgPSAgICAgIHho Y2lfbWFwX3VyYl9mb3JfZG1hLAogCS51cmJfZW5xdWV1ZSA9CQl4aGNpX3VyYl9lbnF1ZXVlLAog CS51cmJfZGVxdWV1ZSA9CQl4aGNpX3VyYl9kZXF1ZXVlLAogCS5hbGxvY19kZXYgPQkJeGhjaV9h bGxvY19kZXYsCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9ob3N0L3hoY2kuaCBiL2RyaXZlcnMv dXNiL2hvc3QveGhjaS5oCmluZGV4IDY1MmRjMzZlMzAxMi4uOWQ3N2IwOTAxYWI3IDEwMDY0NAot LS0gYS9kcml2ZXJzL3VzYi9ob3N0L3hoY2kuaAorKysgYi9kcml2ZXJzL3VzYi9ob3N0L3hoY2ku aApAQCAtMTI5NSw2ICsxMjk1LDggQEAgZW51bSB4aGNpX3NldHVwX2RldiB7CiAjZGVmaW5lIFRS Ql9JT0MJCQkoMTw8NSkKIC8qIFRoZSBidWZmZXIgcG9pbnRlciBjb250YWlucyBpbW1lZGlhdGUg ZGF0YSAqLwogI2RlZmluZSBUUkJfSURUCQkJKDE8PDYpCisvKiBURHMgc21hbGxlciB0aGFuIHRo aXMgbWlnaHQgdXNlIElEVCAqLworI2RlZmluZSBUUkJfSURUX01BWF9TSVpFCTgKIAogLyogQmxv Y2sgRXZlbnQgSW50ZXJydXB0ICovCiAjZGVmaW5lCVRSQl9CRUkJCQkoMTw8OSkKQEAgLTIxNDEs NiArMjE0MywxNiBAQCBzdGF0aWMgaW5saW5lIHN0cnVjdCB4aGNpX3JpbmcgKnhoY2lfdXJiX3Rv X3RyYW5zZmVyX3Jpbmcoc3RydWN0IHhoY2lfaGNkICp4aGNpLAogCQkJCQl1cmItPnN0cmVhbV9p ZCk7CiB9CiAKK3N0YXRpYyBpbmxpbmUgYm9vbCB4aGNpX3VyYl9zdWl0YWJsZV9mb3JfaWR0KHN0 cnVjdCB1cmIgKnVyYikKK3sKKwlpZiAodXNiX2VuZHBvaW50X21heHAoJnVyYi0+ZXAtPmRlc2Mp ID49IFRSQl9JRFRfTUFYX1NJWkUgJiYKKwkgICAgdXJiLT50cmFuc2Zlcl9idWZmZXJfbGVuZ3Ro IDw9IFRSQl9JRFRfTUFYX1NJWkUgJiYKKwkgICAgdXNiX3VyYl9kaXJfb3V0KHVyYikpCisJCXJl dHVybiB0cnVlOworCisJcmV0dXJuIGZhbHNlOworfQorCiBzdGF0aWMgaW5saW5lIGNoYXIgKnho Y2lfc2xvdF9zdGF0ZV9zdHJpbmcodTMyIHN0YXRlKQogewogCXN3aXRjaCAoc3RhdGUpIHsK