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.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, MAILING_LIST_MULTI,MENTIONS_GIT_HOSTING,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 F2962C10F14 for ; Tue, 16 Apr 2019 15:44:43 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id BEA7E20868 for ; Tue, 16 Apr 2019 15:44:43 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729852AbfDPPom (ORCPT ); Tue, 16 Apr 2019 11:44:42 -0400 Received: from iolanthe.rowland.org ([192.131.102.54]:42922 "HELO iolanthe.rowland.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with SMTP id S1726860AbfDPPom (ORCPT ); Tue, 16 Apr 2019 11:44:42 -0400 Received: (qmail 7409 invoked by uid 2102); 16 Apr 2019 11:44:41 -0400 Received: from localhost (sendmail-bs@127.0.0.1) by localhost with SMTP; 16 Apr 2019 11:44:41 -0400 Date: Tue, 16 Apr 2019 11:44:41 -0400 (EDT) From: Alan Stern X-X-Sender: stern@iolanthe.rowland.org To: Andrey Konovalov cc: Greg Kroah-Hartman , , Kernel development list , USB list , syzkaller-bugs , syzbot Subject: Re: INFO: task hung in usb_kill_urb In-Reply-To: Message-ID: MIME-Version: 1.0 Content-Type: TEXT/PLAIN; charset=US-ASCII Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Mon, 15 Apr 2019, Andrey Konovalov wrote: > On Mon, Apr 15, 2019 at 8:06 PM Alan Stern wrote: > > > > It looks like something is stuck waiting for usb_kill_urb() to finish. > > > > But what happened before that? > > > > > > This crash is somewhat special. It happens quite often during USB > > > fuzzing, but at the same time it's a hang, which makes it a bit harder > > > debug. I initially thought that is somehow related to my custom USB > > > fuzzing kernel patches, but then I saw that someone else hit this > > > issue while doing USB fuzzing in a completely different way that > > > doesn't require kernel modifications. So it might be an actual issue > > > in the kernel. > > > > > > The full console output is provided by the syzbot, but I guess it's > > > not very useful in this case. I've just made sure that this issue is > > > manually reproducible, so we can easily retest it with debug patches > > > (syzbot should be also able to do that via the syz test command). Or > > > is there a way to turn on some verbose mode to see some USB debug > > > messages? > > > > If I were doing this manually, I would run the following commands after > > loading the dummy-hcd driver but before starting the main test > > (requires CONFIG_USB_MON; you can skip the modprobe if > > CONFIG_USB_MON=y): > > > > modprobe usbmon > > cat /sys/kernel/debug/usb/usbmon/Nu >/tmp/mon.out & > > > > where N is the USB bus number corresponding to the dummy-hcd bus. > > Then after the test hangs, on another VT kill the "cat" process and > > examine the contents of /tmp/mon.out. > > > > Maybe you can do the equivalent with syzkaller? If necessary, you can > > start the "cat" before loading dummy-hcd and specify a bus number of 0. > > That will capture data for all the USB buses, including the dummy-hcd > > bus when it gets added (I think -- I haven't actually tried it). > > Right now the best way to do this is to run the reproducer manually. > I've attached the resulting mon.out and syslog. Okay, it looks like the system is getting stuck on the very first URB. Let's add some more traditional debugging and see what shows up. This test won't require any manual intervention. Alan Stern #syz test: https://github.com/google/kasan.git usb-fuzzer --- a/drivers/usb/gadget/udc/dummy_hcd.c +++ b/drivers/usb/gadget/udc/dummy_hcd.c @@ -992,6 +992,7 @@ static int dummy_udc_start(struct usb_ga dum->driver = driver; dum->ints_enabled = 1; spin_unlock_irq(&dum->lock); + dev_info(udc_dev(dum), "%s\n", __func__); return 0; } @@ -1001,6 +1002,7 @@ static int dummy_udc_stop(struct usb_gad struct dummy_hcd *dum_hcd = gadget_to_dummy_hcd(g); struct dummy *dum = dum_hcd->dum; + dev_info(udc_dev(dum), "%s\n", __func__); spin_lock_irq(&dum->lock); dum->ints_enabled = 0; stop_activity(dum); @@ -1277,6 +1279,8 @@ static int dummy_urb_enqueue( } else if (unlikely(dum_hcd->udev != urb->dev)) dev_err(dummy_dev(dum_hcd), "usb_device address has changed!\n"); + dev_info(dummy_dev(dum_hcd), "enqueue URB %p len %u\n", urb, + urb->transfer_buffer_length); list_add_tail(&urbp->urbp_list, &dum_hcd->urbp_list); urb->hcpriv = urbp; if (!dum_hcd->next_frame_urbp) @@ -1306,8 +1310,10 @@ static int dummy_urb_dequeue(struct usb_ rc = usb_hcd_check_unlink_urb(hcd, urb, status); if (!rc && dum_hcd->rh_state != DUMMY_RH_RUNNING && - !list_empty(&dum_hcd->urbp_list)) + !list_empty(&dum_hcd->urbp_list)) { + dev_info(dummy_dev(dum_hcd), "dequeue URB %p\n", urb); mod_timer(&dum_hcd->timer, jiffies); + } spin_unlock_irqrestore(&dum_hcd->dum->lock, flags); return rc; @@ -1827,8 +1833,10 @@ restart: continue; /* Used up this frame's bandwidth? */ - if (total <= 0) + if (total <= 0) { + dev_info(dummy_dev(dum_hcd), "total exceeded\n"); break; + } /* find the gadget's ep for this request (if configured) */ address = usb_pipeendpoint (urb->pipe); @@ -1965,6 +1973,7 @@ return_urb: usb_hcd_unlink_urb_from_ep(dummy_hcd_to_hcd(dum_hcd), urb); spin_unlock(&dum->lock); + dev_info(dummy_dev(dum_hcd), "giveback URB %p\n", urb); usb_hcd_giveback_urb(dummy_hcd_to_hcd(dum_hcd), urb, status); spin_lock(&dum->lock); @@ -2329,7 +2338,7 @@ static int dummy_bus_suspend(struct usb_ { struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd); - dev_dbg(&hcd->self.root_hub->dev, "%s\n", __func__); + dev_info(&hcd->self.root_hub->dev, "%s\n", __func__); spin_lock_irq(&dum_hcd->dum->lock); dum_hcd->rh_state = DUMMY_RH_SUSPENDED; @@ -2344,7 +2353,7 @@ static int dummy_bus_resume(struct usb_h struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd); int rc = 0; - dev_dbg(&hcd->self.root_hub->dev, "%s\n", __func__); + dev_info(&hcd->self.root_hub->dev, "%s\n", __func__); spin_lock_irq(&dum_hcd->dum->lock); if (!HCD_HW_ACCESSIBLE(hcd)) { @@ -2431,6 +2440,7 @@ static DEVICE_ATTR_RO(urbs); static int dummy_start_ss(struct dummy_hcd *dum_hcd) { + dev_info(dummy_dev(dum_hcd), "%s\n", __func__); timer_setup(&dum_hcd->timer, dummy_timer, 0); dum_hcd->rh_state = DUMMY_RH_RUNNING; dum_hcd->stream_en_ep = 0; @@ -2459,6 +2469,7 @@ static int dummy_start(struct usb_hcd *h if (!usb_hcd_is_primary_hcd(hcd)) return dummy_start_ss(dum_hcd); + dev_info(dummy_dev(dum_hcd), "%s\n", __func__); spin_lock_init(&dum_hcd->dum->lock); timer_setup(&dum_hcd->timer, dummy_timer, 0); dum_hcd->rh_state = DUMMY_RH_RUNNING; 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: INFO: task hung in usb_kill_urb From: Alan Stern Message-Id: Date: Tue, 16 Apr 2019 11:44:41 -0400 (EDT) To: Andrey Konovalov Cc: Greg Kroah-Hartman , gustavo@embeddedor.com, Kernel development list , USB list , syzkaller-bugs , syzbot List-ID: T24gTW9uLCAxNSBBcHIgMjAxOSwgQW5kcmV5IEtvbm92YWxvdiB3cm90ZToKCj4gT24gTW9uLCBB cHIgMTUsIDIwMTkgYXQgODowNiBQTSBBbGFuIFN0ZXJuIDxzdGVybkByb3dsYW5kLmhhcnZhcmQu ZWR1PiB3cm90ZToKCj4gPiA+ID4gSXQgbG9va3MgbGlrZSBzb21ldGhpbmcgaXMgc3R1Y2sgd2Fp dGluZyBmb3IgdXNiX2tpbGxfdXJiKCkgdG8gZmluaXNoLgo+ID4gPiA+IEJ1dCB3aGF0IGhhcHBl bmVkIGJlZm9yZSB0aGF0Pwo+ID4gPgo+ID4gPiBUaGlzIGNyYXNoIGlzIHNvbWV3aGF0IHNwZWNp YWwuIEl0IGhhcHBlbnMgcXVpdGUgb2Z0ZW4gZHVyaW5nIFVTQgo+ID4gPiBmdXp6aW5nLCBidXQg YXQgdGhlIHNhbWUgdGltZSBpdCdzIGEgaGFuZywgd2hpY2ggbWFrZXMgaXQgYSBiaXQgaGFyZGVy Cj4gPiA+IGRlYnVnLiBJIGluaXRpYWxseSB0aG91Z2h0IHRoYXQgaXMgc29tZWhvdyByZWxhdGVk IHRvIG15IGN1c3RvbSBVU0IKPiA+ID4gZnV6emluZyBrZXJuZWwgcGF0Y2hlcywgYnV0IHRoZW4g SSBzYXcgdGhhdCBzb21lb25lIGVsc2UgaGl0IHRoaXMKPiA+ID4gaXNzdWUgd2hpbGUgZG9pbmcg VVNCIGZ1enppbmcgaW4gYSBjb21wbGV0ZWx5IGRpZmZlcmVudCB3YXkgdGhhdAo+ID4gPiBkb2Vz bid0IHJlcXVpcmUga2VybmVsIG1vZGlmaWNhdGlvbnMuIFNvIGl0IG1pZ2h0IGJlIGFuIGFjdHVh bCBpc3N1ZQo+ID4gPiBpbiB0aGUga2VybmVsLgo+ID4gPgo+ID4gPiBUaGUgZnVsbCBjb25zb2xl IG91dHB1dCBpcyBwcm92aWRlZCBieSB0aGUgc3l6Ym90LCBidXQgSSBndWVzcyBpdCdzCj4gPiA+ IG5vdCB2ZXJ5IHVzZWZ1bCBpbiB0aGlzIGNhc2UuIEkndmUganVzdCBtYWRlIHN1cmUgdGhhdCB0 aGlzIGlzc3VlIGlzCj4gPiA+IG1hbnVhbGx5IHJlcHJvZHVjaWJsZSwgc28gd2UgY2FuIGVhc2ls eSByZXRlc3QgaXQgd2l0aCBkZWJ1ZyBwYXRjaGVzCj4gPiA+IChzeXpib3Qgc2hvdWxkIGJlIGFs c28gYWJsZSB0byBkbyB0aGF0IHZpYSB0aGUgc3l6IHRlc3QgY29tbWFuZCkuIE9yCj4gPiA+IGlz IHRoZXJlIGEgd2F5IHRvIHR1cm4gb24gc29tZSB2ZXJib3NlIG1vZGUgdG8gc2VlIHNvbWUgVVNC IGRlYnVnCj4gPiA+IG1lc3NhZ2VzPwo+ID4KPiA+IElmIEkgd2VyZSBkb2luZyB0aGlzIG1hbnVh bGx5LCBJIHdvdWxkIHJ1biB0aGUgZm9sbG93aW5nIGNvbW1hbmRzIGFmdGVyCj4gPiBsb2FkaW5n IHRoZSBkdW1teS1oY2QgZHJpdmVyIGJ1dCBiZWZvcmUgc3RhcnRpbmcgdGhlIG1haW4gdGVzdAo+ ID4gKHJlcXVpcmVzIENPTkZJR19VU0JfTU9OOyB5b3UgY2FuIHNraXAgdGhlIG1vZHByb2JlIGlm Cj4gPiBDT05GSUdfVVNCX01PTj15KToKPiA+Cj4gPiAgICAgICAgIG1vZHByb2JlIHVzYm1vbgo+ ID4gICAgICAgICBjYXQgL3N5cy9rZXJuZWwvZGVidWcvdXNiL3VzYm1vbi9OdSA+L3RtcC9tb24u b3V0ICYKPiA+Cj4gPiB3aGVyZSBOIGlzIHRoZSBVU0IgYnVzIG51bWJlciBjb3JyZXNwb25kaW5n IHRvIHRoZSBkdW1teS1oY2QgYnVzLgo+ID4gVGhlbiBhZnRlciB0aGUgdGVzdCBoYW5ncywgb24g YW5vdGhlciBWVCBraWxsIHRoZSAiY2F0IiBwcm9jZXNzIGFuZAo+ID4gZXhhbWluZSB0aGUgY29u dGVudHMgb2YgL3RtcC9tb24ub3V0Lgo+ID4KPiA+IE1heWJlIHlvdSBjYW4gZG8gdGhlIGVxdWl2 YWxlbnQgd2l0aCBzeXprYWxsZXI/ICBJZiBuZWNlc3NhcnksIHlvdSBjYW4KPiA+IHN0YXJ0IHRo ZSAiY2F0IiBiZWZvcmUgbG9hZGluZyBkdW1teS1oY2QgYW5kIHNwZWNpZnkgYSBidXMgbnVtYmVy IG9mIDAuCj4gPiBUaGF0IHdpbGwgY2FwdHVyZSBkYXRhIGZvciBhbGwgdGhlIFVTQiBidXNlcywg aW5jbHVkaW5nIHRoZSBkdW1teS1oY2QKPiA+IGJ1cyB3aGVuIGl0IGdldHMgYWRkZWQgKEkgdGhp bmsgLS0gSSBoYXZlbid0IGFjdHVhbGx5IHRyaWVkIGl0KS4KPiAKPiBSaWdodCBub3cgdGhlIGJl c3Qgd2F5IHRvIGRvIHRoaXMgaXMgdG8gcnVuIHRoZSByZXByb2R1Y2VyIG1hbnVhbGx5Lgo+IEkn dmUgYXR0YWNoZWQgdGhlIHJlc3VsdGluZyBtb24ub3V0IGFuZCBzeXNsb2cuCgpPa2F5LCBpdCBs b29rcyBsaWtlIHRoZSBzeXN0ZW0gaXMgZ2V0dGluZyBzdHVjayBvbiB0aGUgdmVyeSBmaXJzdCBV UkIuICAKTGV0J3MgYWRkIHNvbWUgbW9yZSB0cmFkaXRpb25hbCBkZWJ1Z2dpbmcgYW5kIHNlZSB3 aGF0IHNob3dzIHVwLiAgVGhpcyAKdGVzdCB3b24ndCByZXF1aXJlIGFueSBtYW51YWwgaW50ZXJ2 ZW50aW9uLgoKQWxhbiBTdGVybgoKCiNzeXogdGVzdDogaHR0cHM6Ly9naXRodWIuY29tL2dvb2ds ZS9rYXNhbi5naXQgdXNiLWZ1enplcgoKLS0tIGEvZHJpdmVycy91c2IvZ2FkZ2V0L3VkYy9kdW1t eV9oY2QuYworKysgYi9kcml2ZXJzL3VzYi9nYWRnZXQvdWRjL2R1bW15X2hjZC5jCkBAIC05OTIs NiArOTkyLDcgQEAgc3RhdGljIGludCBkdW1teV91ZGNfc3RhcnQoc3RydWN0IHVzYl9nYQogCWR1 bS0+ZHJpdmVyID0gZHJpdmVyOwogCWR1bS0+aW50c19lbmFibGVkID0gMTsKIAlzcGluX3VubG9j a19pcnEoJmR1bS0+bG9jayk7CisJZGV2X2luZm8odWRjX2RldihkdW0pLCAiJXNcbiIsIF9fZnVu Y19fKTsKIAogCXJldHVybiAwOwogfQpAQCAtMTAwMSw2ICsxMDAyLDcgQEAgc3RhdGljIGludCBk dW1teV91ZGNfc3RvcChzdHJ1Y3QgdXNiX2dhZAogCXN0cnVjdCBkdW1teV9oY2QJKmR1bV9oY2Qg PSBnYWRnZXRfdG9fZHVtbXlfaGNkKGcpOwogCXN0cnVjdCBkdW1teQkJKmR1bSA9IGR1bV9oY2Qt PmR1bTsKIAorCWRldl9pbmZvKHVkY19kZXYoZHVtKSwgIiVzXG4iLCBfX2Z1bmNfXyk7CiAJc3Bp bl9sb2NrX2lycSgmZHVtLT5sb2NrKTsKIAlkdW0tPmludHNfZW5hYmxlZCA9IDA7CiAJc3RvcF9h Y3Rpdml0eShkdW0pOwpAQCAtMTI3Nyw2ICsxMjc5LDggQEAgc3RhdGljIGludCBkdW1teV91cmJf ZW5xdWV1ZSgKIAl9IGVsc2UgaWYgKHVubGlrZWx5KGR1bV9oY2QtPnVkZXYgIT0gdXJiLT5kZXYp KQogCQlkZXZfZXJyKGR1bW15X2RldihkdW1faGNkKSwgInVzYl9kZXZpY2UgYWRkcmVzcyBoYXMg Y2hhbmdlZCFcbiIpOwogCisJZGV2X2luZm8oZHVtbXlfZGV2KGR1bV9oY2QpLCAiZW5xdWV1ZSBV UkIgJXAgbGVuICV1XG4iLCB1cmIsCisJCQl1cmItPnRyYW5zZmVyX2J1ZmZlcl9sZW5ndGgpOwog CWxpc3RfYWRkX3RhaWwoJnVyYnAtPnVyYnBfbGlzdCwgJmR1bV9oY2QtPnVyYnBfbGlzdCk7CiAJ dXJiLT5oY3ByaXYgPSB1cmJwOwogCWlmICghZHVtX2hjZC0+bmV4dF9mcmFtZV91cmJwKQpAQCAt MTMwNiw4ICsxMzEwLDEwIEBAIHN0YXRpYyBpbnQgZHVtbXlfdXJiX2RlcXVldWUoc3RydWN0IHVz Yl8KIAogCXJjID0gdXNiX2hjZF9jaGVja191bmxpbmtfdXJiKGhjZCwgdXJiLCBzdGF0dXMpOwog CWlmICghcmMgJiYgZHVtX2hjZC0+cmhfc3RhdGUgIT0gRFVNTVlfUkhfUlVOTklORyAmJgotCQkJ IWxpc3RfZW1wdHkoJmR1bV9oY2QtPnVyYnBfbGlzdCkpCisJCQkhbGlzdF9lbXB0eSgmZHVtX2hj ZC0+dXJicF9saXN0KSkgeworCQlkZXZfaW5mbyhkdW1teV9kZXYoZHVtX2hjZCksICJkZXF1ZXVl IFVSQiAlcFxuIiwgdXJiKTsKIAkJbW9kX3RpbWVyKCZkdW1faGNkLT50aW1lciwgamlmZmllcyk7 CisJfQogCiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZHVtX2hjZC0+ZHVtLT5sb2NrLCBmbGFn cyk7CiAJcmV0dXJuIHJjOwpAQCAtMTgyNyw4ICsxODMzLDEwIEBAIHJlc3RhcnQ6CiAJCQljb250 aW51ZTsKIAogCQkvKiBVc2VkIHVwIHRoaXMgZnJhbWUncyBiYW5kd2lkdGg/ICovCi0JCWlmICh0 b3RhbCA8PSAwKQorCQlpZiAodG90YWwgPD0gMCkgeworCQkJZGV2X2luZm8oZHVtbXlfZGV2KGR1 bV9oY2QpLCAidG90YWwgZXhjZWVkZWRcbiIpOwogCQkJYnJlYWs7CisJCX0KIAogCQkvKiBmaW5k IHRoZSBnYWRnZXQncyBlcCBmb3IgdGhpcyByZXF1ZXN0IChpZiBjb25maWd1cmVkKSAqLwogCQlh ZGRyZXNzID0gdXNiX3BpcGVlbmRwb2ludCAodXJiLT5waXBlKTsKQEAgLTE5NjUsNiArMTk3Myw3 IEBAIHJldHVybl91cmI6CiAKIAkJdXNiX2hjZF91bmxpbmtfdXJiX2Zyb21fZXAoZHVtbXlfaGNk X3RvX2hjZChkdW1faGNkKSwgdXJiKTsKIAkJc3Bpbl91bmxvY2soJmR1bS0+bG9jayk7CisJCWRl dl9pbmZvKGR1bW15X2RldihkdW1faGNkKSwgImdpdmViYWNrIFVSQiAlcFxuIiwgdXJiKTsKIAkJ dXNiX2hjZF9naXZlYmFja191cmIoZHVtbXlfaGNkX3RvX2hjZChkdW1faGNkKSwgdXJiLCBzdGF0 dXMpOwogCQlzcGluX2xvY2soJmR1bS0+bG9jayk7CiAKQEAgLTIzMjksNyArMjMzOCw3IEBAIHN0 YXRpYyBpbnQgZHVtbXlfYnVzX3N1c3BlbmQoc3RydWN0IHVzYl8KIHsKIAlzdHJ1Y3QgZHVtbXlf aGNkICpkdW1faGNkID0gaGNkX3RvX2R1bW15X2hjZChoY2QpOwogCi0JZGV2X2RiZygmaGNkLT5z ZWxmLnJvb3RfaHViLT5kZXYsICIlc1xuIiwgX19mdW5jX18pOworCWRldl9pbmZvKCZoY2QtPnNl bGYucm9vdF9odWItPmRldiwgIiVzXG4iLCBfX2Z1bmNfXyk7CiAKIAlzcGluX2xvY2tfaXJxKCZk dW1faGNkLT5kdW0tPmxvY2spOwogCWR1bV9oY2QtPnJoX3N0YXRlID0gRFVNTVlfUkhfU1VTUEVO REVEOwpAQCAtMjM0NCw3ICsyMzUzLDcgQEAgc3RhdGljIGludCBkdW1teV9idXNfcmVzdW1lKHN0 cnVjdCB1c2JfaAogCXN0cnVjdCBkdW1teV9oY2QgKmR1bV9oY2QgPSBoY2RfdG9fZHVtbXlfaGNk KGhjZCk7CiAJaW50IHJjID0gMDsKIAotCWRldl9kYmcoJmhjZC0+c2VsZi5yb290X2h1Yi0+ZGV2 LCAiJXNcbiIsIF9fZnVuY19fKTsKKwlkZXZfaW5mbygmaGNkLT5zZWxmLnJvb3RfaHViLT5kZXYs ICIlc1xuIiwgX19mdW5jX18pOwogCiAJc3Bpbl9sb2NrX2lycSgmZHVtX2hjZC0+ZHVtLT5sb2Nr KTsKIAlpZiAoIUhDRF9IV19BQ0NFU1NJQkxFKGhjZCkpIHsKQEAgLTI0MzEsNiArMjQ0MCw3IEBA IHN0YXRpYyBERVZJQ0VfQVRUUl9STyh1cmJzKTsKIAogc3RhdGljIGludCBkdW1teV9zdGFydF9z cyhzdHJ1Y3QgZHVtbXlfaGNkICpkdW1faGNkKQogeworCWRldl9pbmZvKGR1bW15X2RldihkdW1f aGNkKSwgIiVzXG4iLCBfX2Z1bmNfXyk7CiAJdGltZXJfc2V0dXAoJmR1bV9oY2QtPnRpbWVyLCBk dW1teV90aW1lciwgMCk7CiAJZHVtX2hjZC0+cmhfc3RhdGUgPSBEVU1NWV9SSF9SVU5OSU5HOwog CWR1bV9oY2QtPnN0cmVhbV9lbl9lcCA9IDA7CkBAIC0yNDU5LDYgKzI0NjksNyBAQCBzdGF0aWMg aW50IGR1bW15X3N0YXJ0KHN0cnVjdCB1c2JfaGNkICpoCiAJaWYgKCF1c2JfaGNkX2lzX3ByaW1h cnlfaGNkKGhjZCkpCiAJCXJldHVybiBkdW1teV9zdGFydF9zcyhkdW1faGNkKTsKIAorCWRldl9p bmZvKGR1bW15X2RldihkdW1faGNkKSwgIiVzXG4iLCBfX2Z1bmNfXyk7CiAJc3Bpbl9sb2NrX2lu aXQoJmR1bV9oY2QtPmR1bS0+bG9jayk7CiAJdGltZXJfc2V0dXAoJmR1bV9oY2QtPnRpbWVyLCBk dW1teV90aW1lciwgMCk7CiAJZHVtX2hjZC0+cmhfc3RhdGUgPSBEVU1NWV9SSF9SVU5OSU5HOwo=