From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754233AbcEOPM3 (ORCPT ); Sun, 15 May 2016 11:12:29 -0400 Received: from p3plsmtps2ded04.prod.phx3.secureserver.net ([208.109.80.198]:50305 "EHLO p3plsmtps2ded04.prod.phx3.secureserver.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751738AbcEOPMZ (ORCPT ); Sun, 15 May 2016 11:12:25 -0400 x-originating-ip: 72.167.245.219 From: Dexuan Cui To: gregkh@linuxfoundation.org, davem@davemloft.net, netdev@vger.kernel.org, linux-kernel@vger.kernel.org, devel@linuxdriverproject.org, olaf@aepfle.de, apw@canonical.com, jasowang@redhat.com, cavery@redhat.com, kys@microsoft.com, haiyangz@microsoft.com Cc: joe@perches.com, vkuznets@redhat.com Subject: =?UTF-8?q?=5BPATCH=20v11=20net-next=200/1=5D=20introduce=20Hyper-V=20VM=20Sockets=28hv=5Fsock=29?= Date: Sun, 15 May 2016 09:52:42 -0700 Message-Id: <1463331162-6679-1-git-send-email-decui@microsoft.com> X-Mailer: git-send-email 1.7.4.1 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-CMAE-Envelope: MS4wfMQkSD7VnWB+ipKrZW40tEj2A6Xew/oLlLb8qTcuEQX70xgGk99sudpGkjwF8FlDcYCr588pq3e6Vh6LkkHmKfDuN8fV8jElByb2kQIZ4WLbncPMvkv/ pNllCdvGx04qrmLlGr5q6FGx2H2JjY7ICm1tCWbens57gsJSdjTBLOL71MuiGfhPfVR4nWdMNEEvYrAoLNL8qEaL3f3iqP4QKknaqGH0q0cwV3or7HM6O3FH mQ4xOvlZ6iaQ+tC4pcxRaeRcu87I2J26bg37kcPwz6waO/1l76SAn8IphrsJY5JVnWgEapDtoZ03t8by6lLbRgZgZkHbSH9mtyP/Nbi/1v/S/nmNCFAlajkA ZXC9BaPC87MJ8CVD0/S+TCbgS8E4CBGSxpdAdGMb0CV5HmlCwCrZT1kznx2ILwR9pF0cqKiWa5B0nZcsrmKZEVkE99wPhlu3vj3VpMYwZIlYXYWhvfVg+20R G5692bM3sPvqJPYBFyL3eJjnux554zDIUYEhIZXutVgTrlPWgvumIkmRxP5F0SrzMXfNLO7WwLBICpoSl0dFquYDP3Bv4h2me/cmQw== Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hyper-V Sockets (hv_sock) supplies a byte-stream based communication mechanism between the host and the guest. It's somewhat like TCP over VMBus, but the transportation layer (VMBus) is much simpler than IP. With Hyper-V Sockets, applications between the host and the guest can talk to each other directly by the traditional BSD-style socket APIs. Hyper-V Sockets is only available on new Windows hosts, like Windows Server 2016. More info is in this article "Make your own integration services": https://msdn.microsoft.com/en-us/virtualization/hyperv_on_windows/develop/make_mgmt_service The patch implements the necessary support in the guest side by introducing a new socket address family AF_HYPERV. You can also get the patch by: https://github.com/dcui/linux/commits/decui/hv_sock/net-next/20160512_v10 Note: the VMBus driver side's supporting patches have been in the mainline tree. I know the kernel has already had a VM Sockets driver (AF_VSOCK) based on VMware VMCI (net/vmw_vsock/, drivers/misc/vmw_vmci), and KVM is proposing AF_VSOCK of virtio version: http://marc.info/?l=linux-netdev&m=145952064004765&w=2 However, though Hyper-V Sockets may seem conceptually similar to AF_VOSCK, there are differences in the transportation layer, and IMO these make the direct code reusing impractical: 1. In AF_VSOCK, the endpoint type is: , but in AF_HYPERV, the endpoint type is: . Here GUID is 128-bit. 2. AF_VSOCK supports SOCK_DGRAM, while AF_HYPERV doesn't. 3. AF_VSOCK supports some special sock opts, like SO_VM_SOCKETS_BUFFER_SIZE, SO_VM_SOCKETS_BUFFER_MIN/MAX_SIZE and SO_VM_SOCKETS_CONNECT_TIMEOUT. These are meaningless to AF_HYPERV. 4. Some AF_VSOCK's VMCI transportation ops are meanless to AF_HYPERV/VMBus, like .notify_recv_init .notify_recv_pre_block .notify_recv_pre_dequeue .notify_recv_post_dequeue .notify_send_init .notify_send_pre_block .notify_send_pre_enqueue .notify_send_post_enqueue etc. So I think we'd better introduce a new address family: AF_HYPERV. Please review the patch. Looking forward to your comments, especially comments from David. :-) Changes since v1: - updated "[PATCH 6/7] hvsock: introduce Hyper-V VM Sockets feature" - added __init and __exit for the module init/exit functions - net/hv_sock/Kconfig: "default m" -> "default m if HYPERV" - MODULE_LICENSE: "Dual MIT/GPL" -> "Dual BSD/GPL" Changes since v2: - fixed various coding issue pointed out by David Miller - fixed indentation issues - removed pr_debug in net/hv_sock/af_hvsock.c - used reverse-Chrismas-tree style for local variables. - EXPORT_SYMBOL -> EXPORT_SYMBOL_GPL Changes since v3: - fixed a few coding issue pointed by Vitaly Kuznetsov and Dan Carpenter - fixed the ret value in vmbus_recvpacket_hvsock on error - fixed the style of multi-line comment: vmbus_get_hvsock_rw_status() Changes since v4 (https://lkml.org/lkml/2015/7/28/404): - addressed all the comments about V4. - treat the hvsock offers/channels as special VMBus devices - add a mechanism to pass hvsock events to the hvsock driver - fixed some corner cases with proper locking when a connection is closed - rebased to the latest Greg's tree Changes since v5 (https://lkml.org/lkml/2015/12/24/103): - addressed the coding style issues (Vitaly Kuznetsov & David Miller, thanks!) - used a better coding for the per-channel rescind callback (Thank Vitaly!) - avoided the introduction of new VMBUS driver APIs vmbus_sendpacket_hvsock() and vmbus_recvpacket_hvsock() and used vmbus_sendpacket()/vmbus_recvpacket() in the higher level (i.e., the vmsock driver). Thank Vitaly! Changes since v6 (http://lkml.iu.edu/hypermail/linux/kernel/1601.3/01813.html) - only a few minor changes of coding style and comments Changes since v7 - a few minor changes of coding style: thanks, Joe Perches! - added some lines of comments about GUID/UUID before the struct sockaddr_hv. Changes since v8 - removed the unnecessary __packed for some definitions: thanks, David! - hvsock_open_connection: use offer.u.pipe.user_def[0] to know the connection and reorganized the function direction - reorganized the code according to suggestions from Cathy Avery: split big functions into small ones, set .setsockopt and getsockopt to sock_no_setsockopt/sock_no_getsockopt - inline'd some small list helper functions Changes since v9 - minimized struct hvsock_sock by making the send/recv buffers pointers. the buffers are allocated by kmalloc() in __hvsock_create() now. - minimized the sizes of the send/recv buffers and the vmbus ringbuffers. Changes since v10 1) add module params: send_ring_page, recv_ring_page. They can be used to enlarge the ringbuffer size to get better performance, e.g., # modprobe hv_sock recv_ring_page=16 send_ring_page=16 By default, recv_ring_page is 3 and send_ring_page is 2. 2) add module param max_socket_number (the default is 1024). A user can enlarge the number to create more than 1024 hv_sock sockets. By default, 1024 sockets take about 1024 * (3+2+1+1) * 4KB = 28M bytes. (Here 1+1 means 1 page for send/recv buffers per connection, respectively.) 3) implement the TODO in hvsock_shutdown(). 4) fix a bug in hvsock_close_connection(): I remove "sk->sk_socket->state = SS_UNCONNECTED;" -- actually this line is not really useful. For a connection triggered by a host app’s connect(), sk->sk_socket remains NULL before the connection is accepted by the server app (in Linux VM): see hvsock_accept() -> hvsock_accept_wait() -> sock_graft(connected, newsock). If the host app exits before the server app’s accept() returns, the host can send a rescind-message to close the connection and later in the Linux VM’s message handler i.e. vmbus_onoffer_rescind()), Linux will get a NULL de-referencing crash. 5) fix a bug in hvsock_open_connection() I move the vmbus_set_chn_rescind_callback() to a later place, because when vmbus_open() fails, hvsock_close_connection() can do nothing and we count on vmbus_onoffer_rescind() -> vmbus_device_unregister() to clean up the device. 6) some stylistic modificiation. Dexuan Cui (1): hv_sock: introduce Hyper-V Sockets MAINTAINERS | 2 + include/linux/hyperv.h | 14 + include/linux/socket.h | 4 +- include/net/af_hvsock.h | 78 +++ include/uapi/linux/hyperv.h | 25 + net/Kconfig | 1 + net/Makefile | 1 + net/hv_sock/Kconfig | 10 + net/hv_sock/Makefile | 3 + net/hv_sock/af_hvsock.c | 1520 +++++++++++++++++++++++++++++++++++++++++++ 10 files changed, 1657 insertions(+), 1 deletion(-) create mode 100644 include/net/af_hvsock.h create mode 100644 net/hv_sock/Kconfig create mode 100644 net/hv_sock/Makefile create mode 100644 net/hv_sock/af_hvsock.c -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dexuan Cui Subject: =?UTF-8?q?=5BPATCH=20v11=20net-next=200/1=5D=20introduce=20Hyper-V=20VM=20Sockets=28hv=5Fsock=29?= Date: Sun, 15 May 2016 09:52:42 -0700 Message-ID: <1463331162-6679-1-git-send-email-decui@microsoft.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Cc: joe@perches.com To: gregkh@linuxfoundation.org, davem@davemloft.net, netdev@vger.kernel.org, linux-kernel@vger.kernel.org, devel@linuxdriverproject.org, olaf@aepfle.de, apw@canonical.com, jasowang@redhat.com, cavery@redhat.com, kys@microsoft.com, haiyangz@microsoft.com Return-path: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: driverdev-devel-bounces@linuxdriverproject.org Sender: "devel" List-Id: netdev.vger.kernel.org SHlwZXItViBTb2NrZXRzIChodl9zb2NrKSBzdXBwbGllcyBhIGJ5dGUtc3RyZWFtIGJhc2VkIGNv bW11bmljYXRpb24KbWVjaGFuaXNtIGJldHdlZW4gdGhlIGhvc3QgYW5kIHRoZSBndWVzdC4gSXQn cyBzb21ld2hhdCBsaWtlIFRDUCBvdmVyClZNQnVzLCBidXQgdGhlIHRyYW5zcG9ydGF0aW9uIGxh eWVyIChWTUJ1cykgaXMgbXVjaCBzaW1wbGVyIHRoYW4gSVAuCgpXaXRoIEh5cGVyLVYgU29ja2V0 cywgYXBwbGljYXRpb25zIGJldHdlZW4gdGhlIGhvc3QgYW5kIHRoZSBndWVzdCBjYW4gdGFsawp0 byBlYWNoIG90aGVyIGRpcmVjdGx5IGJ5IHRoZSB0cmFkaXRpb25hbCBCU0Qtc3R5bGUgc29ja2V0 IEFQSXMuCgpIeXBlci1WIFNvY2tldHMgaXMgb25seSBhdmFpbGFibGUgb24gbmV3IFdpbmRvd3Mg aG9zdHMsIGxpa2UgV2luZG93cyBTZXJ2ZXIKMjAxNi4gTW9yZSBpbmZvIGlzIGluIHRoaXMgYXJ0 aWNsZSAiTWFrZSB5b3VyIG93biBpbnRlZ3JhdGlvbiBzZXJ2aWNlcyI6Cmh0dHBzOi8vbXNkbi5t aWNyb3NvZnQuY29tL2VuLXVzL3ZpcnR1YWxpemF0aW9uL2h5cGVydl9vbl93aW5kb3dzL2RldmVs b3AvbWFrZV9tZ210X3NlcnZpY2UKClRoZSBwYXRjaCBpbXBsZW1lbnRzIHRoZSBuZWNlc3Nhcnkg c3VwcG9ydCBpbiB0aGUgZ3Vlc3Qgc2lkZSBieQppbnRyb2R1Y2luZyBhIG5ldyBzb2NrZXQgYWRk cmVzcyBmYW1pbHkgQUZfSFlQRVJWLgoKWW91IGNhbiBhbHNvIGdldCB0aGUgcGF0Y2ggYnk6Cmh0 dHBzOi8vZ2l0aHViLmNvbS9kY3VpL2xpbnV4L2NvbW1pdHMvZGVjdWkvaHZfc29jay9uZXQtbmV4 dC8yMDE2MDUxMl92MTAKCk5vdGU6IHRoZSBWTUJ1cyBkcml2ZXIgc2lkZSdzIHN1cHBvcnRpbmcg cGF0Y2hlcyBoYXZlIGJlZW4gaW4gdGhlIG1haW5saW5lCnRyZWUuCgpJIGtub3cgdGhlIGtlcm5l bCBoYXMgYWxyZWFkeSBoYWQgYSBWTSBTb2NrZXRzIGRyaXZlciAoQUZfVlNPQ0spIGJhc2VkCm9u IFZNd2FyZSBWTUNJIChuZXQvdm13X3Zzb2NrLywgZHJpdmVycy9taXNjL3Ztd192bWNpKSwgYW5k IEtWTSBpcwpwcm9wb3NpbmcgQUZfVlNPQ0sgb2YgdmlydGlvIHZlcnNpb246Cmh0dHA6Ly9tYXJj LmluZm8vP2w9bGludXgtbmV0ZGV2Jm09MTQ1OTUyMDY0MDA0NzY1Jnc9MgoKSG93ZXZlciwgdGhv dWdoIEh5cGVyLVYgU29ja2V0cyBtYXkgc2VlbSBjb25jZXB0dWFsbHkgc2ltaWxhciB0bwpBRl9W T1NDSywgdGhlcmUgYXJlIGRpZmZlcmVuY2VzIGluIHRoZSB0cmFuc3BvcnRhdGlvbiBsYXllciwg YW5kIElNTyB0aGVzZQptYWtlIHRoZSBkaXJlY3QgY29kZSByZXVzaW5nIGltcHJhY3RpY2FsOgoK MS4gSW4gQUZfVlNPQ0ssIHRoZSBlbmRwb2ludCB0eXBlIGlzOiA8dTMyIENvbnRleHRJRCwgdTMy IFBvcnQ+LCBidXQgaW4KQUZfSFlQRVJWLCB0aGUgZW5kcG9pbnQgdHlwZSBpczogPEdVSUQgVk1f SUQsIEdVSUQgU2VydmljZUlEPi4gSGVyZSBHVUlECmlzIDEyOC1iaXQuCgoyLiBBRl9WU09DSyBz dXBwb3J0cyBTT0NLX0RHUkFNLCB3aGlsZSBBRl9IWVBFUlYgZG9lc24ndC4KCjMuIEFGX1ZTT0NL IHN1cHBvcnRzIHNvbWUgc3BlY2lhbCBzb2NrIG9wdHMsIGxpa2UgU09fVk1fU09DS0VUU19CVUZG RVJfU0laRSwKU09fVk1fU09DS0VUU19CVUZGRVJfTUlOL01BWF9TSVpFIGFuZCBTT19WTV9TT0NL RVRTX0NPTk5FQ1RfVElNRU9VVC4KVGhlc2UgYXJlIG1lYW5pbmdsZXNzIHRvIEFGX0hZUEVSVi4K CjQuIFNvbWUgQUZfVlNPQ0sncyBWTUNJIHRyYW5zcG9ydGF0aW9uIG9wcyBhcmUgbWVhbmxlc3Mg dG8gQUZfSFlQRVJWL1ZNQnVzLApsaWtlIC5ub3RpZnlfcmVjdl9pbml0Ci5ub3RpZnlfcmVjdl9w cmVfYmxvY2sKLm5vdGlmeV9yZWN2X3ByZV9kZXF1ZXVlCi5ub3RpZnlfcmVjdl9wb3N0X2RlcXVl dWUKLm5vdGlmeV9zZW5kX2luaXQKLm5vdGlmeV9zZW5kX3ByZV9ibG9jawoubm90aWZ5X3NlbmRf cHJlX2VucXVldWUKLm5vdGlmeV9zZW5kX3Bvc3RfZW5xdWV1ZQpldGMuCgpTbyBJIHRoaW5rIHdl J2QgYmV0dGVyIGludHJvZHVjZSBhIG5ldyBhZGRyZXNzIGZhbWlseTogQUZfSFlQRVJWLgoKUGxl YXNlIHJldmlldyB0aGUgcGF0Y2guCgpMb29raW5nIGZvcndhcmQgdG8geW91ciBjb21tZW50cywg ZXNwZWNpYWxseSBjb21tZW50cyBmcm9tIERhdmlkLiA6LSkKCkNoYW5nZXMgc2luY2UgdjE6Ci0g dXBkYXRlZCAiW1BBVENIIDYvN10gaHZzb2NrOiBpbnRyb2R1Y2UgSHlwZXItViBWTSBTb2NrZXRz IGZlYXR1cmUiCi0gYWRkZWQgX19pbml0IGFuZCBfX2V4aXQgZm9yIHRoZSBtb2R1bGUgaW5pdC9l eGl0IGZ1bmN0aW9ucwotIG5ldC9odl9zb2NrL0tjb25maWc6ICJkZWZhdWx0IG0iIC0+ICJkZWZh dWx0IG0gaWYgSFlQRVJWIgotIE1PRFVMRV9MSUNFTlNFOiAiRHVhbCBNSVQvR1BMIiAtPiAiRHVh bCBCU0QvR1BMIgoKQ2hhbmdlcyBzaW5jZSB2MjoKLSBmaXhlZCB2YXJpb3VzIGNvZGluZyBpc3N1 ZSBwb2ludGVkIG91dCBieSBEYXZpZCBNaWxsZXIKLSBmaXhlZCBpbmRlbnRhdGlvbiBpc3N1ZXMK LSByZW1vdmVkIHByX2RlYnVnIGluIG5ldC9odl9zb2NrL2FmX2h2c29jay5jCi0gdXNlZCByZXZl cnNlLUNocmlzbWFzLXRyZWUgc3R5bGUgZm9yIGxvY2FsIHZhcmlhYmxlcy4KLSBFWFBPUlRfU1lN Qk9MIC0+IEVYUE9SVF9TWU1CT0xfR1BMCgpDaGFuZ2VzIHNpbmNlIHYzOgotIGZpeGVkIGEgZmV3 IGNvZGluZyBpc3N1ZSBwb2ludGVkIGJ5IFZpdGFseSBLdXpuZXRzb3YgYW5kIERhbiBDYXJwZW50 ZXIKLSBmaXhlZCB0aGUgcmV0IHZhbHVlIGluIHZtYnVzX3JlY3ZwYWNrZXRfaHZzb2NrIG9uIGVy cm9yCi0gZml4ZWQgdGhlIHN0eWxlIG9mIG11bHRpLWxpbmUgY29tbWVudDogdm1idXNfZ2V0X2h2 c29ja19yd19zdGF0dXMoKQoKQ2hhbmdlcyBzaW5jZSB2NCAoaHR0cHM6Ly9sa21sLm9yZy9sa21s LzIwMTUvNy8yOC80MDQpOgotIGFkZHJlc3NlZCBhbGwgdGhlIGNvbW1lbnRzIGFib3V0IFY0Lgot IHRyZWF0IHRoZSBodnNvY2sgb2ZmZXJzL2NoYW5uZWxzIGFzIHNwZWNpYWwgVk1CdXMgZGV2aWNl cwotIGFkZCBhIG1lY2hhbmlzbSB0byBwYXNzIGh2c29jayBldmVudHMgdG8gdGhlIGh2c29jayBk cml2ZXIKLSBmaXhlZCBzb21lIGNvcm5lciBjYXNlcyB3aXRoIHByb3BlciBsb2NraW5nIHdoZW4g YSBjb25uZWN0aW9uIGlzIGNsb3NlZAotIHJlYmFzZWQgdG8gdGhlIGxhdGVzdCBHcmVnJ3MgdHJl ZQoKQ2hhbmdlcyBzaW5jZSB2NSAoaHR0cHM6Ly9sa21sLm9yZy9sa21sLzIwMTUvMTIvMjQvMTAz KToKLSBhZGRyZXNzZWQgdGhlIGNvZGluZyBzdHlsZSBpc3N1ZXMgKFZpdGFseSBLdXpuZXRzb3Yg JiBEYXZpZCBNaWxsZXIsIHRoYW5rcyEpCi0gdXNlZCBhIGJldHRlciBjb2RpbmcgZm9yIHRoZSBw ZXItY2hhbm5lbCByZXNjaW5kIGNhbGxiYWNrIChUaGFuayBWaXRhbHkhKQotIGF2b2lkZWQgdGhl IGludHJvZHVjdGlvbiBvZiBuZXcgVk1CVVMgZHJpdmVyIEFQSXMgdm1idXNfc2VuZHBhY2tldF9o dnNvY2soKQphbmQgdm1idXNfcmVjdnBhY2tldF9odnNvY2soKSBhbmQgdXNlZCB2bWJ1c19zZW5k cGFja2V0KCkvdm1idXNfcmVjdnBhY2tldCgpCmluIHRoZSBoaWdoZXIgbGV2ZWwgKGkuZS4sIHRo ZSB2bXNvY2sgZHJpdmVyKS4gVGhhbmsgVml0YWx5IQoKQ2hhbmdlcyBzaW5jZSB2NiAoaHR0cDov L2xrbWwuaXUuZWR1L2h5cGVybWFpbC9saW51eC9rZXJuZWwvMTYwMS4zLzAxODEzLmh0bWwpCi0g b25seSBhIGZldyBtaW5vciBjaGFuZ2VzIG9mIGNvZGluZyBzdHlsZSBhbmQgY29tbWVudHMKCkNo YW5nZXMgc2luY2UgdjcKLSBhIGZldyBtaW5vciBjaGFuZ2VzIG9mIGNvZGluZyBzdHlsZTogdGhh bmtzLCBKb2UgUGVyY2hlcyEKLSBhZGRlZCBzb21lIGxpbmVzIG9mIGNvbW1lbnRzIGFib3V0IEdV SUQvVVVJRCBiZWZvcmUgdGhlIHN0cnVjdCBzb2NrYWRkcl9odi4KCkNoYW5nZXMgc2luY2UgdjgK LSByZW1vdmVkIHRoZSB1bm5lY2Vzc2FyeSBfX3BhY2tlZCBmb3Igc29tZSBkZWZpbml0aW9uczog dGhhbmtzLCBEYXZpZCEKLSBodnNvY2tfb3Blbl9jb25uZWN0aW9uOiAgdXNlIG9mZmVyLnUucGlw ZS51c2VyX2RlZlswXSB0byBrbm93IHRoZSBjb25uZWN0aW9uCmFuZCByZW9yZ2FuaXplZCB0aGUg ZnVuY3Rpb24KZGlyZWN0aW9uIAotIHJlb3JnYW5pemVkIHRoZSBjb2RlIGFjY29yZGluZyB0byBz dWdnZXN0aW9ucyBmcm9tIENhdGh5IEF2ZXJ5OiBzcGxpdCBiaWcKZnVuY3Rpb25zIGludG8gc21h bGwgb25lcywgc2V0IC5zZXRzb2Nrb3B0IGFuZCBnZXRzb2Nrb3B0IHRvCnNvY2tfbm9fc2V0c29j a29wdC9zb2NrX25vX2dldHNvY2tvcHQKLSBpbmxpbmUnZCBzb21lIHNtYWxsIGxpc3QgaGVscGVy IGZ1bmN0aW9ucwoKQ2hhbmdlcyBzaW5jZSB2OQotIG1pbmltaXplZCBzdHJ1Y3QgaHZzb2NrX3Nv Y2sgYnkgbWFraW5nIHRoZSBzZW5kL3JlY3YgYnVmZmVycyBwb2ludGVycy4KICAgdGhlIGJ1ZmZl cnMgYXJlIGFsbG9jYXRlZCBieSBrbWFsbG9jKCkgaW4gX19odnNvY2tfY3JlYXRlKCkgbm93Lgot IG1pbmltaXplZCB0aGUgc2l6ZXMgb2YgdGhlIHNlbmQvcmVjdiBidWZmZXJzIGFuZCB0aGUgdm1i dXMgcmluZ2J1ZmZlcnMuCgpDaGFuZ2VzIHNpbmNlIHYxMAoKMSkgYWRkIG1vZHVsZSBwYXJhbXM6 IHNlbmRfcmluZ19wYWdlLCByZWN2X3JpbmdfcGFnZS4gVGhleSBjYW4gYmUgdXNlZCB0bwplbmxh cmdlIHRoZSByaW5nYnVmZmVyIHNpemUgdG8gZ2V0IGJldHRlciBwZXJmb3JtYW5jZSwgZS5nLiwK IyBtb2Rwcm9iZSBodl9zb2NrICByZWN2X3JpbmdfcGFnZT0xNiBzZW5kX3JpbmdfcGFnZT0xNgpC eSBkZWZhdWx0LCByZWN2X3JpbmdfcGFnZSBpcyAzIGFuZCBzZW5kX3JpbmdfcGFnZSBpcyAyLgoK MikgYWRkIG1vZHVsZSBwYXJhbSBtYXhfc29ja2V0X251bWJlciAodGhlIGRlZmF1bHQgaXMgMTAy NCkuCkEgdXNlciBjYW4gZW5sYXJnZSB0aGUgbnVtYmVyIHRvIGNyZWF0ZSBtb3JlIHRoYW4gMTAy NCBodl9zb2NrIHNvY2tldHMuCkJ5IGRlZmF1bHQsIDEwMjQgc29ja2V0cyB0YWtlIGFib3V0IDEw MjQgKiAoMysyKzErMSkgKiA0S0IgPSAyOE0gYnl0ZXMuCihIZXJlIDErMSBtZWFucyAxIHBhZ2Ug Zm9yIHNlbmQvcmVjdiBidWZmZXJzIHBlciBjb25uZWN0aW9uLCByZXNwZWN0aXZlbHkuKQoKMykg aW1wbGVtZW50IHRoZSBUT0RPIGluIGh2c29ja19zaHV0ZG93bigpLgoKNCkgZml4IGEgYnVnIGlu IGh2c29ja19jbG9zZV9jb25uZWN0aW9uKCk6CiAgIEkgcmVtb3ZlICJzay0+c2tfc29ja2V0LT5z dGF0ZSA9IFNTX1VOQ09OTkVDVEVEOyIgLS0gYWN0dWFsbHkgdGhpcyBsaW5lCmlzIG5vdCByZWFs bHkgdXNlZnVsLiBGb3IgYSBjb25uZWN0aW9uIHRyaWdnZXJlZCBieSBhIGhvc3QgYXBw4oCZcyBj b25uZWN0KCksCnNrLT5za19zb2NrZXQgcmVtYWlucyBOVUxMIGJlZm9yZSB0aGUgY29ubmVjdGlv biBpcyBhY2NlcHRlZCBieSB0aGUgc2VydmVyCmFwcCAoaW4gTGludXggVk0pOiBzZWUgaHZzb2Nr X2FjY2VwdCgpIC0+IGh2c29ja19hY2NlcHRfd2FpdCgpIC0+CnNvY2tfZ3JhZnQoY29ubmVjdGVk LCBuZXdzb2NrKS4gSWYgdGhlIGhvc3QgYXBwIGV4aXRzIGJlZm9yZSB0aGUgc2VydmVyCmFwcOKA mXMgYWNjZXB0KCkgcmV0dXJucywgdGhlIGhvc3QgY2FuIHNlbmQgYSByZXNjaW5kLW1lc3NhZ2Ug dG8gY2xvc2UgdGhlCmNvbm5lY3Rpb24gYW5kIGxhdGVyIGluIHRoZSBMaW51eCBWTeKAmXMgbWVz c2FnZSBoYW5kbGVyIAppLmUuIHZtYnVzX29ub2ZmZXJfcmVzY2luZCgpKSwgTGludXggd2lsbCBn ZXQgYSBOVUxMIGRlLXJlZmVyZW5jaW5nIGNyYXNoLiAKCjUpIGZpeCBhIGJ1ZyBpbiBodnNvY2tf b3Blbl9jb25uZWN0aW9uKCkKICBJIG1vdmUgdGhlIHZtYnVzX3NldF9jaG5fcmVzY2luZF9jYWxs YmFjaygpIHRvIGEgbGF0ZXIgcGxhY2UsIGJlY2F1c2UKd2hlbiB2bWJ1c19vcGVuKCkgZmFpbHMs IGh2c29ja19jbG9zZV9jb25uZWN0aW9uKCkgY2FuIGRvIG5vdGhpbmcgYW5kIHdlCmNvdW50IG9u IHZtYnVzX29ub2ZmZXJfcmVzY2luZCgpIC0+IHZtYnVzX2RldmljZV91bnJlZ2lzdGVyKCkgdG8g Y2xlYW4gdXAKdGhlIGRldmljZS4KCjYpIHNvbWUgc3R5bGlzdGljIG1vZGlmaWNpYXRpb24uCgpE ZXh1YW4gQ3VpICgxKToKICBodl9zb2NrOiBpbnRyb2R1Y2UgSHlwZXItViBTb2NrZXRzCgogTUFJ TlRBSU5FUlMgICAgICAgICAgICAgICAgIHwgICAgMiArCiBpbmNsdWRlL2xpbnV4L2h5cGVydi5o ICAgICAgfCAgIDE0ICsKIGluY2x1ZGUvbGludXgvc29ja2V0LmggICAgICB8ICAgIDQgKy0KIGlu Y2x1ZGUvbmV0L2FmX2h2c29jay5oICAgICB8ICAgNzggKysrCiBpbmNsdWRlL3VhcGkvbGludXgv aHlwZXJ2LmggfCAgIDI1ICsKIG5ldC9LY29uZmlnICAgICAgICAgICAgICAgICB8ICAgIDEgKwog bmV0L01ha2VmaWxlICAgICAgICAgICAgICAgIHwgICAgMSArCiBuZXQvaHZfc29jay9LY29uZmln ICAgICAgICAgfCAgIDEwICsKIG5ldC9odl9zb2NrL01ha2VmaWxlICAgICAgICB8ICAgIDMgKwog bmV0L2h2X3NvY2svYWZfaHZzb2NrLmMgICAgIHwgMTUyMCArKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrCiAxMCBmaWxlcyBjaGFuZ2VkLCAxNjU3IGluc2VydGlvbnMo KyksIDEgZGVsZXRpb24oLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL25ldC9hZl9odnNv Y2suaAogY3JlYXRlIG1vZGUgMTAwNjQ0IG5ldC9odl9zb2NrL0tjb25maWcKIGNyZWF0ZSBtb2Rl IDEwMDY0NCBuZXQvaHZfc29jay9NYWtlZmlsZQogY3JlYXRlIG1vZGUgMTAwNjQ0IG5ldC9odl9z b2NrL2FmX2h2c29jay5jCgotLSAKMi43LjQKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCmRldmVsIG1haWxpbmcgbGlzdApkZXZlbEBsaW51eGRyaXZlcnBy b2plY3Qub3JnCmh0dHA6Ly9kcml2ZXJkZXYubGludXhkcml2ZXJwcm9qZWN0Lm9yZy9tYWlsbWFu L2xpc3RpbmZvL2RyaXZlcmRldi1kZXZlbAo=