From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1756235AbaGVQV4 (ORCPT ); Tue, 22 Jul 2014 12:21:56 -0400 Received: from mail-ie0-f174.google.com ([209.85.223.174]:53736 "EHLO mail-ie0-f174.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753793AbaGVQVy convert rfc822-to-8bit (ORCPT ); Tue, 22 Jul 2014 12:21:54 -0400 MIME-Version: 1.0 X-Originating-IP: [84.73.67.144] In-Reply-To: <53CE8A57.2000803@vodafone.de> 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> Date: Tue, 22 Jul 2014 18:21:53 +0200 Message-ID: Subject: Re: [Nouveau] [PATCH 09/17] drm/radeon: use common fence implementation for fences From: Daniel Vetter To: =?UTF-8?Q?Christian_K=C3=B6nig?= Cc: =?UTF-8?Q?Christian_K=C3=B6nig?= , Thomas Hellstrom , nouveau , LKML , dri-devel , "Deucher, Alexander" , Ben Skeggs 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 On Tue, Jul 22, 2014 at 5:59 PM, Christian König wrote: > 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()? Maybe I've mixed things up a bit in my description. There is fence_signal which the implementor/exporter of a fence must call when the fence is completed. If the exporter has an ->enable_signaling callback it can delay that call to fence_signal for as long as it wishes as long as enable_signaling isn't called yet. But that's just the optimization to not required irqs to be turned on all the time. The other function is fence_is_signaled, which is used by code that is interested in the fence state, together with fence_wait if it wants to block and not just wants to know the momentary fence state. All the other functions (the stuff that adds callbacks and the various _locked and other versions) are just for fancy special cases. >> 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? Yeah, as an optimization you can get the set of currently attached fences to a dma-buf with just rcu. But if you update the set of fences attached to a dma-buf (e.g. radeon blits the newly rendered frame to a dma-buf exported by i915 for scanout on i915) then you need a write lock on that buffer. Which is what the ww_mutex is for, to make sure that you don't deadlock with i915 doing concurrent ops on the same underlying buffer. > 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. Yeah, if the only thing you want to do is wait for fences, then the rcu-protected fence ref grabbing + lockless waiting is all you need. But e.g. in an execbuf you also need to update fences and maybe deep down in the reservation code you notice that you need to evict some stuff and so need to wait on some other guy to finish, and it's too complicated to drop and reacquire all the locks. Or you simply need to do a blocking wait on other gpus (because there's no direct hw sync mechanism) and again dropping locks would needlessly complicate the code. So I think we should allow this just to avoid too hairy/brittle (and almost definitely little tested code) in drivers. Afaik this is also the same way ttm currently handles things wrt buffer reservation and eviction. >> 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. fence updates are atomic on a dma-buf, protected by ww_mutex. The neat trick of ww_mutex is that they enforce a global ordering, so in your scenario either i915 or radeon would be first and you can't deadlock. There is no way to interleave anything even if you have lots of buffers shared between i915/radeon. Wrt deadlocking it's exactly the same guarantees as the magic ttm provides for just one driver with concurrent command submission since it's the same idea. >> 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. I'm not versed on the details in readon, but on i915 we can attach a memory location and cookie value to each fence and just do a memory fetch to figure out whether the fence has passed or not. So no locking needed at all. Of course the fence itself needs to lock a reference onto that memory location, which is a neat piece of integration work that we still need to tackle in some cases - there's conflicting patch series all over this ;-) But like I've said fence->signaled is optional so you don't need this necessarily, as long as radeon eventually calls fence_signaled once the fence has completed. -Daniel -- Daniel Vetter Software Engineer, Intel Corporation +41 (0) 79 365 57 48 - http://blog.ffwll.ch From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: Re: [Nouveau] [PATCH 09/17] drm/radeon: use common fence implementation for fences Date: Tue, 22 Jul 2014 18:21:53 +0200 Message-ID: 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?Q?Christian_K=C3=B6nig?= Cc: Thomas Hellstrom , nouveau , LKML , dri-devel , Ben Skeggs , "Deucher, Alexander" , =?UTF-8?Q?Christian_K=C3=B6nig?= List-Id: nouveau.vger.kernel.org T24gVHVlLCBKdWwgMjIsIDIwMTQgYXQgNTo1OSBQTSwgQ2hyaXN0aWFuIEvDtm5pZwo8ZGVhdGhz aW1wbGVAdm9kYWZvbmUuZGU+IHdyb3RlOgo+IEFtIDIyLjA3LjIwMTQgMTc6NDIsIHNjaHJpZWIg RGFuaWVsIFZldHRlcjoKPgo+PiBPbiBUdWUsIEp1bCAyMiwgMjAxNCBhdCA1OjM1IFBNLCBDaHJp c3RpYW4gS8O2bmlnCj4+IDxjaHJpc3RpYW4ua29lbmlnQGFtZC5jb20+IHdyb3RlOgo+Pj4KPj4+ IERyaXZlcnMgZXhwb3J0aW5nIGZlbmNlcyBuZWVkIHRvIHByb3ZpZGUgYSBmZW5jZS0+c2lnbmFs ZWQgYW5kIGEKPj4+IGZlbmNlLT53YWl0Cj4+PiBmdW5jdGlvbiwgZXZlcnl0aGluZyBlbHNlIGxp a2UgZmVuY2UtPmVuYWJsZV9zaWduYWxpbmcgb3IgY2FsbGluZwo+Pj4gZmVuY2Vfc2lnbmFsZWQo KSBmcm9tIHRoZSBkcml2ZXIgaXMgb3B0aW9uYWwuCj4+Pgo+Pj4gRHJpdmVycyB3YW50aW5nIHRv IHVzZSBleHBvcnRlZCBmZW5jZXMgZG9uJ3QgY2FsbCBmZW5jZS0+c2lnbmFsZWQgb3IKPj4+IGZl bmNlLT53YWl0IGluIGF0b21pYyBvciBpbnRlcnJ1cHQgY29udGV4dCwgYW5kIG5vdCB3aXRoIGhv bGRpbmcgYW55Cj4+PiBnbG9iYWwKPj4+IGxvY2tpbmcgcHJpbWl0aXZlcyAobGlrZSBtbWFwX3Nl bSBldGMuLi4pLiBIb2xkaW5nIGxvY2tpbmcgcHJpbWl0aXZlcwo+Pj4gbG9jYWwKPj4+IHRvIHRo ZSBkcml2ZXIgaXMgb2ssIGFzIGxvbmcgYXMgdGhleSBkb24ndCBjb25mbGljdCB3aXRoIGFueXRo aW5nCj4+PiBwb3NzaWJsZQo+Pj4gdXNlZCBieSB0aGVpciBvd24gZmVuY2UgaW1wbGVtZW50YXRp b24uCj4+Cj4+IFdlbGwgdGhhdCdzIGFsbW9zdCB3aGF0IHdlIGhhdmUgcmlnaHQgbm93IHdpdGgg dGhlIGV4Y2VwdGlvbiB0aGF0Cj4+IGRyaXZlcnMgYXJlIGFsbG93ZWQgKGFjdHVhbGx5IG11c3Qg Zm9yIGNvcnJlY3RuZXNzIHdoZW4gdXBkYXRpbmcKPj4gZmVuY2VzKSB0aGUgd3dfbXV0ZXhlcyBm b3IgZG1hLWJ1ZnMgKG9yIG90aGVyIGJ1ZmZlciBvYmplY3RzKS4KPgo+Cj4gSW4gdGhpcyBjYXNl IHNvcnJ5IGZvciBzbyBtdWNoIG5vaXNlLiBJIHJlYWxseSBoYXZlbid0IGxvb2tlZCBpbiBzbyBt dWNoCj4gZGV0YWlsIGludG8gYW55dGhpbmcgYnV0IE1hYXJ0ZW4ncyBSYWRlb24gcGF0Y2hlcy4K Pgo+IEJ1dCBob3cgZG9lcyB0aGF0IHRoZW4gd29yayByaWdodCBub3c/IE15IGltcHJlc3Npb24g d2FzIHRoYXQgaXQncyBtYW5kYXRvcnkKPiBmb3IgZHJpdmVycyB0byBjYWxsIGZlbmNlX3NpZ25h bGVkKCk/CgpNYXliZSBJJ3ZlIG1peGVkIHRoaW5ncyB1cCBhIGJpdCBpbiBteSBkZXNjcmlwdGlv bi4gVGhlcmUgaXMKZmVuY2Vfc2lnbmFsIHdoaWNoIHRoZSBpbXBsZW1lbnRvci9leHBvcnRlciBv ZiBhIGZlbmNlIG11c3QgY2FsbCB3aGVuCnRoZSBmZW5jZSBpcyBjb21wbGV0ZWQuIElmIHRoZSBl eHBvcnRlciBoYXMgYW4gLT5lbmFibGVfc2lnbmFsaW5nCmNhbGxiYWNrIGl0IGNhbiBkZWxheSB0 aGF0IGNhbGwgdG8gZmVuY2Vfc2lnbmFsIGZvciBhcyBsb25nIGFzIGl0Cndpc2hlcyBhcyBsb25n IGFzIGVuYWJsZV9zaWduYWxpbmcgaXNuJ3QgY2FsbGVkIHlldC4gQnV0IHRoYXQncyBqdXN0CnRo ZSBvcHRpbWl6YXRpb24gdG8gbm90IHJlcXVpcmVkIGlycXMgdG8gYmUgdHVybmVkIG9uIGFsbCB0 aGUgdGltZS4KClRoZSBvdGhlciBmdW5jdGlvbiBpcyBmZW5jZV9pc19zaWduYWxlZCwgd2hpY2gg aXMgdXNlZCBieSBjb2RlIHRoYXQgaXMKaW50ZXJlc3RlZCBpbiB0aGUgZmVuY2Ugc3RhdGUsIHRv Z2V0aGVyIHdpdGggZmVuY2Vfd2FpdCBpZiBpdCB3YW50cyB0bwpibG9jayBhbmQgbm90IGp1c3Qg d2FudHMgdG8ga25vdyB0aGUgbW9tZW50YXJ5IGZlbmNlIHN0YXRlLiBBbGwgdGhlCm90aGVyIGZ1 bmN0aW9ucyAodGhlIHN0dWZmIHRoYXQgYWRkcyBjYWxsYmFja3MgYW5kIHRoZSB2YXJpb3VzIF9s b2NrZWQKYW5kIG90aGVyIHZlcnNpb25zKSBhcmUganVzdCBmb3IgZmFuY3kgc3BlY2lhbCBjYXNl cy4KCj4+IExvY2tpbmcKPj4gY29ycmVjdG5lc3MgaXMgZW5mb3JjZWQgd2l0aCBzb21lIGV4dHJl bWVseSBuYXN0eSBsb2NrZGVwIGFubm90YXRpb25zCj4+ICsgYWRkaXRpb25hbCBkZWJ1Z2dpbmcg aW5mcmFzdHJ1Y3R1cmUgZW5hYmxlZCB3aXRoCj4+IENPTkZJR19ERUJVR19XV19NVVRFWF9TTE9X UEFUSC4gV2UgcmVhbGx5IG5lZWQgdG8gYmUgYWJsZSB0byBob2xkCj4+IGRtYS1idWYgd3dfbXV0 ZXhlcyB3aGlsZSB1cGRhdGluZyBmZW5jZXMgb3Igd2FpdGluZyBmb3IgdGhlbS4gQW5kCj4+IG9i dmlvdXNseSBmb3IgLT53YWl0IHdlIG5lZWQgbm9uLWF0b21pYyBjb250ZXh0LCBub3QganVzdAo+ PiBub24taW50ZXJydXB0Lgo+Cj4KPiBTb3VuZHMgbW9zdGx5IHJlYXNvbmFibGUsIGJ1dCBmb3Ig aG9sZGluZyB0aGUgZG1hLWJ1ZiB3d19tdXRleCwgd291bGRuJ3QgYmUKPiBhbiBSQ1UgYmUgbW9y ZSBhcHByb3ByaWF0ZSBoZXJlPyBFLmcuIGFyZW4ndCB3ZSBqdXN0IGludGVyZXN0ZWQgdGhhdCB0 aGUKPiBjdXJyZW50IGFzc2lnbmVkIGZlbmNlIGF0IHNvbWUgcG9pbnQgaXMgc2lnbmFsZWQ/CgpZ ZWFoLCBhcyBhbiBvcHRpbWl6YXRpb24geW91IGNhbiBnZXQgdGhlIHNldCBvZiBjdXJyZW50bHkg YXR0YWNoZWQKZmVuY2VzIHRvIGEgZG1hLWJ1ZiB3aXRoIGp1c3QgcmN1LiBCdXQgaWYgeW91IHVw ZGF0ZSB0aGUgc2V0IG9mIGZlbmNlcwphdHRhY2hlZCB0byBhIGRtYS1idWYgKGUuZy4gcmFkZW9u IGJsaXRzIHRoZSBuZXdseSByZW5kZXJlZCBmcmFtZSB0byBhCmRtYS1idWYgZXhwb3J0ZWQgYnkg aTkxNSBmb3Igc2Nhbm91dCBvbiBpOTE1KSB0aGVuIHlvdSBuZWVkIGEgd3JpdGUKbG9jayBvbiB0 aGF0IGJ1ZmZlci4gV2hpY2ggaXMgd2hhdCB0aGUgd3dfbXV0ZXggaXMgZm9yLCB0byBtYWtlIHN1 cmUKdGhhdCB5b3UgZG9uJ3QgZGVhZGxvY2sgd2l0aCBpOTE1IGRvaW5nIGNvbmN1cnJlbnQgb3Bz IG9uIHRoZSBzYW1lCnVuZGVybHlpbmcgYnVmZmVyLgoKPiBTb21ldGhpbmcgbGlrZSBncmFiIHd3 X211dGV4ZXMsIGdyYWIgYSByZWZlcmVuY2UgdG8gdGhlIGN1cnJlbnQgZmVuY2UKPiBvYmplY3Qs IHJlbGVhc2Ugd3dfbXV0ZXgsIHdhaXQgZm9yIGZlbmNlLCByZWxlYXNlIHJlZmVyZW5jZSB0byB0 aGUgZmVuY2UKPiBvYmplY3QuCgpZZWFoLCBpZiB0aGUgb25seSB0aGluZyB5b3Ugd2FudCB0byBk byBpcyB3YWl0IGZvciBmZW5jZXMsIHRoZW4gdGhlCnJjdS1wcm90ZWN0ZWQgZmVuY2UgcmVmIGdy YWJiaW5nICsgbG9ja2xlc3Mgd2FpdGluZyBpcyBhbGwgeW91IG5lZWQuCkJ1dCBlLmcuIGluIGFu IGV4ZWNidWYgeW91IGFsc28gbmVlZCB0byB1cGRhdGUgZmVuY2VzIGFuZCBtYXliZSBkZWVwCmRv d24gaW4gdGhlIHJlc2VydmF0aW9uIGNvZGUgeW91IG5vdGljZSB0aGF0IHlvdSBuZWVkIHRvIGV2 aWN0IHNvbWUKc3R1ZmYgYW5kIHNvIG5lZWQgdG8gd2FpdCBvbiBzb21lIG90aGVyIGd1eSB0byBm aW5pc2gsIGFuZCBpdCdzIHRvbwpjb21wbGljYXRlZCB0byBkcm9wIGFuZCByZWFjcXVpcmUgYWxs IHRoZSBsb2Nrcy4gT3IgeW91IHNpbXBseSBuZWVkIHRvCmRvIGEgYmxvY2tpbmcgd2FpdCBvbiBv dGhlciBncHVzIChiZWNhdXNlIHRoZXJlJ3Mgbm8gZGlyZWN0IGh3IHN5bmMKbWVjaGFuaXNtKSBh bmQgYWdhaW4gZHJvcHBpbmcgbG9ja3Mgd291bGQgbmVlZGxlc3NseSBjb21wbGljYXRlIHRoZQpj b2RlLiBTbyBJIHRoaW5rIHdlIHNob3VsZCBhbGxvdyB0aGlzIGp1c3QgdG8gYXZvaWQgdG9vIGhh aXJ5L2JyaXR0bGUKKGFuZCBhbG1vc3QgZGVmaW5pdGVseSBsaXR0bGUgdGVzdGVkIGNvZGUpIGlu IGRyaXZlcnMuCgpBZmFpayB0aGlzIGlzIGFsc28gdGhlIHNhbWUgd2F5IHR0bSBjdXJyZW50bHkg aGFuZGxlcyB0aGluZ3Mgd3J0CmJ1ZmZlciByZXNlcnZhdGlvbiBhbmQgZXZpY3Rpb24uCgo+PiBB Z3JlZWQgdGhhdCBhbnkgc2hhcmVkIGxvY2tzIGFyZSBvdXQgb2YgdGhlIHdheSAoZXNwZWNpYWxs eSBzdHVmZiBsaWtlCj4+IGRldi0+c3RydWN0X211dGV4IG9yIG90aGVyIG5vbi1zdHJpY3RseSBk cml2ZXItcHJpdmF0ZSBzdHVmZiwgaTkxNSBpcwo+PiByZWFsbHkgYmFkIGhlcmUgc3RpbGwpLgo+ Cj4KPiBZZWFoIHRoYXQncyBhbHNvIGFuIHBvaW50IEkndmUgd2FudGVkIHRvIG5vdGUgb24gTWFh cnRlbnMgcGF0Y2guIFJhZGVvbgo+IGdyYWJzIHRoZSByZWFkIHNpZGUgb2YgaXQncyBleGNsdXNp dmUgc2VtYXBob3JlIHdoaWxlIHdhaXRpbmcgZm9yIGZlbmNlcwo+IChiZWNhdXNlIGl0IGFzc3Vt ZXMgdGhhdCB0aGUgZmVuY2UgaXQgd2FpdHMgZm9yIGlzIGEgUmFkZW9uIGZlbmNlKS4KPgo+IEFz c3VtaW5nIHRoYXQgd2UgbmVlZCB0byB3YWl0IGluIGJvdGggZGlyZWN0aW9ucyB3aXRoIFByaW1l IChlLmcuIEludGVsCj4gZHJpdmVyIG5lZWRzIHRvIHdhaXQgZm9yIFJhZGVvbiB0byBmaW5pc2gg cmVuZGVyaW5nIGFuZCBSYWRlb24gbmVlZHMgdG8gd2FpdAo+IGZvciBJbnRlbCB0byBmaW5pc2gg ZGlzcGxheWluZyksIHRoaXMgbWlnaHQgYmVjb21lIGEgcGVyZmVjdCBleGFtcGxlIG9mCj4gbG9j a2luZyBpbnZlcnNpb24uCgpmZW5jZSB1cGRhdGVzIGFyZSBhdG9taWMgb24gYSBkbWEtYnVmLCBw cm90ZWN0ZWQgYnkgd3dfbXV0ZXguIFRoZSBuZWF0CnRyaWNrIG9mIHd3X211dGV4IGlzIHRoYXQg dGhleSBlbmZvcmNlIGEgZ2xvYmFsIG9yZGVyaW5nLCBzbyBpbiB5b3VyCnNjZW5hcmlvIGVpdGhl ciBpOTE1IG9yIHJhZGVvbiB3b3VsZCBiZSBmaXJzdCBhbmQgeW91IGNhbid0IGRlYWRsb2NrLgpU aGVyZSBpcyBubyB3YXkgdG8gaW50ZXJsZWF2ZSBhbnl0aGluZyBldmVuIGlmIHlvdSBoYXZlIGxv dHMgb2YKYnVmZmVycyBzaGFyZWQgYmV0d2VlbiBpOTE1L3JhZGVvbi4gV3J0IGRlYWRsb2NraW5n IGl0J3MgZXhhY3RseSB0aGUKc2FtZSBndWFyYW50ZWVzIGFzIHRoZSBtYWdpYyB0dG0gcHJvdmlk ZXMgZm9yIGp1c3Qgb25lIGRyaXZlciB3aXRoCmNvbmN1cnJlbnQgY29tbWFuZCBzdWJtaXNzaW9u IHNpbmNlIGl0J3MgdGhlIHNhbWUgaWRlYS4KCj4+IFNvIGZyb20gdGhlIGNvcmUgZmVuY2UgZnJh bWV3b3JrIEkgdGhpbmsgd2UgYWxyZWFkeSBoYXZlIGV4YWN0bHkgdGhpcywKPj4gYW5kIHdlIG9u bHkgbmVlZCB0byBhZGp1c3QgdGhlIHJhZGVvbiBpbXBsZW1lbnRhdGlvbiBhIGJpdCB0byBtYWtl IGl0Cj4+IGxlc3Mgcmlza3kgYW5kIGludmFzaXZlIHRvIHRoZSByYWRlb24gZHJpdmVyIGxvZ2lj Lgo+Cj4KPiBBZ3JlZS4gV2VsbCB0aGUgYmlnZ2VzdCBwcm9ibGVtIEkgc2VlIGlzIHRoYXQgZXhj bHVzaXZlIHNlbWFwaG9yZSBJIG5lZWQgdG8KPiB0YWtlIHdoZW4gYW55dGhpbmcgY2FsbHMgaW50 byB0aGUgZHJpdmVyLiBGb3IgdGhlIGZlbmNlIGNvZGUgSSBuZWVkIHRvIG1vdmUKPiB0aGF0IGRv d24gaW50byB0aGUgZmVuY2UtPnNpZ25hbGVkIGhhbmRsZXIsIGNhdXNlIHRoYXQgbm93IGNhbiBi ZSBjYWxsZWQKPiBmcm9tIG91dHNpZGUgdGhlIGRyaXZlci4KPgo+IE1hYXJ0ZW4gc29sdmVkIHRo aXMgYnkgdGVsbGluZyB0aGUgZHJpdmVyIGluIHRoZSBsb2NrdXAgaGFuZGxlciAod2hlcmUgd2UK PiBncmFiIHRoZSB3cml0ZSBzaWRlIG9mIHRoZSBleGNsdXNpdmUgbG9jaykgdGhhdCBhbGwgaW50 ZXJydXB0cyBhcmUgYWxyZWFkeQo+IGVuYWJsZWQsIHNvIHRoYXQgZmVuY2UtPnNpZ25hbGVkIGhv cGVmdWxseSB3b3VsZG4ndCBtZXNzIHdpdGggdGhlIGhhcmR3YXJlCj4gYXQgYWxsLiBXaGlsZSB0 aGlzIHByb2JhYmx5IHdvcmtzLCBpdCBqdXN0IGxlYXZlcyBtZSB3aXRoIGEgZmVlbGluZyB0aGF0 IHdlCj4gYXJlIGRvaW5nIHNvbWV0aGluZyB3cm9uZyBoZXJlLgoKSSdtIG5vdCB2ZXJzZWQgb24g dGhlIGRldGFpbHMgaW4gcmVhZG9uLCBidXQgb24gaTkxNSB3ZSBjYW4gYXR0YWNoIGEKbWVtb3J5 IGxvY2F0aW9uIGFuZCBjb29raWUgdmFsdWUgdG8gZWFjaCBmZW5jZSBhbmQganVzdCBkbyBhIG1l bW9yeQpmZXRjaCB0byBmaWd1cmUgb3V0IHdoZXRoZXIgdGhlIGZlbmNlIGhhcyBwYXNzZWQgb3Ig bm90LiBTbyBubyBsb2NraW5nCm5lZWRlZCBhdCBhbGwuIE9mIGNvdXJzZSB0aGUgZmVuY2UgaXRz ZWxmIG5lZWRzIHRvIGxvY2sgYSByZWZlcmVuY2UKb250byB0aGF0IG1lbW9yeSBsb2NhdGlvbiwg d2hpY2ggaXMgYSBuZWF0IHBpZWNlIG9mIGludGVncmF0aW9uIHdvcmsKdGhhdCB3ZSBzdGlsbCBu ZWVkIHRvIHRhY2tsZSBpbiBzb21lIGNhc2VzIC0gdGhlcmUncyBjb25mbGljdGluZyBwYXRjaApz ZXJpZXMgYWxsIG92ZXIgdGhpcyA7LSkKCkJ1dCBsaWtlIEkndmUgc2FpZCBmZW5jZS0+c2lnbmFs ZWQgaXMgb3B0aW9uYWwgc28geW91IGRvbid0IG5lZWQgdGhpcwpuZWNlc3NhcmlseSwgYXMgbG9u ZyBhcyByYWRlb24gZXZlbnR1YWxseSBjYWxscyBmZW5jZV9zaWduYWxlZCBvbmNlCnRoZSBmZW5j ZSBoYXMgY29tcGxldGVkLgotRGFuaWVsCi0tIApEYW5pZWwgVmV0dGVyClNvZnR3YXJlIEVuZ2lu ZWVyLCBJbnRlbCBDb3Jwb3JhdGlvbgorNDEgKDApIDc5IDM2NSA1NyA0OCAtIGh0dHA6Ly9ibG9n LmZmd2xsLmNoCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f CmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpo dHRwOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==