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 smtp3.osuosl.org (smtp3.osuosl.org [140.211.166.136]) (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 9F914C61DA4 for ; Wed, 15 Mar 2023 07:06:10 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp3.osuosl.org (Postfix) with ESMTP id 2A81B60BCC; Wed, 15 Mar 2023 07:06:10 +0000 (UTC) DKIM-Filter: OpenDKIM Filter v2.11.0 smtp3.osuosl.org 2A81B60BCC Authentication-Results: smtp3.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=a9koFKD3 X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp3.osuosl.org ([127.0.0.1]) by localhost (smtp3.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id xGnBT1y-EBRL; Wed, 15 Mar 2023 07:06:08 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by smtp3.osuosl.org (Postfix) with ESMTPS id 2A31D60A92; Wed, 15 Mar 2023 07:06:08 +0000 (UTC) DKIM-Filter: OpenDKIM Filter v2.11.0 smtp3.osuosl.org 2A31D60A92 Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 06C48C0035; Wed, 15 Mar 2023 07:06:08 +0000 (UTC) Received: from smtp3.osuosl.org (smtp3.osuosl.org [IPv6:2605:bc80:3010::136]) by lists.linuxfoundation.org (Postfix) with ESMTP id 03580C0032 for ; Wed, 15 Mar 2023 07:06:07 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp3.osuosl.org (Postfix) with ESMTP id D1B3760B9F for ; Wed, 15 Mar 2023 07:06:06 +0000 (UTC) DKIM-Filter: OpenDKIM Filter v2.11.0 smtp3.osuosl.org D1B3760B9F X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp3.osuosl.org ([127.0.0.1]) by localhost (smtp3.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id DhLHsJPdqFGF for ; Wed, 15 Mar 2023 07:06:05 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.8.0 DKIM-Filter: OpenDKIM Filter v2.11.0 smtp3.osuosl.org 5B56660A92 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by smtp3.osuosl.org (Postfix) with ESMTPS id 5B56660A92 for ; Wed, 15 Mar 2023 07:06:05 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1678863964; 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=AVeDCxcVeUEwINX4A+87k6K5ylMcJjroc1LtLw+moxQ=; b=a9koFKD3EzrXRBkAbU/cPmNOWplJwQ2EAU5QKojbZfH9XUPBDgQ0Cf+gbCLMXH35jb3QpR eKtfr6eS2uAL2pKBGF6pwRbOZ+GFdrdX84t0zKedVBH3cRWuO3Gh8Bf9CcG3GLh8XSvnlI BybQgRHzEerDLXFsQicBjBJt3zP8yXk= Received: from mail-oa1-f70.google.com (mail-oa1-f70.google.com [209.85.160.70]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-551-ZI2fwZmhOKKm4L7QaZ_xVQ-1; Wed, 15 Mar 2023 03:05:58 -0400 X-MC-Unique: ZI2fwZmhOKKm4L7QaZ_xVQ-1 Received: by mail-oa1-f70.google.com with SMTP id 586e51a60fabf-1779d667819so6127859fac.19 for ; Wed, 15 Mar 2023 00:05:58 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; t=1678863957; h=content-transfer-encoding:cc:to:subject:message-id:date:from :in-reply-to:references:mime-version:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=AVeDCxcVeUEwINX4A+87k6K5ylMcJjroc1LtLw+moxQ=; b=MqZv1+5WABTk/eEUPX3x+gqr28EV7DdwcSL6hX9zNG6viJiR9Lyg+VmMv8hxxCf5CU QSK5G/CISgI3N8r6fKnElHDjrQFC1rUXk9iZBSQF0BHSlqYbp3Cc2unOW2WdoyNA4sGu UUneNyIccXBriRaXdyejLIIK3S8yPTAxlS+uh36Hb/UX/9UOtASF22OuQn7b8DctvpuC pW1XwfzdrfwVSsa/h8sH1RKM9Enw792KSpH78a/H7uNOhW2/YPS/L64DAYr+WjbVf2iL W4CguVhBD2JH51LYkwgZJd1BtPMA76q0FG8ptylY5XO8W/Z0v9jFwGwHlEaA9dO4B+a1 GTMw== X-Gm-Message-State: AO0yUKUwYDJUdgOWvkd6dtwjbTXPBaHGPDzF11GW5y8s4/jn5tgxDJaq 9cu2gty9dAz13l/s/0vc84Aq0RJ5LotpiCDdKGu16TvAXVo9Qzy38fd+z4PGlR1hwInEgre6mFK VDNctqauiWWN4DsSZ79UDW0YLkTyLOwW5GyAzXYOdN0cUp39kkJZ9z/OlfA== X-Received: by 2002:a05:6808:6149:b0:384:27f0:bd0a with SMTP id dl9-20020a056808614900b0038427f0bd0amr478947oib.9.1678863957085; Wed, 15 Mar 2023 00:05:57 -0700 (PDT) X-Google-Smtp-Source: AK7set+WnuE5eiOs7ylPDUY/5xAf0BR2cgfz7T7MefTilIcifHuh2d99Dz/ke1uLTyhJHXSO0Bcmb0NygY8kmrYJ4So= X-Received: by 2002:a05:6808:6149:b0:384:27f0:bd0a with SMTP id dl9-20020a056808614900b0038427f0bd0amr478946oib.9.1678863956756; Wed, 15 Mar 2023 00:05:56 -0700 (PDT) MIME-Version: 1.0 References: <20230309013046.23523-1-shannon.nelson@amd.com> <20230309013046.23523-6-shannon.nelson@amd.com> In-Reply-To: <20230309013046.23523-6-shannon.nelson@amd.com> From: Jason Wang Date: Wed, 15 Mar 2023 15:05:45 +0800 Message-ID: Subject: Re: [PATCH RFC v2 virtio 5/7] pds_vdpa: add support for vdpa and vdpamgmt interfaces To: Shannon Nelson X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Cc: brett.creeley@amd.com, mst@redhat.com, netdev@vger.kernel.org, virtualization@lists.linux-foundation.org, kuba@kernel.org, drivers@pensando.io, davem@davemloft.net 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-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: virtualization-bounces@lists.linux-foundation.org Sender: "Virtualization" T24gVGh1LCBNYXIgOSwgMjAyMyBhdCA5OjMx4oCvQU0gU2hhbm5vbiBOZWxzb24gPHNoYW5ub24u bmVsc29uQGFtZC5jb20+IHdyb3RlOgo+Cj4gVGhpcyBpcyB0aGUgdkRQQSBkZXZpY2Ugc3VwcG9y dCwgd2hlcmUgd2UgYWR2ZXJ0aXNlIHRoYXQgd2UgY2FuCj4gc3VwcG9ydCB0aGUgdmlydGlvIHF1 ZXVlcyBhbmQgZGVhbCB3aXRoIHRoZSBjb25maWd1cmF0aW9uIHdvcmsKPiB0aHJvdWdoIHRoZSBw ZHNfY29yZSdzIGFkbWlucS4KPgo+IFNpZ25lZC1vZmYtYnk6IFNoYW5ub24gTmVsc29uIDxzaGFu bm9uLm5lbHNvbkBhbWQuY29tPgo+IC0tLQo+ICBkcml2ZXJzL3ZkcGEvcGRzL2F1eF9kcnYuYyAg fCAgMTUgKwo+ICBkcml2ZXJzL3ZkcGEvcGRzL2F1eF9kcnYuaCAgfCAgIDEgKwo+ICBkcml2ZXJz L3ZkcGEvcGRzL2RlYnVnZnMuYyAgfCAxNzIgKysrKysrKysrKysrCj4gIGRyaXZlcnMvdmRwYS9w ZHMvZGVidWdmcy5oICB8ICAgOCArCj4gIGRyaXZlcnMvdmRwYS9wZHMvdmRwYV9kZXYuYyB8IDU0 NSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0KPiAgNSBmaWxlcyBjaGFuZ2Vk LCA3NDAgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQo+Cj4gZGlmZiAtLWdpdCBhL2RyaXZl cnMvdmRwYS9wZHMvYXV4X2Rydi5jIGIvZHJpdmVycy92ZHBhL3Bkcy9hdXhfZHJ2LmMKPiBpbmRl eCAyODE1OGQwZDk4YTUuLmQ3MDZmMDZmNzQwMCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3ZkcGEv cGRzL2F1eF9kcnYuYwo+ICsrKyBiL2RyaXZlcnMvdmRwYS9wZHMvYXV4X2Rydi5jCj4gQEAgLTYw LDggKzYwLDIxIEBAIHN0YXRpYyBpbnQgcGRzX3ZkcGFfcHJvYmUoc3RydWN0IGF1eGlsaWFyeV9k ZXZpY2UgKmF1eF9kZXYsCj4gICAgICAgICAgICAgICAgIGdvdG8gZXJyX2ZyZWVfbWdtdF9pbmZv Owo+ICAgICAgICAgfQo+Cj4gKyAgICAgICAvKiBMZXQgdmRwYSBrbm93IHRoYXQgd2UgY2FuIHBy b3ZpZGUgZGV2aWNlcyAqLwo+ICsgICAgICAgZXJyID0gdmRwYV9tZ210ZGV2X3JlZ2lzdGVyKCZ2 ZHBhX2F1eC0+dmRwYV9tZGV2KTsKPiArICAgICAgIGlmIChlcnIpIHsKPiArICAgICAgICAgICAg ICAgZGV2X2VycihkZXYsICIlczogRmFpbGVkIHRvIGluaXRpYWxpemUgdmRwYV9tZ210IGludGVy ZmFjZTogJXBlXG4iLAo+ICsgICAgICAgICAgICAgICAgICAgICAgIF9fZnVuY19fLCBFUlJfUFRS KGVycikpOwo+ICsgICAgICAgICAgICAgICBnb3RvIGVycl9mcmVlX3ZpcnRpbzsKPiArICAgICAg IH0KPiArCj4gKyAgICAgICBwZHNfdmRwYV9kZWJ1Z2ZzX2FkZF9wY2lkZXYodmRwYV9hdXgpOwo+ ICsgICAgICAgcGRzX3ZkcGFfZGVidWdmc19hZGRfaWRlbnQodmRwYV9hdXgpOwo+ICsKPiAgICAg ICAgIHJldHVybiAwOwo+Cj4gK2Vycl9mcmVlX3ZpcnRpbzoKPiArICAgICAgIHBkc192ZHBhX3Jl bW92ZV92aXJ0aW8oJnZkcGFfYXV4LT52ZF9tZGV2KTsKPiAgZXJyX2ZyZWVfbWdtdF9pbmZvOgo+ ICAgICAgICAgcGNpX2ZyZWVfaXJxX3ZlY3RvcnMocGFkZXYtPnZmLT5wZGV2KTsKPiAgZXJyX2F1 eF91bnJlZzoKPiBAQCAtNzgsMTEgKzkxLDEzIEBAIHN0YXRpYyB2b2lkIHBkc192ZHBhX3JlbW92 ZShzdHJ1Y3QgYXV4aWxpYXJ5X2RldmljZSAqYXV4X2RldikKPiAgICAgICAgIHN0cnVjdCBwZHNf dmRwYV9hdXggKnZkcGFfYXV4ID0gYXV4aWxpYXJ5X2dldF9kcnZkYXRhKGF1eF9kZXYpOwo+ICAg ICAgICAgc3RydWN0IGRldmljZSAqZGV2ID0gJmF1eF9kZXYtPmRldjsKPgo+ICsgICAgICAgdmRw YV9tZ210ZGV2X3VucmVnaXN0ZXIoJnZkcGFfYXV4LT52ZHBhX21kZXYpOwo+ICAgICAgICAgcGRz X3ZkcGFfcmVtb3ZlX3ZpcnRpbygmdmRwYV9hdXgtPnZkX21kZXYpOwo+ICAgICAgICAgcGNpX2Zy ZWVfaXJxX3ZlY3RvcnModmRwYV9hdXgtPnBhZGV2LT52Zi0+cGRldik7Cj4KPiAgICAgICAgIHZk cGFfYXV4LT5wYWRldi0+b3BzLT51bnJlZ2lzdGVyX2NsaWVudCh2ZHBhX2F1eC0+cGFkZXYpOwo+ Cj4gKyAgICAgICBwZHNfdmRwYV9kZWJ1Z2ZzX2RlbF92ZHBhZGV2KHZkcGFfYXV4KTsKPiAgICAg ICAgIGtmcmVlKHZkcGFfYXV4KTsKPiAgICAgICAgIGF1eGlsaWFyeV9zZXRfZHJ2ZGF0YShhdXhf ZGV2LCBOVUxMKTsKPgo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3ZkcGEvcGRzL2F1eF9kcnYuaCBi L2RyaXZlcnMvdmRwYS9wZHMvYXV4X2Rydi5oCj4gaW5kZXggODdhYzNjMDFjNDc2Li4xYWIxY2U2 NGRhN2MgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy92ZHBhL3Bkcy9hdXhfZHJ2LmgKPiArKysgYi9k cml2ZXJzL3ZkcGEvcGRzL2F1eF9kcnYuaAo+IEBAIC0xMSw2ICsxMSw3IEBAIHN0cnVjdCBwZHNf dmRwYV9hdXggewo+ICAgICAgICAgc3RydWN0IHBkc19hdXhpbGlhcnlfZGV2ICpwYWRldjsKPgo+ ICAgICAgICAgc3RydWN0IHZkcGFfbWdtdF9kZXYgdmRwYV9tZGV2Owo+ICsgICAgICAgc3RydWN0 IHBkc192ZHBhX2RldmljZSAqcGRzdjsKPgo+ICAgICAgICAgc3RydWN0IHBkc192ZHBhX2lkZW50 IGlkZW50Owo+Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmRwYS9wZHMvZGVidWdmcy5jIGIvZHJp dmVycy92ZHBhL3Bkcy9kZWJ1Z2ZzLmMKPiBpbmRleCBhYTVlOTY3N2ZlNzQuLmIzZWU0ZjQyZjNi NiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3ZkcGEvcGRzL2RlYnVnZnMuYwo+ICsrKyBiL2RyaXZl cnMvdmRwYS9wZHMvZGVidWdmcy5jCj4gQEAgLTksNiArOSw3IEBACj4gICNpbmNsdWRlIDxsaW51 eC9wZHMvcGRzX2F1eGJ1cy5oPgo+Cj4gICNpbmNsdWRlICJhdXhfZHJ2LmgiCj4gKyNpbmNsdWRl ICJ2ZHBhX2Rldi5oIgo+ICAjaW5jbHVkZSAiZGVidWdmcy5oIgo+Cj4gICNpZmRlZiBDT05GSUdf REVCVUdfRlMKPiBAQCAtMjYsNCArMjcsMTc1IEBAIHZvaWQgcGRzX3ZkcGFfZGVidWdmc19kZXN0 cm95KHZvaWQpCj4gICAgICAgICBkYmZzX2RpciA9IE5VTEw7Cj4gIH0KPgo+ICsjZGVmaW5lIFBS SU5UX1NCSVRfTkFNRShfX3NlcSwgX19mLCBfX25hbWUpICAgICAgICAgICAgICAgICAgICAgXAo+ ICsgICAgICAgZG8geyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBcCj4gKyAgICAgICAgICAgICAgIGlmICgoX19mKSAmIChfX25hbWUpKSAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBcCj4gKyAgICAgICAgICAgICAgICAgICAgICAgc2VxX3By aW50ZihfX3NlcSwgIiAlcyIsICYjX19uYW1lWzE2XSk7IFwKPiArICAgICAgIH0gd2hpbGUgKDAp Cj4gKwo+ICtzdGF0aWMgdm9pZCBwcmludF9zdGF0dXNfYml0cyhzdHJ1Y3Qgc2VxX2ZpbGUgKnNl cSwgdTE2IHN0YXR1cykKPiArewo+ICsgICAgICAgc2VxX3B1dHMoc2VxLCAic3RhdHVzOiIpOwo+ ICsgICAgICAgUFJJTlRfU0JJVF9OQU1FKHNlcSwgc3RhdHVzLCBWSVJUSU9fQ09ORklHX1NfQUNL Tk9XTEVER0UpOwo+ICsgICAgICAgUFJJTlRfU0JJVF9OQU1FKHNlcSwgc3RhdHVzLCBWSVJUSU9f Q09ORklHX1NfRFJJVkVSKTsKPiArICAgICAgIFBSSU5UX1NCSVRfTkFNRShzZXEsIHN0YXR1cywg VklSVElPX0NPTkZJR19TX0RSSVZFUl9PSyk7Cj4gKyAgICAgICBQUklOVF9TQklUX05BTUUoc2Vx LCBzdGF0dXMsIFZJUlRJT19DT05GSUdfU19GRUFUVVJFU19PSyk7Cj4gKyAgICAgICBQUklOVF9T QklUX05BTUUoc2VxLCBzdGF0dXMsIFZJUlRJT19DT05GSUdfU19ORUVEU19SRVNFVCk7Cj4gKyAg ICAgICBQUklOVF9TQklUX05BTUUoc2VxLCBzdGF0dXMsIFZJUlRJT19DT05GSUdfU19GQUlMRUQp Owo+ICsgICAgICAgc2VxX3B1dHMoc2VxLCAiXG4iKTsKPiArfQo+ICsKPiArI2RlZmluZSBQUklO VF9GQklUX05BTUUoX19zZXEsIF9fZiwgX19uYW1lKSAgICAgICAgICAgICAgICBcCj4gKyAgICAg ICBkbyB7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCj4g KyAgICAgICAgICAgICAgIGlmICgoX19mKSAmIEJJVF9VTEwoX19uYW1lKSkgICAgICAgICAgICAg ICAgIFwKPiArICAgICAgICAgICAgICAgICAgICAgICBzZXFfcHJpbnRmKF9fc2VxLCAiICVzIiwg I19fbmFtZSk7IFwKPiArICAgICAgIH0gd2hpbGUgKDApCj4gKwo+ICtzdGF0aWMgdm9pZCBwcmlu dF9mZWF0dXJlX2JpdHMoc3RydWN0IHNlcV9maWxlICpzZXEsIHU2NCBmZWF0dXJlcykKPiArewo+ ICsgICAgICAgc2VxX3B1dHMoc2VxLCAiZmVhdHVyZXM6Iik7Cj4gKyAgICAgICBQUklOVF9GQklU X05BTUUoc2VxLCBmZWF0dXJlcywgVklSVElPX05FVF9GX0NTVU0pOwo+ICsgICAgICAgUFJJTlRf RkJJVF9OQU1FKHNlcSwgZmVhdHVyZXMsIFZJUlRJT19ORVRfRl9HVUVTVF9DU1VNKTsKPiArICAg ICAgIFBSSU5UX0ZCSVRfTkFNRShzZXEsIGZlYXR1cmVzLCBWSVJUSU9fTkVUX0ZfQ1RSTF9HVUVT VF9PRkZMT0FEUyk7Cj4gKyAgICAgICBQUklOVF9GQklUX05BTUUoc2VxLCBmZWF0dXJlcywgVklS VElPX05FVF9GX01UVSk7Cj4gKyAgICAgICBQUklOVF9GQklUX05BTUUoc2VxLCBmZWF0dXJlcywg VklSVElPX05FVF9GX01BQyk7Cj4gKyAgICAgICBQUklOVF9GQklUX05BTUUoc2VxLCBmZWF0dXJl cywgVklSVElPX05FVF9GX0dVRVNUX1RTTzQpOwo+ICsgICAgICAgUFJJTlRfRkJJVF9OQU1FKHNl cSwgZmVhdHVyZXMsIFZJUlRJT19ORVRfRl9HVUVTVF9UU082KTsKPiArICAgICAgIFBSSU5UX0ZC SVRfTkFNRShzZXEsIGZlYXR1cmVzLCBWSVJUSU9fTkVUX0ZfR1VFU1RfRUNOKTsKPiArICAgICAg IFBSSU5UX0ZCSVRfTkFNRShzZXEsIGZlYXR1cmVzLCBWSVJUSU9fTkVUX0ZfR1VFU1RfVUZPKTsK PiArICAgICAgIFBSSU5UX0ZCSVRfTkFNRShzZXEsIGZlYXR1cmVzLCBWSVJUSU9fTkVUX0ZfSE9T VF9UU080KTsKPiArICAgICAgIFBSSU5UX0ZCSVRfTkFNRShzZXEsIGZlYXR1cmVzLCBWSVJUSU9f TkVUX0ZfSE9TVF9UU082KTsKPiArICAgICAgIFBSSU5UX0ZCSVRfTkFNRShzZXEsIGZlYXR1cmVz LCBWSVJUSU9fTkVUX0ZfSE9TVF9FQ04pOwo+ICsgICAgICAgUFJJTlRfRkJJVF9OQU1FKHNlcSwg ZmVhdHVyZXMsIFZJUlRJT19ORVRfRl9IT1NUX1VGTyk7Cj4gKyAgICAgICBQUklOVF9GQklUX05B TUUoc2VxLCBmZWF0dXJlcywgVklSVElPX05FVF9GX01SR19SWEJVRik7Cj4gKyAgICAgICBQUklO VF9GQklUX05BTUUoc2VxLCBmZWF0dXJlcywgVklSVElPX05FVF9GX1NUQVRVUyk7Cj4gKyAgICAg ICBQUklOVF9GQklUX05BTUUoc2VxLCBmZWF0dXJlcywgVklSVElPX05FVF9GX0NUUkxfVlEpOwo+ ICsgICAgICAgUFJJTlRfRkJJVF9OQU1FKHNlcSwgZmVhdHVyZXMsIFZJUlRJT19ORVRfRl9DVFJM X1JYKTsKPiArICAgICAgIFBSSU5UX0ZCSVRfTkFNRShzZXEsIGZlYXR1cmVzLCBWSVJUSU9fTkVU X0ZfQ1RSTF9WTEFOKTsKPiArICAgICAgIFBSSU5UX0ZCSVRfTkFNRShzZXEsIGZlYXR1cmVzLCBW SVJUSU9fTkVUX0ZfQ1RSTF9SWF9FWFRSQSk7Cj4gKyAgICAgICBQUklOVF9GQklUX05BTUUoc2Vx LCBmZWF0dXJlcywgVklSVElPX05FVF9GX0dVRVNUX0FOTk9VTkNFKTsKPiArICAgICAgIFBSSU5U X0ZCSVRfTkFNRShzZXEsIGZlYXR1cmVzLCBWSVJUSU9fTkVUX0ZfTVEpOwo+ICsgICAgICAgUFJJ TlRfRkJJVF9OQU1FKHNlcSwgZmVhdHVyZXMsIFZJUlRJT19ORVRfRl9DVFJMX01BQ19BRERSKTsK PiArICAgICAgIFBSSU5UX0ZCSVRfTkFNRShzZXEsIGZlYXR1cmVzLCBWSVJUSU9fTkVUX0ZfSEFT SF9SRVBPUlQpOwo+ICsgICAgICAgUFJJTlRfRkJJVF9OQU1FKHNlcSwgZmVhdHVyZXMsIFZJUlRJ T19ORVRfRl9SU1MpOwo+ICsgICAgICAgUFJJTlRfRkJJVF9OQU1FKHNlcSwgZmVhdHVyZXMsIFZJ UlRJT19ORVRfRl9SU0NfRVhUKTsKPiArICAgICAgIFBSSU5UX0ZCSVRfTkFNRShzZXEsIGZlYXR1 cmVzLCBWSVJUSU9fTkVUX0ZfU1RBTkRCWSk7Cj4gKyAgICAgICBQUklOVF9GQklUX05BTUUoc2Vx LCBmZWF0dXJlcywgVklSVElPX05FVF9GX1NQRUVEX0RVUExFWCk7Cj4gKyAgICAgICBQUklOVF9G QklUX05BTUUoc2VxLCBmZWF0dXJlcywgVklSVElPX0ZfTk9USUZZX09OX0VNUFRZKTsKPiArICAg ICAgIFBSSU5UX0ZCSVRfTkFNRShzZXEsIGZlYXR1cmVzLCBWSVJUSU9fRl9BTllfTEFZT1VUKTsK PiArICAgICAgIFBSSU5UX0ZCSVRfTkFNRShzZXEsIGZlYXR1cmVzLCBWSVJUSU9fRl9WRVJTSU9O XzEpOwo+ICsgICAgICAgUFJJTlRfRkJJVF9OQU1FKHNlcSwgZmVhdHVyZXMsIFZJUlRJT19GX0FD Q0VTU19QTEFURk9STSk7Cj4gKyAgICAgICBQUklOVF9GQklUX05BTUUoc2VxLCBmZWF0dXJlcywg VklSVElPX0ZfUklOR19QQUNLRUQpOwo+ICsgICAgICAgUFJJTlRfRkJJVF9OQU1FKHNlcSwgZmVh dHVyZXMsIFZJUlRJT19GX09SREVSX1BMQVRGT1JNKTsKPiArICAgICAgIFBSSU5UX0ZCSVRfTkFN RShzZXEsIGZlYXR1cmVzLCBWSVJUSU9fRl9TUl9JT1YpOwo+ICsgICAgICAgc2VxX3B1dHMoc2Vx LCAiXG4iKTsKClNob3VsZCB3ZSBwcmludCB0aGUgZmVhdHVyZXMgdGhhdCBhcmUgbm90IHVuZGVy c3Rvb2QgaGVyZT8KCj4gK30KPiArCj4gK3ZvaWQgcGRzX3ZkcGFfZGVidWdmc19hZGRfcGNpZGV2 KHN0cnVjdCBwZHNfdmRwYV9hdXggKnZkcGFfYXV4KQo+ICt7Cj4gKyAgICAgICB2ZHBhX2F1eC0+ ZGVudHJ5ID0gZGVidWdmc19jcmVhdGVfZGlyKHBjaV9uYW1lKHZkcGFfYXV4LT5wYWRldi0+dmYt PnBkZXYpLCBkYmZzX2Rpcik7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgaWRlbnRpdHlfc2hvdyhz dHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgdm9pZCAqdikKPiArewo+ICsgICAgICAgc3RydWN0IHBkc192 ZHBhX2F1eCAqdmRwYV9hdXggPSBzZXEtPnByaXZhdGU7Cj4gKyAgICAgICBzdHJ1Y3QgdmRwYV9t Z210X2RldiAqbWdtdDsKPiArCj4gKyAgICAgICBzZXFfcHJpbnRmKHNlcSwgImF1eF9kZXY6ICAg ICAgICAgICAgJXNcbiIsCj4gKyAgICAgICAgICAgICAgICAgIGRldl9uYW1lKCZ2ZHBhX2F1eC0+ cGFkZXYtPmF1eF9kZXYuZGV2KSk7Cj4gKwo+ICsgICAgICAgbWdtdCA9ICZ2ZHBhX2F1eC0+dmRw YV9tZGV2Owo+ICsgICAgICAgc2VxX3ByaW50ZihzZXEsICJtYXhfdnFzOiAgICAgICAgICAgICVk XG4iLCBtZ210LT5tYXhfc3VwcG9ydGVkX3Zxcyk7Cj4gKyAgICAgICBzZXFfcHJpbnRmKHNlcSwg ImNvbmZpZ19hdHRyX21hc2s6ICAgJSNsbHhcbiIsIG1nbXQtPmNvbmZpZ19hdHRyX21hc2spOwo+ ICsgICAgICAgc2VxX3ByaW50ZihzZXEsICJzdXBwb3J0ZWRfZmVhdHVyZXM6ICUjbGx4XG4iLCBt Z210LT5zdXBwb3J0ZWRfZmVhdHVyZXMpOwo+ICsgICAgICAgcHJpbnRfZmVhdHVyZV9iaXRzKHNl cSwgbWdtdC0+c3VwcG9ydGVkX2ZlYXR1cmVzKTsKPiArCj4gKyAgICAgICByZXR1cm4gMDsKPiAr fQo+ICtERUZJTkVfU0hPV19BVFRSSUJVVEUoaWRlbnRpdHkpOwo+ICsKPiArdm9pZCBwZHNfdmRw YV9kZWJ1Z2ZzX2FkZF9pZGVudChzdHJ1Y3QgcGRzX3ZkcGFfYXV4ICp2ZHBhX2F1eCkKPiArewo+ ICsgICAgICAgZGVidWdmc19jcmVhdGVfZmlsZSgiaWRlbnRpdHkiLCAwNDAwLCB2ZHBhX2F1eC0+ ZGVudHJ5LAo+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICB2ZHBhX2F1eCwgJmlkZW50aXR5 X2ZvcHMpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGNvbmZpZ19zaG93KHN0cnVjdCBzZXFfZmls ZSAqc2VxLCB2b2lkICp2KQo+ICt7Cj4gKyAgICAgICBzdHJ1Y3QgcGRzX3ZkcGFfZGV2aWNlICpw ZHN2ID0gc2VxLT5wcml2YXRlOwo+ICsgICAgICAgc3RydWN0IHZpcnRpb19uZXRfY29uZmlnIHZj Owo+ICsKPiArICAgICAgIG1lbWNweV9mcm9taW8oJnZjLCBwZHN2LT52ZHBhX2F1eC0+dmRfbWRl di5kZXZpY2UsCj4gKyAgICAgICAgICAgICAgICAgICAgIHNpemVvZihzdHJ1Y3QgdmlydGlvX25l dF9jb25maWcpKTsKPiArCj4gKyAgICAgICBzZXFfcHJpbnRmKHNlcSwgIm1hYzogICAgICAgICAg ICAgICAgICAlcE1cbiIsIHZjLm1hYyk7Cj4gKyAgICAgICBzZXFfcHJpbnRmKHNlcSwgIm1heF92 aXJ0cXVldWVfcGFpcnM6ICAlZFxuIiwKPiArICAgICAgICAgICAgICAgICAgX192aXJ0aW8xNl90 b19jcHUodHJ1ZSwgdmMubWF4X3ZpcnRxdWV1ZV9wYWlycykpOwo+ICsgICAgICAgc2VxX3ByaW50 ZihzZXEsICJtdHU6ICAgICAgICAgICAgICAgICAgJWRcbiIsIF9fdmlydGlvMTZfdG9fY3B1KHRy dWUsIHZjLm10dSkpOwo+ICsgICAgICAgc2VxX3ByaW50ZihzZXEsICJzcGVlZDogICAgICAgICAg ICAgICAgJWRcbiIsIGxlMzJfdG9fY3B1KHZjLnNwZWVkKSk7Cj4gKyAgICAgICBzZXFfcHJpbnRm KHNlcSwgImR1cGxleDogICAgICAgICAgICAgICAlZFxuIiwgdmMuZHVwbGV4KTsKPiArICAgICAg IHNlcV9wcmludGYoc2VxLCAicnNzX21heF9rZXlfc2l6ZTogICAgICVkXG4iLCB2Yy5yc3NfbWF4 X2tleV9zaXplKTsKPiArICAgICAgIHNlcV9wcmludGYoc2VxLCAicnNzX21heF9pbmRpcmVjdGlv bl90YWJsZV9sZW5ndGg6ICVkXG4iLAo+ICsgICAgICAgICAgICAgICAgICBsZTE2X3RvX2NwdSh2 Yy5yc3NfbWF4X2luZGlyZWN0aW9uX3RhYmxlX2xlbmd0aCkpOwo+ICsgICAgICAgc2VxX3ByaW50 ZihzZXEsICJzdXBwb3J0ZWRfaGFzaF90eXBlczogJSN4XG4iLAo+ICsgICAgICAgICAgICAgICAg ICBsZTMyX3RvX2NwdSh2Yy5zdXBwb3J0ZWRfaGFzaF90eXBlcykpOwo+ICsgICAgICAgc2VxX3By aW50ZihzZXEsICJ2bl9zdGF0dXM6ICAgICAgICAgICAgJSN4XG4iLAo+ICsgICAgICAgICAgICAg ICAgICBfX3ZpcnRpbzE2X3RvX2NwdSh0cnVlLCB2Yy5zdGF0dXMpKTsKPiArICAgICAgIHByaW50 X3N0YXR1c19iaXRzKHNlcSwgX192aXJ0aW8xNl90b19jcHUodHJ1ZSwgdmMuc3RhdHVzKSk7Cj4g Kwo+ICsgICAgICAgc2VxX3ByaW50ZihzZXEsICJyZXFfZmVhdHVyZXM6ICAgICAgICAgJSNsbHhc biIsIHBkc3YtPnJlcV9mZWF0dXJlcyk7Cj4gKyAgICAgICBwcmludF9mZWF0dXJlX2JpdHMoc2Vx LCBwZHN2LT5yZXFfZmVhdHVyZXMpOwo+ICsgICAgICAgc2VxX3ByaW50ZihzZXEsICJhY3R1YWxf ZmVhdHVyZXM6ICAgICAgJSNsbHhcbiIsIHBkc3YtPmFjdHVhbF9mZWF0dXJlcyk7Cj4gKyAgICAg ICBwcmludF9mZWF0dXJlX2JpdHMoc2VxLCBwZHN2LT5hY3R1YWxfZmVhdHVyZXMpOwo+ICsgICAg ICAgc2VxX3ByaW50ZihzZXEsICJ2ZHBhX2luZGV4OiAgICAgICAgICAgJWRcbiIsIHBkc3YtPnZk cGFfaW5kZXgpOwo+ICsgICAgICAgc2VxX3ByaW50ZihzZXEsICJudW1fdnFzOiAgICAgICAgICAg ICAgJWRcbiIsIHBkc3YtPm51bV92cXMpOwo+ICsKPiArICAgICAgIHJldHVybiAwOwo+ICt9Cj4g K0RFRklORV9TSE9XX0FUVFJJQlVURShjb25maWcpOwo+ICsKPiArc3RhdGljIGludCB2cV9zaG93 KHN0cnVjdCBzZXFfZmlsZSAqc2VxLCB2b2lkICp2KQo+ICt7Cj4gKyAgICAgICBzdHJ1Y3QgcGRz X3ZkcGFfdnFfaW5mbyAqdnEgPSBzZXEtPnByaXZhdGU7Cj4gKwo+ICsgICAgICAgc2VxX3ByaW50 ZihzZXEsICJyZWFkeTogICAgICAlZFxuIiwgdnEtPnJlYWR5KTsKPiArICAgICAgIHNlcV9wcmlu dGYoc2VxLCAiZGVzY19hZGRyOiAgJSNsbHhcbiIsIHZxLT5kZXNjX2FkZHIpOwo+ICsgICAgICAg c2VxX3ByaW50ZihzZXEsICJhdmFpbF9hZGRyOiAlI2xseFxuIiwgdnEtPmF2YWlsX2FkZHIpOwo+ ICsgICAgICAgc2VxX3ByaW50ZihzZXEsICJ1c2VkX2FkZHI6ICAlI2xseFxuIiwgdnEtPnVzZWRf YWRkcik7Cj4gKyAgICAgICBzZXFfcHJpbnRmKHNlcSwgInFfbGVuOiAgICAgICVkXG4iLCB2cS0+ cV9sZW4pOwo+ICsgICAgICAgc2VxX3ByaW50ZihzZXEsICJxaWQ6ICAgICAgICAlZFxuIiwgdnEt PnFpZCk7Cj4gKwo+ICsgICAgICAgc2VxX3ByaW50ZihzZXEsICJkb29yYmVsbDogICAlI2xseFxu IiwgdnEtPmRvb3JiZWxsKTsKPiArICAgICAgIHNlcV9wcmludGYoc2VxLCAiYXZhaWxfaWR4OiAg JWRcbiIsIHZxLT5hdmFpbF9pZHgpOwo+ICsgICAgICAgc2VxX3ByaW50ZihzZXEsICJ1c2VkX2lk eDogICAlZFxuIiwgdnEtPnVzZWRfaWR4KTsKPiArICAgICAgIHNlcV9wcmludGYoc2VxLCAiaXJx OiAgICAgICAgJWRcbiIsIHZxLT5pcnEpOwo+ICsgICAgICAgc2VxX3ByaW50ZihzZXEsICJpcnEt bmFtZTogICAlc1xuIiwgdnEtPmlycV9uYW1lKTsKPiArCj4gKyAgICAgICBzZXFfcHJpbnRmKHNl cSwgImh3X3F0eXBlOiAgICVkXG4iLCB2cS0+aHdfcXR5cGUpOwo+ICsgICAgICAgc2VxX3ByaW50 ZihzZXEsICJod19xaW5kZXg6ICAlZFxuIiwgdnEtPmh3X3FpbmRleCk7Cj4gKwo+ICsgICAgICAg cmV0dXJuIDA7Cj4gK30KPiArREVGSU5FX1NIT1dfQVRUUklCVVRFKHZxKTsKPiArCj4gK3ZvaWQg cGRzX3ZkcGFfZGVidWdmc19hZGRfdmRwYWRldihzdHJ1Y3QgcGRzX3ZkcGFfYXV4ICp2ZHBhX2F1 eCkKPiArewo+ICsgICAgICAgaW50IGk7Cj4gKwo+ICsgICAgICAgZGVidWdmc19jcmVhdGVfZmls ZSgiY29uZmlnIiwgMDQwMCwgdmRwYV9hdXgtPmRlbnRyeSwgdmRwYV9hdXgtPnBkc3YsICZjb25m aWdfZm9wcyk7Cj4gKwo+ICsgICAgICAgZm9yIChpID0gMDsgaSA8IHZkcGFfYXV4LT5wZHN2LT5u dW1fdnFzOyBpKyspIHsKPiArICAgICAgICAgICAgICAgY2hhciBuYW1lWzhdOwo+ICsKPiArICAg ICAgICAgICAgICAgc25wcmludGYobmFtZSwgc2l6ZW9mKG5hbWUpLCAidnElMDJkIiwgaSk7Cj4g KyAgICAgICAgICAgICAgIGRlYnVnZnNfY3JlYXRlX2ZpbGUobmFtZSwgMDQwMCwgdmRwYV9hdXgt PmRlbnRyeSwKPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmdmRwYV9hdXgt PnBkc3YtPnZxc1tpXSwgJnZxX2ZvcHMpOwo+ICsgICAgICAgfQo+ICt9Cj4gKwo+ICt2b2lkIHBk c192ZHBhX2RlYnVnZnNfZGVsX3ZkcGFkZXYoc3RydWN0IHBkc192ZHBhX2F1eCAqdmRwYV9hdXgp Cj4gK3sKPiArICAgICAgIGRlYnVnZnNfcmVtb3ZlX3JlY3Vyc2l2ZSh2ZHBhX2F1eC0+ZGVudHJ5 KTsKPiArICAgICAgIHZkcGFfYXV4LT5kZW50cnkgPSBOVUxMOwo+ICt9Cj4gICNlbmRpZiAvKiBD T05GSUdfREVCVUdfRlMgKi8KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy92ZHBhL3Bkcy9kZWJ1Z2Zz LmggYi9kcml2ZXJzL3ZkcGEvcGRzL2RlYnVnZnMuaAo+IGluZGV4IGZmZjA3OGE4NjllNS4uMjNl ODM0NWFkZDBkIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvdmRwYS9wZHMvZGVidWdmcy5oCj4gKysr IGIvZHJpdmVycy92ZHBhL3Bkcy9kZWJ1Z2ZzLmgKPiBAQCAtMTAsOSArMTAsMTcgQEAKPgo+ICB2 b2lkIHBkc192ZHBhX2RlYnVnZnNfY3JlYXRlKHZvaWQpOwo+ICB2b2lkIHBkc192ZHBhX2RlYnVn ZnNfZGVzdHJveSh2b2lkKTsKPiArdm9pZCBwZHNfdmRwYV9kZWJ1Z2ZzX2FkZF9wY2lkZXYoc3Ry dWN0IHBkc192ZHBhX2F1eCAqdmRwYV9hdXgpOwo+ICt2b2lkIHBkc192ZHBhX2RlYnVnZnNfYWRk X2lkZW50KHN0cnVjdCBwZHNfdmRwYV9hdXggKnZkcGFfYXV4KTsKPiArdm9pZCBwZHNfdmRwYV9k ZWJ1Z2ZzX2FkZF92ZHBhZGV2KHN0cnVjdCBwZHNfdmRwYV9hdXggKnZkcGFfYXV4KTsKPiArdm9p ZCBwZHNfdmRwYV9kZWJ1Z2ZzX2RlbF92ZHBhZGV2KHN0cnVjdCBwZHNfdmRwYV9hdXggKnZkcGFf YXV4KTsKPiAgI2Vsc2UKPiAgc3RhdGljIGlubGluZSB2b2lkIHBkc192ZHBhX2RlYnVnZnNfY3Jl YXRlKHZvaWQpIHsgfQo+ICBzdGF0aWMgaW5saW5lIHZvaWQgcGRzX3ZkcGFfZGVidWdmc19kZXN0 cm95KHZvaWQpIHsgfQo+ICtzdGF0aWMgaW5saW5lIHZvaWQgcGRzX3ZkcGFfZGVidWdmc19hZGRf cGNpZGV2KHN0cnVjdCBwZHNfdmRwYV9hdXggKnZkcGFfYXV4KSB7IH0KPiArc3RhdGljIGlubGlu ZSB2b2lkIHBkc192ZHBhX2RlYnVnZnNfYWRkX2lkZW50KHN0cnVjdCBwZHNfdmRwYV9hdXggKnZk cGFfYXV4KSB7IH0KPiArc3RhdGljIGlubGluZSB2b2lkIHBkc192ZHBhX2RlYnVnZnNfYWRkX3Zk cGFkZXYoc3RydWN0IHBkc192ZHBhX2F1eCAqdmRwYV9hdXgpIHsgfQo+ICtzdGF0aWMgaW5saW5l IHZvaWQgcGRzX3ZkcGFfZGVidWdmc19kZWxfdmRwYWRldihzdHJ1Y3QgcGRzX3ZkcGFfYXV4ICp2 ZHBhX2F1eCkgeyB9Cj4gICNlbmRpZgo+Cj4gICNlbmRpZiAvKiBfUERTX1ZEUEFfREVCVUdGU19I XyAqLwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3ZkcGEvcGRzL3ZkcGFfZGV2LmMgYi9kcml2ZXJz L3ZkcGEvcGRzL3ZkcGFfZGV2LmMKPiBpbmRleCAxNWQ2MjMyOTcyMDMuLjJlMGE1MDc4ZDM3OSAx MDA2NDQKPiAtLS0gYS9kcml2ZXJzL3ZkcGEvcGRzL3ZkcGFfZGV2LmMKPiArKysgYi9kcml2ZXJz L3ZkcGEvcGRzL3ZkcGFfZGV2LmMKPiBAQCAtNSw2ICs1LDcgQEAKPiAgI2luY2x1ZGUgPGxpbnV4 L3ZkcGEuaD4KPiAgI2luY2x1ZGUgPHVhcGkvbGludXgvdmRwYS5oPgo+ICAjaW5jbHVkZSA8bGlu dXgvdmlydGlvX3BjaV9tb2Rlcm4uaD4KPiArI2luY2x1ZGUgPHVhcGkvbGludXgvdmlydGlvX3Bj aS5oPgo+Cj4gICNpbmNsdWRlIDxsaW51eC9wZHMvcGRzX2NvcmUuaD4KPiAgI2luY2x1ZGUgPGxp bnV4L3Bkcy9wZHNfYWRtaW5xLmg+Cj4gQEAgLTEzLDcgKzE0LDQyNiBAQAo+Cj4gICNpbmNsdWRl ICJ2ZHBhX2Rldi5oIgo+ICAjaW5jbHVkZSAiYXV4X2Rydi5oIgo+ICsjaW5jbHVkZSAiY21kcy5o Igo+ICsjaW5jbHVkZSAiZGVidWdmcy5oIgo+Cj4gK3N0YXRpYyBzdHJ1Y3QgcGRzX3ZkcGFfZGV2 aWNlICp2ZHBhX3RvX3Bkc3Yoc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhX2RldikKPiArewo+ICsg ICAgICAgcmV0dXJuIGNvbnRhaW5lcl9vZih2ZHBhX2Rldiwgc3RydWN0IHBkc192ZHBhX2Rldmlj ZSwgdmRwYV9kZXYpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHBkc192ZHBhX3NldF92cV9hZGRy ZXNzKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYV9kZXYsIHUxNiBxaWQsCj4gKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICB1NjQgZGVzY19hZGRyLCB1NjQgZHJpdmVyX2FkZHIsIHU2 NCBkZXZpY2VfYWRkcikKPiArewo+ICsgICAgICAgc3RydWN0IHBkc192ZHBhX2RldmljZSAqcGRz diA9IHZkcGFfdG9fcGRzdih2ZHBhX2Rldik7Cj4gKwo+ICsgICAgICAgcGRzdi0+dnFzW3FpZF0u ZGVzY19hZGRyID0gZGVzY19hZGRyOwo+ICsgICAgICAgcGRzdi0+dnFzW3FpZF0uYXZhaWxfYWRk ciA9IGRyaXZlcl9hZGRyOwo+ICsgICAgICAgcGRzdi0+dnFzW3FpZF0udXNlZF9hZGRyID0gZGV2 aWNlX2FkZHI7Cj4gKwo+ICsgICAgICAgcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lk IHBkc192ZHBhX3NldF92cV9udW0oc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhX2RldiwgdTE2IHFp ZCwgdTMyIG51bSkKPiArewo+ICsgICAgICAgc3RydWN0IHBkc192ZHBhX2RldmljZSAqcGRzdiA9 IHZkcGFfdG9fcGRzdih2ZHBhX2Rldik7Cj4gKwo+ICsgICAgICAgcGRzdi0+dnFzW3FpZF0ucV9s ZW4gPSBudW07Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHBkc192ZHBhX2tpY2tfdnEoc3RydWN0 IHZkcGFfZGV2aWNlICp2ZHBhX2RldiwgdTE2IHFpZCkKPiArewo+ICsgICAgICAgc3RydWN0IHBk c192ZHBhX2RldmljZSAqcGRzdiA9IHZkcGFfdG9fcGRzdih2ZHBhX2Rldik7Cj4gKwo+ICsgICAg ICAgaW93cml0ZTE2KHFpZCwgcGRzdi0+dnFzW3FpZF0ubm90aWZ5KTsKPiArfQo+ICsKPiArc3Rh dGljIHZvaWQgcGRzX3ZkcGFfc2V0X3ZxX2NiKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYV9kZXYs IHUxNiBxaWQsCj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCB2ZHBhX2Nh bGxiYWNrICpjYikKPiArewo+ICsgICAgICAgc3RydWN0IHBkc192ZHBhX2RldmljZSAqcGRzdiA9 IHZkcGFfdG9fcGRzdih2ZHBhX2Rldik7Cj4gKwo+ICsgICAgICAgcGRzdi0+dnFzW3FpZF0uZXZl bnRfY2IgPSAqY2I7Cj4gK30KPiArCj4gK3N0YXRpYyBpcnFyZXR1cm5fdCBwZHNfdmRwYV9pc3Io aW50IGlycSwgdm9pZCAqZGF0YSkKPiArewo+ICsgICAgICAgc3RydWN0IHBkc192ZHBhX3ZxX2lu Zm8gKnZxOwo+ICsKPiArICAgICAgIHZxID0gZGF0YTsKPiArICAgICAgIGlmICh2cS0+ZXZlbnRf Y2IuY2FsbGJhY2spCj4gKyAgICAgICAgICAgICAgIHZxLT5ldmVudF9jYi5jYWxsYmFjayh2cS0+ ZXZlbnRfY2IucHJpdmF0ZSk7Cj4gKwo+ICsgICAgICAgcmV0dXJuIElSUV9IQU5ETEVEOwo+ICt9 Cj4gKwo+ICtzdGF0aWMgdm9pZCBwZHNfdmRwYV9yZWxlYXNlX2lycShzdHJ1Y3QgcGRzX3ZkcGFf ZGV2aWNlICpwZHN2LCBpbnQgcWlkKQo+ICt7Cj4gKyAgICAgICBpZiAocGRzdi0+dnFzW3FpZF0u aXJxID09IFZJUlRJT19NU0lfTk9fVkVDVE9SKQo+ICsgICAgICAgICAgICAgICByZXR1cm47Cj4g Kwo+ICsgICAgICAgZnJlZV9pcnEocGRzdi0+dnFzW3FpZF0uaXJxLCAmcGRzdi0+dnFzW3FpZF0p Owo+ICsgICAgICAgcGRzdi0+dnFzW3FpZF0uaXJxID0gVklSVElPX01TSV9OT19WRUNUT1I7Cj4g K30KPiArCj4gK3N0YXRpYyB2b2lkIHBkc192ZHBhX3NldF92cV9yZWFkeShzdHJ1Y3QgdmRwYV9k ZXZpY2UgKnZkcGFfZGV2LCB1MTYgcWlkLCBib29sIHJlYWR5KQo+ICt7Cj4gKyAgICAgICBzdHJ1 Y3QgcGRzX3ZkcGFfZGV2aWNlICpwZHN2ID0gdmRwYV90b19wZHN2KHZkcGFfZGV2KTsKPiArICAg ICAgIHN0cnVjdCBwY2lfZGV2ICpwZGV2ID0gcGRzdi0+dmRwYV9hdXgtPnBhZGV2LT52Zi0+cGRl djsKPiArICAgICAgIHN0cnVjdCBkZXZpY2UgKmRldiA9ICZwZHN2LT52ZHBhX2Rldi5kZXY7Cj4g KyAgICAgICBpbnQgaXJxOwo+ICsgICAgICAgaW50IGVycjsKPiArCj4gKyAgICAgICBkZXZfZGJn KGRldiwgIiVzOiBxaWQgJWQgcmVhZHkgJWQgPT4gJWRcbiIsCj4gKyAgICAgICAgICAgICAgIF9f ZnVuY19fLCBxaWQsIHBkc3YtPnZxc1txaWRdLnJlYWR5LCByZWFkeSk7Cj4gKyAgICAgICBpZiAo cmVhZHkgPT0gcGRzdi0+dnFzW3FpZF0ucmVhZHkpCj4gKyAgICAgICAgICAgICAgIHJldHVybjsK PiArCj4gKyAgICAgICBpZiAocmVhZHkpIHsKPiArICAgICAgICAgICAgICAgaXJxID0gcGNpX2ly cV92ZWN0b3IocGRldiwgcWlkKTsKPiArICAgICAgICAgICAgICAgc25wcmludGYocGRzdi0+dnFz W3FpZF0uaXJxX25hbWUsIHNpemVvZihwZHN2LT52cXNbcWlkXS5pcnFfbmFtZSksCj4gKyAgICAg ICAgICAgICAgICAgICAgICAgICJ2ZHBhLSVzLSVkIiwgZGV2X25hbWUoZGV2KSwgcWlkKTsKPiAr Cj4gKyAgICAgICAgICAgICAgIGVyciA9IHJlcXVlc3RfaXJxKGlycSwgcGRzX3ZkcGFfaXNyLCAw LAo+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwZHN2LT52cXNbcWlkXS5pcnFf bmFtZSwgJnBkc3YtPnZxc1txaWRdKTsKPiArICAgICAgICAgICAgICAgaWYgKGVycikgewo+ICsg ICAgICAgICAgICAgICAgICAgICAgIGRldl9lcnIoZGV2LCAiJXM6IG5vIGlycSBmb3IgcWlkICVk OiAlcGVcbiIsCj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBfX2Z1bmNfXywgcWlk LCBFUlJfUFRSKGVycikpOwo+ICsgICAgICAgICAgICAgICAgICAgICAgIHJldHVybjsKPiArICAg ICAgICAgICAgICAgfQo+ICsgICAgICAgICAgICAgICBwZHN2LT52cXNbcWlkXS5pcnEgPSBpcnE7 Cj4gKwo+ICsgICAgICAgICAgICAgICAvKiBQYXNzIHZxIHNldHVwIGluZm8gdG8gRFNDICovCj4g KyAgICAgICAgICAgICAgIGVyciA9IHBkc192ZHBhX2NtZF9pbml0X3ZxKHBkc3YsIHFpZCwgJnBk c3YtPnZxc1txaWRdKTsKPiArICAgICAgICAgICAgICAgaWYgKGVycikgewo+ICsgICAgICAgICAg ICAgICAgICAgICAgIHBkc192ZHBhX3JlbGVhc2VfaXJxKHBkc3YsIHFpZCk7Cj4gKyAgICAgICAg ICAgICAgICAgICAgICAgcmVhZHkgPSBmYWxzZTsKPiArICAgICAgICAgICAgICAgfQo+ICsgICAg ICAgfSBlbHNlIHsKPiArICAgICAgICAgICAgICAgZXJyID0gcGRzX3ZkcGFfY21kX3Jlc2V0X3Zx KHBkc3YsIHFpZCk7Cj4gKyAgICAgICAgICAgICAgIGlmIChlcnIpCj4gKyAgICAgICAgICAgICAg ICAgICAgICAgZGV2X2VycihkZXYsICIlczogcmVzZXRfdnEgZmFpbGVkIHFpZCAlZDogJXBlXG4i LAo+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgX19mdW5jX18sIHFpZCwgRVJSX1BU UihlcnIpKTsKPiArICAgICAgICAgICAgICAgcGRzX3ZkcGFfcmVsZWFzZV9pcnEocGRzdiwgcWlk KTsKPiArICAgICAgIH0KPiArCj4gKyAgICAgICBwZHN2LT52cXNbcWlkXS5yZWFkeSA9IHJlYWR5 Owo+ICt9Cj4gKwo+ICtzdGF0aWMgYm9vbCBwZHNfdmRwYV9nZXRfdnFfcmVhZHkoc3RydWN0IHZk cGFfZGV2aWNlICp2ZHBhX2RldiwgdTE2IHFpZCkKPiArewo+ICsgICAgICAgc3RydWN0IHBkc192 ZHBhX2RldmljZSAqcGRzdiA9IHZkcGFfdG9fcGRzdih2ZHBhX2Rldik7Cj4gKwo+ICsgICAgICAg cmV0dXJuIHBkc3YtPnZxc1txaWRdLnJlYWR5Owo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHBkc192 ZHBhX3NldF92cV9zdGF0ZShzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGFfZGV2LCB1MTYgcWlkLAo+ ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IHN0cnVjdCB2ZHBhX3ZxX3N0 YXRlICpzdGF0ZSkKPiArewo+ICsgICAgICAgc3RydWN0IHBkc192ZHBhX2RldmljZSAqcGRzdiA9 IHZkcGFfdG9fcGRzdih2ZHBhX2Rldik7Cj4gKyAgICAgICBzdHJ1Y3QgcGRzX2F1eGlsaWFyeV9k ZXYgKnBhZGV2ID0gcGRzdi0+dmRwYV9hdXgtPnBhZGV2Owo+ICsgICAgICAgc3RydWN0IGRldmlj ZSAqZGV2ID0gJnBhZGV2LT5hdXhfZGV2LmRldjsKPiArICAgICAgIHN0cnVjdCBwZHNfdmRwYV92 cV9zZXRfc3RhdGVfY21kIGNtZCA9IHsKPiArICAgICAgICAgICAgICAgLm9wY29kZSA9IFBEU19W RFBBX0NNRF9WUV9TRVRfU1RBVEUsCj4gKyAgICAgICAgICAgICAgIC52ZHBhX2luZGV4ID0gcGRz di0+dmRwYV9pbmRleCwKPiArICAgICAgICAgICAgICAgLnZmX2lkID0gY3B1X3RvX2xlMTYocGRz di0+dmRwYV9hdXgtPnZmX2lkKSwKPiArICAgICAgICAgICAgICAgLnFpZCA9IGNwdV90b19sZTE2 KHFpZCksCj4gKyAgICAgICB9Owo+ICsgICAgICAgc3RydWN0IHBkc192ZHBhX2NvbXAgY29tcCA9 IHswfTsKPiArICAgICAgIGludCBlcnI7Cj4gKwo+ICsgICAgICAgZGV2X2RiZyhkZXYsICIlczog cWlkICVkIGF2YWlsICUjeFxuIiwKPiArICAgICAgICAgICAgICAgX19mdW5jX18sIHFpZCwgc3Rh dGUtPnBhY2tlZC5sYXN0X2F2YWlsX2lkeCk7Cj4gKwo+ICsgICAgICAgaWYgKHBkc3YtPmFjdHVh bF9mZWF0dXJlcyAmIFZJUlRJT19GX1JJTkdfUEFDS0VEKSB7Cj4gKyAgICAgICAgICAgICAgIGNt ZC5hdmFpbCA9IGNwdV90b19sZTE2KHN0YXRlLT5wYWNrZWQubGFzdF9hdmFpbF9pZHggfAo+ICsg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAoc3RhdGUtPnBhY2tlZC5sYXN0 X2F2YWlsX2NvdW50ZXIgPDwgMTUpKTsKPiArICAgICAgICAgICAgICAgY21kLnVzZWQgPSBjcHVf dG9fbGUxNihzdGF0ZS0+cGFja2VkLmxhc3RfdXNlZF9pZHggfAo+ICsgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIChzdGF0ZS0+cGFja2VkLmxhc3RfdXNlZF9jb3VudGVyIDw8 IDE1KSk7Cj4gKyAgICAgICB9IGVsc2Ugewo+ICsgICAgICAgICAgICAgICBjbWQuYXZhaWwgPSBj cHVfdG9fbGUxNihzdGF0ZS0+c3BsaXQuYXZhaWxfaW5kZXgpOwo+ICsgICAgICAgICAgICAgICAv KiBzdGF0ZS0+c3BsaXQgZG9lcyBub3QgcHJvdmlkZSBhIHVzZWRfaW5kZXg6Cj4gKyAgICAgICAg ICAgICAgICAqIHRoZSB2cSB3aWxsIGJlIHNldCB0byAiZW1wdHkiIGhlcmUsIGFuZCB0aGUgdnEg d2lsbCByZWFkCj4gKyAgICAgICAgICAgICAgICAqIHRoZSBjdXJyZW50IHVzZWQgaW5kZXggdGhl IG5leHQgdGltZSB0aGUgdnEgaXMga2lja2VkLgo+ICsgICAgICAgICAgICAgICAgKi8KPiArICAg ICAgICAgICAgICAgY21kLnVzZWQgPSBjcHVfdG9fbGUxNihzdGF0ZS0+c3BsaXQuYXZhaWxfaW5k ZXgpOwo+ICsgICAgICAgfQo+ICsKPiArICAgICAgIGVyciA9IHBhZGV2LT5vcHMtPmFkbWlucV9j bWQocGFkZXYsCj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICh1bmlvbiBw ZHNfY29yZV9hZG1pbnFfY21kICopJmNtZCwKPiArICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgc2l6ZW9mKGNtZCksCj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICh1bmlvbiBwZHNfY29yZV9hZG1pbnFfY29tcCAqKSZjb21wLAo+ICsgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAwKTsKCkkgaGFkIG9uZSBxdWVzdGlvbiBmb3IgYWRtaW5x IGNvbW1hbmQuIEkgdGhpbmsgd2Ugc2hvdWxkIHVzZSBQRgppbnN0ZWFkIG9mIFZGIGJ1dCBpbiBf X3Bkc2NfYWRtaW5xX3Bvc3QoKSBJIHNhdzoKCiAgICAgICAgcV9pbmZvLT5kZXN0ID0gY29tcDsK ICAgICAgICBtZW1jcHkocV9pbmZvLT5kZXNjLCBjbWQsIHNpemVvZigqY21kKSk7CgpTbyBjbWQg c2hvdWxkIGJlIGZpbmUgc2luY2UgaXQgaXMgY29waWVkIHRvIHRoZSBxX2luZm8tPmRlc2Mgd2hp Y2ggaXMKYWxyZWFkeSBtYXBwZWQuIEJ1dCBxX2luZm8tPmRlc3QgbG9vayBzdXNwaWNpb3VzLCB3 aGVyZSBkaWQgaXQgbWFwcGVkPwoKVGhhbmtzCgoKPiArICAgICAgIGlmIChlcnIpCj4gKyAgICAg ICAgICAgICAgIGRldl9lcnIoZGV2LCAiRmFpbGVkIHRvIHNldCB2cSBzdGF0ZSBxaWQgJXUsIHN0 YXR1cyAlZDogJXBlXG4iLAo+ICsgICAgICAgICAgICAgICAgICAgICAgIHFpZCwgY29tcC5zdGF0 dXMsIEVSUl9QVFIoZXJyKSk7Cj4gKwo+ICsgICAgICAgcmV0dXJuIGVycjsKPiArfQo+ICsKPiAr c3RhdGljIGludCBwZHNfdmRwYV9nZXRfdnFfc3RhdGUoc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBh X2RldiwgdTE2IHFpZCwKPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3Qg dmRwYV92cV9zdGF0ZSAqc3RhdGUpCj4gK3sKPiArICAgICAgIHN0cnVjdCBwZHNfdmRwYV9kZXZp Y2UgKnBkc3YgPSB2ZHBhX3RvX3Bkc3YodmRwYV9kZXYpOwo+ICsgICAgICAgc3RydWN0IHBkc19h dXhpbGlhcnlfZGV2ICpwYWRldiA9IHBkc3YtPnZkcGFfYXV4LT5wYWRldjsKPiArICAgICAgIHN0 cnVjdCBkZXZpY2UgKmRldiA9ICZwYWRldi0+YXV4X2Rldi5kZXY7Cj4gKyAgICAgICBzdHJ1Y3Qg cGRzX3ZkcGFfdnFfZ2V0X3N0YXRlX2NtZCBjbWQgPSB7Cj4gKyAgICAgICAgICAgICAgIC5vcGNv ZGUgPSBQRFNfVkRQQV9DTURfVlFfR0VUX1NUQVRFLAo+ICsgICAgICAgICAgICAgICAudmRwYV9p bmRleCA9IHBkc3YtPnZkcGFfaW5kZXgsCj4gKyAgICAgICAgICAgICAgIC52Zl9pZCA9IGNwdV90 b19sZTE2KHBkc3YtPnZkcGFfYXV4LT52Zl9pZCksCj4gKyAgICAgICAgICAgICAgIC5xaWQgPSBj cHVfdG9fbGUxNihxaWQpLAo+ICsgICAgICAgfTsKPiArICAgICAgIHN0cnVjdCBwZHNfdmRwYV92 cV9nZXRfc3RhdGVfY29tcCBjb21wID0gezB9Owo+ICsgICAgICAgaW50IGVycjsKPiArCj4gKyAg ICAgICBkZXZfZGJnKGRldiwgIiVzOiBxaWQgJWRcbiIsIF9fZnVuY19fLCBxaWQpOwo+ICsKPiAr ICAgICAgIGVyciA9IHBhZGV2LT5vcHMtPmFkbWlucV9jbWQocGFkZXYsCj4gKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICh1bmlvbiBwZHNfY29yZV9hZG1pbnFfY21kICopJmNt ZCwKPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc2l6ZW9mKGNtZCksCj4g KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICh1bmlvbiBwZHNfY29yZV9hZG1p bnFfY29tcCAqKSZjb21wLAo+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAw KTsKPiArICAgICAgIGlmIChlcnIpIHsKPiArICAgICAgICAgICAgICAgZGV2X2VycihkZXYsICJG YWlsZWQgdG8gZ2V0IHZxIHN0YXRlIHFpZCAldSwgc3RhdHVzICVkOiAlcGVcbiIsCj4gKyAgICAg ICAgICAgICAgICAgICAgICAgcWlkLCBjb21wLnN0YXR1cywgRVJSX1BUUihlcnIpKTsKPiArICAg ICAgICAgICAgICAgcmV0dXJuIGVycjsKPiArICAgICAgIH0KPiArCj4gKyAgICAgICBpZiAocGRz di0+YWN0dWFsX2ZlYXR1cmVzICYgVklSVElPX0ZfUklOR19QQUNLRUQpIHsKPiArICAgICAgICAg ICAgICAgc3RhdGUtPnBhY2tlZC5sYXN0X2F2YWlsX2lkeCA9IGxlMTZfdG9fY3B1KGNvbXAuYXZh aWwpICYgMHg3ZmZmOwo+ICsgICAgICAgICAgICAgICBzdGF0ZS0+cGFja2VkLmxhc3RfYXZhaWxf Y291bnRlciA9IGxlMTZfdG9fY3B1KGNvbXAuYXZhaWwpID4+IDE1Owo+ICsgICAgICAgfSBlbHNl IHsKPiArICAgICAgICAgICAgICAgc3RhdGUtPnNwbGl0LmF2YWlsX2luZGV4ID0gbGUxNl90b19j cHUoY29tcC5hdmFpbCk7Cj4gKyAgICAgICAgICAgICAgIC8qIHN0YXRlLT5zcGxpdCBkb2VzIG5v dCBwcm92aWRlIGEgdXNlZF9pbmRleC4gKi8KPiArICAgICAgIH0KPiArCj4gKyAgICAgICByZXR1 cm4gZXJyOwo+ICt9Cj4gKwo+ICtzdGF0aWMgc3RydWN0IHZkcGFfbm90aWZpY2F0aW9uX2FyZWEK PiArcGRzX3ZkcGFfZ2V0X3ZxX25vdGlmaWNhdGlvbihzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGFf ZGV2LCB1MTYgcWlkKQo+ICt7Cj4gKyAgICAgICBzdHJ1Y3QgcGRzX3ZkcGFfZGV2aWNlICpwZHN2 ID0gdmRwYV90b19wZHN2KHZkcGFfZGV2KTsKPiArICAgICAgIHN0cnVjdCB2aXJ0aW9fcGNpX21v ZGVybl9kZXZpY2UgKnZkX21kZXY7Cj4gKyAgICAgICBzdHJ1Y3QgdmRwYV9ub3RpZmljYXRpb25f YXJlYSBhcmVhOwo+ICsKPiArICAgICAgIGFyZWEuYWRkciA9IHBkc3YtPnZxc1txaWRdLm5vdGlm eV9wYTsKPiArCj4gKyAgICAgICB2ZF9tZGV2ID0gJnBkc3YtPnZkcGFfYXV4LT52ZF9tZGV2Owo+ ICsgICAgICAgaWYgKCF2ZF9tZGV2LT5ub3RpZnlfb2Zmc2V0X211bHRpcGxpZXIpCj4gKyAgICAg ICAgICAgICAgIGFyZWEuc2l6ZSA9IFBBR0VfU0laRTsKCk5vdGUgdGhhdCBQQUdFX1NJWkUgdmFy aWVzIGFtb25nIGFyY2hzLCBJIGRvdWJ0IHdlIHNob3VsZCB1c2UgYSBmaXhlZCBzaXplIGhlcmUu CgpPdGhlcnMgbG9vayBnb29kLgoKVGhhbmtzCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXwpWaXJ0dWFsaXphdGlvbiBtYWlsaW5nIGxpc3QKVmlydHVhbGl6 YXRpb25AbGlzdHMubGludXgtZm91bmRhdGlvbi5vcmcKaHR0cHM6Ly9saXN0cy5saW51eGZvdW5k YXRpb24ub3JnL21haWxtYW4vbGlzdGluZm8vdmlydHVhbGl6YXRpb24= 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 EDBE6C6FD1D for ; Wed, 15 Mar 2023 07:07:34 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231579AbjCOHHd (ORCPT ); Wed, 15 Mar 2023 03:07:33 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38026 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231575AbjCOHHW (ORCPT ); Wed, 15 Mar 2023 03:07:22 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 35359591FF for ; Wed, 15 Mar 2023 00:06:02 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1678863961; 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=AVeDCxcVeUEwINX4A+87k6K5ylMcJjroc1LtLw+moxQ=; b=iqG40+YtT0VvLDvKcIbHZ7Cm19HMQxivUQX2tPRl93SpwmMnvMq1qaOI56DOS1vMibZIlv tXlWTIatCPbNArj14HTrBGj8hD5BXHvB66yiOkYG745iTWXXOgIHHDABJHb5BzwIYE6Y+g EqA2KhWglO2ZIh/mUjowad5K2tv3M+4= Received: from mail-ot1-f71.google.com (mail-ot1-f71.google.com [209.85.210.71]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-283-gj3l3qGRMoSk4TazEBk95A-1; Wed, 15 Mar 2023 03:05:59 -0400 X-MC-Unique: gj3l3qGRMoSk4TazEBk95A-1 Received: by mail-ot1-f71.google.com with SMTP id w27-20020a056830411b00b0069411644fc5so8461379ott.14 for ; Wed, 15 Mar 2023 00:05:59 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; t=1678863957; h=content-transfer-encoding:cc:to:subject:message-id:date:from :in-reply-to:references:mime-version:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=AVeDCxcVeUEwINX4A+87k6K5ylMcJjroc1LtLw+moxQ=; b=p9dZfp+Fouc3Bc5/2sE/kXSamouwKa639IqPpXYDQPGTpmtdCV1JOqeOjbe0CF0B02 8m+H+0JCWQxXtQv+jXh495ac7DTFqz5OgDK2IAIo9TLvCnxs2qrEDbnhgPqZXWWrQGZr yZrz8jeIJPCyXcEwCcKHJCEBtCJpht8TYjortn/u6PwerntN8P7FT3HlnE3kpmsdZLh3 8Ns/cXgEJ1IsOVwl3nNxiJ0AD1Ohdz2/x/Qky6R2GSnbZfzlmu9F/XH3zEIbDFSv8oKg tUs0Z17O/agGhKrhjUf2hIPyNDeAOmKFLES3pfSUjJ3WP5PplI8fwGPbGhEIKMi1YIIS eBMA== X-Gm-Message-State: AO0yUKUi4c4Gy3xN4QGHeTFhHd5Ot3Xk1XCV96QkkOGu7JU4o8G6D2jW BrJu/nY8XTnfPoz6tcvDx1FbR2xy5bm5HtnolIpRPlwUrUhCl2mNPv0epYV5LBvfmvOO9VOx5Wv uawNpjIhQKTpBjSRouYMnZKjXbDzTV58K X-Received: by 2002:a05:6808:6149:b0:384:27f0:bd0a with SMTP id dl9-20020a056808614900b0038427f0bd0amr478950oib.9.1678863957086; Wed, 15 Mar 2023 00:05:57 -0700 (PDT) X-Google-Smtp-Source: AK7set+WnuE5eiOs7ylPDUY/5xAf0BR2cgfz7T7MefTilIcifHuh2d99Dz/ke1uLTyhJHXSO0Bcmb0NygY8kmrYJ4So= X-Received: by 2002:a05:6808:6149:b0:384:27f0:bd0a with SMTP id dl9-20020a056808614900b0038427f0bd0amr478946oib.9.1678863956756; Wed, 15 Mar 2023 00:05:56 -0700 (PDT) MIME-Version: 1.0 References: <20230309013046.23523-1-shannon.nelson@amd.com> <20230309013046.23523-6-shannon.nelson@amd.com> In-Reply-To: <20230309013046.23523-6-shannon.nelson@amd.com> From: Jason Wang Date: Wed, 15 Mar 2023 15:05:45 +0800 Message-ID: Subject: Re: [PATCH RFC v2 virtio 5/7] pds_vdpa: add support for vdpa and vdpamgmt interfaces To: Shannon Nelson Cc: mst@redhat.com, virtualization@lists.linux-foundation.org, brett.creeley@amd.com, davem@davemloft.net, netdev@vger.kernel.org, kuba@kernel.org, drivers@pensando.io Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org On Thu, Mar 9, 2023 at 9:31=E2=80=AFAM Shannon Nelson wrote: > > This is the vDPA device support, where we advertise that we can > support the virtio queues and deal with the configuration work > through the pds_core's adminq. > > Signed-off-by: Shannon Nelson > --- > drivers/vdpa/pds/aux_drv.c | 15 + > drivers/vdpa/pds/aux_drv.h | 1 + > drivers/vdpa/pds/debugfs.c | 172 ++++++++++++ > drivers/vdpa/pds/debugfs.h | 8 + > drivers/vdpa/pds/vdpa_dev.c | 545 +++++++++++++++++++++++++++++++++++- > 5 files changed, 740 insertions(+), 1 deletion(-) > > diff --git a/drivers/vdpa/pds/aux_drv.c b/drivers/vdpa/pds/aux_drv.c > index 28158d0d98a5..d706f06f7400 100644 > --- a/drivers/vdpa/pds/aux_drv.c > +++ b/drivers/vdpa/pds/aux_drv.c > @@ -60,8 +60,21 @@ static int pds_vdpa_probe(struct auxiliary_device *aux= _dev, > goto err_free_mgmt_info; > } > > + /* Let vdpa know that we can provide devices */ > + err =3D vdpa_mgmtdev_register(&vdpa_aux->vdpa_mdev); > + if (err) { > + dev_err(dev, "%s: Failed to initialize vdpa_mgmt interfac= e: %pe\n", > + __func__, ERR_PTR(err)); > + goto err_free_virtio; > + } > + > + pds_vdpa_debugfs_add_pcidev(vdpa_aux); > + pds_vdpa_debugfs_add_ident(vdpa_aux); > + > return 0; > > +err_free_virtio: > + pds_vdpa_remove_virtio(&vdpa_aux->vd_mdev); > err_free_mgmt_info: > pci_free_irq_vectors(padev->vf->pdev); > err_aux_unreg: > @@ -78,11 +91,13 @@ static void pds_vdpa_remove(struct auxiliary_device *= aux_dev) > struct pds_vdpa_aux *vdpa_aux =3D auxiliary_get_drvdata(aux_dev); > struct device *dev =3D &aux_dev->dev; > > + vdpa_mgmtdev_unregister(&vdpa_aux->vdpa_mdev); > pds_vdpa_remove_virtio(&vdpa_aux->vd_mdev); > pci_free_irq_vectors(vdpa_aux->padev->vf->pdev); > > vdpa_aux->padev->ops->unregister_client(vdpa_aux->padev); > > + pds_vdpa_debugfs_del_vdpadev(vdpa_aux); > kfree(vdpa_aux); > auxiliary_set_drvdata(aux_dev, NULL); > > diff --git a/drivers/vdpa/pds/aux_drv.h b/drivers/vdpa/pds/aux_drv.h > index 87ac3c01c476..1ab1ce64da7c 100644 > --- a/drivers/vdpa/pds/aux_drv.h > +++ b/drivers/vdpa/pds/aux_drv.h > @@ -11,6 +11,7 @@ struct pds_vdpa_aux { > struct pds_auxiliary_dev *padev; > > struct vdpa_mgmt_dev vdpa_mdev; > + struct pds_vdpa_device *pdsv; > > struct pds_vdpa_ident ident; > > diff --git a/drivers/vdpa/pds/debugfs.c b/drivers/vdpa/pds/debugfs.c > index aa5e9677fe74..b3ee4f42f3b6 100644 > --- a/drivers/vdpa/pds/debugfs.c > +++ b/drivers/vdpa/pds/debugfs.c > @@ -9,6 +9,7 @@ > #include > > #include "aux_drv.h" > +#include "vdpa_dev.h" > #include "debugfs.h" > > #ifdef CONFIG_DEBUG_FS > @@ -26,4 +27,175 @@ void pds_vdpa_debugfs_destroy(void) > dbfs_dir =3D NULL; > } > > +#define PRINT_SBIT_NAME(__seq, __f, __name) \ > + do { \ > + if ((__f) & (__name)) \ > + seq_printf(__seq, " %s", &#__name[16]); \ > + } while (0) > + > +static void print_status_bits(struct seq_file *seq, u16 status) > +{ > + seq_puts(seq, "status:"); > + PRINT_SBIT_NAME(seq, status, VIRTIO_CONFIG_S_ACKNOWLEDGE); > + PRINT_SBIT_NAME(seq, status, VIRTIO_CONFIG_S_DRIVER); > + PRINT_SBIT_NAME(seq, status, VIRTIO_CONFIG_S_DRIVER_OK); > + PRINT_SBIT_NAME(seq, status, VIRTIO_CONFIG_S_FEATURES_OK); > + PRINT_SBIT_NAME(seq, status, VIRTIO_CONFIG_S_NEEDS_RESET); > + PRINT_SBIT_NAME(seq, status, VIRTIO_CONFIG_S_FAILED); > + seq_puts(seq, "\n"); > +} > + > +#define PRINT_FBIT_NAME(__seq, __f, __name) \ > + do { \ > + if ((__f) & BIT_ULL(__name)) \ > + seq_printf(__seq, " %s", #__name); \ > + } while (0) > + > +static void print_feature_bits(struct seq_file *seq, u64 features) > +{ > + seq_puts(seq, "features:"); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_CSUM); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_GUEST_CSUM); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_MTU); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_MAC); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_GUEST_TSO4); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_GUEST_TSO6); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_GUEST_ECN); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_GUEST_UFO); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_HOST_TSO4); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_HOST_TSO6); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_HOST_ECN); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_HOST_UFO); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_MRG_RXBUF); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_STATUS); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_CTRL_VQ); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_CTRL_RX); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_CTRL_VLAN); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_CTRL_RX_EXTRA); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_GUEST_ANNOUNCE); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_MQ); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_CTRL_MAC_ADDR); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_HASH_REPORT); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_RSS); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_RSC_EXT); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_STANDBY); > + PRINT_FBIT_NAME(seq, features, VIRTIO_NET_F_SPEED_DUPLEX); > + PRINT_FBIT_NAME(seq, features, VIRTIO_F_NOTIFY_ON_EMPTY); > + PRINT_FBIT_NAME(seq, features, VIRTIO_F_ANY_LAYOUT); > + PRINT_FBIT_NAME(seq, features, VIRTIO_F_VERSION_1); > + PRINT_FBIT_NAME(seq, features, VIRTIO_F_ACCESS_PLATFORM); > + PRINT_FBIT_NAME(seq, features, VIRTIO_F_RING_PACKED); > + PRINT_FBIT_NAME(seq, features, VIRTIO_F_ORDER_PLATFORM); > + PRINT_FBIT_NAME(seq, features, VIRTIO_F_SR_IOV); > + seq_puts(seq, "\n"); Should we print the features that are not understood here? > +} > + > +void pds_vdpa_debugfs_add_pcidev(struct pds_vdpa_aux *vdpa_aux) > +{ > + vdpa_aux->dentry =3D debugfs_create_dir(pci_name(vdpa_aux->padev-= >vf->pdev), dbfs_dir); > +} > + > +static int identity_show(struct seq_file *seq, void *v) > +{ > + struct pds_vdpa_aux *vdpa_aux =3D seq->private; > + struct vdpa_mgmt_dev *mgmt; > + > + seq_printf(seq, "aux_dev: %s\n", > + dev_name(&vdpa_aux->padev->aux_dev.dev)); > + > + mgmt =3D &vdpa_aux->vdpa_mdev; > + seq_printf(seq, "max_vqs: %d\n", mgmt->max_supported_v= qs); > + seq_printf(seq, "config_attr_mask: %#llx\n", mgmt->config_attr_= mask); > + seq_printf(seq, "supported_features: %#llx\n", mgmt->supported_fe= atures); > + print_feature_bits(seq, mgmt->supported_features); > + > + return 0; > +} > +DEFINE_SHOW_ATTRIBUTE(identity); > + > +void pds_vdpa_debugfs_add_ident(struct pds_vdpa_aux *vdpa_aux) > +{ > + debugfs_create_file("identity", 0400, vdpa_aux->dentry, > + vdpa_aux, &identity_fops); > +} > + > +static int config_show(struct seq_file *seq, void *v) > +{ > + struct pds_vdpa_device *pdsv =3D seq->private; > + struct virtio_net_config vc; > + > + memcpy_fromio(&vc, pdsv->vdpa_aux->vd_mdev.device, > + sizeof(struct virtio_net_config)); > + > + seq_printf(seq, "mac: %pM\n", vc.mac); > + seq_printf(seq, "max_virtqueue_pairs: %d\n", > + __virtio16_to_cpu(true, vc.max_virtqueue_pairs)); > + seq_printf(seq, "mtu: %d\n", __virtio16_to_cpu(t= rue, vc.mtu)); > + seq_printf(seq, "speed: %d\n", le32_to_cpu(vc.spee= d)); > + seq_printf(seq, "duplex: %d\n", vc.duplex); > + seq_printf(seq, "rss_max_key_size: %d\n", vc.rss_max_key_size= ); > + seq_printf(seq, "rss_max_indirection_table_length: %d\n", > + le16_to_cpu(vc.rss_max_indirection_table_length)); > + seq_printf(seq, "supported_hash_types: %#x\n", > + le32_to_cpu(vc.supported_hash_types)); > + seq_printf(seq, "vn_status: %#x\n", > + __virtio16_to_cpu(true, vc.status)); > + print_status_bits(seq, __virtio16_to_cpu(true, vc.status)); > + > + seq_printf(seq, "req_features: %#llx\n", pdsv->req_featur= es); > + print_feature_bits(seq, pdsv->req_features); > + seq_printf(seq, "actual_features: %#llx\n", pdsv->actual_fea= tures); > + print_feature_bits(seq, pdsv->actual_features); > + seq_printf(seq, "vdpa_index: %d\n", pdsv->vdpa_index); > + seq_printf(seq, "num_vqs: %d\n", pdsv->num_vqs); > + > + return 0; > +} > +DEFINE_SHOW_ATTRIBUTE(config); > + > +static int vq_show(struct seq_file *seq, void *v) > +{ > + struct pds_vdpa_vq_info *vq =3D seq->private; > + > + seq_printf(seq, "ready: %d\n", vq->ready); > + seq_printf(seq, "desc_addr: %#llx\n", vq->desc_addr); > + seq_printf(seq, "avail_addr: %#llx\n", vq->avail_addr); > + seq_printf(seq, "used_addr: %#llx\n", vq->used_addr); > + seq_printf(seq, "q_len: %d\n", vq->q_len); > + seq_printf(seq, "qid: %d\n", vq->qid); > + > + seq_printf(seq, "doorbell: %#llx\n", vq->doorbell); > + seq_printf(seq, "avail_idx: %d\n", vq->avail_idx); > + seq_printf(seq, "used_idx: %d\n", vq->used_idx); > + seq_printf(seq, "irq: %d\n", vq->irq); > + seq_printf(seq, "irq-name: %s\n", vq->irq_name); > + > + seq_printf(seq, "hw_qtype: %d\n", vq->hw_qtype); > + seq_printf(seq, "hw_qindex: %d\n", vq->hw_qindex); > + > + return 0; > +} > +DEFINE_SHOW_ATTRIBUTE(vq); > + > +void pds_vdpa_debugfs_add_vdpadev(struct pds_vdpa_aux *vdpa_aux) > +{ > + int i; > + > + debugfs_create_file("config", 0400, vdpa_aux->dentry, vdpa_aux->p= dsv, &config_fops); > + > + for (i =3D 0; i < vdpa_aux->pdsv->num_vqs; i++) { > + char name[8]; > + > + snprintf(name, sizeof(name), "vq%02d", i); > + debugfs_create_file(name, 0400, vdpa_aux->dentry, > + &vdpa_aux->pdsv->vqs[i], &vq_fops); > + } > +} > + > +void pds_vdpa_debugfs_del_vdpadev(struct pds_vdpa_aux *vdpa_aux) > +{ > + debugfs_remove_recursive(vdpa_aux->dentry); > + vdpa_aux->dentry =3D NULL; > +} > #endif /* CONFIG_DEBUG_FS */ > diff --git a/drivers/vdpa/pds/debugfs.h b/drivers/vdpa/pds/debugfs.h > index fff078a869e5..23e8345add0d 100644 > --- a/drivers/vdpa/pds/debugfs.h > +++ b/drivers/vdpa/pds/debugfs.h > @@ -10,9 +10,17 @@ > > void pds_vdpa_debugfs_create(void); > void pds_vdpa_debugfs_destroy(void); > +void pds_vdpa_debugfs_add_pcidev(struct pds_vdpa_aux *vdpa_aux); > +void pds_vdpa_debugfs_add_ident(struct pds_vdpa_aux *vdpa_aux); > +void pds_vdpa_debugfs_add_vdpadev(struct pds_vdpa_aux *vdpa_aux); > +void pds_vdpa_debugfs_del_vdpadev(struct pds_vdpa_aux *vdpa_aux); > #else > static inline void pds_vdpa_debugfs_create(void) { } > static inline void pds_vdpa_debugfs_destroy(void) { } > +static inline void pds_vdpa_debugfs_add_pcidev(struct pds_vdpa_aux *vdpa= _aux) { } > +static inline void pds_vdpa_debugfs_add_ident(struct pds_vdpa_aux *vdpa_= aux) { } > +static inline void pds_vdpa_debugfs_add_vdpadev(struct pds_vdpa_aux *vdp= a_aux) { } > +static inline void pds_vdpa_debugfs_del_vdpadev(struct pds_vdpa_aux *vdp= a_aux) { } > #endif > > #endif /* _PDS_VDPA_DEBUGFS_H_ */ > diff --git a/drivers/vdpa/pds/vdpa_dev.c b/drivers/vdpa/pds/vdpa_dev.c > index 15d623297203..2e0a5078d379 100644 > --- a/drivers/vdpa/pds/vdpa_dev.c > +++ b/drivers/vdpa/pds/vdpa_dev.c > @@ -5,6 +5,7 @@ > #include > #include > #include > +#include > > #include > #include > @@ -13,7 +14,426 @@ > > #include "vdpa_dev.h" > #include "aux_drv.h" > +#include "cmds.h" > +#include "debugfs.h" > > +static struct pds_vdpa_device *vdpa_to_pdsv(struct vdpa_device *vdpa_dev= ) > +{ > + return container_of(vdpa_dev, struct pds_vdpa_device, vdpa_dev); > +} > + > +static int pds_vdpa_set_vq_address(struct vdpa_device *vdpa_dev, u16 qid= , > + u64 desc_addr, u64 driver_addr, u64 de= vice_addr) > +{ > + struct pds_vdpa_device *pdsv =3D vdpa_to_pdsv(vdpa_dev); > + > + pdsv->vqs[qid].desc_addr =3D desc_addr; > + pdsv->vqs[qid].avail_addr =3D driver_addr; > + pdsv->vqs[qid].used_addr =3D device_addr; > + > + return 0; > +} > + > +static void pds_vdpa_set_vq_num(struct vdpa_device *vdpa_dev, u16 qid, u= 32 num) > +{ > + struct pds_vdpa_device *pdsv =3D vdpa_to_pdsv(vdpa_dev); > + > + pdsv->vqs[qid].q_len =3D num; > +} > + > +static void pds_vdpa_kick_vq(struct vdpa_device *vdpa_dev, u16 qid) > +{ > + struct pds_vdpa_device *pdsv =3D vdpa_to_pdsv(vdpa_dev); > + > + iowrite16(qid, pdsv->vqs[qid].notify); > +} > + > +static void pds_vdpa_set_vq_cb(struct vdpa_device *vdpa_dev, u16 qid, > + struct vdpa_callback *cb) > +{ > + struct pds_vdpa_device *pdsv =3D vdpa_to_pdsv(vdpa_dev); > + > + pdsv->vqs[qid].event_cb =3D *cb; > +} > + > +static irqreturn_t pds_vdpa_isr(int irq, void *data) > +{ > + struct pds_vdpa_vq_info *vq; > + > + vq =3D data; > + if (vq->event_cb.callback) > + vq->event_cb.callback(vq->event_cb.private); > + > + return IRQ_HANDLED; > +} > + > +static void pds_vdpa_release_irq(struct pds_vdpa_device *pdsv, int qid) > +{ > + if (pdsv->vqs[qid].irq =3D=3D VIRTIO_MSI_NO_VECTOR) > + return; > + > + free_irq(pdsv->vqs[qid].irq, &pdsv->vqs[qid]); > + pdsv->vqs[qid].irq =3D VIRTIO_MSI_NO_VECTOR; > +} > + > +static void pds_vdpa_set_vq_ready(struct vdpa_device *vdpa_dev, u16 qid,= bool ready) > +{ > + struct pds_vdpa_device *pdsv =3D vdpa_to_pdsv(vdpa_dev); > + struct pci_dev *pdev =3D pdsv->vdpa_aux->padev->vf->pdev; > + struct device *dev =3D &pdsv->vdpa_dev.dev; > + int irq; > + int err; > + > + dev_dbg(dev, "%s: qid %d ready %d =3D> %d\n", > + __func__, qid, pdsv->vqs[qid].ready, ready); > + if (ready =3D=3D pdsv->vqs[qid].ready) > + return; > + > + if (ready) { > + irq =3D pci_irq_vector(pdev, qid); > + snprintf(pdsv->vqs[qid].irq_name, sizeof(pdsv->vqs[qid].i= rq_name), > + "vdpa-%s-%d", dev_name(dev), qid); > + > + err =3D request_irq(irq, pds_vdpa_isr, 0, > + pdsv->vqs[qid].irq_name, &pdsv->vqs[qid= ]); > + if (err) { > + dev_err(dev, "%s: no irq for qid %d: %pe\n", > + __func__, qid, ERR_PTR(err)); > + return; > + } > + pdsv->vqs[qid].irq =3D irq; > + > + /* Pass vq setup info to DSC */ > + err =3D pds_vdpa_cmd_init_vq(pdsv, qid, &pdsv->vqs[qid]); > + if (err) { > + pds_vdpa_release_irq(pdsv, qid); > + ready =3D false; > + } > + } else { > + err =3D pds_vdpa_cmd_reset_vq(pdsv, qid); > + if (err) > + dev_err(dev, "%s: reset_vq failed qid %d: %pe\n", > + __func__, qid, ERR_PTR(err)); > + pds_vdpa_release_irq(pdsv, qid); > + } > + > + pdsv->vqs[qid].ready =3D ready; > +} > + > +static bool pds_vdpa_get_vq_ready(struct vdpa_device *vdpa_dev, u16 qid) > +{ > + struct pds_vdpa_device *pdsv =3D vdpa_to_pdsv(vdpa_dev); > + > + return pdsv->vqs[qid].ready; > +} > + > +static int pds_vdpa_set_vq_state(struct vdpa_device *vdpa_dev, u16 qid, > + const struct vdpa_vq_state *state) > +{ > + struct pds_vdpa_device *pdsv =3D vdpa_to_pdsv(vdpa_dev); > + struct pds_auxiliary_dev *padev =3D pdsv->vdpa_aux->padev; > + struct device *dev =3D &padev->aux_dev.dev; > + struct pds_vdpa_vq_set_state_cmd cmd =3D { > + .opcode =3D PDS_VDPA_CMD_VQ_SET_STATE, > + .vdpa_index =3D pdsv->vdpa_index, > + .vf_id =3D cpu_to_le16(pdsv->vdpa_aux->vf_id), > + .qid =3D cpu_to_le16(qid), > + }; > + struct pds_vdpa_comp comp =3D {0}; > + int err; > + > + dev_dbg(dev, "%s: qid %d avail %#x\n", > + __func__, qid, state->packed.last_avail_idx); > + > + if (pdsv->actual_features & VIRTIO_F_RING_PACKED) { > + cmd.avail =3D cpu_to_le16(state->packed.last_avail_idx | > + (state->packed.last_avail_counter= << 15)); > + cmd.used =3D cpu_to_le16(state->packed.last_used_idx | > + (state->packed.last_used_counter <= < 15)); > + } else { > + cmd.avail =3D cpu_to_le16(state->split.avail_index); > + /* state->split does not provide a used_index: > + * the vq will be set to "empty" here, and the vq will re= ad > + * the current used index the next time the vq is kicked. > + */ > + cmd.used =3D cpu_to_le16(state->split.avail_index); > + } > + > + err =3D padev->ops->adminq_cmd(padev, > + (union pds_core_adminq_cmd *)&cmd, > + sizeof(cmd), > + (union pds_core_adminq_comp *)&comp, > + 0); I had one question for adminq command. I think we should use PF instead of VF but in __pdsc_adminq_post() I saw: q_info->dest =3D comp; memcpy(q_info->desc, cmd, sizeof(*cmd)); So cmd should be fine since it is copied to the q_info->desc which is already mapped. But q_info->dest look suspicious, where did it mapped? Thanks > + if (err) > + dev_err(dev, "Failed to set vq state qid %u, status %d: %= pe\n", > + qid, comp.status, ERR_PTR(err)); > + > + return err; > +} > + > +static int pds_vdpa_get_vq_state(struct vdpa_device *vdpa_dev, u16 qid, > + struct vdpa_vq_state *state) > +{ > + struct pds_vdpa_device *pdsv =3D vdpa_to_pdsv(vdpa_dev); > + struct pds_auxiliary_dev *padev =3D pdsv->vdpa_aux->padev; > + struct device *dev =3D &padev->aux_dev.dev; > + struct pds_vdpa_vq_get_state_cmd cmd =3D { > + .opcode =3D PDS_VDPA_CMD_VQ_GET_STATE, > + .vdpa_index =3D pdsv->vdpa_index, > + .vf_id =3D cpu_to_le16(pdsv->vdpa_aux->vf_id), > + .qid =3D cpu_to_le16(qid), > + }; > + struct pds_vdpa_vq_get_state_comp comp =3D {0}; > + int err; > + > + dev_dbg(dev, "%s: qid %d\n", __func__, qid); > + > + err =3D padev->ops->adminq_cmd(padev, > + (union pds_core_adminq_cmd *)&cmd, > + sizeof(cmd), > + (union pds_core_adminq_comp *)&comp, > + 0); > + if (err) { > + dev_err(dev, "Failed to get vq state qid %u, status %d: %= pe\n", > + qid, comp.status, ERR_PTR(err)); > + return err; > + } > + > + if (pdsv->actual_features & VIRTIO_F_RING_PACKED) { > + state->packed.last_avail_idx =3D le16_to_cpu(comp.avail) = & 0x7fff; > + state->packed.last_avail_counter =3D le16_to_cpu(comp.ava= il) >> 15; > + } else { > + state->split.avail_index =3D le16_to_cpu(comp.avail); > + /* state->split does not provide a used_index. */ > + } > + > + return err; > +} > + > +static struct vdpa_notification_area > +pds_vdpa_get_vq_notification(struct vdpa_device *vdpa_dev, u16 qid) > +{ > + struct pds_vdpa_device *pdsv =3D vdpa_to_pdsv(vdpa_dev); > + struct virtio_pci_modern_device *vd_mdev; > + struct vdpa_notification_area area; > + > + area.addr =3D pdsv->vqs[qid].notify_pa; > + > + vd_mdev =3D &pdsv->vdpa_aux->vd_mdev; > + if (!vd_mdev->notify_offset_multiplier) > + area.size =3D PAGE_SIZE; Note that PAGE_SIZE varies among archs, I doubt we should use a fixed size = here. Others look good. Thanks