From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1756429AbaGWGlL (ORCPT ); Wed, 23 Jul 2014 02:41:11 -0400 Received: from youngberry.canonical.com ([91.189.89.112]:46987 "EHLO youngberry.canonical.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1756305AbaGWGlH (ORCPT ); Wed, 23 Jul 2014 02:41:07 -0400 Message-ID: <53CF58FB.8070609@canonical.com> Date: Wed, 23 Jul 2014 08:40:59 +0200 From: Maarten Lankhorst User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:24.0) Gecko/20100101 Thunderbird/24.5.0 MIME-Version: 1.0 To: =?UTF-8?B?Q2hyaXN0aWFuIEvDtm5pZw==?= , Daniel Vetter , =?UTF-8?B?Q2hyaXN0aWFuIEvDtm5pZw==?= CC: Dave Airlie , Thomas Hellstrom , nouveau , LKML , dri-devel , Ben Skeggs , "Deucher, Alexander" Subject: Re: [Nouveau] [PATCH 09/17] drm/radeon: use common fence implementation for fences References: <20140709093124.11354.3774.stgit@patser> <20140709122953.11354.46381.stgit@patser> <53CE2421.5040906@amd.com> <20140722114607.GL15237@phenom.ffwll.local> <20140722115737.GN15237@phenom.ffwll.local> <53CE56ED.4040109@vodafone.de> <20140722132652.GO15237@phenom.ffwll.local> <53CE6AFA.1060807@vodafone.de> <53CE84AA.9030703@amd.com> <53CE8A57.2000803@vodafone.de> In-Reply-To: <53CE8A57.2000803@vodafone.de> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org op 22-07-14 17:59, Christian König schreef: > Am 22.07.2014 17:42, schrieb Daniel Vetter: >> On Tue, Jul 22, 2014 at 5:35 PM, Christian König >> wrote: >>> Drivers exporting fences need to provide a fence->signaled and a fence->wait >>> function, everything else like fence->enable_signaling or calling >>> fence_signaled() from the driver is optional. >>> >>> Drivers wanting to use exported fences don't call fence->signaled or >>> fence->wait in atomic or interrupt context, and not with holding any global >>> locking primitives (like mmap_sem etc...). Holding locking primitives local >>> to the driver is ok, as long as they don't conflict with anything possible >>> used by their own fence implementation. >> Well that's almost what we have right now with the exception that >> drivers are allowed (actually must for correctness when updating >> fences) the ww_mutexes for dma-bufs (or other buffer objects). > > In this case sorry for so much noise. I really haven't looked in so much detail into anything but Maarten's Radeon patches. > > But how does that then work right now? My impression was that it's mandatory for drivers to call fence_signaled()? It's only mandatory to call fence_signal() if the .enable_signaling callback has been called, else you can get away with never calling signaling a fence at all before dropping the last refcount to it. This allows you to keep interrupts disabled when you don't need them. >> Locking >> correctness is enforced with some extremely nasty lockdep annotations >> + additional debugging infrastructure enabled with >> CONFIG_DEBUG_WW_MUTEX_SLOWPATH. We really need to be able to hold >> dma-buf ww_mutexes while updating fences or waiting for them. And >> obviously for ->wait we need non-atomic context, not just >> non-interrupt. > > Sounds mostly reasonable, but for holding the dma-buf ww_mutex, wouldn't be an RCU be more appropriate here? E.g. aren't we just interested that the current assigned fence at some point is signaled? You can wait with RCU, without holding the ww_mutex, by calling reservation_object_wait_timeout_rcu on ttm_bo->resv. If you don't want to block you could test with reservation_object_test_signaled_rcu. Or if you want a copy of all fences without taking locks, try reservation_object_get_fences_rcu. (Might be out of date by the time the function returns if you don't hold ww_mutex, if you hold ww_mutex you probably don't need to call this function.) I didn't add non-rcu versions, but using the RCU functions would work with ww_mutex held too, probably with some small overhead. > Something like grab ww_mutexes, grab a reference to the current fence object, release ww_mutex, wait for fence, release reference to the fence object. This is what I do currently. :-) The reservation_object that's embedded in TTM gets shared with the dma-buf, so there will be no special case needed for dma-buf at all, all objects can simply be shared and the synchronization is handled in the same way. ttm_bo_reserve and friends automatically end up locking the dma-buf too, and lockdep works on it. > >> Agreed that any shared locks are out of the way (especially stuff like >> dev->struct_mutex or other non-strictly driver-private stuff, i915 is >> really bad here still). > > Yeah that's also an point I've wanted to note on Maartens patch. Radeon grabs the read side of it's exclusive semaphore while waiting for fences (because it assumes that the fence it waits for is a Radeon fence). > > Assuming that we need to wait in both directions with Prime (e.g. Intel driver needs to wait for Radeon to finish rendering and Radeon needs to wait for Intel to finish displaying), this might become a perfect example of locking inversion. In the preliminary patches where I can sync radeon with other GPU's I've been very careful in all the places that call into fences, to make sure that radeon wouldn't try to handle lockups for a different (possibly also radeon) card. This is also why fence_is_signaled should never block, and why it trylocks the exclusive_lock. :-) I think lockdep would complain if I grabbed exclusive_lock while blocking in is_signaled. >> So from the core fence framework I think we already have exactly this, >> and we only need to adjust the radeon implementation a bit to make it >> less risky and invasive to the radeon driver logic. > > Agree. Well the biggest problem I see is that exclusive semaphore I need to take when anything calls into the driver. For the fence code I need to move that down into the fence->signaled handler, cause that now can be called from outside the driver. > > Maarten solved this by telling the driver in the lockup handler (where we grab the write side of the exclusive lock) that all interrupts are already enabled, so that fence->signaled hopefully wouldn't mess with the hardware at all. While this probably works, it just leaves me with a feeling that we are doing something wrong here. There is unfortunately no global mechanism to say 'this card is locked up, please don't call into any of my fences', and I don't associate fences with devices, and radeon doesn't keep a global list of fences. If all of that existed, it would complicate the interface and its callers a lot, while I like to keep things simple. So I did the best I could, and simply prevented the fence calls from fiddling with the hardware. Fortunately gpu lockup is not a common operation. :-) ~Maarten From mboxrd@z Thu Jan 1 00:00:00 1970 From: Maarten Lankhorst Subject: Re: [Nouveau] [PATCH 09/17] drm/radeon: use common fence implementation for fences Date: Wed, 23 Jul 2014 08:40:59 +0200 Message-ID: <53CF58FB.8070609@canonical.com> References: <20140709093124.11354.3774.stgit@patser> <20140709122953.11354.46381.stgit@patser> <53CE2421.5040906@amd.com> <20140722114607.GL15237@phenom.ffwll.local> <20140722115737.GN15237@phenom.ffwll.local> <53CE56ED.4040109@vodafone.de> <20140722132652.GO15237@phenom.ffwll.local> <53CE6AFA.1060807@vodafone.de> <53CE84AA.9030703@amd.com> <53CE8A57.2000803@vodafone.de> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <53CE8A57.2000803@vodafone.de> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: =?UTF-8?B?Q2hyaXN0aWFuIEvDtm5pZw==?= , Daniel Vetter , =?UTF-8?B?Q2hyaXN0aWFuIEvDtm5pZw==?= Cc: Thomas Hellstrom , nouveau , LKML , dri-devel , Ben Skeggs , "Deucher, Alexander" List-Id: nouveau.vger.kernel.org b3AgMjItMDctMTQgMTc6NTksIENocmlzdGlhbiBLw7ZuaWcgc2NocmVlZjoKPiBBbSAyMi4wNy4y MDE0IDE3OjQyLCBzY2hyaWViIERhbmllbCBWZXR0ZXI6Cj4+IE9uIFR1ZSwgSnVsIDIyLCAyMDE0 IGF0IDU6MzUgUE0sIENocmlzdGlhbiBLw7ZuaWcKPj4gPGNocmlzdGlhbi5rb2VuaWdAYW1kLmNv bT4gd3JvdGU6Cj4+PiBEcml2ZXJzIGV4cG9ydGluZyBmZW5jZXMgbmVlZCB0byBwcm92aWRlIGEg ZmVuY2UtPnNpZ25hbGVkIGFuZCBhIGZlbmNlLT53YWl0Cj4+PiBmdW5jdGlvbiwgZXZlcnl0aGlu ZyBlbHNlIGxpa2UgZmVuY2UtPmVuYWJsZV9zaWduYWxpbmcgb3IgY2FsbGluZwo+Pj4gZmVuY2Vf c2lnbmFsZWQoKSBmcm9tIHRoZSBkcml2ZXIgaXMgb3B0aW9uYWwuCj4+Pgo+Pj4gRHJpdmVycyB3 YW50aW5nIHRvIHVzZSBleHBvcnRlZCBmZW5jZXMgZG9uJ3QgY2FsbCBmZW5jZS0+c2lnbmFsZWQg b3IKPj4+IGZlbmNlLT53YWl0IGluIGF0b21pYyBvciBpbnRlcnJ1cHQgY29udGV4dCwgYW5kIG5v dCB3aXRoIGhvbGRpbmcgYW55IGdsb2JhbAo+Pj4gbG9ja2luZyBwcmltaXRpdmVzIChsaWtlIG1t YXBfc2VtIGV0Yy4uLikuIEhvbGRpbmcgbG9ja2luZyBwcmltaXRpdmVzIGxvY2FsCj4+PiB0byB0 aGUgZHJpdmVyIGlzIG9rLCBhcyBsb25nIGFzIHRoZXkgZG9uJ3QgY29uZmxpY3Qgd2l0aCBhbnl0 aGluZyBwb3NzaWJsZQo+Pj4gdXNlZCBieSB0aGVpciBvd24gZmVuY2UgaW1wbGVtZW50YXRpb24u Cj4+IFdlbGwgdGhhdCdzIGFsbW9zdCB3aGF0IHdlIGhhdmUgcmlnaHQgbm93IHdpdGggdGhlIGV4 Y2VwdGlvbiB0aGF0Cj4+IGRyaXZlcnMgYXJlIGFsbG93ZWQgKGFjdHVhbGx5IG11c3QgZm9yIGNv cnJlY3RuZXNzIHdoZW4gdXBkYXRpbmcKPj4gZmVuY2VzKSB0aGUgd3dfbXV0ZXhlcyBmb3IgZG1h LWJ1ZnMgKG9yIG90aGVyIGJ1ZmZlciBvYmplY3RzKS4KPgo+IEluIHRoaXMgY2FzZSBzb3JyeSBm b3Igc28gbXVjaCBub2lzZS4gSSByZWFsbHkgaGF2ZW4ndCBsb29rZWQgaW4gc28gbXVjaCBkZXRh aWwgaW50byBhbnl0aGluZyBidXQgTWFhcnRlbidzIFJhZGVvbiBwYXRjaGVzLgo+Cj4gQnV0IGhv dyBkb2VzIHRoYXQgdGhlbiB3b3JrIHJpZ2h0IG5vdz8gTXkgaW1wcmVzc2lvbiB3YXMgdGhhdCBp dCdzIG1hbmRhdG9yeSBmb3IgZHJpdmVycyB0byBjYWxsIGZlbmNlX3NpZ25hbGVkKCk/Ckl0J3Mg b25seSBtYW5kYXRvcnkgdG8gY2FsbCBmZW5jZV9zaWduYWwoKSBpZiB0aGUgLmVuYWJsZV9zaWdu YWxpbmcgY2FsbGJhY2sgaGFzIGJlZW4gY2FsbGVkLCBlbHNlIHlvdSBjYW4gZ2V0IGF3YXkgd2l0 aCBuZXZlciBjYWxsaW5nIHNpZ25hbGluZyBhIGZlbmNlIGF0IGFsbCBiZWZvcmUgZHJvcHBpbmcg dGhlIGxhc3QgcmVmY291bnQgdG8gaXQuClRoaXMgYWxsb3dzIHlvdSB0byBrZWVwIGludGVycnVw dHMgZGlzYWJsZWQgd2hlbiB5b3UgZG9uJ3QgbmVlZCB0aGVtLgo+PiBMb2NraW5nCj4+IGNvcnJl Y3RuZXNzIGlzIGVuZm9yY2VkIHdpdGggc29tZSBleHRyZW1lbHkgbmFzdHkgbG9ja2RlcCBhbm5v dGF0aW9ucwo+PiArIGFkZGl0aW9uYWwgZGVidWdnaW5nIGluZnJhc3RydWN0dXJlIGVuYWJsZWQg d2l0aAo+PiBDT05GSUdfREVCVUdfV1dfTVVURVhfU0xPV1BBVEguIFdlIHJlYWxseSBuZWVkIHRv IGJlIGFibGUgdG8gaG9sZAo+PiBkbWEtYnVmIHd3X211dGV4ZXMgd2hpbGUgdXBkYXRpbmcgZmVu Y2VzIG9yIHdhaXRpbmcgZm9yIHRoZW0uIEFuZAo+PiBvYnZpb3VzbHkgZm9yIC0+d2FpdCB3ZSBu ZWVkIG5vbi1hdG9taWMgY29udGV4dCwgbm90IGp1c3QKPj4gbm9uLWludGVycnVwdC4KPgo+IFNv dW5kcyBtb3N0bHkgcmVhc29uYWJsZSwgYnV0IGZvciBob2xkaW5nIHRoZSBkbWEtYnVmIHd3X211 dGV4LCB3b3VsZG4ndCBiZSBhbiBSQ1UgYmUgbW9yZSBhcHByb3ByaWF0ZSBoZXJlPyBFLmcuIGFy ZW4ndCB3ZSBqdXN0IGludGVyZXN0ZWQgdGhhdCB0aGUgY3VycmVudCBhc3NpZ25lZCBmZW5jZSBh dCBzb21lIHBvaW50IGlzIHNpZ25hbGVkPwpZb3UgY2FuIHdhaXQgd2l0aCBSQ1UsIHdpdGhvdXQg aG9sZGluZyB0aGUgd3dfbXV0ZXgsIGJ5IGNhbGxpbmcgcmVzZXJ2YXRpb25fb2JqZWN0X3dhaXRf dGltZW91dF9yY3Ugb24gdHRtX2JvLT5yZXN2LgpJZiB5b3UgZG9uJ3Qgd2FudCB0byBibG9jayB5 b3UgY291bGQgdGVzdCB3aXRoIHJlc2VydmF0aW9uX29iamVjdF90ZXN0X3NpZ25hbGVkX3JjdS4K T3IgaWYgeW91IHdhbnQgYSBjb3B5IG9mIGFsbCBmZW5jZXMgd2l0aG91dCB0YWtpbmcgbG9ja3Ms IHRyeSByZXNlcnZhdGlvbl9vYmplY3RfZ2V0X2ZlbmNlc19yY3UuIChNaWdodCBiZSBvdXQgb2Yg ZGF0ZSBieSB0aGUgdGltZSB0aGUgZnVuY3Rpb24gcmV0dXJucyBpZiB5b3UgZG9uJ3QgaG9sZCB3 d19tdXRleCwgaWYgeW91IGhvbGQgd3dfbXV0ZXggeW91IHByb2JhYmx5IGRvbid0IG5lZWQgdG8g Y2FsbCB0aGlzIGZ1bmN0aW9uLikKCkkgZGlkbid0IGFkZCBub24tcmN1IHZlcnNpb25zLCBidXQg dXNpbmcgdGhlIFJDVSBmdW5jdGlvbnMgd291bGQgd29yayB3aXRoIHd3X211dGV4IGhlbGQgdG9v LCBwcm9iYWJseSB3aXRoIHNvbWUgc21hbGwgb3ZlcmhlYWQuCj4gU29tZXRoaW5nIGxpa2UgZ3Jh YiB3d19tdXRleGVzLCBncmFiIGEgcmVmZXJlbmNlIHRvIHRoZSBjdXJyZW50IGZlbmNlIG9iamVj dCwgcmVsZWFzZSB3d19tdXRleCwgd2FpdCBmb3IgZmVuY2UsIHJlbGVhc2UgcmVmZXJlbmNlIHRv IHRoZSBmZW5jZSBvYmplY3QuClRoaXMgaXMgd2hhdCBJIGRvIGN1cnJlbnRseS4gOi0pIFRoZSBy ZXNlcnZhdGlvbl9vYmplY3QgdGhhdCdzIGVtYmVkZGVkIGluIFRUTSBnZXRzIHNoYXJlZCB3aXRo IHRoZSBkbWEtYnVmLCBzbyB0aGVyZSB3aWxsIGJlIG5vIHNwZWNpYWwgY2FzZSBuZWVkZWQgZm9y IGRtYS1idWYgYXQgYWxsLCBhbGwgb2JqZWN0cyBjYW4gc2ltcGx5IGJlIHNoYXJlZCBhbmQgdGhl IHN5bmNocm9uaXphdGlvbiBpcyBoYW5kbGVkIGluIHRoZSBzYW1lIHdheS4KCnR0bV9ib19yZXNl cnZlIGFuZCBmcmllbmRzIGF1dG9tYXRpY2FsbHkgZW5kIHVwIGxvY2tpbmcgdGhlIGRtYS1idWYg dG9vLCBhbmQgbG9ja2RlcCB3b3JrcyBvbiBpdC4KCj4KPj4gQWdyZWVkIHRoYXQgYW55IHNoYXJl ZCBsb2NrcyBhcmUgb3V0IG9mIHRoZSB3YXkgKGVzcGVjaWFsbHkgc3R1ZmYgbGlrZQo+PiBkZXYt PnN0cnVjdF9tdXRleCBvciBvdGhlciBub24tc3RyaWN0bHkgZHJpdmVyLXByaXZhdGUgc3R1ZmYs IGk5MTUgaXMKPj4gcmVhbGx5IGJhZCBoZXJlIHN0aWxsKS4KPgo+IFllYWggdGhhdCdzIGFsc28g YW4gcG9pbnQgSSd2ZSB3YW50ZWQgdG8gbm90ZSBvbiBNYWFydGVucyBwYXRjaC4gUmFkZW9uIGdy YWJzIHRoZSByZWFkIHNpZGUgb2YgaXQncyBleGNsdXNpdmUgc2VtYXBob3JlIHdoaWxlIHdhaXRp bmcgZm9yIGZlbmNlcyAoYmVjYXVzZSBpdCBhc3N1bWVzIHRoYXQgdGhlIGZlbmNlIGl0IHdhaXRz IGZvciBpcyBhIFJhZGVvbiBmZW5jZSkuCj4KPiBBc3N1bWluZyB0aGF0IHdlIG5lZWQgdG8gd2Fp dCBpbiBib3RoIGRpcmVjdGlvbnMgd2l0aCBQcmltZSAoZS5nLiBJbnRlbCBkcml2ZXIgbmVlZHMg dG8gd2FpdCBmb3IgUmFkZW9uIHRvIGZpbmlzaCByZW5kZXJpbmcgYW5kIFJhZGVvbiBuZWVkcyB0 byB3YWl0IGZvciBJbnRlbCB0byBmaW5pc2ggZGlzcGxheWluZyksIHRoaXMgbWlnaHQgYmVjb21l IGEgcGVyZmVjdCBleGFtcGxlIG9mIGxvY2tpbmcgaW52ZXJzaW9uLgpJbiB0aGUgcHJlbGltaW5h cnkgcGF0Y2hlcyB3aGVyZSBJIGNhbiBzeW5jIHJhZGVvbiB3aXRoIG90aGVyIEdQVSdzIEkndmUg YmVlbiB2ZXJ5IGNhcmVmdWwgaW4gYWxsIHRoZSBwbGFjZXMgdGhhdCBjYWxsIGludG8gZmVuY2Vz LCB0byBtYWtlIHN1cmUgdGhhdCByYWRlb24gd291bGRuJ3QgdHJ5IHRvIGhhbmRsZSBsb2NrdXBz IGZvciBhIGRpZmZlcmVudCAocG9zc2libHkgYWxzbyByYWRlb24pIGNhcmQuCgpUaGlzIGlzIGFs c28gd2h5IGZlbmNlX2lzX3NpZ25hbGVkIHNob3VsZCBuZXZlciBibG9jaywgYW5kIHdoeSBpdCB0 cnlsb2NrcyB0aGUgZXhjbHVzaXZlX2xvY2suIDotKSBJIHRoaW5rIGxvY2tkZXAgd291bGQgY29t cGxhaW4gaWYgSSBncmFiYmVkIGV4Y2x1c2l2ZV9sb2NrIHdoaWxlIGJsb2NraW5nIGluIGlzX3Np Z25hbGVkLgoKPj4gU28gZnJvbSB0aGUgY29yZSBmZW5jZSBmcmFtZXdvcmsgSSB0aGluayB3ZSBh bHJlYWR5IGhhdmUgZXhhY3RseSB0aGlzLAo+PiBhbmQgd2Ugb25seSBuZWVkIHRvIGFkanVzdCB0 aGUgcmFkZW9uIGltcGxlbWVudGF0aW9uIGEgYml0IHRvIG1ha2UgaXQKPj4gbGVzcyByaXNreSBh bmQgaW52YXNpdmUgdG8gdGhlIHJhZGVvbiBkcml2ZXIgbG9naWMuCj4KPiBBZ3JlZS4gV2VsbCB0 aGUgYmlnZ2VzdCBwcm9ibGVtIEkgc2VlIGlzIHRoYXQgZXhjbHVzaXZlIHNlbWFwaG9yZSBJIG5l ZWQgdG8gdGFrZSB3aGVuIGFueXRoaW5nIGNhbGxzIGludG8gdGhlIGRyaXZlci4gRm9yIHRoZSBm ZW5jZSBjb2RlIEkgbmVlZCB0byBtb3ZlIHRoYXQgZG93biBpbnRvIHRoZSBmZW5jZS0+c2lnbmFs ZWQgaGFuZGxlciwgY2F1c2UgdGhhdCBub3cgY2FuIGJlIGNhbGxlZCBmcm9tIG91dHNpZGUgdGhl IGRyaXZlci4KPgo+IE1hYXJ0ZW4gc29sdmVkIHRoaXMgYnkgdGVsbGluZyB0aGUgZHJpdmVyIGlu IHRoZSBsb2NrdXAgaGFuZGxlciAod2hlcmUgd2UgZ3JhYiB0aGUgd3JpdGUgc2lkZSBvZiB0aGUg ZXhjbHVzaXZlIGxvY2spIHRoYXQgYWxsIGludGVycnVwdHMgYXJlIGFscmVhZHkgZW5hYmxlZCwg c28gdGhhdCBmZW5jZS0+c2lnbmFsZWQgaG9wZWZ1bGx5IHdvdWxkbid0IG1lc3Mgd2l0aCB0aGUg aGFyZHdhcmUgYXQgYWxsLiBXaGlsZSB0aGlzIHByb2JhYmx5IHdvcmtzLCBpdCBqdXN0IGxlYXZl cyBtZSB3aXRoIGEgZmVlbGluZyB0aGF0IHdlIGFyZSBkb2luZyBzb21ldGhpbmcgd3JvbmcgaGVy ZS4KVGhlcmUgaXMgdW5mb3J0dW5hdGVseSBubyBnbG9iYWwgbWVjaGFuaXNtIHRvIHNheSAndGhp cyBjYXJkIGlzIGxvY2tlZCB1cCwgcGxlYXNlIGRvbid0IGNhbGwgaW50byBhbnkgb2YgbXkgZmVu Y2VzJywgYW5kIEkgZG9uJ3QgYXNzb2NpYXRlIGZlbmNlcyB3aXRoIGRldmljZXMsIGFuZCByYWRl b24gZG9lc24ndCBrZWVwIGEgZ2xvYmFsIGxpc3Qgb2YgZmVuY2VzLgpJZiBhbGwgb2YgdGhhdCBl eGlzdGVkLCBpdCB3b3VsZCBjb21wbGljYXRlIHRoZSBpbnRlcmZhY2UgYW5kIGl0cyBjYWxsZXJz IGEgbG90LCB3aGlsZSBJIGxpa2UgdG8ga2VlcCB0aGluZ3Mgc2ltcGxlLgpTbyBJIGRpZCB0aGUg YmVzdCBJIGNvdWxkLCBhbmQgc2ltcGx5IHByZXZlbnRlZCB0aGUgZmVuY2UgY2FsbHMgZnJvbSBm aWRkbGluZyB3aXRoIHRoZSBoYXJkd2FyZS4gRm9ydHVuYXRlbHkgZ3B1IGxvY2t1cCBpcyBub3Qg YSBjb21tb24gb3BlcmF0aW9uLiA6LSkKCn5NYWFydGVuCgoKX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2 ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHA6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFp bG1hbi9saXN0aW5mby9kcmktZGV2ZWwK