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 Received: from smtp1.osuosl.org (smtp1.osuosl.org [140.211.166.138]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 8905FC4332F for ; Tue, 20 Dec 2022 07:58:56 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp1.osuosl.org (Postfix) with ESMTP id DA5AC819D6; Tue, 20 Dec 2022 07:58:55 +0000 (UTC) DKIM-Filter: OpenDKIM Filter v2.11.0 smtp1.osuosl.org DA5AC819D6 Authentication-Results: smtp1.osuosl.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256 header.s=mimecast20190719 header.b=IzT0KYQG X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp1.osuosl.org ([127.0.0.1]) by localhost (smtp1.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id bvH4RE4R088E; Tue, 20 Dec 2022 07:58:54 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by smtp1.osuosl.org (Postfix) with ESMTPS id 802A581766; Tue, 20 Dec 2022 07:58:53 +0000 (UTC) DKIM-Filter: OpenDKIM Filter v2.11.0 smtp1.osuosl.org 802A581766 Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 3C384C0032; Tue, 20 Dec 2022 07:58:53 +0000 (UTC) Received: from smtp4.osuosl.org (smtp4.osuosl.org [140.211.166.137]) by lists.linuxfoundation.org (Postfix) with ESMTP id 80809C002D for ; Tue, 20 Dec 2022 07:58:52 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp4.osuosl.org (Postfix) with ESMTP id 5FFA2410E6 for ; Tue, 20 Dec 2022 07:58:52 +0000 (UTC) DKIM-Filter: OpenDKIM Filter v2.11.0 smtp4.osuosl.org 5FFA2410E6 Authentication-Results: smtp4.osuosl.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256 header.s=mimecast20190719 header.b=IzT0KYQG X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp4.osuosl.org ([127.0.0.1]) by localhost (smtp4.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 1svSGLJDiZuX for ; Tue, 20 Dec 2022 07:58:49 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.8.0 DKIM-Filter: OpenDKIM Filter v2.11.0 smtp4.osuosl.org A54D040591 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by smtp4.osuosl.org (Postfix) with ESMTPS id A54D040591 for ; Tue, 20 Dec 2022 07:58:49 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1671523128; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=LAkDABgx8HzSx8BPBPDsB4Ty4n30S5ghEZh7HCO2wzg=; b=IzT0KYQG3me5qaRwPUyShgLbcovdK8jeEwb9jU4C/wc/DllbtVIpnILI6VutHAz9AFYXIy DjSIgwLyQQ8huYZAxPOCC75kooGUHmOsfVXs5gQYrSxO10ZzrqsAe1fm5/mGFGT5oPJG/+ IE3VfPtlNXb0xWd72J7bps6T7nLdlXU= Received: from mail-pj1-f69.google.com (mail-pj1-f69.google.com [209.85.216.69]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_128_GCM_SHA256) id us-mta-465-UzNqB0HvMFWCYY-jzKKocw-1; Tue, 20 Dec 2022 02:58:44 -0500 X-MC-Unique: UzNqB0HvMFWCYY-jzKKocw-1 Received: by mail-pj1-f69.google.com with SMTP id q92-20020a17090a17e500b00223b688fe9fso2411182pja.3 for ; Mon, 19 Dec 2022 23:58:44 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:in-reply-to:from:references:cc:to :content-language:subject:user-agent:mime-version:date:message-id :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=LAkDABgx8HzSx8BPBPDsB4Ty4n30S5ghEZh7HCO2wzg=; b=UeEN34KEC5BhuFIKokECLGsKm9mqrUXlnJuVGhAS6zfTGhCFnQbnzyp6lCB/es3MyB /XuDlaJmGwTra4JxcJ9PCaphO0tpd7JdF05g/18VuBle3x7bza3L8fye26H/gW0yzk/1 xtoohEP1wJvXu7qnJXONGzkYBkMRPAl6qq80bG2eIo1Wgh5qgDjHW3GoRf1BAXPUjVxI 55xzHksxX132U3pSGe0VqQ2GsKcoENvNP9cWrTjGAQ+yt9ZmO0LEmlu0GYitziAQ+V2B 9/Uf9sv0tzg/Yy3Pb+/UNitcg/pVWawA7VHH0m6F0KUkfXJebtLKJEyHKOkkDB4BUmmn fSdg== X-Gm-Message-State: AFqh2kr1+oy2uNKhTLWblPDWs+cSjsOi2UpAt1tKDv2lFaH0yF2bpV7K yOLhzQtqUxR2hvk48WCp6iDktcMR3ghgsvc8LeutM7bBCf6F5sETF6/W0wppO/oGKA+T3P3s95x 8xUUzPPGzdfkioq4TPRBtwnm4gsSrmecEMdcrjwVBGA== X-Received: by 2002:a17:903:285:b0:191:3c6:1748 with SMTP id j5-20020a170903028500b0019103c61748mr17185323plr.11.1671523123373; Mon, 19 Dec 2022 23:58:43 -0800 (PST) X-Google-Smtp-Source: AMrXdXtAqcbfM3Erqn1ywAHHC6v158tmWx5cRq2Dpz7SndX4HjltBG84ehvKchcj/dhv1eF4CT10Lg== X-Received: by 2002:a17:903:285:b0:191:3c6:1748 with SMTP id j5-20020a170903028500b0019103c61748mr17185301plr.11.1671523122868; Mon, 19 Dec 2022 23:58:42 -0800 (PST) Received: from [10.72.13.235] ([43.228.180.230]) by smtp.gmail.com with ESMTPSA id z4-20020a1709027e8400b0017d97d13b18sm8599923pla.65.2022.12.19.23.58.38 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 19 Dec 2022 23:58:40 -0800 (PST) Message-ID: <49499671-eef7-0ff1-03c8-e391cc8b225e@redhat.com> Date: Tue, 20 Dec 2022 15:58:33 +0800 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:102.0) Gecko/20100101 Thunderbird/102.6.0 Subject: Re: [PATCH v3 3/4] vdpa: show dev config as-is in "vdpa dev show" output To: Si-Wei Liu , Eli Cohen References: <1666392237-4042-1-git-send-email-si-wei.liu@oracle.com> <1666392237-4042-4-git-send-email-si-wei.liu@oracle.com> <5b9efa3a-8a82-4bd1-a5b4-b9ca5b15b51a@oracle.com> <25a18d7a-ebae-3647-32f0-14ad733118be@oracle.com> <38b9648b-8795-5b41-b06c-d13a1a6d5d3f@redhat.com> From: Jason Wang In-Reply-To: X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Language: en-US Cc: virtualization@lists.linux-foundation.org, linux-kernel@vger.kernel.org, Cindy Lu , mst@redhat.com X-BeenThere: virtualization@lists.linux-foundation.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Linux virtualization List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Errors-To: virtualization-bounces@lists.linux-foundation.org Sender: "Virtualization" CuWcqCAyMDIyLzEwLzI5IDA3OjIzLCBTaS1XZWkgTGl1IOWGmemBkzoKPgo+Cj4gT24gMTAvMjcv MjAyMiAxOjQ3IEFNLCBKYXNvbiBXYW5nIHdyb3RlOgo+PiBPbiBUaHUsIE9jdCAyNywgMjAyMiBh dCAyOjMxIFBNIFNpLVdlaSBMaXUgPHNpLXdlaS5saXVAb3JhY2xlLmNvbT4gCj4+IHdyb3RlOgo+ Pj4KPj4+Cj4+PiBPbiAxMC8yNS8yMDIyIDk6NDQgUE0sIEphc29uIFdhbmcgd3JvdGU6Cj4+Pj4g 5ZyoIDIwMjIvMTAvMjYgMDk6MTAsIFNpLVdlaSBMaXUg5YaZ6YGTOgo+Pj4+Pgo+Pj4+PiBPbiAx MC8yNC8yMDIyIDc6MjQgUE0sIEphc29uIFdhbmcgd3JvdGU6Cj4+Pj4+PiBPbiBUdWUsIE9jdCAy NSwgMjAyMiBhdCAzOjE0IEFNIFNpLVdlaSBMaXU8c2ktd2VpLmxpdUBvcmFjbGUuY29tPgo+Pj4+ Pj4gd3JvdGU6Cj4+Pj4+Pj4gT24gMTAvMjQvMjAyMiAxOjQwIEFNLCBKYXNvbiBXYW5nIHdyb3Rl Ogo+Pj4+Pj4+PiBPbiBTYXQsIE9jdCAyMiwgMjAyMiBhdCA3OjQ5IEFNIFNpLVdlaSBMaXU8c2kt d2VpLmxpdUBvcmFjbGUuY29tPgo+Pj4+Pj4+PiB3cm90ZToKPj4+Pj4+Pj4+IExpdmUgbWlncmF0 aW9uIG9mIHZkcGEgd291bGQgdHlwaWNhbGx5IHJlcXVpcmUgcmUtaW5zdGF0ZSB2ZHBhCj4+Pj4+ Pj4+PiBkZXZpY2Ugd2l0aCBhbiBpZGVudGlhbCBzZXQgb2YgY29uZmlncyBvbiB0aGUgZGVzdGlu YXRpb24gbm9kZSwKPj4+Pj4+Pj4+IHNhbWUgd2F5IGFzIGhvdyBzb3VyY2Ugbm9kZSBjcmVhdGVk IHRoZSBkZXZpY2UgaW4gdGhlIGZpcnN0Cj4+Pj4+Pj4+PiBwbGFjZS4gSW4gb3JkZXIgdG8gc2F2 ZSBvcmNoZXN0cmF0aW9uIHNvZnR3YXJlIGZyb20gbWVtb3JpemluZwo+Pj4+Pj4+Pj4gYW5kIGtl ZXBpbmcgdHJhY2sgb2YgdmRwYSBjb25maWcsIGl0IHdpbGwgYmUgaGVscGZ1bCBpZiB0aGUgdmRw YQo+Pj4+Pj4+Pj4gdG9vbCBwcm92aWRlcyB0aGUgYWlkcyBmb3IgZXhwb3J0aW5nIHRoZSBpbml0 aWFsIGNvbmZpZ3MgYXMtaXMsCj4+Pj4+Pj4+PiB0aGUgd2F5IGhvdyB2ZHBhIGRldmljZSB3YXMg Y3JlYXRlZC4gVGhlICJ2ZHBhIGRldiBzaG93IiBjb21tYW5kCj4+Pj4+Pj4+PiBzZWVtcyB0byBi ZSB0aGUgcmlnaHQgdmVoaWNsZSBmb3IgdGhhdC4gSXQgaXMgdW5saWtlIHRoZSAidmRwYSAKPj4+ Pj4+Pj4+IGRldgo+Pj4+Pj4+Pj4gY29uZmlnIHNob3ciIGNvbW1hbmQgb3V0cHV0IHdoaWNoIHVz dWFsbHkgZ29lcyB3aXRoIHRoZSBsaXZlIAo+Pj4+Pj4+Pj4gdmFsdWUKPj4+Pj4+Pj4+IGluIHRo ZSBkZXZpY2UgY29uZmlnIHNwYWNlLCBhbmQgaXMgbm90IHF1aXRlIHJlbGlhYmxlIHN1YmplY3Qg dG8KPj4+Pj4+Pj4+IHRoZSBkeW5hbWljcyBvZiBmZWF0dXJlIG5lZ290aWF0aW9uIG9yIHBvc3Np YmxlIGNoYW5nZSBieSB0aGUKPj4+Pj4+Pj4+IGRyaXZlciB0byB0aGUgY29uZmlnIHNwYWNlLgo+ Pj4+Pj4+Pj4KPj4+Pj4+Pj4+IEV4YW1wbGVzOgo+Pj4+Pj4+Pj4KPj4+Pj4+Pj4+IDEpIENyZWF0 ZSB2RFBBIGJ5IGRlZmF1bHQgd2l0aG91dCBhbnkgY29uZmlnIGF0dHJpYnV0ZQo+Pj4+Pj4+Pj4K Pj4+Pj4+Pj4+ICQgdmRwYSBkZXYgYWRkIG1nbXRkZXYgcGNpLzAwMDA6NDE6MDQuMiBuYW1lIHZk cGEwCj4+Pj4+Pj4+PiAkIHZkcGEgZGV2IHNob3cgdmRwYTAKPj4+Pj4+Pj4+IHZkcGEwOiB0eXBl IG5ldHdvcmsgbWdtdGRldiBwY2kvMDAwMDo0MTowNC4yIHZlbmRvcl9pZCA1NTU1Cj4+Pj4+Pj4+ PiBtYXhfdnFzIDkgbWF4X3ZxX3NpemUgMjU2Cj4+Pj4+Pj4+PiAkIHZkcGEgZGV2IC1qcCBzaG93 IHZkcGEwCj4+Pj4+Pj4+PiB7Cj4+Pj4+Pj4+PiDCoMKgwqDCoMKgwqAgImRldiI6IHsKPj4+Pj4+ Pj4+IMKgwqDCoMKgwqDCoMKgwqDCoMKgICJ2ZHBhMCI6IHsKPj4+Pj4+Pj4+IMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqAgInR5cGUiOiAibmV0d29yayIsCj4+Pj4+Pj4+PiDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgICJtZ210ZGV2IjogInBjaS8wMDAwOjQxOjA0LjIiLAo+Pj4+Pj4+ Pj4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAidmVuZG9yX2lkIjogNTU1NSwKPj4+Pj4+ Pj4+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgIm1heF92cXMiOiA5LAo+Pj4+Pj4+Pj4g wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAibWF4X3ZxX3NpemUiOiAyNTYsCj4+Pj4+Pj4+ PiDCoMKgwqDCoMKgwqDCoMKgwqDCoCB9Cj4+Pj4+Pj4+PiDCoMKgwqDCoMKgwqAgfQo+Pj4+Pj4+ Pj4gfQo+Pj4+Pj4+Pj4KPj4+Pj4+Pj4+IDIpIENyZWF0ZSB2RFBBIHdpdGggY29uZmlnIGF0dHJp YnV0ZShzKSBzcGVjaWZpZWQKPj4+Pj4+Pj4+Cj4+Pj4+Pj4+PiAkIHZkcGEgZGV2IGFkZCBtZ210 ZGV2IHBjaS8wMDAwOjQxOjA0LjIgbmFtZSB2ZHBhMCBcCj4+Pj4+Pj4+PiDCoMKgwqDCoMKgwqAg bWFjIGU0OjExOmM2OmQzOjQ1OmYwIG1heF92cV9wYWlycyA0Cj4+Pj4+Pj4+PiAkIHZkcGEgZGV2 IHNob3cKPj4+Pj4+Pj4+IHZkcGEwOiB0eXBlIG5ldHdvcmsgbWdtdGRldiBwY2kvMDAwMDo0MTow NC4yIHZlbmRvcl9pZCA1NTU1Cj4+Pj4+Pj4+PiBtYXhfdnFzIDkgbWF4X3ZxX3NpemUgMjU2Cj4+ Pj4+Pj4+PiDCoMKgwqDCoCBpbml0aWFsX2NvbmZpZzogbWFjIGU0OjExOmM2OmQzOjQ1OmYwIG1h eF92cV9wYWlycyA0Cj4+Pj4+Pj4+PiAkIHZkcGEgZGV2IC1qcCBzaG93Cj4+Pj4+Pj4+PiB7Cj4+ Pj4+Pj4+PiDCoMKgwqDCoMKgwqAgImRldiI6IHsKPj4+Pj4+Pj4+IMKgwqDCoMKgwqDCoMKgwqDC oMKgICJ2ZHBhMCI6IHsKPj4+Pj4+Pj4+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgInR5 cGUiOiAibmV0d29yayIsCj4+Pj4+Pj4+PiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgICJt Z210ZGV2IjogInBjaS8wMDAwOjQxOjA0LjIiLAo+Pj4+Pj4+Pj4gwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoCAidmVuZG9yX2lkIjogNTU1NSwKPj4+Pj4+Pj4+IMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqAgIm1heF92cXMiOiA5LAo+Pj4+Pj4+Pj4gwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoCAibWF4X3ZxX3NpemUiOiAyNTYsCj4+Pj4+Pj4+PiDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgICJpbml0aWFsX2NvbmZpZyI6IHsKPj4+Pj4+Pj4+IMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoCAibWFjIjogImU0OjExOmM2OmQzOjQ1OmYwIiwKPj4+Pj4+Pj4+ IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAibWF4X3ZxX3BhaXJzIjogNAo+ Pj4+Pj4+Pj4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB9Cj4+Pj4+Pj4+PiDCoMKgwqDC oMKgwqDCoMKgwqDCoCB9Cj4+Pj4+Pj4+PiDCoMKgwqDCoMKgwqAgfQo+Pj4+Pj4+Pj4gfQo+Pj4+ Pj4+Pj4KPj4+Pj4+Pj4+IFNpZ25lZC1vZmYtYnk6IFNpLVdlaSBMaXU8c2ktd2VpLmxpdUBvcmFj bGUuY29tPgo+Pj4+Pj4+Pj4gLS0tCj4+Pj4+Pj4+PiDCoMKgwqAgZHJpdmVycy92ZHBhL3ZkcGEu YyB8IDM5IAo+Pj4+Pj4+Pj4gKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr Cj4+Pj4+Pj4+PiDCoMKgwqAgMSBmaWxlIGNoYW5nZWQsIDM5IGluc2VydGlvbnMoKykKPj4+Pj4+ Pj4+Cj4+Pj4+Pj4+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy92ZHBhL3ZkcGEuYyBiL2RyaXZlcnMv dmRwYS92ZHBhLmMKPj4+Pj4+Pj4+IGluZGV4IGJlYmRlZDYuLmJmYjhmNTQgMTAwNjQ0Cj4+Pj4+ Pj4+PiAtLS0gYS9kcml2ZXJzL3ZkcGEvdmRwYS5jCj4+Pj4+Pj4+PiArKysgYi9kcml2ZXJzL3Zk cGEvdmRwYS5jCj4+Pj4+Pj4+PiBAQCAtNjc3LDYgKzY3Nyw0MSBAQCBzdGF0aWMgaW50Cj4+Pj4+ Pj4+PiB2ZHBhX25sX2NtZF9kZXZfZGVsX3NldF9kb2l0KHN0cnVjdCBza19idWZmICpza2IsIHN0 cnVjdAo+Pj4+Pj4+Pj4gZ2VubF9pbmZvICppCj4+Pj4+Pj4+PiDCoMKgwqAgfQo+Pj4+Pj4+Pj4K Pj4+Pj4+Pj4+IMKgwqDCoCBzdGF0aWMgaW50Cj4+Pj4+Pj4+PiArdmRwYV9kZXZfaW5pdGNmZ19m aWxsKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRldiwgc3RydWN0IHNrX2J1ZmYKPj4+Pj4+Pj4+ICpt c2csIHUzMiBkZXZpY2VfaWQpCj4+Pj4+Pj4+PiArewo+Pj4+Pj4+Pj4gK8KgwqDCoMKgwqDCoCBz dHJ1Y3QgdmRwYV9kZXZfc2V0X2NvbmZpZyAqY2ZnID0gJnZkZXYtPmluaXRfY2ZnOwo+Pj4+Pj4+ Pj4gK8KgwqDCoMKgwqDCoCBpbnQgZXJyID0gLUVNU0dTSVpFOwo+Pj4+Pj4+Pj4gKwo+Pj4+Pj4+ Pj4gK8KgwqDCoMKgwqDCoCBpZiAoIWNmZy0+bWFzaykKPj4+Pj4+Pj4+ICvCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgIHJldHVybiAwOwo+Pj4+Pj4+Pj4gKwo+Pj4+Pj4+Pj4gK8KgwqDCoMKg wqDCoCBzd2l0Y2ggKGRldmljZV9pZCkgewo+Pj4+Pj4+Pj4gK8KgwqDCoMKgwqDCoCBjYXNlIFZJ UlRJT19JRF9ORVQ6Cj4+Pj4+Pj4+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBpZiAo KGNmZy0+bWFzayAmCj4+Pj4+Pj4+PiBCSVRfVUxMKFZEUEFfQVRUUl9ERVZfTkVUX0NGR19NQUNB RERSKSkgIT0gMCAmJgo+Pj4+Pj4+Pj4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoCBubGFfcHV0KG1zZywgVkRQQV9BVFRSX0RFVl9ORVRfQ0ZHX01BQ0FERFIsCj4+Pj4+Pj4+ PiArIHNpemVvZihjZmctPm5ldC5tYWMpLCBjZmctPm5ldC5tYWMpKQo+Pj4+Pj4+Pj4gK8KgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHJldHVybiBlcnI7Cj4+Pj4+ Pj4+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBpZiAoKGNmZy0+bWFzayAmCj4+Pj4+ Pj4+PiBCSVRfVUxMKFZEUEFfQVRUUl9ERVZfTkVUX0NGR19NVFUpKSAhPSAwICYmCj4+Pj4+Pj4+ PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIG5sYV9wdXRfdTE2KG1zZywg VkRQQV9BVFRSX0RFVl9ORVRfQ0ZHX01UVSwKPj4+Pj4+Pj4+IGNmZy0+bmV0Lm10dSkpCj4+Pj4+ Pj4+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgcmV0dXJu IGVycjsKPj4+Pj4+Pj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGlmICgoY2ZnLT5t YXNrICYKPj4+Pj4+Pj4+IEJJVF9VTEwoVkRQQV9BVFRSX0RFVl9ORVRfQ0ZHX01BWF9WUVApKSAh PSAwICYmCj4+Pj4+Pj4+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIG5s YV9wdXRfdTE2KG1zZywgCj4+Pj4+Pj4+PiBWRFBBX0FUVFJfREVWX05FVF9DRkdfTUFYX1ZRUCwK Pj4+Pj4+Pj4+ICsgY2ZnLT5uZXQubWF4X3ZxX3BhaXJzKSkKPj4+Pj4+Pj4+ICvCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCByZXR1cm4gZXJyOwo+Pj4+Pj4+Pj4g K8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgYnJlYWs7Cj4+Pj4+Pj4+PiArwqDCoMKgwqDC oMKgIGRlZmF1bHQ6Cj4+Pj4+Pj4+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBicmVh azsKPj4+Pj4+Pj4+ICvCoMKgwqDCoMKgwqAgfQo+Pj4+Pj4+Pj4gKwo+Pj4+Pj4+Pj4gK8KgwqDC oMKgwqDCoCBpZiAoKGNmZy0+bWFzayAmIEJJVF9VTEwoVkRQQV9BVFRSX0RFVl9GRUFUVVJFUykp ICE9IDAgJiYKPj4+Pj4+Pj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoCBubGFfcHV0X3U2NF82NGJp dChtc2csIFZEUEFfQVRUUl9ERVZfRkVBVFVSRVMsCj4+Pj4+Pj4+PiArIGNmZy0+ZGV2aWNlX2Zl YXR1cmVzLCBWRFBBX0FUVFJfUEFEKSkKPj4+Pj4+Pj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgIHJldHVybiBlcnI7Cj4+Pj4+Pj4+IEEgcXVlc3Rpb246IElmIGFueSBvZiB0aG9zZSBh Ym92ZSBhdHRyaWJ1dGVzIHdlcmUgbm90IHByb3Zpc2lvbmVkLAo+Pj4+Pj4+PiBzaG91bGQgd2Ug c2hvdyB0aGUgb25lcyB0aGF0IGFyZSBpbmhlcml0ZWQgZnJvbSB0aGUgcGFyZW50Pwo+Pj4+Pj4+ IEEgc2ltcGxlIGFuc3dlciB3b3VsZCBiZSB5ZXMsIGJ1dCB0aGUgbG9uZyBhbnN3ZXIgaXMgdGhh dCBJIGFtIG5vdAo+Pj4+Pj4+IHN1cmUKPj4+Pj4+PiBpZiB0aGVyZSdzIGFueSBmb3IgdGhlIG1v bWVudCAtIHRoZXJlJ3Mgbm/CoCBkZWZhdWx0IHZhbHVlIGZvciBtdHUsCj4+Pj4+Pj4gbWFjLAo+ Pj4+Pj4+IGFuZCBtYXhfdnFwIHRoYXQgY2FuIGJlIGluaGVyaXRlZCBmcm9tIHRoZSBwYXJlbnQg KG1heF92cXAgYnkgCj4+Pj4+Pj4gZGVmYXVsdAo+Pj4+Pj4+IGJlaW5nIDEgaXMgc3BlYyBkZWZp bmVkLCBub3Qgc29tZXRoaW5nIGluaGVyaXRlZCBmcm9tIHRoZSBwYXJlbnQpLgo+Pj4+Pj4gTm90 ZSB0aGF0IGl0IGlzIGJ5IGRlZmF1bHQgZnJvbSBkcml2ZXIgbGV2ZWwgdGhhdCBpZiBfRl9NUSBp cyBub3QKPj4+Pj4+IG5lZ290aWF0ZWQuIEJ1dCBJIHRoaW5rIHdlIGFyZSB0YWxraW5nIGFib3V0 IHNvbWV0aGluZyBkaWZmZXJlbnQgCj4+Pj4+PiB0aGF0Cj4+Pj4+PiBpcyBvdXQgb2YgdGhlIHNw ZWMgaGVyZSwgd2hhdCBpZjoKPj4+Pj4+Cj4+Pj4+PiB2RFBBIGluaGVyaXQgX0ZfTVEgYnV0IG1x eF92cXAgaXMgbm90IHByb3Zpc2lvbmVkIHZpYSBuZXRsaW5rLgo+Pj4+Pj4KPj4+Pj4+IE9yIGlz IGl0IG5vdCBhbGxvd2VkPwo+Pj4+PiBNeSB1bmRlcnN0YW5kaW5nIGlzIHRoYXQgdGhpcyBpcyBu b3QgYWxsb3dlZCBhbnkgbW9yZSBzaW5jZSB0aGUKPj4+Pj4gaW50cm9kdWN0aW9uIG9mIG1heF92 cXAgYXR0cmlidXRlLiBOb3RlZCwgY3VycmVudGx5IHdlIGRvbid0IGhhdmUgYQo+Pj4+PiB3YXkg Zm9yIHZlbmRvciBkcml2ZXIgdG8gcmVwb3J0IHRoZSBkZWZhdWx0IHZhbHVlIGZvciBtcXhfdnFw LAo+Pj4+Cj4+Pj4gSSB0aGluayBpdCBjYW4gYmUgcmVwb3J0ZWQgaW4gdGhpcyBwYXRjaD8KPj4+ IFllcywgd2UgY2FuIGFkZCwgYnV0IEkgYW0gbm90IHN1cmUgd2hldGhlciBvciBub3QgdGhpcyB3 aWxsIGJlCj4+PiBwcmFjdGljYWxseSB1c2VmdWwsIGZvciBlLmcuIHRoZSBzYW1lIGNvbW1hbmQg d2l0aG91dCBtYXhfdnFwIHNwZWNpZmllZAo+Pj4gbWF5IHJlbmRlciBkaWZmZXJlbnQgbnVtYmVy IG9mIHF1ZXVlcyBhY3Jvc3MgZGlmZmVyZW50IGRldmljZXMsIG9yCj4+PiBkaWZmZXJlbnQgcmV2 aXNpb25zIG9mIHRoZSBzYW1lIHZlbmRvcidzIGRldmljZXMuIERvZXMgaXQgY29tcGxpY2F0ZSAK Pj4+IHRoZQo+Pj4gbWdtdCBzb2Z0d2FyZSBldmVuIG1vcmUsIEknbSBub3Qgc3VyZS4uLi4KPj4g SXQgZGVwZW5kcyBvbiB0aGUgdXNlIGNhc2UsIGUuZyBpZiB3ZSB3YW50IHRvIGNvbXBhcmUgdGhl IG1pZ3JhdGlvbgo+PiBjb21wYXRpYmlsaXR5LCBoYXZpbmcgYSBzaW5nbGUgdmRwYSBjb21tYW5k IHF1ZXJ5IGlzIG11Y2ggZWFzaWVyIHRoYW4KPj4gaGF2aW5nIHR3byBvciBtb3JlLgo+IFllcCBJ IGFncmVlLiBJIHdhcyBzYXlpbmcgbm90IHZlcnkgYXR0cmlidXRlIHdvdWxkIG5lZWQgdG8gYmUg Cj4gaW5oZXJpdGVkIGZyb20gdGhlIHBhcmVudCBkZXZpY2UuIEFjdHVhbGx5IGF0dHJpYnV0ZXMg bGlrZSBtYXhfdnFwIAo+IGNvdWxkIHRha2UgdGhlIGRlZmF1bHQgZnJvbSBzb21lIGNvbW1vbiBw bGFjZSBmb3IgZS5nLiBzb21lIGRlZmF1bHQgCj4gdmFsdWUgY2FuIGJlIGFwcGxpZWQgYnkgdmRw YSBjb3JlLiBBbmQgd2UgY2FuIGRvY3VtZW50IHRoZXNlIAo+IGF0dHJpYnV0ZXMgcnVsZWQgYnkg dmRwYSBjb3JlIGluIHZkcGEtZGV2KDgpIG1hbiBwYWdlLiBSZWR1Y2UgdGhlIAo+IGV4dHJhIGNh bGwgb2YgaGF2aW5nIG1nbXQgc29mdHdhcmUgaXNzdWUgYW5vdGhlciBxdWVyeSBjb21tYW5kIHdo aWNoIAo+IGFjdHVhbGx5IGRvZXNuJ3QgbmVlZCB0by4KPgo+Pgo+Pj4gQ291bGQgd2UgaW5zdGVh ZCBtYW5kYXRlCj4+PiBtYXhfdnFwIHRvIGJlIDEgZnJvbSB2ZHBhIGNvcmUgbGV2ZWwgaWYgdXNl ciBkb2Vzbid0IGV4cGxpY2l0bHkgc3BlY2lmeQo+Pj4gdGhlIHZhbHVlPwo+PiBUaGlzIHNlZW1z IHRvIGJlIG5vdCBlYXN5LCBhdCBsZWFzdCBub3QgZWFzeSBpbiB0aGUgdkRQQSBjb3JlLgo+IFdl IGNhbiBsb2FkIHRoZXNlIGRlZmF1bHQgdmFsdWVzIGZyb20gdmRwYV9ubF9jbWRfZGV2X2FkZF9z ZXRfZG9pdCgpIAo+IGJlZm9yZSBvcHMtPmRldl9hZGQgaXMgY2FsbGVkLiBJIGNhbiBwb3N0IGEg djMgdGhhdCBzaG93cyB0aGUgY29kZSwgaXQgCj4gc2hvdWxkbid0IGJlIHRvbyBoYXJkLgoKCk9r LCBhbmQgSSB3b25kZXIgaWYgaXQncyB0aW1lIHRvIG1vdmUgbmV0bGluayBzcGVjaWZpYyBjb2Rl IGludG8gYSAKZGVkaWNhdGVkIGZpbGUuCgoKPgo+PiDCoCBXZSBjYW4KPj4gcHJvYmFibHkgZG9j dW1lbnQgdGhpcyBzb21ld2hlcmUgYnV0IG1heF92cXAgaXMgb25seSBvbmUgZXhhbXBsZSwgd2UK Pj4gaGF2ZSBvdGhlciBtcSBkZXZpY2VzIGxpa2UgYmxvY2svU0NTSS9jb25zb2xlLgo+IEFjdHVh bGx5IG1heF92cXAgaXMgYSBuZXR3b3JrIGRldmljZSBzcGVjaWZpYyBjb25maWcgdG8gcHJvdmlz aW9uIG1xIAo+IGRldmljZXMuIElmIHRoZSBwYXJlbnQgbWdtdGRldiBzdXBwb3J0cyBuZXQgdmRw YSBkZXZpY2UgY3JlYXRpb24gYW5kIAo+IHVzZXIgcmVxdWVzdHMgdG8gcHJvdmlzaW9uIF9GX01R IHdpdGggbm8gc3VwcGxpZWQgbWF4X3ZxcCB2YWx1ZSwgd2UgCj4gc2hvdWxkIGxvYWQgc29tZSBn bG9iYWwgZGVmYXVsdCB2YWx1ZSB0aGVyZS4KPgo+Pgo+Pj4gVGhhdCB3YXkgaXQgaXMgbW9yZSBj b25zaXN0ZW50IGluIHRlcm1zIG9mIHRoZSByZXN1bHRpbmcKPj4+IG51bWJlciBvZiBxdWV1ZSBw YWlycyAoPTEpIHdpdGggdGhlIGNhc2Ugd2hlcmUgcGFyZW50IGRldmljZSBkb2VzIG5vdAo+Pj4g b2ZmZXIgdGhlIF9GX01RIGZlYXR1cmUuCj4+IFJpZ2h0LCBidXQgYSBjb3JuZXIgY2FzZSBpcyB0 byBwcm92aXNpb24gX0ZfTVEgYnV0IHdpdGhvdXQgbWF4X3ZxcC4KPiBZZXMsIEkgd2lsbCBwb3N0 IHRoZSBwYXRjaCB0aGF0IHN1cHBvcnRzIHRoaXMuCj4+Cj4+Pj4KPj4+Pj4gaWYgbm90IG90aGVy d2lzZSBzcGVjaWZpZWQgaW4gdGhlIENMSS4gV2l0aG91dCBnZXR0aW5nIHRoZSBkZWZhdWx0Cj4+ Pj4+IHZhbHVlIHJlcG9ydGVkIGluICd2ZHBhIG1nbXRkZXYgc2hvdycgbGV2ZWwsIGl0J2QganVz dCBjb25mdXNlIG1nbXQKPj4+Pj4gc29mdHdhcmUgZXZlbiBtb3JlLgo+Pj4+Cj4+Pj4gWWVzLCB0 aGlzIGlzIHNvbWV0aGluZyB0aGF0IHdlIG5lZWQgdG8gZml4LiBBbmQgd2hhdCdzIG1vcmUgaW4g b3JkZXIKPj4+PiB0byBzdXBwb3J0IGR5bmFtaWMgcHJvdmlzaW9uaW5nLCB3ZSBuZWVkIGEgd2F5 IHRvIHJlcG9ydCB0aGUgbnVtYmVyIG9mCj4+Pj4gYXZhaWxhYmxlIGluc3RhbmNlcyB0aGF0IGNv dWxkIGJlIHVzZWQgZm9yIHZEUEEgZGV2aWNlIHByb3Zpc2lvbmluZy4KPj4+IFdvdWxkbid0IGl0 IGJlIHBvc3NpYmxlIHRvIGFjaGlldmUgdGhhdCBieSBzaW1wbHkgY2hlY2tpbmcgaG93IG1hbnkK Pj4+IHBhcmVudCBtZ210ZGV2IGluc3RhbmNlcyBkb24ndCBoYXZlIHZkcGEgZGV2aWNlIHByb3Zp c2lvbmVkIHlldD8gZS5nLgo+Pj4KPj4+IGludXNlPSQodmRwYSBkZXYgc2hvdyB8IGdyZXAgbWdt dGRldiB8IHdjIC1sKQo+Pj4gdG90YWw9JCh2ZHBhIG1nbXRkZXYgc2hvd8KgIHwgZ3JlcCAic3Vw cG9ydGVkX2NsYXNzZXMiIHwgd2MgLWwgKQo+Pj4gZWNobyAkKCh0b3RhbCAtIGludXNlKSkKPj4g SSBtZWFudCBob3cgbWFueSBhdmFpbGFibGUgdkRQQSBkZXZpY2VzIHRoYXQgYXJlIGF2YWlsYWJs ZSBmb3IgdGhlCj4+IG1nbXQgdG8gY3JlYXRlPwo+IE9oIEkgc2VlLgo+Cj4+Cj4+IEUuZyBpbiB0 aGUgY2FzZSBvZiBzdWIgZnVuY3Rpb24gb3Igc2ltdWxhdG9yIGEgbWdtdGRldiBjYW4gY3JlYXRl IG1vcmUKPj4gdGhhbiAxIHZkcGEgZGV2aWNlcy4KPiBEb2VzIHRoZSBzdWIgZnVuY3Rpb24gdG9k YXkgc3VwcG9ydHMgY3JlYXRpb24gb2YgbXVsdGlwbGUgdkRQQSAKPiBpbnN0YW5jZSBwZXIgbWdt dGRldj8KCgpJIHRoaW5rIHNvLCBvdGhlcndpc2UgU0YgZG9lc24ndCBtYWtlIHRvbyBtdWNoIHNl bnNlLgoKCj4gU29tZXRoaW5nIEkgd2Fzbid0IGF3YXJlIG9mIGJlZm9yZS4gSXMgaXQgd2l0aCBk aWZmZXJlbnQgZGV2aWNlIGNsYXNzPwoKCkl0IHNob3VsZCBiZSBwb3NzaWJsZSAobm8gbGltaXRh dGlvbiBpbiB0aGUgdmRwYSBjb3JlIGF0IGxlYXN0KS4gRWFjaCAKZGV2aWNlIGNsYXNzIHNob3Vs ZCByZWdpc3RlciBpdHMgb3duIG1nbXRkZXYuCgoKPgo+Pgo+Pj4+Cj4+Pj4+PiDCoMKgwqAgQXQg bGVhc3Qgc29tZSB0aW1lIGluIHRoZSBwYXN0LCBtbHg1IHdlcmUKPj4+Pj4+IGVuYWJsZWQgd2l0 aCBNUSB3aXRoIDggcXVldWUgcGFpcnMgYnkgZGVmYXVsdC4KPj4+Pj4gVGhhdCB3YXMgdGhlIHNp dHVhdGlvbiB3aGVuIHRoZXJlJ3Mgbm8gbWF4X3ZxcCBhdHRyaWJ1dGUgc3VwcG9ydCBmcm9tCj4+ Pj4+IHZkcGEgbmV0bGluayBBUEkgbGV2ZWwuIEkgdGhpbmsgbm93IGV2ZXJ5IGRyaXZlciBob25v cnMgdGhlIHZkcGEgY29yZQo+Pj4+PiBkaXNwb3NpdGlvbiB0byBnZXQgYSBzaW5nbGUgcXVldWUg cGFpciBpZiBtYXhfdnFwIGNvbmZpZyBpcyBtaXNzaW5nLgo+Pj4+IFNvIHdlIGhhdmU6Cj4+Pj4K Pj4+PiBpbnQgdmRwYV9yZWdpc3Rlcl9kZXZpY2Uoc3RydWN0IHZkcGFfZGV2aWNlICp2ZGV2LCBp bnQgbnZxcykKPj4+Pgo+Pj4+IFRoaXMgbWVhbnMgdGVjaG5pY2FsbHksIHBhcmVudCBjYW4gYWxs b2NhdGUgYSBtdWx0aXF1ZXVlIGRldmljZXMgd2l0aAo+Pj4+IF9GX01RIGZlYXR1cmVzIGlmIG1h eF92cXAgYW5kIGRldmljZV9mZWF0dXJlcyBpcyBub3QgcHJvdmlzaW9uZWQuIEFuZAo+Pj4+IHdo YXQncyBtb3JlLCB3aGF0IGhhcHBlbnMgaWYgX0ZfTVEgaXMgcHJvdmlzaW9uZWQgYnkgbWF4X3Zx cCBpcyBub3QKPj4+PiBzcGVjaWZpZWQ/Cj4+Pj4KPj4+PiBUaGUgcXVlc3Rpb24gaXM6Cj4+Pj4K Pj4+PiBXaGVuIGEgYXR0cmlidXRlIGlzIG5vdCBzcGVjaWZpY2VkL3Byb3Zpc2lvbmVkIHZpYSBu ZXQgbGluaywgd2hhdCdzCj4+Pj4gdGhlIGRlZmF1bHQgdmFsdWU/IFRoZSBhbnN3ZXIgc2hvdWxk IGJlIGNvbnNpc3RlbnQ6IGlmIGRldmljZV9mZWF0dXJlcwo+Pj4+IGlzIGRldGVybWluZWQgYnkg dGhlIHBhcmVudCwgd2Ugc2hvdWxkIGRvIHRoZSBzYW1lIGZvciBtcXhfdnFwLgo+Pj4gT0sgSSBn b3QgeW91ciBwb2ludC4KPj4+Cj4+Pj4gQW5kIGl0IGxvb2tzIHRvIG1lIGFsbCBvZiB0aG9zZSBi ZWxvbmdzIHRvIHRoZSBpbml0aWFsIGNvbmZpZwo+Pj4+IChzZWxmLWNvbnRhaW5lZCkKPj4+IFJp Z2h0LiBJIHdvbmRlciBpZiB3ZSBjYW4gaGF2ZSB2ZHBhIGNvcmUgZGVmaW5lIHRoZSBkZWZhdWx0 IHZhbHVlIChmb3IKPj4+IGUuZy4gbWF4X3ZxcD0xKSBmb3IgdGhvc2UgdW5zcGVjaWZpZWQgYXR0 cmlidXRlIChlc3AuIHdoZW4gdGhlCj4+PiBjb3JyZXNwb25kaW5nIGRldmljZSBmZWF0dXJlIGlz IG9mZmVyZWQgYW5kIHByb3Zpc2lvbmVkKSB3aGVuZXZlcgo+Pj4gcG9zc2libGUuIFdoaWNoIEkg dGhpbmsgaXQnbGwgYmUgbW9yZSBjb25zaXN0ZW50IGZvciB0aGUgc2FtZSAKPj4+IGNvbW1hbmQg dG8KPj4+IGdldCB0byB0aGUgc2FtZSByZXN1bHQgYmV0d2VlbiBkaWZmZXJlbnQgdmVuZG9yIGRy aXZlcnMuIFdoaWxlIHdlIHN0aWxsCj4+PiBrZWVwIHRoZSBwb3NzaWJpbGl0eSBmb3IgZnV0dXJl IGV4dGVuc2lvbiB0byBhbGxvdyBkcml2ZXIgb3ZlcnJpZGUgdGhlCj4+PiB2ZHBhIGNvcmUgZGlz cG9zaXRpb24gaWYgdGhlIHJlYWwgdXNlIGNhc2UgZW1lcmdlcy4gV2hhdCBkbyB5b3UgdGhpbms/ Cj4+IFRoYXQncyBwb3NzaWJsZSBidXQgd2UgbWF5IGVuZCB1cCB3aXRoIGRldmljZSBzcGVjaWZp YyBjb2RlIGluIHRoZQo+PiB2RFBBIGNvcmUgd2hpY2ggaXMgbm90IGVsZWdhbnQsIGFuZCB0aGUg Y29kZSB3aWxsIGdyb3cgYXMgdGhlIG51bWJlcgo+PiBvZiBzdXBwb3J0ZWQgdHlwZXMgZ3Jvd3Mu Cj4gSSBndWVzcyB0aGF0J3MgdW5hdm9pZGFibGUgYXMgdGhpcyBpcyBhbHJlYWR5IHRoZSBjYXNl IHRvZGF5LiBTZWUgCj4gdmFyaW91cyBWSVJUSU9fSURfTkVUIGNhc2Ugc3dpdGNoIGluIHRoZSB2 ZHBhLmMgY29kZS4gSSB0aGluayB0eXBlIAo+IHNwZWNpZmljIGNvZGUganVzdCBsaW1pdHMgaXRz ZWxmIHRvIHRoZSBuZXRsaW5rIEFQSSBpbnRlcmZhY2luZyBsYXllciAKPiByYXRoZXIgdGhhbiBk b3duIHRvIHRoZSBkcml2ZXIgQVBJLCBpdCBtaWdodCBiZSBqdXN0IG9rYXkgKGFzIHRoYXQncyAK PiBhbHJlYWR5IHRoZSBjYXNlKS4KPgo+Pgo+PiBOb3RlIHRoYXQsIG1heF92cXAgaXMgbm90IHRo ZSBvbmx5IGF0dHJpYnV0ZSB0aGF0IG1heSBzdWZmZXIgZnJvbQo+PiB0aGlzLCBiYXNpY2FsbHkg YW55IGNvbmZpZyBmaWVsZCB0aGF0IGRlcGVuZHMgb24gYSBzcGVjaWZpYyBmZWF0dXJlCj4+IGJp dCBtYXkgaGF2ZSB0aGUgc2FtZSBpc3N1ZS4KPj4KPj4+Pgo+Pj4+PiBBbmQgdGhlIG1seDVfdmRw YSBkcml2ZXIgd2l0aCA4IHF1ZXVlIHBhaXJzIGluIHRoZSB3aWxkIGRheXMgaXMganVzdAo+Pj4+ PiBpcnJlbGV2YW50IHRvIGJlIG1hbmFnZWFibGUgYnkgbWdtdCBzb2Z0d2FyZSwgcmVnYXJkbGVz cyBvZiBsaXZlCj4+Pj4+IG1pZ3JhdGlvbi4KPj4+Pj4+PiBBbmQKPj4+Pj4+PiB0aGUgZGV2aWNl X2ZlYXR1cmVzIGlmIGluaGVyaXRlZCBpcyBkaXNwbGF5ZWQgYXQgJ3ZkcGEgZGV2IGNvbmZpZwo+ Pj4+Pj4+IHNob3cnCj4+Pj4+Pj4gb3V0cHV0LiBDYW4geW91IHJlbWluZCBtZSBvZiBhIGdvb2Qg ZXhhbXBsZSBmb3IgaW5oZXJpdGVkIHZhbHVlCj4+Pj4+Pj4gdGhhdCB3ZQo+Pj4+Pj4+IG1heSB3 YW50IHRvIHNob3cgaGVyZT8KPj4+Pj4+IFNvbWUgb3RoZXIgY2FzZXM6Cj4+Pj4+Pgo+Pj4+Pj4g MSkgTVRVOiB0aGVyZSBzaG91bGQgYmUgc29tZXRoaW5nIHRoYXQgdGhlIGRldmljZSBuZWVkcyB0 byByZXBvcnQgaWYKPj4+Pj4+IF9GX01UVSBpcyBuZWdvdGlhdGVkIGV2ZW4gaWYgaXQgaXMgbm90 IHByb3Zpc2lvbmVkIGZyb20gbmV0bGluay4KPj4+Pj4gSSBhbSBub3Qgc3VyZSBJIHVuZGVyc3Rh bmQgdGhlIGFzayBoZXJlLiBOb3RlZCB0aGUgUUVNVSBhcmd1bWVudCBoYXMKPj4+Pj4gdG8gb2Zm ZXIgaG9zdF9tdHU9WCB3aXRoIHRoZSBtYXhpbXVtIE1UVSB2YWx1ZSBmb3IgZ3Vlc3QgdG8gdXNl IChhbmQKPj4+Pj4gYXBwbGllZCBhcyB0aGUgaW5pdGlhbCBNVFUgY29uZmlnIGR1cmluZyB2aXJ0 aW8tbmV0IHByb2JpbmcgZm9yIExpbnV4Cj4+Pj4+IGRyaXZlciksCj4+Pj4KPj4+PiBBZGRpbmcg Q2luZHkuCj4+Pj4KPj4+PiBJIHRoaW5rIGl0J3MgYSBrbm93biBpc3N1ZSB0aGF0IHdlIG5lZWQg dG8gZG8gc2FuaXR5IGNoZWNrIHRvIG1ha2UKPj4+PiBzdXJlIGNsaSBwYXJhbWV0ZXJzIG1hdGNo ZXMgd2hhdCBpcyBwcm92aXNpb25lZCBmcm9tIG5ldGxpbmsuCj4+PiBSaWdodC4gSG93J3MgdGhl IHBsYW4gZm9yIFFFTVUgdG8gZ2V0IHRvIHRoZSBtdHUgcHJvdmlzaW9uZWQgYnkgCj4+PiBuZXRs aW5rLAo+Pj4gdmlhIGEgbmV3IHZob3N0LXZkcGEgaW9jdGwgY2FsbD8KPj4gSSB0aGluayBuZXRs aW5rIGlzIG5vdCBkZXNpZ25lZCBmb3IgcWVtdSB0byB1c2UsIHRoZSBkZXNpZ24gaXMgdG8KPj4g ZXhwb3NlIGEgdmhvc3QgZGV2aWNlIHRvIFFlbXUuCj4+Cj4+PiBJZiBzbywgd2lsbMKgIFFFTVUg YmUgYWJsZSB0byByZWFkIGl0Cj4+PiBkaXJlY3RseSBmcm9tIGtlcm5lbCB3aGVuIGl0IGNvbWVz IHRvIHRoZSB2aG9zdC12ZHBhIGJhY2tlbmQsIHdpdGhvdXQKPj4+IGhhdmluZyB1c2VyIHRvIHNw ZWNpZnkgaG9zdF9tdHUgZnJvbSBDTEk/Cj4+IEknbSBub3Qgc3VyZSBJIGdldCB0aGUgcXVlc3Rp b24sIGJ1dCBRZW11IHNob3VsZCBnZXQgdGhpcyB2aWEgY29uZmlnCj4+IHNwYWNlIChvdGhlcndp c2UgaXQgc2hvdWxkIGJlIGEgYnVnKS4KPiBJdCdzIGhhcmQgZm9yIFFFTVUgdG8gd29yayB0aGlz IHdheSB3aXRoIHRoZSBleGlzdGluZyBnZXRfY29uZmlnKCkgb3BzIAo+IEkgdGhpbmssIGFzIGl0 IGhhcyBhc3N1bXB0aW9uIGFyb3VuZCBlbmRpYW5uZXNzIGFuZCBmZWF0dXJlIAo+IG5lZ290aWF0 aW9uLCB1bnRpbCB0aGUgbGF0dGVyIGlzIGRvbmUgeW91IGNhbid0IGdldCBhbnkgcmVsaWFibGUg dmFsdWUgCj4gZm9yIHByb3Zpc2lvbmVkIHByb3BlcnR5LiBJIHRoaW5rIFFFTVUgd2hpY2ggbmVl ZCB0byB2YWxpZGF0ZSB0aGUgCj4gcHJvdmlzaW9uZWQgdmFsdWUgd2F5IGVhcmxpZXIgKHdoZW4g UUVNVSBpcyBsYXVuY2hlZCksIGJlZm9yZSAKPiBuZWdvdGlhdGlvbiBraWNrcyBpbi4gSXQgd291 bGQgYmUgY2xlYXJuZXIgdG8gdXNlIGFub3RoZXIgdmhvc3QgYW5kIGEgCj4gbmV3IHZkcGEgZHJp dmVyIG9wcyB0byByZXRyaWV2ZSB0aGUgcHJvdmlzaW9uZWQgZmVhdHVyZSBjb25maWcgdmFsdWVz IAo+IGZyb20gdmVuZG9yIGRyaXZlcnMuCj4KPj4gwqAgQW5kIFFlbXUgbmVlZCB0byB2ZXJpZnkg dGhlIG10dQo+PiBnb3QgZnJvbSBjbGkgdnMgdGhlIG10dSBnb3QgZnJvbSB2aG9zdCBhbmQgZmFp bCB0aGUgZGV2aWNlCj4+IGluaXRpYWxpemF0aW9uIGlmIHRoZXkgZG9uJ3QgbWF0Y2guCj4gSSBt ZWFuIHRvZGF5IHRoZXJlJ3MgYSBwcm9ibGVtIGZvciBkb3VibGUgcHJvdmlzaW9uaW5nOiBmb3Ig ZS5nLiBtdHUgCj4gaGFzIHRvIGJlIGZpcnN0IHByb3ZpZGVkIGluIHRoZSAndmRwYSBkZXYgYWRk JyBjb21tYW5kIHdoZW4gdG8gCj4gcHJvdmlzaW9uIF9GX01UVSwgaW4gUUVNVSBDTEkgdGhlIHNh bWUgdmFsdWUgaGFzIHRvIGJlIHN1cHBsaWVkIHRvIAo+IGhvc3RfbXR1LiBUaGUgc2FtZSBhcHBs aWVzIHRvIG1hYyBhZGRyZXNzLiBJdCB3b3VsZCBiZSB0aGUgYmVzdCB3ZSBjYW4gCj4gYWxsb3cg UUVNVSBsb2FkIHRoZSBwcm92aXNpb25lZCB2YWx1ZSBmcm9tIHZkcGEgZGV2aWNlIGRpcmVjdGx5 LCAKPiB3aXRob3V0IGhhdmluZyB0byBwcm92aWRlIGV4dHJhIGR1cGxpY2F0ZWQgY29uZmlncyBp biBRRU1VIENMSSBsZXZlbC4KCgpUaGF0J3MgdGhlIHBsYW4sIEkgd2FudCB0byBzYXkgaXMgdGhh dCBRZW11IHNob3VsZCBkbyBzYW50aXkgdGVzdCB0byAKbWFrZSBzdXJlIHdoYXQgcHJvdmlkZWQg ZnJvbSBDTEkgbWF0Y2hlcyB3aGF0IGlzIHByb3Zpc2lvbmVkIGZyb20gdGhlIApkZXZpY2UuCgoK Pgo+Pgo+Pj4+Cj4+Pj4+IGFuZCB0aGUgd2F5IHRvIGdldCB0aGUgcGFyZW50IGRldmljZSBNVFUg YW5kIHdoZXRoZXIgdGhhdCdzIHJlbGV2YW50Cj4+Pj4+IHRvIHZkcGEgZGV2aWNlJ3MgTVRVIGlz IHZlcnkgdmVuZG9yIHNwZWNpZmljLgo+Pj4+Cj4+Pj4gU28gSSB0aGluayB0aGUgbWF4IE1UVSBv ZiBwYXJlbnQgc2hvdWxkIGJlIGVxdWFsIHRvIHRoZSBtYXggTVRVIG9mIHRoZQo+Pj4+IHZEUEEu Cj4+PiBOb3RlZCBoZXJlIHRoZSBwYXJlbnQgbWlnaHQgbm90IGJlIG5lY2Vzc2FyaWx5IHRoZSBt Z210ZGV2IHdoZXJlIHZkcGEKPj4+IGdldHMgY3JlYXRlZCBvdmVyLiBJdCBtYXkgd2VsbCBlbmQg dXAgd2l0aCB0aGUgTVRVIG9uIHRoZSBQRiAodXBsaW5rCj4+PiBwb3J0KSB3aGljaCB0aGUgbWdt dCBzb2Z0d2FyZSBoYXMgdG8gY29uY2VybiB3aXRoLiBNeSBwb2ludCBpcyB0aGUKPj4+IHV0aWxp dHkgYW5kIHRvb2wgY2hhaW4gYWJsZSB0byBkZXJpdmUgdGhlIG1heGltYWwgTVRVIGVmZmVjdGl2 ZWx5Cj4+PiBhbGxvd2VkIGZvciB2RFBBIGRldmljZSBtYXkgbGl2ZSBvdXQgb2YgdkRQQSdzIHJl YWxtLiBJdCdzIGEgcmFyZSBvcgo+Pj4gZXZlbiBpbnZhbGlkIGNvbmZpZ3VyYXRpb24gdG8gaGF2 ZSB2RFBBIGNvbmZpZ3VyZWQgd2l0aCBhIGJpZ2dlciB2YWx1ZQo+Pj4gdGhhbiB0aGUgTVRVIG9u IHRoZSB1cGxpbmsgcG9ydCBvciBwYXJlbnQgZGV2aWNlLiBJdCdzIG1vcmUgY29tbW9uIHdoZW4K Pj4+IE1UVSBjb25maWcgaXMgaW52b2x2ZWQsIGl0IGhhcyB0byBiZSBjb25zaXN0ZW50bHkgY29u ZmlndXJlZCBhY3Jvc3MgYWxsCj4+PiB0aGUgbmV0d29yayBsaW5rcyBhbG9uZywgZnJvbSBwYXJl bnQgZGV2aWNlICh1cGxpbmsgcG9ydCkgZG93biB0byB0aGUKPj4+IHN3aXRjaGRldiByZXByZXNl bnRvciBwb3J0LCB2ZHBhIGRldmljZSwgYW5kIFFFTVUgdmlydGlvLW5ldCBvYmplY3QuCj4+IE9r LCByaWdodC4KPj4KPj4+Pgo+Pj4+PiBJIHRoaW5rIHdlIHdvdWxkIG5lZWQgbmV3IGF0dHJpYnV0 ZShzKSBpbiB0aGUgbWdtdGRldiBsZXZlbCB0bwo+Pj4+PiBzdXBwb3J0IHdoYXQgeW91IHdhbnQg aGVyZT8KPj4+Pgo+Pj4+IE5vdCBzdXJlLCBidXQgd2hhdCBJIHdhbnQgdG8gYXNrIGlzIGNvbnNp ZGVyIHdlIHByb3Zpc2lvbiBNVFUgZmVhdHVyZQo+Pj4+IGJ1dCB3aXRob3V0IG1heCBNVFUgdmFs dWUsIGRvIHdlIG5lZWQgdG8gcmVwb3J0IHRoZSBpbml0aWFsIG1heCBNVFUgCj4+Pj4gaGVyZT8K Pj4+IFllcCwgbWF5YmUuIEknbSBub3QgdmVyeSBzdXJlIGlmIHRoaXMgd2lsbCBiZSB2ZXJ5IHVz ZWZ1bCB0byBiZSBob25lc3QsCj4+PiBjb25zaWRlciBpdCdzIGtpbmRhIGEgcmFyZSBjYXNlIHRv IG1lIHdlcmUgdG8gcHJvdmlzaW9uIE1UVSBmZWF0dXJlCj4+PiB3aXRob3V0IGEgc3BlY2lmaWMg TVRVIHZhbHVlLiBJZiBvbmUgY2FyZXMgYWJvdXQgTVRVLCBtZ210IHNvZnR3YXJlCj4+PiBzaG91 bGQgY29uZmlndXJlIHNvbWUgbXR1IHRocm91Z2ggInZkcGEgZGV2IGFkZCAuLi4gbXR1IC4uLiIs IG5vPwo+PiBZZXMsIGJ1dCB0aGlzIG9ubHkgd29ya3MgaWYgYWxsIGNvbmZpZyBmaWVsZHMgY291 bGQgYmUgcHJvdmlzaW9uZWQsCj4+IHdoaWNoIHNlZW1zIG5vdCB0aGUgY2FzZSBub3csIHZkcGFf ZGV2X3NldF9jb25maWcgaXMgY3VycmVudGx5IGEKPj4gc3Vic2V0IG9mIHZpcnRpb19uZXRfY29u ZmlnLiBTbyB0aGlzIGdvZXMgYmFjayB0byB0aGUgcXVlc3Rpb24gSQo+PiByYWlzZWQgZWFybGll ci4gSXMgdGhlIHRpbWUgdG8gc3dpdGNoIHRvIHVzZSB2aXJ0aW9fbmV0X2NvbmZpZyBhbmQKPj4g YWxsb3cgYWxsIGZpZWxkcyB0byBiZSBwcm92aXNpb25lZD8KPiBEb24ndCBxdWl0ZSBnZXQgaG93 IGl0IHdpbGwgYmUgdXNlZnVsIGlmIHN3aXRjaGluZyB0byAKPiB2aXJ0aW9fbmV0X2NvbmZpZy4g SSB0aG91Z2h0IHdlIGNhbiBhZGQgdGhlIG1pc3NpbmcgZmllbGRzIHRvIAo+IHZkcGFfZGV2X3Nl dF9jb25maWcgZXZlbiBub3cgdG8gbWFrZSBpdCBtYXRjaCB2aXJ0aW9fbmV0X2NvbmZpZy4gCj4g VGhvdWdoIHRoZSByZWFsaXR5IGlzIHRoZXJlJ3MgZmV3IHZkcGEgZGV2aWNlIHRoYXQgc3VwcG9y dHMgdGhvc2UgCj4gZmVhdHVyZXMgbm93LiBJZiBhbnkgcmVhbCBkZXZpY2Ugc3VwcG9ydHMgZmVh dHVyZSBmaWVsZCBpbiAKPiB2aXJ0aW9fbmV0X2NvbmZpZyBidXQgbm90IGluIHZkcGFfZGV2X3Nl dF9jb25maWcsIGl0IGNhbiBiZSBncmFkdWFsbHkgCj4gYWRkZWQgc28gbG9uZyBhcyBuZWVkZWQu Cj4KPj4KPj4gQW5kIGV2ZW4gZm9yIG10dSB3ZSdyZSBsYWNraW5nIGEgd2F5IHRvIHJlcG9ydCB0 aGUgbWF4aW11bSBNVFUgYWxsb3dlZAo+PiBieSBtZ210IGRldiAoZS5nIHRoZSB1cGxpbmsgTVRV IHZpYSBuZXRsaW5rKToKPiBTaW5jZSBNVFUgaXMgb25seSBpbXBsZW1lbnRlZCBpbiBtbHg1X3Zk cGEgYnkgbm93IGV4Y2VwdCBmb3IgCj4gc2ltdWxhdG9ycywgY29weSBFbGkgdG8gc2VlIGlmIHRo aXMgaXMgZmVhc2libGUgdG8gaW1wbGVtZW50IGluIHJlYWwgCj4gZGV2aWNlLiBJIHRoaW5rIHdl IGFsc28gbmVlZCB0byB2YWxpZGF0ZSB0aGF0IHRoZSBtdHUgY29uZmlndXJlZCBvbiAKPiB2RFBB IGRldmljZSBpbnN0YW5jZSBzaG91bGRuJ3QgZXhjZWVkIHRoZSB1cGxpbmsgTVRVIChtYXhpbXVt IE1UVSAKPiBhbGxvd2VkKS4KPgo+PiAxKSByZXBvcnQgdGhlIG1heGltdW0gaG9zdCBtdHUgc3Vw cG9ydGVkIGJ5IHRoZSBtZ210ZGV2IHZpYSBuZXRsaW5rCj4+IChub3QgZG9uZSwgc28gbWFuYWdl bWVudCBuZWVkcyB0byBndWVzcyB0aGUgbWF4aW11bSB2YWx1ZSBub3cpCj4+IDIpIGFsbG93IG10 dSB0byBiZSBwcm92aXNpb25lZCAoZG9uZSkKPj4gMykgc2hvdyBpbml0aWFsIG10dSAoZG9uZSBi eSB0aGlzIHBhdGNoKQo+IFNvIEkgd29uZGVyIGlzIGl0IGZpbmUgZm9yIHZkcGEgY29yZSB0byBj b21lIHVwIHdpdGggYSBkZWZhdWx0IHZhbHVlIAo+IGZvciBNVFUgd2hlbiBfRl9NVFUgZmVhdHVy ZSBpcyB0byBiZSBwcm92aXNpb25lZCBvciBpbmhlcml0ZWQ/CgoKSXQgc2hvdWxkIGJlIG5vdCBl YXN5IHNpbmNlIGl0IGRlcGVuZHMgb24gdGhlIHBhcmVudC4KCgo+IElmIHdlIG1hbmRhdGUgZWFj aCB2RFBBIHZlbmRvciB0byBzdXBwb3J0IGF0IGxlYXN0IHRoZSBzdGFuZGFyZCAxNTAwIAo+IE1U VSBmb3IgX0ZfTVRVIGZlYXR1cmUsIHdlIGNhbiBtYWtlIGl0IGRlZmF1bHQgdG8gMTUwMC4KPgo+ IE90aGVyd2lzZSB0aGUgdkRQQSBoYXMgdG8gYmUgdGFrZW4gKGluaGVyaXRlZCkgZnJvbSB0aGUg cGFyZW50IGRldmljZS4gCj4gVW5mb3J0dW5hdGVseSwgcmlnaHQgbm93IGZvciBtbHg1X3ZkcGEs IHRoZSBwYXJlbnQgbWdtdGRldiBkZXZpY2UgaGFzIAo+IDE1MDAgTVRVIGJ5IGRlZmF1bHQgcmVn YXJkbGVzcyBvZiB0aGUgTVRVIG9uIHRoZSB1cGxpbmsgcG9ydCwgYW5kIEknbSAKPiBub3Qgc3Vy ZSBpZiBpdCdzIGEgcmlnaHQgbW9kZWwgdG8gZW5mb3JjZSBtZ210ZGV2IGdvIHdpdGggdXBsaW5r IAo+IHBvcnQncyBNVFUuIEkgd291bGQgbmVlZCB0byBoZWFyIHdoYXQgdmVuZG9ycyBzYXkgYWJv dXQgdGhpcyByZXF1aXJlbWVudC4KPgo+Pgo+PiBXZSBwcm9iYWJseSBuZWVkIHRvIGRvIHRoZSBh Ym92ZSBmb3IgYWxsIGZpZWxkcyB0byBiZSBzZWxmLWNvbnRhaW5lZC4KPiBBZ3JlZWQgb24gdGhl IHBhcnQgb2YgYmVpbmcgc2VsZi1jb250YWluZWQuCj4KPj4KPj4+IE9uIHRoZSBvdGhlciBoYW5k LCBubyBtdHUgdmFsdWUgc3BlY2lmaWVkIG1heSBtZWFuICJnbyB3aXRoIHdoYXQgdGhlCj4+PiB1 cGxpbmsgcG9ydCBvciBwYXJlbnQgZGV2aWNlIGhhcyIuIEkgdGhpbmsgdGhpcyBpcyBhIHByZXR0 eSB1c2VmdWwgY2FzZQo+Pj4gaWYgdGhlIHZlbmRvcidzIE5JQyBzdXBwb3J0cyB1cGRhdGluZyBN VFUgb24gdGhlIGZseSB3aXRob3V0IGhhdmluZyB0bwo+Pj4gdGVhciBkb3duIFFFTVUgYW5kIHJl Y29uZmlndXJlIHZkcGEuIEknbSBub3Qgc3VyZSBpZiB3ZSBlbmQgdXAgd2l0aAo+Pj4ga2lsbGlu ZyB0aGlzIHVzZSBjYXNlIGJ5IGxpbWl0aW5nIGluaXRpYWwgbWF4IE1UVSB0byBhIGZpeGVkIHZh bHVlLgo+Pj4KPj4+Pgo+Pj4+Pj4gMikgZGV2aWNlX2ZlYXR1cmVzOiBpZiBkZXZpY2VfZmVhdHVy ZXMgaXMgbm90IHByb3Zpc2lvbmVkLCB3ZSBzaG91bGQKPj4+Pj4+IHN0aWxsIHJlcG9ydCBpdCB2 aWEgbmV0bGluayBoZXJlCj4+Pj4+IE5vdCB0aGUgd2F5IEkgZXhwZWN0ZWQgaXQsIGJ1dCB3aXRo IExpbmdzaGFuJ3Mgc2VyaWVzIHRvIGV4cG9zZQo+Pj4+PiBmaWVsZHMgb3V0IG9mIEZFQVRVUkVT X09LLCB0aGUgZGV2aWNlX2ZlYXR1cmVzIGlzIG5vdyByZXBvcnRlZAo+Pj4+PiB0aHJvdWdoICd2 ZHBhIGRldiBjb25maWcgc2hvdycgcmVnYXJkbGVzcyBiZWluZyBzcGVjaWZpZWQgb3Igbm90LCBp Zgo+Pj4+PiBJIGFtIG5vdCBtaXN0YWtlbj8KPj4+Pgo+Pj4+IFllcy4KPj4+IERvIHlvdSB3YW50 IG1lIHRvIHJlbG9jYXRlIHRvICd2ZHBhIGRldiBzaG93Jywgb3IgaXQncyBva2F5IHRvIGxlYXZl IGl0Cj4+PiBiZWhpbmQgdGhlcmU/Cj4+IEl0J3MgcHJvYmFibHkgdG9vIGxhdGUgZm9yIHRoZSBy ZWxvY2F0aW9uIGJ1dCBJIGZlZWwgaXQncyBiZXR0ZXIgdG8KPj4gcGxhY2UgYWxsIHRoZSBpbml0 aWFsL2luaGVyaXRlZCBhdHRyaWJ1dGVzIGludG8gYSBzaW5nbGUgY29tbWFuZCBldmVuCj4+IGlm IHNvbWUgb2YgdGhlbSBhcmUgYWxyZWFkeSBzb21ld2hlcmUgaW4gYW5vdGhlciBjb21tYW5kLCBi dXQgd2UgY2FuCj4+IGhlYXIgZnJvbSBvdGhlcnMuCj4gT2ssIHRoYXQnbGwgYmUgZmluZS4gSSBz dXBwb3NlZCBtZ210IHNvZnR3YXJlIHNob3VsZCBvbmx5IHF1ZXJ5IAo+IHRocm91Z2ggIm1nbXRk ZXYgc2hvdyIgb3IgImRldiBzaG93IiwgYXZvaWRpbmcgYW55IHF1ZXJ5IHZpYSJkZXYgCj4gY29u ZmlnIHNob3ciLiBJdCdkIGJlIHRoZSBiZXN0IHRvIGdldCBhbGwgb2YgdGhlIGNvbXBhdGliaWxp dHkgcmVsYXRlZCAKPiBpbmZvIGNvbnNvbGlkYXRlZCBpbiBvbmUgc2luZ2xlIHBsYWNlLiBMZXQg bWUgdHJ5IHRvIGluY2x1ZGUgaXQgaW4gCj4gImRldiBzaG93Ii4KPgo+Pgo+Pj4+Cj4+Pj4+IEN1 cnJlbnRseSB3ZSBleHBvcnQgdGhlIGNvbmZpZyBhdHRyaWJ1dGVzIHVwb24gdmRwYSBjcmVhdGlv biB1bmRlcgo+Pj4+PiB0aGUgImluaXRpYWxfY29uZmlnIiBrZXkuIElmIHdlIHdhbnQgdG8gZXhw b3NlIG1vcmUgZGVmYXVsdCB2YWx1ZXMKPj4+Pj4gaW5oZXJpdGVkIGZyb20gbWdtdGRldiwgSSB0 aGluayB3ZSBjYW4gd3JhcCB1cCB0aGVzZSBkZWZhdWx0IHZhbHVlcwo+Pj4+PiB1bmRlciBhbm90 aGVyIGtleSAiaW5oZXJpdGVkX2NvbmZpZyIgdG8gZGlzcGxheSBpbiAndmRwYSBkZXYgc2hvdycK Pj4+Pj4gb3V0cHV0LiBEb2VzIGl0IGZpdCB3aGF0IHlvdSBoYXZlIGluIG1pbmQ/Cj4+Pj4KPj4+ PiBJIHdvbmRlciBpZiBpdCdzIGJldHRlciB0byBtZXJnZSB0aG9zZSB0d28sIG9yIGlzIHRoZXJl IGFueSBhZHZhbnRhZ2VzCj4+Pj4gb2Ygc3BsaXR0aW5nIHRoZW0/Cj4+PiBJIHRoaW5rIGZvciB0 aGUgbW9zdCBwYXJ0ICJpbml0aWFsX2NvbmZpZyIgd2lsbCBiZSBzdWZmaWNpZW50IGZvciB0aG9z ZQo+Pj4gY29uZmlnIGF0dHJpYnV0ZXMgd2l0aCAidmRwYSBkZXYgYWRkIiBlcXVpdmFsZW50cywg YmUgaXQgdXNlciAKPj4+IHNwZWNpZmllZCwKPj4+IHZkcGEgZW5mb3JjZWQgZGVmYXVsdCBpZiBt aXNzaW5nIHVzZXIgaW5wdXQsIG9yIGRlZmF1bHQgb3ZlcnJpZGRlbiBieQo+Pj4gdGhlIHBhcmVu dCBkZXZpY2UuICJpbmhlcml0ZWRfY29uZmlnIiB3aWxsIGJlIHVzZWZ1bCBmb3IgdGhlIGNvbmZp Z3MKPj4+IHdpdGggbm8gInZkcGEgZGV2IGFkZCIgZXF1aXZhbGVudCBvciBsaXZlIG91dCBzaWRl IG9mIHZkcGEgdG9vbCwgYnV0Cj4+PiBzdGlsbCBpbXBvcnRhbnQgZm9yIG1nbXQgc29mdHdhcmUg dG8gcmVwbGljYXRlIGlkZW50aWNhbCB2ZHBhIHNldHVwLgo+Pj4gTGlrZSBtYXgtc3VwcG9ydGVk LW10dSAoZm9yIHRoZSB1cGxpbmsgcG9ydCBvciBwYXJlbnQgZGV2aWNlKSwKPj4+IGVmZmVjdGl2 ZS1saW5rLXNwZWVkLCBlZmZlY3RpdmUtbGluay1zdGF0dXMgZXQgYWwuIExldCdzIHNlZSBpZiB0 aGVyZSdzCj4+PiBtb3JlIHdoZW4gd2UgZ2V0IHRoZXJlLgo+PiBTbyBvbmUgcG9pbnQgSSBjYW4g c2VlIGlzIHRoYXQsIGlmIHRoZXJlJ3Mgbm8gZGlmZmVyZW5jZSBmcm9tIHRoZQo+PiB1c2VycHNh Y2UgcGVyc3BlY3RpdmUsIHdlJ2QgYmV0dGVyIG1lcmdlIHRoZW0uIEFuZCBJIGRvbid0IHNlZSBh bnkKPj4gZGlmZmVyZW5jZSBiZXR3ZWVuIHRoZSBpbml0aWFsIHZlcnN1cyBpbmhlcml0ZWQgZnJv bSB0aGUgdmlldyBvZiB1c2VyCj4+IHNwYWNlLiBEbyB5b3U/Cj4gU28gdGhlIG1ham9yIGRpZmZl cmVuY2UgaXMgImluaXRpYWxfY29uZmlnIiBpcyBzZXR0YWJsZSBhbmQgZXF1aXZhbGVudCAKPiB0 byB0aGUgY29uZmlnIGF0dHJpYnV0ZSBpbiAidmRwYSBkZXYgYWRkIiBjb21tYW5kLCB3aGlsZSAK PiAiaW5oZXJpdGVkX2NvbmZpZyIgaXMgdGhlIHJlYWQtb25seSBmaWVsZHMgZnJvbSAibWdtdGRl diBzaG93IiB0aGF0IAo+IGRvZXMgbm90IGNvcnJlc3BvbmQgdG8gYW55ICJ2ZHBhIGRldiBhZGQi IHZkcGEgYXR0cmlidXRlLiBUaGF0IHdheSB0aGUgCj4gbWdtdCBzb2Z0d2FyZSBjYW4gdXNlIHRo ZSAiaW5pdGlhbF9jb25maWciIGRpcmVjdGx5IHRvIHJlY3JlYXRlIHZkcGEgCj4gd2l0aCBpZGVu dGljYWwgZGV2aWNlIGNvbmZpZywgd2hpbGUgdXNpbmcgdGhlICJpbmhlcml0ZWRfY29uZmlnIiB0 byAKPiByZXBsaWNhdGUgdGhlIG90aGVyIGNvbmZpZ3Mgb3V0IG9mIHZkcGEsIGZvciBlLmcuIHNl dCB1cGxpbmsgcG9ydCdzIAo+IE1UVSB0byA5MDAwLiBNYXliZSB0aGVyZSdzIG5vIG5lZWQgdG8g Zm9sZCBzdWNoIGluZm8gaW50byBhbiAKPiAiaW5oZXJpdGVkX2NvbmZpZyIga2V5PyB0aG91Z2gg SSBqdXN0IHdhbnQgdG8gbWFrZSBpdCByZWxldmFudCB0byAKPiBtaWdyYXRpb24gY29tcGF0aWJp bGl0eS4gQW55IHN1Z2dlc3Rpb24gZm9yIHRoZSBuYW1lIG9yIGxheW91dD8KCgpBcyBzdGF0ZWQg YWJvdmUgSSB0aGluayBhIHNpbmdsZSBrZXkgd291bGQgYmUgYmV0dGVyIHNpbmNlIEkgZG9uJ3Qg c2VlIGEgCnJlYXNvbiB1c2VyIG5lZWQgdG8gZGlmZmVyIHRoZW0uCgpUaGFua3MKCgo+Cj4KPiBU aGFua3MsCj4gLVNpd2VpCj4KPj4KPj4gVGhhbmtzCj4+Cj4+PiBUaGFua3MsCj4+PiAtU2l3ZWkK Pj4+Cj4+Pj4KPj4+Pj4+IG9yIGRvIHlvdSBtZWFuIHRoZSBtZ210IGNhbiBhc3N1bWUgaXQKPj4+ Pj4+IHNob3VsZCBiZSB0aGUgc2FtZSBhcyBtZ210ZGV2LiBBbnlob3cgaWYgd2UgZG9uJ3Qgc2hv dyAKPj4+Pj4+IGRldmljZV9mZWF0dXJlcwo+Pj4+Pj4gaWYgaXQgaXMgbm90IHByb3Zpc2lvbmVk LCBpdCB3aWxsIGNvbXBsaWNhdGUgdGhlIG1nbXQgc29mdHdhcmUuCj4+Pj4+IFllcywgYXMgSSBz YWlkIGVhcmxpZXIsIHNpbmNlIHRoZSBkZXZpY2VfZmVhdHVyZXMgYXR0ciBnZXR0aW5nIGFkZGVk Cj4+Pj4+IHRvIHRoZSAndmRwYSBkZXYgY29uZmlnIHNob3cnIGNvbW1hbmQsIHRoaXMgZGl2ZXJn ZW5jZSBzdGFydGVkIHRvCj4+Pj4+IGNvbXBsaWNhdGUgbWdtdCBzb2Z0d2FyZSBhbHJlYWR5Lgo+ Pj4+Pgo+Pj4+PiBUaGFua3MsCj4+Pj4KPj4+PiBUaGFua3MKPj4+Pgo+Pj4+Cj4+Pj4+IC1TaXdl aQo+Pj4+Pj4gVGhhbmtzCj4+Pj4+Pgo+Pj4+Pj4+IFRoYW5rcywKPj4+Pj4+PiAtU2l3ZWkKPj4+ Pj4+Pgo+Pj4+Pj4+Cj4+Pj4+Pj4+IFRoYW5rcwo+Pj4+Pj4+Pgo+Pj4+Pj4+Pj4gKwo+Pj4+Pj4+ Pj4gK8KgwqDCoMKgwqDCoCByZXR1cm4gMDsKPj4+Pj4+Pj4+ICt9Cj4+Pj4+Pj4+PiArCj4+Pj4+ Pj4+PiArc3RhdGljIGludAo+Pj4+Pj4+Pj4gwqDCoMKgIHZkcGFfZGV2X2ZpbGwoc3RydWN0IHZk cGFfZGV2aWNlICp2ZGV2LCBzdHJ1Y3Qgc2tfYnVmZiAqbXNnLAo+Pj4+Pj4+Pj4gdTMyIHBvcnRp ZCwgdTMyIHNlcSwKPj4+Pj4+Pj4+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGlu dCBmbGFncywgc3RydWN0IG5ldGxpbmtfZXh0X2FjayAqZXh0YWNrKQo+Pj4+Pj4+Pj4gwqDCoMKg IHsKPj4+Pj4+Pj4+IEBAIC03MTUsNiArNzUwLDEwIEBAIHN0YXRpYyBpbnQKPj4+Pj4+Pj4+IHZk cGFfbmxfY21kX2Rldl9kZWxfc2V0X2RvaXQoc3RydWN0IHNrX2J1ZmYgKnNrYiwgc3RydWN0Cj4+ Pj4+Pj4+PiBnZW5sX2luZm8gKmkKPj4+Pj4+Pj4+IMKgwqDCoMKgwqDCoMKgwqDCoMKgIGlmIChu bGFfcHV0X3UxNihtc2csIFZEUEFfQVRUUl9ERVZfTUlOX1ZRX1NJWkUsCj4+Pj4+Pj4+PiBtaW5f dnFfc2l6ZSkpCj4+Pj4+Pj4+PiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAg Z290byBtc2dfZXJyOwo+Pj4+Pj4+Pj4KPj4+Pj4+Pj4+ICvCoMKgwqDCoMKgwqAgZXJyID0gdmRw YV9kZXZfaW5pdGNmZ19maWxsKHZkZXYsIG1zZywgZGV2aWNlX2lkKTsKPj4+Pj4+Pj4+ICvCoMKg wqDCoMKgwqAgaWYgKGVycikKPj4+Pj4+Pj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg IGdvdG8gbXNnX2VycjsKPj4+Pj4+Pj4+ICsKPj4+Pj4+Pj4+IMKgwqDCoMKgwqDCoMKgwqDCoMKg IGdlbmxtc2dfZW5kKG1zZywgaGRyKTsKPj4+Pj4+Pj4+IMKgwqDCoMKgwqDCoMKgwqDCoMKgIHJl dHVybiAwOwo+Pj4+Pj4+Pj4KPj4+Pj4+Pj4+IC0tIAo+Pj4+Pj4+Pj4gMS44LjMuMQo+Pj4+Pj4+ Pj4KPgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KVmly dHVhbGl6YXRpb24gbWFpbGluZyBsaXN0ClZpcnR1YWxpemF0aW9uQGxpc3RzLmxpbnV4LWZvdW5k YXRpb24ub3JnCmh0dHBzOi8vbGlzdHMubGludXhmb3VuZGF0aW9uLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL3ZpcnR1YWxpemF0aW9u 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 Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8F336C4332F for ; Tue, 20 Dec 2022 07:59:44 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233149AbiLTH7n (ORCPT ); Tue, 20 Dec 2022 02:59:43 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35244 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233241AbiLTH7f (ORCPT ); Tue, 20 Dec 2022 02:59:35 -0500 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 35828765D for ; Mon, 19 Dec 2022 23:58:47 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1671523126; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=LAkDABgx8HzSx8BPBPDsB4Ty4n30S5ghEZh7HCO2wzg=; b=RfS75sVPk9YwmK+GEHiMep+cTa497A/r3VmlL/KSTQXT4rg5l0CRX2ZHfzjdRvpd3yuDLG wTMZK6/oqT13M+NDqiHFSQ7NWVygIPNDvNjeRV8tjUOX9lQKn3P3GWKvxi/6+IuNCQGLsj r2LxMw2nkaDdDz9VPrVxgYvNK6h4y58= Received: from mail-pl1-f198.google.com (mail-pl1-f198.google.com [209.85.214.198]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_128_GCM_SHA256) id us-mta-614-7UT4pEgUO2ym4hT4mwGf9Q-1; Tue, 20 Dec 2022 02:58:44 -0500 X-MC-Unique: 7UT4pEgUO2ym4hT4mwGf9Q-1 Received: by mail-pl1-f198.google.com with SMTP id u15-20020a170902e5cf00b001899d29276eso8680282plf.10 for ; Mon, 19 Dec 2022 23:58:44 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:in-reply-to:from:references:cc:to :content-language:subject:user-agent:mime-version:date:message-id :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=LAkDABgx8HzSx8BPBPDsB4Ty4n30S5ghEZh7HCO2wzg=; b=pL8fJcw2NBJocl4bdW/kUK1bZeCokG0g6p6WyhfXULsmmDUYaNBhTb+ADNn70466Xg kkja/DOnbLjJLjhQhojTLkosr/E8YZ7mvS1d8qLryhaCX6HgEIVFoBCD+4Qi0Ga43rFs 7N1AMEUspp7yNfWDFs41BVuYvYPrgpre4X05mvDJ4NQ8HZD2PlUcK0d+rvjJWYjRUT4N NGCnx/7eMNxiKNZGG5jhey2r+JWEsBJjwDJqG9TLq84An6ME3d1XI2SyH0K6CeS1o5Ye IRCnzEW6r2sq3rIA8CutVudP/E1vTIRfLXkhkjnxpUQjInr9ihqVjTXuXSf2bvPZCkPw xqvA== X-Gm-Message-State: AFqh2ko0cH9TZbPUKdDYiqQDbL3nCLmO2Za6pzseQaINjgPuWjFk2jH2 Gvxa/85l/5Qe/oFqv2Zni3FcPa9qmAie6AfbDZyLcFKsJFhCLO6ByHmlR6Oc8je3pbKaS+trP0S anNcXmyurE+G3cV8CfG53qfWi X-Received: by 2002:a17:903:285:b0:191:3c6:1748 with SMTP id j5-20020a170903028500b0019103c61748mr17185325plr.11.1671523123383; Mon, 19 Dec 2022 23:58:43 -0800 (PST) X-Google-Smtp-Source: AMrXdXtAqcbfM3Erqn1ywAHHC6v158tmWx5cRq2Dpz7SndX4HjltBG84ehvKchcj/dhv1eF4CT10Lg== X-Received: by 2002:a17:903:285:b0:191:3c6:1748 with SMTP id j5-20020a170903028500b0019103c61748mr17185301plr.11.1671523122868; Mon, 19 Dec 2022 23:58:42 -0800 (PST) Received: from [10.72.13.235] ([43.228.180.230]) by smtp.gmail.com with ESMTPSA id z4-20020a1709027e8400b0017d97d13b18sm8599923pla.65.2022.12.19.23.58.38 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 19 Dec 2022 23:58:40 -0800 (PST) Message-ID: <49499671-eef7-0ff1-03c8-e391cc8b225e@redhat.com> Date: Tue, 20 Dec 2022 15:58:33 +0800 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:102.0) Gecko/20100101 Thunderbird/102.6.0 Subject: Re: [PATCH v3 3/4] vdpa: show dev config as-is in "vdpa dev show" output Content-Language: en-US To: Si-Wei Liu , Eli Cohen Cc: mst@redhat.com, parav@nvidia.com, virtualization@lists.linux-foundation.org, linux-kernel@vger.kernel.org, Cindy Lu References: <1666392237-4042-1-git-send-email-si-wei.liu@oracle.com> <1666392237-4042-4-git-send-email-si-wei.liu@oracle.com> <5b9efa3a-8a82-4bd1-a5b4-b9ca5b15b51a@oracle.com> <25a18d7a-ebae-3647-32f0-14ad733118be@oracle.com> <38b9648b-8795-5b41-b06c-d13a1a6d5d3f@redhat.com> From: Jason Wang In-Reply-To: Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org 在 2022/10/29 07:23, Si-Wei Liu 写道: > > > On 10/27/2022 1:47 AM, Jason Wang wrote: >> On Thu, Oct 27, 2022 at 2:31 PM Si-Wei Liu >> wrote: >>> >>> >>> On 10/25/2022 9:44 PM, Jason Wang wrote: >>>> 在 2022/10/26 09:10, Si-Wei Liu 写道: >>>>> >>>>> On 10/24/2022 7:24 PM, Jason Wang wrote: >>>>>> On Tue, Oct 25, 2022 at 3:14 AM Si-Wei Liu >>>>>> wrote: >>>>>>> On 10/24/2022 1:40 AM, Jason Wang wrote: >>>>>>>> On Sat, Oct 22, 2022 at 7:49 AM Si-Wei Liu >>>>>>>> wrote: >>>>>>>>> Live migration of vdpa would typically require re-instate vdpa >>>>>>>>> device with an idential set of configs on the destination node, >>>>>>>>> same way as how source node created the device in the first >>>>>>>>> place. In order to save orchestration software from memorizing >>>>>>>>> and keeping track of vdpa config, it will be helpful if the vdpa >>>>>>>>> tool provides the aids for exporting the initial configs as-is, >>>>>>>>> the way how vdpa device was created. The "vdpa dev show" command >>>>>>>>> seems to be the right vehicle for that. It is unlike the "vdpa >>>>>>>>> dev >>>>>>>>> config show" command output which usually goes with the live >>>>>>>>> value >>>>>>>>> in the device config space, and is not quite reliable subject to >>>>>>>>> the dynamics of feature negotiation or possible change by the >>>>>>>>> driver to the config space. >>>>>>>>> >>>>>>>>> Examples: >>>>>>>>> >>>>>>>>> 1) Create vDPA by default without any config attribute >>>>>>>>> >>>>>>>>> $ vdpa dev add mgmtdev pci/0000:41:04.2 name vdpa0 >>>>>>>>> $ vdpa dev show vdpa0 >>>>>>>>> vdpa0: type network mgmtdev pci/0000:41:04.2 vendor_id 5555 >>>>>>>>> max_vqs 9 max_vq_size 256 >>>>>>>>> $ vdpa dev -jp show vdpa0 >>>>>>>>> { >>>>>>>>>        "dev": { >>>>>>>>>            "vdpa0": { >>>>>>>>>                "type": "network", >>>>>>>>>                "mgmtdev": "pci/0000:41:04.2", >>>>>>>>>                "vendor_id": 5555, >>>>>>>>>                "max_vqs": 9, >>>>>>>>>                "max_vq_size": 256, >>>>>>>>>            } >>>>>>>>>        } >>>>>>>>> } >>>>>>>>> >>>>>>>>> 2) Create vDPA with config attribute(s) specified >>>>>>>>> >>>>>>>>> $ vdpa dev add mgmtdev pci/0000:41:04.2 name vdpa0 \ >>>>>>>>>        mac e4:11:c6:d3:45:f0 max_vq_pairs 4 >>>>>>>>> $ vdpa dev show >>>>>>>>> vdpa0: type network mgmtdev pci/0000:41:04.2 vendor_id 5555 >>>>>>>>> max_vqs 9 max_vq_size 256 >>>>>>>>>      initial_config: mac e4:11:c6:d3:45:f0 max_vq_pairs 4 >>>>>>>>> $ vdpa dev -jp show >>>>>>>>> { >>>>>>>>>        "dev": { >>>>>>>>>            "vdpa0": { >>>>>>>>>                "type": "network", >>>>>>>>>                "mgmtdev": "pci/0000:41:04.2", >>>>>>>>>                "vendor_id": 5555, >>>>>>>>>                "max_vqs": 9, >>>>>>>>>                "max_vq_size": 256, >>>>>>>>>                "initial_config": { >>>>>>>>>                    "mac": "e4:11:c6:d3:45:f0", >>>>>>>>>                    "max_vq_pairs": 4 >>>>>>>>>                } >>>>>>>>>            } >>>>>>>>>        } >>>>>>>>> } >>>>>>>>> >>>>>>>>> Signed-off-by: Si-Wei Liu >>>>>>>>> --- >>>>>>>>>     drivers/vdpa/vdpa.c | 39 >>>>>>>>> +++++++++++++++++++++++++++++++++++++++ >>>>>>>>>     1 file changed, 39 insertions(+) >>>>>>>>> >>>>>>>>> diff --git a/drivers/vdpa/vdpa.c b/drivers/vdpa/vdpa.c >>>>>>>>> index bebded6..bfb8f54 100644 >>>>>>>>> --- a/drivers/vdpa/vdpa.c >>>>>>>>> +++ b/drivers/vdpa/vdpa.c >>>>>>>>> @@ -677,6 +677,41 @@ static int >>>>>>>>> vdpa_nl_cmd_dev_del_set_doit(struct sk_buff *skb, struct >>>>>>>>> genl_info *i >>>>>>>>>     } >>>>>>>>> >>>>>>>>>     static int >>>>>>>>> +vdpa_dev_initcfg_fill(struct vdpa_device *vdev, struct sk_buff >>>>>>>>> *msg, u32 device_id) >>>>>>>>> +{ >>>>>>>>> +       struct vdpa_dev_set_config *cfg = &vdev->init_cfg; >>>>>>>>> +       int err = -EMSGSIZE; >>>>>>>>> + >>>>>>>>> +       if (!cfg->mask) >>>>>>>>> +               return 0; >>>>>>>>> + >>>>>>>>> +       switch (device_id) { >>>>>>>>> +       case VIRTIO_ID_NET: >>>>>>>>> +               if ((cfg->mask & >>>>>>>>> BIT_ULL(VDPA_ATTR_DEV_NET_CFG_MACADDR)) != 0 && >>>>>>>>> +                   nla_put(msg, VDPA_ATTR_DEV_NET_CFG_MACADDR, >>>>>>>>> + sizeof(cfg->net.mac), cfg->net.mac)) >>>>>>>>> +                       return err; >>>>>>>>> +               if ((cfg->mask & >>>>>>>>> BIT_ULL(VDPA_ATTR_DEV_NET_CFG_MTU)) != 0 && >>>>>>>>> +                   nla_put_u16(msg, VDPA_ATTR_DEV_NET_CFG_MTU, >>>>>>>>> cfg->net.mtu)) >>>>>>>>> +                       return err; >>>>>>>>> +               if ((cfg->mask & >>>>>>>>> BIT_ULL(VDPA_ATTR_DEV_NET_CFG_MAX_VQP)) != 0 && >>>>>>>>> +                   nla_put_u16(msg, >>>>>>>>> VDPA_ATTR_DEV_NET_CFG_MAX_VQP, >>>>>>>>> + cfg->net.max_vq_pairs)) >>>>>>>>> +                       return err; >>>>>>>>> +               break; >>>>>>>>> +       default: >>>>>>>>> +               break; >>>>>>>>> +       } >>>>>>>>> + >>>>>>>>> +       if ((cfg->mask & BIT_ULL(VDPA_ATTR_DEV_FEATURES)) != 0 && >>>>>>>>> +           nla_put_u64_64bit(msg, VDPA_ATTR_DEV_FEATURES, >>>>>>>>> + cfg->device_features, VDPA_ATTR_PAD)) >>>>>>>>> +               return err; >>>>>>>> A question: If any of those above attributes were not provisioned, >>>>>>>> should we show the ones that are inherited from the parent? >>>>>>> A simple answer would be yes, but the long answer is that I am not >>>>>>> sure >>>>>>> if there's any for the moment - there's no  default value for mtu, >>>>>>> mac, >>>>>>> and max_vqp that can be inherited from the parent (max_vqp by >>>>>>> default >>>>>>> being 1 is spec defined, not something inherited from the parent). >>>>>> Note that it is by default from driver level that if _F_MQ is not >>>>>> negotiated. But I think we are talking about something different >>>>>> that >>>>>> is out of the spec here, what if: >>>>>> >>>>>> vDPA inherit _F_MQ but mqx_vqp is not provisioned via netlink. >>>>>> >>>>>> Or is it not allowed? >>>>> My understanding is that this is not allowed any more since the >>>>> introduction of max_vqp attribute. Noted, currently we don't have a >>>>> way for vendor driver to report the default value for mqx_vqp, >>>> >>>> I think it can be reported in this patch? >>> Yes, we can add, but I am not sure whether or not this will be >>> practically useful, for e.g. the same command without max_vqp specified >>> may render different number of queues across different devices, or >>> different revisions of the same vendor's devices. Does it complicate >>> the >>> mgmt software even more, I'm not sure.... >> It depends on the use case, e.g if we want to compare the migration >> compatibility, having a single vdpa command query is much easier than >> having two or more. > Yep I agree. I was saying not very attribute would need to be > inherited from the parent device. Actually attributes like max_vqp > could take the default from some common place for e.g. some default > value can be applied by vdpa core. And we can document these > attributes ruled by vdpa core in vdpa-dev(8) man page. Reduce the > extra call of having mgmt software issue another query command which > actually doesn't need to. > >> >>> Could we instead mandate >>> max_vqp to be 1 from vdpa core level if user doesn't explicitly specify >>> the value? >> This seems to be not easy, at least not easy in the vDPA core. > We can load these default values from vdpa_nl_cmd_dev_add_set_doit() > before ops->dev_add is called. I can post a v3 that shows the code, it > shouldn't be too hard. Ok, and I wonder if it's time to move netlink specific code into a dedicated file. > >>   We can >> probably document this somewhere but max_vqp is only one example, we >> have other mq devices like block/SCSI/console. > Actually max_vqp is a network device specific config to provision mq > devices. If the parent mgmtdev supports net vdpa device creation and > user requests to provision _F_MQ with no supplied max_vqp value, we > should load some global default value there. > >> >>> That way it is more consistent in terms of the resulting >>> number of queue pairs (=1) with the case where parent device does not >>> offer the _F_MQ feature. >> Right, but a corner case is to provision _F_MQ but without max_vqp. > Yes, I will post the patch that supports this. >> >>>> >>>>> if not otherwise specified in the CLI. Without getting the default >>>>> value reported in 'vdpa mgmtdev show' level, it'd just confuse mgmt >>>>> software even more. >>>> >>>> Yes, this is something that we need to fix. And what's more in order >>>> to support dynamic provisioning, we need a way to report the number of >>>> available instances that could be used for vDPA device provisioning. >>> Wouldn't it be possible to achieve that by simply checking how many >>> parent mgmtdev instances don't have vdpa device provisioned yet? e.g. >>> >>> inuse=$(vdpa dev show | grep mgmtdev | wc -l) >>> total=$(vdpa mgmtdev show  | grep "supported_classes" | wc -l ) >>> echo $((total - inuse)) >> I meant how many available vDPA devices that are available for the >> mgmt to create? > Oh I see. > >> >> E.g in the case of sub function or simulator a mgmtdev can create more >> than 1 vdpa devices. > Does the sub function today supports creation of multiple vDPA > instance per mgmtdev? I think so, otherwise SF doesn't make too much sense. > Something I wasn't aware of before. Is it with different device class? It should be possible (no limitation in the vdpa core at least). Each device class should register its own mgmtdev. > >> >>>> >>>>>>     At least some time in the past, mlx5 were >>>>>> enabled with MQ with 8 queue pairs by default. >>>>> That was the situation when there's no max_vqp attribute support from >>>>> vdpa netlink API level. I think now every driver honors the vdpa core >>>>> disposition to get a single queue pair if max_vqp config is missing. >>>> So we have: >>>> >>>> int vdpa_register_device(struct vdpa_device *vdev, int nvqs) >>>> >>>> This means technically, parent can allocate a multiqueue devices with >>>> _F_MQ features if max_vqp and device_features is not provisioned. And >>>> what's more, what happens if _F_MQ is provisioned by max_vqp is not >>>> specified? >>>> >>>> The question is: >>>> >>>> When a attribute is not specificed/provisioned via net link, what's >>>> the default value? The answer should be consistent: if device_features >>>> is determined by the parent, we should do the same for mqx_vqp. >>> OK I got your point. >>> >>>> And it looks to me all of those belongs to the initial config >>>> (self-contained) >>> Right. I wonder if we can have vdpa core define the default value (for >>> e.g. max_vqp=1) for those unspecified attribute (esp. when the >>> corresponding device feature is offered and provisioned) whenever >>> possible. Which I think it'll be more consistent for the same >>> command to >>> get to the same result between different vendor drivers. While we still >>> keep the possibility for future extension to allow driver override the >>> vdpa core disposition if the real use case emerges. What do you think? >> That's possible but we may end up with device specific code in the >> vDPA core which is not elegant, and the code will grow as the number >> of supported types grows. > I guess that's unavoidable as this is already the case today. See > various VIRTIO_ID_NET case switch in the vdpa.c code. I think type > specific code just limits itself to the netlink API interfacing layer > rather than down to the driver API, it might be just okay (as that's > already the case). > >> >> Note that, max_vqp is not the only attribute that may suffer from >> this, basically any config field that depends on a specific feature >> bit may have the same issue. >> >>>> >>>>> And the mlx5_vdpa driver with 8 queue pairs in the wild days is just >>>>> irrelevant to be manageable by mgmt software, regardless of live >>>>> migration. >>>>>>> And >>>>>>> the device_features if inherited is displayed at 'vdpa dev config >>>>>>> show' >>>>>>> output. Can you remind me of a good example for inherited value >>>>>>> that we >>>>>>> may want to show here? >>>>>> Some other cases: >>>>>> >>>>>> 1) MTU: there should be something that the device needs to report if >>>>>> _F_MTU is negotiated even if it is not provisioned from netlink. >>>>> I am not sure I understand the ask here. Noted the QEMU argument has >>>>> to offer host_mtu=X with the maximum MTU value for guest to use (and >>>>> applied as the initial MTU config during virtio-net probing for Linux >>>>> driver), >>>> >>>> Adding Cindy. >>>> >>>> I think it's a known issue that we need to do sanity check to make >>>> sure cli parameters matches what is provisioned from netlink. >>> Right. How's the plan for QEMU to get to the mtu provisioned by >>> netlink, >>> via a new vhost-vdpa ioctl call? >> I think netlink is not designed for qemu to use, the design is to >> expose a vhost device to Qemu. >> >>> If so, will  QEMU be able to read it >>> directly from kernel when it comes to the vhost-vdpa backend, without >>> having user to specify host_mtu from CLI? >> I'm not sure I get the question, but Qemu should get this via config >> space (otherwise it should be a bug). > It's hard for QEMU to work this way with the existing get_config() ops > I think, as it has assumption around endianness and feature > negotiation, until the latter is done you can't get any reliable value > for provisioned property. I think QEMU which need to validate the > provisioned value way earlier (when QEMU is launched), before > negotiation kicks in. It would be clearner to use another vhost and a > new vdpa driver ops to retrieve the provisioned feature config values > from vendor drivers. > >>   And Qemu need to verify the mtu >> got from cli vs the mtu got from vhost and fail the device >> initialization if they don't match. > I mean today there's a problem for double provisioning: for e.g. mtu > has to be first provided in the 'vdpa dev add' command when to > provision _F_MTU, in QEMU CLI the same value has to be supplied to > host_mtu. The same applies to mac address. It would be the best we can > allow QEMU load the provisioned value from vdpa device directly, > without having to provide extra duplicated configs in QEMU CLI level. That's the plan, I want to say is that Qemu should do santiy test to make sure what provided from CLI matches what is provisioned from the device. > >> >>>> >>>>> and the way to get the parent device MTU and whether that's relevant >>>>> to vdpa device's MTU is very vendor specific. >>>> >>>> So I think the max MTU of parent should be equal to the max MTU of the >>>> vDPA. >>> Noted here the parent might not be necessarily the mgmtdev where vdpa >>> gets created over. It may well end up with the MTU on the PF (uplink >>> port) which the mgmt software has to concern with. My point is the >>> utility and tool chain able to derive the maximal MTU effectively >>> allowed for vDPA device may live out of vDPA's realm. It's a rare or >>> even invalid configuration to have vDPA configured with a bigger value >>> than the MTU on the uplink port or parent device. It's more common when >>> MTU config is involved, it has to be consistently configured across all >>> the network links along, from parent device (uplink port) down to the >>> switchdev representor port, vdpa device, and QEMU virtio-net object. >> Ok, right. >> >>>> >>>>> I think we would need new attribute(s) in the mgmtdev level to >>>>> support what you want here? >>>> >>>> Not sure, but what I want to ask is consider we provision MTU feature >>>> but without max MTU value, do we need to report the initial max MTU >>>> here? >>> Yep, maybe. I'm not very sure if this will be very useful to be honest, >>> consider it's kinda a rare case to me were to provision MTU feature >>> without a specific MTU value. If one cares about MTU, mgmt software >>> should configure some mtu through "vdpa dev add ... mtu ...", no? >> Yes, but this only works if all config fields could be provisioned, >> which seems not the case now, vdpa_dev_set_config is currently a >> subset of virtio_net_config. So this goes back to the question I >> raised earlier. Is the time to switch to use virtio_net_config and >> allow all fields to be provisioned? > Don't quite get how it will be useful if switching to > virtio_net_config. I thought we can add the missing fields to > vdpa_dev_set_config even now to make it match virtio_net_config. > Though the reality is there's few vdpa device that supports those > features now. If any real device supports feature field in > virtio_net_config but not in vdpa_dev_set_config, it can be gradually > added so long as needed. > >> >> And even for mtu we're lacking a way to report the maximum MTU allowed >> by mgmt dev (e.g the uplink MTU via netlink): > Since MTU is only implemented in mlx5_vdpa by now except for > simulators, copy Eli to see if this is feasible to implement in real > device. I think we also need to validate that the mtu configured on > vDPA device instance shouldn't exceed the uplink MTU (maximum MTU > allowed). > >> 1) report the maximum host mtu supported by the mgmtdev via netlink >> (not done, so management needs to guess the maximum value now) >> 2) allow mtu to be provisioned (done) >> 3) show initial mtu (done by this patch) > So I wonder is it fine for vdpa core to come up with a default value > for MTU when _F_MTU feature is to be provisioned or inherited? It should be not easy since it depends on the parent. > If we mandate each vDPA vendor to support at least the standard 1500 > MTU for _F_MTU feature, we can make it default to 1500. > > Otherwise the vDPA has to be taken (inherited) from the parent device. > Unfortunately, right now for mlx5_vdpa, the parent mgmtdev device has > 1500 MTU by default regardless of the MTU on the uplink port, and I'm > not sure if it's a right model to enforce mgmtdev go with uplink > port's MTU. I would need to hear what vendors say about this requirement. > >> >> We probably need to do the above for all fields to be self-contained. > Agreed on the part of being self-contained. > >> >>> On the other hand, no mtu value specified may mean "go with what the >>> uplink port or parent device has". I think this is a pretty useful case >>> if the vendor's NIC supports updating MTU on the fly without having to >>> tear down QEMU and reconfigure vdpa. I'm not sure if we end up with >>> killing this use case by limiting initial max MTU to a fixed value. >>> >>>> >>>>>> 2) device_features: if device_features is not provisioned, we should >>>>>> still report it via netlink here >>>>> Not the way I expected it, but with Lingshan's series to expose >>>>> fields out of FEATURES_OK, the device_features is now reported >>>>> through 'vdpa dev config show' regardless being specified or not, if >>>>> I am not mistaken? >>>> >>>> Yes. >>> Do you want me to relocate to 'vdpa dev show', or it's okay to leave it >>> behind there? >> It's probably too late for the relocation but I feel it's better to >> place all the initial/inherited attributes into a single command even >> if some of them are already somewhere in another command, but we can >> hear from others. > Ok, that'll be fine. I supposed mgmt software should only query > through "mgmtdev show" or "dev show", avoiding any query via"dev > config show". It'd be the best to get all of the compatibility related > info consolidated in one single place. Let me try to include it in > "dev show". > >> >>>> >>>>> Currently we export the config attributes upon vdpa creation under >>>>> the "initial_config" key. If we want to expose more default values >>>>> inherited from mgmtdev, I think we can wrap up these default values >>>>> under another key "inherited_config" to display in 'vdpa dev show' >>>>> output. Does it fit what you have in mind? >>>> >>>> I wonder if it's better to merge those two, or is there any advantages >>>> of splitting them? >>> I think for the most part "initial_config" will be sufficient for those >>> config attributes with "vdpa dev add" equivalents, be it user >>> specified, >>> vdpa enforced default if missing user input, or default overridden by >>> the parent device. "inherited_config" will be useful for the configs >>> with no "vdpa dev add" equivalent or live out side of vdpa tool, but >>> still important for mgmt software to replicate identical vdpa setup. >>> Like max-supported-mtu (for the uplink port or parent device), >>> effective-link-speed, effective-link-status et al. Let's see if there's >>> more when we get there. >> So one point I can see is that, if there's no difference from the >> userpsace perspective, we'd better merge them. And I don't see any >> difference between the initial versus inherited from the view of user >> space. Do you? > So the major difference is "initial_config" is settable and equivalent > to the config attribute in "vdpa dev add" command, while > "inherited_config" is the read-only fields from "mgmtdev show" that > does not correspond to any "vdpa dev add" vdpa attribute. That way the > mgmt software can use the "initial_config" directly to recreate vdpa > with identical device config, while using the "inherited_config" to > replicate the other configs out of vdpa, for e.g. set uplink port's > MTU to 9000. Maybe there's no need to fold such info into an > "inherited_config" key? though I just want to make it relevant to > migration compatibility. Any suggestion for the name or layout? As stated above I think a single key would be better since I don't see a reason user need to differ them. Thanks > > > Thanks, > -Siwei > >> >> Thanks >> >>> Thanks, >>> -Siwei >>> >>>> >>>>>> or do you mean the mgmt can assume it >>>>>> should be the same as mgmtdev. Anyhow if we don't show >>>>>> device_features >>>>>> if it is not provisioned, it will complicate the mgmt software. >>>>> Yes, as I said earlier, since the device_features attr getting added >>>>> to the 'vdpa dev config show' command, this divergence started to >>>>> complicate mgmt software already. >>>>> >>>>> Thanks, >>>> >>>> Thanks >>>> >>>> >>>>> -Siwei >>>>>> Thanks >>>>>> >>>>>>> Thanks, >>>>>>> -Siwei >>>>>>> >>>>>>> >>>>>>>> Thanks >>>>>>>> >>>>>>>>> + >>>>>>>>> +       return 0; >>>>>>>>> +} >>>>>>>>> + >>>>>>>>> +static int >>>>>>>>>     vdpa_dev_fill(struct vdpa_device *vdev, struct sk_buff *msg, >>>>>>>>> u32 portid, u32 seq, >>>>>>>>>                  int flags, struct netlink_ext_ack *extack) >>>>>>>>>     { >>>>>>>>> @@ -715,6 +750,10 @@ static int >>>>>>>>> vdpa_nl_cmd_dev_del_set_doit(struct sk_buff *skb, struct >>>>>>>>> genl_info *i >>>>>>>>>            if (nla_put_u16(msg, VDPA_ATTR_DEV_MIN_VQ_SIZE, >>>>>>>>> min_vq_size)) >>>>>>>>>                    goto msg_err; >>>>>>>>> >>>>>>>>> +       err = vdpa_dev_initcfg_fill(vdev, msg, device_id); >>>>>>>>> +       if (err) >>>>>>>>> +               goto msg_err; >>>>>>>>> + >>>>>>>>>            genlmsg_end(msg, hdr); >>>>>>>>>            return 0; >>>>>>>>> >>>>>>>>> -- >>>>>>>>> 1.8.3.1 >>>>>>>>> >