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 X-Spam-Level: X-Spam-Status: No, score=-16.6 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5DD18C433E0 for ; Thu, 4 Mar 2021 23:20:25 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 2919A64FFD for ; Thu, 4 Mar 2021 23:20:25 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 2919A64FFD Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linaro.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id BCBB66EA87; Thu, 4 Mar 2021 23:20:19 +0000 (UTC) Received: from mail-pj1-x102e.google.com (mail-pj1-x102e.google.com [IPv6:2607:f8b0:4864:20::102e]) by gabe.freedesktop.org (Postfix) with ESMTPS id 548FD6EA84 for ; Thu, 4 Mar 2021 23:20:18 +0000 (UTC) Received: by mail-pj1-x102e.google.com with SMTP id fu20so378885pjb.2 for ; Thu, 04 Mar 2021 15:20:18 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=FiKbNF6sIsDFllVX3gZjMXu3m0TjzXNAhqpgm5/+cRY=; b=vMzeNpoKj+AWkNj1Sl0naujTZGOZ/Kd7M8pxVCcQ/geVFWfX9PusFkmpilFBZjEbhf /CmiI/RwQdWjgC1kRvbSjGQ8EdH9S6OXx8JzMfOuHnv+OJsy4nTtWLm4oViJJtwV/ykJ b71l7eMzLaiaFg6t5ebIYh3mgZJxZaVhGeG1tP73aW5gpCGPNuHcLWf7q/s+RvU2IQda uNi8HJnZ7vcyhNapadVbMcduwumQJf/OZ5Mjf4BiTU7LiNbNh+ZgyDamqaiecnvHT33y Ir4CH5oYx8yIDwHIWeW1gMW++1Qf3akAz+kNzQjspA5l/eK+rgMy57iFcl+0eqRRaSD4 BxbA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=FiKbNF6sIsDFllVX3gZjMXu3m0TjzXNAhqpgm5/+cRY=; b=XvXDYiVNZf90EOSMHxLb1piwKTAu5dmpa6O2A3c1BBXb6GIOq2j5rzJyf28N3jr9q+ la53iXBpoidQIhLulx7mDVZF4sy3XcuVCUy8cUgdNQBJD3maBSDvDa0IPH8qknf355kv ymU464kqKahfZSLKwNj/vNOdjC6rCjykWIWihwrFFeSrz5txPd+9gatdiAxWvTRQG9p7 WbCqOOQMcWAyqpKDyUEbajjR6OkW34BulNZn8OHK7rnv83IAXiMpJnIxGQvyKuzv4hgt QYQ6/zdVSh9e9u5p14tnLV+4eDSj/YirZmJpEPKjuZ/AqR6FWKJyfODssjMBT1zujB6X mr+w== X-Gm-Message-State: AOAM531TtEVsOiekUy8blJ2oh21JLe0eRN4jQOGqWb8vVMQ4ol9gQruD cGIZau5zdpF9R/T4M/owfvWo9A== X-Google-Smtp-Source: ABdhPJzaPXe0BX4p/OHpQUy/ewFyfYq+is8O0jHSW93qyBaAZlEvtzKM4hvHDE9/7CV7ZKdlubEr/g== X-Received: by 2002:a17:902:6b43:b029:df:fb48:aece with SMTP id g3-20020a1709026b43b02900dffb48aecemr5995966plt.59.1614900017933; Thu, 04 Mar 2021 15:20:17 -0800 (PST) Received: from localhost.localdomain ([2601:1c2:680:1319:692:26ff:feda:3a81]) by smtp.gmail.com with ESMTPSA id u66sm429290pfc.72.2021.03.04.15.20.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 04 Mar 2021 15:20:17 -0800 (PST) From: John Stultz To: lkml Subject: [PATCH v8 2/5] drm: ttm_pool: Rework ttm_pool to use drm_page_pool Date: Thu, 4 Mar 2021 23:20:08 +0000 Message-Id: <20210304232011.1479036-3-john.stultz@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210304232011.1479036-1-john.stultz@linaro.org> References: <20210304232011.1479036-1-john.stultz@linaro.org> MIME-Version: 1.0 X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: dri-devel@lists.freedesktop.org, Sandeep Patil , Ezequiel Garcia , Robin Murphy , James Jones , Liam Mark , Laura Abbott , Chris Goldsworthy , Hridya Valsaraju , =?UTF-8?q?=C3=98rjan=20Eide?= , linux-media@vger.kernel.org, Suren Baghdasaryan , Christian Koenig , Daniel Mentz Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" VGhpcyBwYXRjaCByZXdvcmtzIHRoZSB0dG1fcG9vbCBsb2dpYyB0byB1dGlsaXplIHRoZSByZWNl bnRseQphZGRlZCBkcm1fcGFnZV9wb29sIGNvZGUuCgpUaGlzIGFkZHMgZHJtX3BhZ2VfcG9vbCBz dHJ1Y3R1cmVzIHRvIHRoZSB0dG1fcG9vbF90eXBlCnN0cnVjdHVyZXMsIGFuZCB0aGVuIHJlbW92 ZXMgYWxsIHRoZSB0dG1fcG9vbF90eXBlIHNocmlua2VyCmxvZ2ljIChhcyBpdHMgaGFuZGxlZCBp biB0aGUgZHJtX3BhZ2VfcG9vbCBzaHJpbmtlcikuCgpOT1RFOiBUaGVyZSBpcyBvbmUgbWlzbWF0 Y2ggaW4gdGhlIGludGVyZmFjZXMgSSdtIG5vdCB0b3RhbGx5CmhhcHB5IHdpdGguIFRoZSB0dG1f cG9vbCB0cmFja3MgYWxsIG9mIGl0cyBwb29sZWQgcGFnZXMgYWNyb3NzCmEgbnVtYmVyIG9mIGRp ZmZlcmVudCBwb29scywgYW5kIHRyaWVzIHRvIGtlZXAgdGhpcyBzaXplIHVuZGVyCnRoZSBzcGVj aWZpZWQgcGFnZV9wb29sX3NpemUgdmFsdWUuIFdpdGggdGhlIGRybV9wYWdlX3Bvb2wsCnRoZXJl IG1heSBvdGhlciB1c2VycywgaG93ZXZlciB0aGVyZSBpcyBzdGlsbCBvbmUgZ2xvYmFsCnNocmlu a2VyIGxpc3Qgb2YgcG9vbHMuIFNvIHdlIGNhbid0IGVhc2lseSByZWR1Y2UgdGhlIHR0bQpwb29s IHVuZGVyIHRoZSB0dG0gc3BlY2lmaWVkIHNpemUgd2l0aG91dCBwb3RlbnRpYWxseSBkb2luZwph IGxvdCBvZiBzaHJpbmtpbmcgdG8gb3RoZXIgbm9uLXR0bSBwb29scy4gU28gZWl0aGVyIHdlIGNh bjoKICAxKSBUcnkgdG8gc3BsaXQgaXQgc28gZWFjaCB1c2VyIG9mIGRybV9wYWdlX3Bvb2xzIG1h bmFnZXMgaXRzCiAgICAgb3duIHBvb2wgc2hyaW5raW5nLgogIDIpIFB1c2ggdGhlIG1heCB2YWx1 ZSBpbnRvIHRoZSBkcm1fcGFnZV9wb29sLCBhbmQgaGF2ZSBpdAogICAgIG1hbmFnZSBzaHJpbmtp bmcgdG8gZml0IHVuZGVyIHRoYXQgZ2xvYmFsIG1heC4gVGhlbiBzaGFyZQogICAgIHRob3NlIHNp emUvbWF4IHZhbHVlcyBvdXQgc28gdGhlIHR0bV9wb29sIGRlYnVnIG91dHB1dAogICAgIGNhbiBo YXZlIG1vcmUgY29udGV4dC4KCkkndmUgdGFrZW4gdGhlIHNlY29uZCBwYXRoIGluIHRoaXMgcGF0 Y2ggc2V0LCBidXQgd2FudGVkIHRvIGNhbGwKaXQgb3V0IHNvIGZvbGtzIGNvdWxkIGxvb2sgY2xv c2VseS4KClRob3VnaHRzIHdvdWxkIGJlIGdyZWF0bHkgYXBwcmVjaWF0ZWQgaGVyZSEKCkNjOiBE YW5pZWwgVmV0dGVyIDxkYW5pZWxAZmZ3bGwuY2g+CkNjOiBDaHJpc3RpYW4gS29lbmlnIDxjaHJp c3RpYW4ua29lbmlnQGFtZC5jb20+CkNjOiBTdW1pdCBTZW13YWwgPHN1bWl0LnNlbXdhbEBsaW5h cm8ub3JnPgpDYzogTGlhbSBNYXJrIDxsbWFya0Bjb2RlYXVyb3JhLm9yZz4KQ2M6IENocmlzIEdv bGRzd29ydGh5IDxjZ29sZHN3b0Bjb2RlYXVyb3JhLm9yZz4KQ2M6IExhdXJhIEFiYm90dCA8bGFi Ym90dEBrZXJuZWwub3JnPgpDYzogQnJpYW4gU3RhcmtleSA8QnJpYW4uU3RhcmtleUBhcm0uY29t PgpDYzogSHJpZHlhIFZhbHNhcmFqdSA8aHJpZHlhQGdvb2dsZS5jb20+CkNjOiBTdXJlbiBCYWdo ZGFzYXJ5YW4gPHN1cmVuYkBnb29nbGUuY29tPgpDYzogU2FuZGVlcCBQYXRpbCA8c3NwYXRpbEBn b29nbGUuY29tPgpDYzogRGFuaWVsIE1lbnR6IDxkYW5pZWxtZW50ekBnb29nbGUuY29tPgpDYzog w5hyamFuIEVpZGUgPG9yamFuLmVpZGVAYXJtLmNvbT4KQ2M6IFJvYmluIE11cnBoeSA8cm9iaW4u bXVycGh5QGFybS5jb20+CkNjOiBFemVxdWllbCBHYXJjaWEgPGV6ZXF1aWVsQGNvbGxhYm9yYS5j b20+CkNjOiBTaW1vbiBTZXIgPGNvbnRhY3RAZW1lcnNpb24uZnI+CkNjOiBKYW1lcyBKb25lcyA8 amFqb25lc0BudmlkaWEuY29tPgpDYzogbGludXgtbWVkaWFAdmdlci5rZXJuZWwub3JnCkNjOiBk cmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnClNpZ25lZC1vZmYtYnk6IEpvaG4gU3R1bHR6 IDxqb2huLnN0dWx0ekBsaW5hcm8ub3JnPgotLS0Kdjc6CiogTWFqb3IgcmVmYWN0b3JpbmcgdG8g dXNlIGRybV9wYWdlX3Bvb2xzIGluc2lkZSB0aGUKICB0dG1fcG9vbF90eXBlIHN0cnVjdHVyZS4g VGhpcyBhbGxvd3MgdXMgdG8gdXNlIGNvbnRhaW5lcl9vZiB0bwogIGdldCB0aGUgbmVlZGVkIGNv bnRleHQgdG8gZnJlZSBhIHBhZ2UuIFRoaXMgYWxzbyBtZWFucyBsZXNzCiAgY29kZSBpcyBjaGFu Z2VkIG92ZXJhbGwuCnY4OgoqIFJld29ya2VkIHRvIHVzZSB0aGUgbmV3IGNsZWFubHkgcmV3cml0 dGVuIGRybV9wYWdlX3Bvb2wgbG9naWMKLS0tCiBkcml2ZXJzL2dwdS9kcm0vS2NvbmZpZyAgICAg ICAgfCAgIDEgKwogZHJpdmVycy9ncHUvZHJtL3R0bS90dG1fcG9vbC5jIHwgMTU2ICsrKysrKy0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogaW5jbHVkZS9kcm0vdHRtL3R0bV9wb29sLmggICAg IHwgICA2ICstCiAzIGZpbGVzIGNoYW5nZWQsIDMxIGluc2VydGlvbnMoKyksIDEzMiBkZWxldGlv bnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vS2NvbmZpZyBiL2RyaXZlcnMvZ3B1 L2RybS9LY29uZmlnCmluZGV4IDdjYmNlY2I4ZjdkZi4uYTZjYmRiNjNmNmM3IDEwMDY0NAotLS0g YS9kcml2ZXJzL2dwdS9kcm0vS2NvbmZpZworKysgYi9kcml2ZXJzL2dwdS9kcm0vS2NvbmZpZwpA QCAtMTg0LDYgKzE4NCw3IEBAIGNvbmZpZyBEUk1fUEFHRV9QT09MCiBjb25maWcgRFJNX1RUTQog CXRyaXN0YXRlCiAJZGVwZW5kcyBvbiBEUk0gJiYgTU1VCisJc2VsZWN0IERSTV9QQUdFX1BPT0wK IAloZWxwCiAJICBHUFUgbWVtb3J5IG1hbmFnZW1lbnQgc3Vic3lzdGVtIGZvciBkZXZpY2VzIHdp dGggbXVsdGlwbGUKIAkgIEdQVSBtZW1vcnkgdHlwZXMuIFdpbGwgYmUgZW5hYmxlZCBhdXRvbWF0 aWNhbGx5IGlmIGEgZGV2aWNlIGRyaXZlcgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3R0 bS90dG1fcG9vbC5jIGIvZHJpdmVycy9ncHUvZHJtL3R0bS90dG1fcG9vbC5jCmluZGV4IDZlMjdj YjFiZjQ4Yi4uZjc0ZWE4MDFkN2FiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vdHRtL3R0 bV9wb29sLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3R0bS90dG1fcG9vbC5jCkBAIC0zOSw2ICsz OSw3IEBACiAjaW5jbHVkZSA8YXNtL3NldF9tZW1vcnkuaD4KICNlbmRpZgogCisjaW5jbHVkZSA8 ZHJtL3BhZ2VfcG9vbC5oPgogI2luY2x1ZGUgPGRybS90dG0vdHRtX3Bvb2wuaD4KICNpbmNsdWRl IDxkcm0vdHRtL3R0bV9ib19kcml2ZXIuaD4KICNpbmNsdWRlIDxkcm0vdHRtL3R0bV90dC5oPgpA QCAtNjgsOCArNjksNiBAQCBzdGF0aWMgc3RydWN0IHR0bV9wb29sX3R5cGUgZ2xvYmFsX2RtYTMy X3dyaXRlX2NvbWJpbmVkW01BWF9PUkRFUl07CiBzdGF0aWMgc3RydWN0IHR0bV9wb29sX3R5cGUg Z2xvYmFsX2RtYTMyX3VuY2FjaGVkW01BWF9PUkRFUl07CiAKIHN0YXRpYyBzdHJ1Y3QgbXV0ZXgg c2hyaW5rZXJfbG9jazsKLXN0YXRpYyBzdHJ1Y3QgbGlzdF9oZWFkIHNocmlua2VyX2xpc3Q7Ci1z dGF0aWMgc3RydWN0IHNocmlua2VyIG1tX3Nocmlua2VyOwogCiAvKiBBbGxvY2F0ZSBwYWdlcyBv ZiBzaXplIDEgPDwgb3JkZXIgd2l0aCB0aGUgZ2l2ZW4gZ2ZwX2ZsYWdzICovCiBzdGF0aWMgc3Ry dWN0IHBhZ2UgKnR0bV9wb29sX2FsbG9jX3BhZ2Uoc3RydWN0IHR0bV9wb29sICpwb29sLCBnZnBf dCBnZnBfZmxhZ3MsCkBAIC0xMjUsOCArMTI0LDkgQEAgc3RhdGljIHN0cnVjdCBwYWdlICp0dG1f cG9vbF9hbGxvY19wYWdlKHN0cnVjdCB0dG1fcG9vbCAqcG9vbCwgZ2ZwX3QgZ2ZwX2ZsYWdzLAog fQogCiAvKiBSZXNldCB0aGUgY2FjaGluZyBhbmQgcGFnZXMgb2Ygc2l6ZSAxIDw8IG9yZGVyICov Ci1zdGF0aWMgdm9pZCB0dG1fcG9vbF9mcmVlX3BhZ2Uoc3RydWN0IHR0bV9wb29sICpwb29sLCBl bnVtIHR0bV9jYWNoaW5nIGNhY2hpbmcsCi0JCQkgICAgICAgdW5zaWduZWQgaW50IG9yZGVyLCBz dHJ1Y3QgcGFnZSAqcCkKK3N0YXRpYyB1bnNpZ25lZCBsb25nIHR0bV9wb29sX2ZyZWVfcGFnZShz dHJ1Y3QgdHRtX3Bvb2wgKnBvb2wsCisJCQkJCWVudW0gdHRtX2NhY2hpbmcgY2FjaGluZywKKwkJ CQkJdW5zaWduZWQgaW50IG9yZGVyLCBzdHJ1Y3QgcGFnZSAqcCkKIHsKIAl1bnNpZ25lZCBsb25n IGF0dHIgPSBETUFfQVRUUl9GT1JDRV9DT05USUdVT1VTOwogCXN0cnVjdCB0dG1fcG9vbF9kbWEg KmRtYTsKQEAgLTE0Miw3ICsxNDIsNyBAQCBzdGF0aWMgdm9pZCB0dG1fcG9vbF9mcmVlX3BhZ2Uo c3RydWN0IHR0bV9wb29sICpwb29sLCBlbnVtIHR0bV9jYWNoaW5nIGNhY2hpbmcsCiAKIAlpZiAo IXBvb2wgfHwgIXBvb2wtPnVzZV9kbWFfYWxsb2MpIHsKIAkJX19mcmVlX3BhZ2VzKHAsIG9yZGVy KTsKLQkJcmV0dXJuOworCQlyZXR1cm4gMVVMIDw8IG9yZGVyOwogCX0KIAogCWlmIChvcmRlcikK QEAgLTE1Myw2ICsxNTMsMTYgQEAgc3RhdGljIHZvaWQgdHRtX3Bvb2xfZnJlZV9wYWdlKHN0cnVj dCB0dG1fcG9vbCAqcG9vbCwgZW51bSB0dG1fY2FjaGluZyBjYWNoaW5nLAogCWRtYV9mcmVlX2F0 dHJzKHBvb2wtPmRldiwgKDFVTCA8PCBvcmRlcikgKiBQQUdFX1NJWkUsIHZhZGRyLCBkbWEtPmFk ZHIsCiAJCSAgICAgICBhdHRyKTsKIAlrZnJlZShkbWEpOworCXJldHVybiAxVUwgPDwgb3JkZXI7 Cit9CisKK3N0YXRpYyB1bnNpZ25lZCBsb25nIHR0bV9zdWJwb29sX2ZyZWVfcGFnZShzdHJ1Y3Qg ZHJtX3BhZ2VfcG9vbCAqc3VicG9vbCwKKwkJCQkJICAgc3RydWN0IHBhZ2UgKnApCit7CisJc3Ry dWN0IHR0bV9wb29sX3R5cGUgKnB0OworCisJcHQgPSBjb250YWluZXJfb2Yoc3VicG9vbCwgc3Ry dWN0IHR0bV9wb29sX3R5cGUsIHN1YnBvb2wpOworCXJldHVybiB0dG1fcG9vbF9mcmVlX3BhZ2Uo cHQtPnBvb2wsIHB0LT5jYWNoaW5nLCBwdC0+b3JkZXIsIHApOwogfQogCiAvKiBBcHBseSBhIG5l dyBjYWNoaW5nIHRvIGFuIGFycmF5IG9mIHBhZ2VzICovCkBAIC0yMTYsNDAgKzIyNiw2IEBAIHN0 YXRpYyB2b2lkIHR0bV9wb29sX3VubWFwKHN0cnVjdCB0dG1fcG9vbCAqcG9vbCwgZG1hX2FkZHJf dCBkbWFfYWRkciwKIAkJICAgICAgIERNQV9CSURJUkVDVElPTkFMKTsKIH0KIAotLyogR2l2ZSBw YWdlcyBpbnRvIGEgc3BlY2lmaWMgcG9vbF90eXBlICovCi1zdGF0aWMgdm9pZCB0dG1fcG9vbF90 eXBlX2dpdmUoc3RydWN0IHR0bV9wb29sX3R5cGUgKnB0LCBzdHJ1Y3QgcGFnZSAqcCkKLXsKLQl1 bnNpZ25lZCBpbnQgaSwgbnVtX3BhZ2VzID0gMSA8PCBwdC0+b3JkZXI7Ci0KLQlmb3IgKGkgPSAw OyBpIDwgbnVtX3BhZ2VzOyArK2kpIHsKLQkJaWYgKFBhZ2VIaWdoTWVtKHApKQotCQkJY2xlYXJf aGlnaHBhZ2UocCArIGkpOwotCQllbHNlCi0JCQljbGVhcl9wYWdlKHBhZ2VfYWRkcmVzcyhwICsg aSkpOwotCX0KLQotCXNwaW5fbG9jaygmcHQtPmxvY2spOwotCWxpc3RfYWRkKCZwLT5scnUsICZw dC0+cGFnZXMpOwotCXNwaW5fdW5sb2NrKCZwdC0+bG9jayk7Ci0JYXRvbWljX2xvbmdfYWRkKDEg PDwgcHQtPm9yZGVyLCAmYWxsb2NhdGVkX3BhZ2VzKTsKLX0KLQotLyogVGFrZSBwYWdlcyBmcm9t IGEgc3BlY2lmaWMgcG9vbF90eXBlLCByZXR1cm4gTlVMTCB3aGVuIG5vdGhpbmcgYXZhaWxhYmxl ICovCi1zdGF0aWMgc3RydWN0IHBhZ2UgKnR0bV9wb29sX3R5cGVfdGFrZShzdHJ1Y3QgdHRtX3Bv b2xfdHlwZSAqcHQpCi17Ci0Jc3RydWN0IHBhZ2UgKnA7Ci0KLQlzcGluX2xvY2soJnB0LT5sb2Nr KTsKLQlwID0gbGlzdF9maXJzdF9lbnRyeV9vcl9udWxsKCZwdC0+cGFnZXMsIHR5cGVvZigqcCks IGxydSk7Ci0JaWYgKHApIHsKLQkJYXRvbWljX2xvbmdfc3ViKDEgPDwgcHQtPm9yZGVyLCAmYWxs b2NhdGVkX3BhZ2VzKTsKLQkJbGlzdF9kZWwoJnAtPmxydSk7Ci0JfQotCXNwaW5fdW5sb2NrKCZw dC0+bG9jayk7Ci0KLQlyZXR1cm4gcDsKLX0KLQogLyogSW5pdGlhbGl6ZSBhbmQgYWRkIGEgcG9v bCB0eXBlIHRvIHRoZSBnbG9iYWwgc2hyaW5rZXIgbGlzdCAqLwogc3RhdGljIHZvaWQgdHRtX3Bv b2xfdHlwZV9pbml0KHN0cnVjdCB0dG1fcG9vbF90eXBlICpwdCwgc3RydWN0IHR0bV9wb29sICpw b29sLAogCQkJICAgICAgIGVudW0gdHRtX2NhY2hpbmcgY2FjaGluZywgdW5zaWduZWQgaW50IG9y ZGVyKQpAQCAtMjU3LDI1ICsyMzMsMTQgQEAgc3RhdGljIHZvaWQgdHRtX3Bvb2xfdHlwZV9pbml0 KHN0cnVjdCB0dG1fcG9vbF90eXBlICpwdCwgc3RydWN0IHR0bV9wb29sICpwb29sLAogCXB0LT5w b29sID0gcG9vbDsKIAlwdC0+Y2FjaGluZyA9IGNhY2hpbmc7CiAJcHQtPm9yZGVyID0gb3JkZXI7 Ci0Jc3Bpbl9sb2NrX2luaXQoJnB0LT5sb2NrKTsKLQlJTklUX0xJU1RfSEVBRCgmcHQtPnBhZ2Vz KTsKIAotCW11dGV4X2xvY2soJnNocmlua2VyX2xvY2spOwotCWxpc3RfYWRkX3RhaWwoJnB0LT5z aHJpbmtlcl9saXN0LCAmc2hyaW5rZXJfbGlzdCk7Ci0JbXV0ZXhfdW5sb2NrKCZzaHJpbmtlcl9s b2NrKTsKKwlkcm1fcGFnZV9wb29sX2luaXQoJnB0LT5zdWJwb29sLCBvcmRlciwgdHRtX3N1YnBv b2xfZnJlZV9wYWdlKTsKIH0KIAogLyogUmVtb3ZlIGEgcG9vbF90eXBlIGZyb20gdGhlIGdsb2Jh bCBzaHJpbmtlciBsaXN0IGFuZCBmcmVlIGFsbCBwYWdlcyAqLwogc3RhdGljIHZvaWQgdHRtX3Bv b2xfdHlwZV9maW5pKHN0cnVjdCB0dG1fcG9vbF90eXBlICpwdCkKIHsKLQlzdHJ1Y3QgcGFnZSAq cCwgKnRtcDsKLQotCW11dGV4X2xvY2soJnNocmlua2VyX2xvY2spOwotCWxpc3RfZGVsKCZwdC0+ c2hyaW5rZXJfbGlzdCk7Ci0JbXV0ZXhfdW5sb2NrKCZzaHJpbmtlcl9sb2NrKTsKLQotCWxpc3Rf Zm9yX2VhY2hfZW50cnlfc2FmZShwLCB0bXAsICZwdC0+cGFnZXMsIGxydSkKLQkJdHRtX3Bvb2xf ZnJlZV9wYWdlKHB0LT5wb29sLCBwdC0+Y2FjaGluZywgcHQtPm9yZGVyLCBwKTsKKwlkcm1fcGFn ZV9wb29sX2ZpbmkoJnB0LT5zdWJwb29sKTsKIH0KIAogLyogUmV0dXJuIHRoZSBwb29sX3R5cGUg dG8gdXNlIGZvciB0aGUgZ2l2ZW4gY2FjaGluZyBhbmQgb3JkZXIgKi8KQEAgLTMwNiwzMCArMjcx LDYgQEAgc3RhdGljIHN0cnVjdCB0dG1fcG9vbF90eXBlICp0dG1fcG9vbF9zZWxlY3RfdHlwZShz dHJ1Y3QgdHRtX3Bvb2wgKnBvb2wsCiAJcmV0dXJuIE5VTEw7CiB9CiAKLS8qIEZyZWUgcGFnZXMg dXNpbmcgdGhlIGdsb2JhbCBzaHJpbmtlciBsaXN0ICovCi1zdGF0aWMgdW5zaWduZWQgaW50IHR0 bV9wb29sX3Nocmluayh2b2lkKQotewotCXN0cnVjdCB0dG1fcG9vbF90eXBlICpwdDsKLQl1bnNp Z25lZCBpbnQgbnVtX2ZyZWVkOwotCXN0cnVjdCBwYWdlICpwOwotCi0JbXV0ZXhfbG9jaygmc2hy aW5rZXJfbG9jayk7Ci0JcHQgPSBsaXN0X2ZpcnN0X2VudHJ5KCZzaHJpbmtlcl9saXN0LCB0eXBl b2YoKnB0KSwgc2hyaW5rZXJfbGlzdCk7Ci0KLQlwID0gdHRtX3Bvb2xfdHlwZV90YWtlKHB0KTsK LQlpZiAocCkgewotCQl0dG1fcG9vbF9mcmVlX3BhZ2UocHQtPnBvb2wsIHB0LT5jYWNoaW5nLCBw dC0+b3JkZXIsIHApOwotCQludW1fZnJlZWQgPSAxIDw8IHB0LT5vcmRlcjsKLQl9IGVsc2Ugewot CQludW1fZnJlZWQgPSAwOwotCX0KLQotCWxpc3RfbW92ZV90YWlsKCZwdC0+c2hyaW5rZXJfbGlz dCwgJnNocmlua2VyX2xpc3QpOwotCW11dGV4X3VubG9jaygmc2hyaW5rZXJfbG9jayk7Ci0KLQly ZXR1cm4gbnVtX2ZyZWVkOwotfQotCiAvKiBSZXR1cm4gdGhlIGFsbG9jYXRpb24gb3JkZXIgYmFz ZWQgZm9yIGEgcGFnZSAqLwogc3RhdGljIHVuc2lnbmVkIGludCB0dG1fcG9vbF9wYWdlX29yZGVy KHN0cnVjdCB0dG1fcG9vbCAqcG9vbCwgc3RydWN0IHBhZ2UgKnApCiB7CkBAIC0zODYsNyArMzI3 LDcgQEAgaW50IHR0bV9wb29sX2FsbG9jKHN0cnVjdCB0dG1fcG9vbCAqcG9vbCwgc3RydWN0IHR0 bV90dCAqdHQsCiAJCXN0cnVjdCB0dG1fcG9vbF90eXBlICpwdDsKIAogCQlwdCA9IHR0bV9wb29s X3NlbGVjdF90eXBlKHBvb2wsIHR0LT5jYWNoaW5nLCBvcmRlcik7Ci0JCXAgPSBwdCA/IHR0bV9w b29sX3R5cGVfdGFrZShwdCkgOiBOVUxMOworCQlwID0gcHQgPyBkcm1fcGFnZV9wb29sX3JlbW92 ZSgmcHQtPnN1YnBvb2wpIDogTlVMTDsKIAkJaWYgKHApIHsKIAkJCWFwcGx5X2NhY2hpbmcgPSB0 cnVlOwogCQl9IGVsc2UgewpAQCAtNDc5LDE2ICs0MjAsMTMgQEAgdm9pZCB0dG1fcG9vbF9mcmVl KHN0cnVjdCB0dG1fcG9vbCAqcG9vbCwgc3RydWN0IHR0bV90dCAqdHQpCiAKIAkJcHQgPSB0dG1f cG9vbF9zZWxlY3RfdHlwZShwb29sLCB0dC0+Y2FjaGluZywgb3JkZXIpOwogCQlpZiAocHQpCi0J CQl0dG1fcG9vbF90eXBlX2dpdmUocHQsIHR0LT5wYWdlc1tpXSk7CisJCQlkcm1fcGFnZV9wb29s X2FkZCgmcHQtPnN1YnBvb2wsIHR0LT5wYWdlc1tpXSk7CiAJCWVsc2UKIAkJCXR0bV9wb29sX2Zy ZWVfcGFnZShwb29sLCB0dC0+Y2FjaGluZywgb3JkZXIsCiAJCQkJCSAgIHR0LT5wYWdlc1tpXSk7 CiAKIAkJaSArPSBudW1fcGFnZXM7CiAJfQotCi0Jd2hpbGUgKGF0b21pY19sb25nX3JlYWQoJmFs bG9jYXRlZF9wYWdlcykgPiBwYWdlX3Bvb2xfc2l6ZSkKLQkJdHRtX3Bvb2xfc2hyaW5rKCk7CiB9 CiBFWFBPUlRfU1lNQk9MKHR0bV9wb29sX2ZyZWUpOwogCkBAIC01MzcsMjEgKzQ3NSw2IEBAIHZv aWQgdHRtX3Bvb2xfZmluaShzdHJ1Y3QgdHRtX3Bvb2wgKnBvb2wpCiB9CiAKICNpZmRlZiBDT05G SUdfREVCVUdfRlMKLS8qIENvdW50IHRoZSBudW1iZXIgb2YgcGFnZXMgYXZhaWxhYmxlIGluIGEg cG9vbF90eXBlICovCi1zdGF0aWMgdW5zaWduZWQgaW50IHR0bV9wb29sX3R5cGVfY291bnQoc3Ry dWN0IHR0bV9wb29sX3R5cGUgKnB0KQotewotCXVuc2lnbmVkIGludCBjb3VudCA9IDA7Ci0Jc3Ry dWN0IHBhZ2UgKnA7Ci0KLQlzcGluX2xvY2soJnB0LT5sb2NrKTsKLQkvKiBPbmx5IHVzZWQgZm9y IGRlYnVnZnMsIHRoZSBvdmVyaGVhZCBkb2Vzbid0IG1hdHRlciAqLwotCWxpc3RfZm9yX2VhY2hf ZW50cnkocCwgJnB0LT5wYWdlcywgbHJ1KQotCQkrK2NvdW50OwotCXNwaW5fdW5sb2NrKCZwdC0+ bG9jayk7Ci0KLQlyZXR1cm4gY291bnQ7Ci19Ci0KIC8qIER1bXAgaW5mb3JtYXRpb24gYWJvdXQg dGhlIGRpZmZlcmVudCBwb29sIHR5cGVzICovCiBzdGF0aWMgdm9pZCB0dG1fcG9vbF9kZWJ1Z2Zz X29yZGVycyhzdHJ1Y3QgdHRtX3Bvb2xfdHlwZSAqcHQsCiAJCQkJICAgIHN0cnVjdCBzZXFfZmls ZSAqbSkKQEAgLTU1OSw3ICs0ODIsOCBAQCBzdGF0aWMgdm9pZCB0dG1fcG9vbF9kZWJ1Z2ZzX29y ZGVycyhzdHJ1Y3QgdHRtX3Bvb2xfdHlwZSAqcHQsCiAJdW5zaWduZWQgaW50IGk7CiAKIAlmb3Ig KGkgPSAwOyBpIDwgTUFYX09SREVSOyArK2kpCi0JCXNlcV9wcmludGYobSwgIiAlOHUiLCB0dG1f cG9vbF90eXBlX2NvdW50KCZwdFtpXSkpOworCQlzZXFfcHJpbnRmKG0sICIgJThsdSIsCisJCQkg ICBkcm1fcGFnZV9wb29sX2dldF9zaXplKCZwdFtpXS5zdWJwb29sKSk7CiAJc2VxX3B1dHMobSwg IlxuIik7CiB9CiAKQEAgLTYwOSw3ICs1MzMsMTAgQEAgaW50IHR0bV9wb29sX2RlYnVnZnMoc3Ry dWN0IHR0bV9wb29sICpwb29sLCBzdHJ1Y3Qgc2VxX2ZpbGUgKm0pCiAJfQogCiAJc2VxX3ByaW50 ZihtLCAiXG50b3RhbFx0OiAlOGx1IG9mICU4bHVcbiIsCi0JCSAgIGF0b21pY19sb25nX3JlYWQo JmFsbG9jYXRlZF9wYWdlcyksIHBhZ2VfcG9vbF9zaXplKTsKKwkJICAgYXRvbWljX2xvbmdfcmVh ZCgmYWxsb2NhdGVkX3BhZ2VzKSwKKwkJICAgZHJtX3BhZ2VfcG9vbF9nZXRfbWF4KCkpOworCXNl cV9wcmludGYobSwgIiglOGx1IGluIG5vbi10dG0gcG9vbHMpXG4iLCBkcm1fcGFnZV9wb29sX2dl dF90b3RhbCgpIC0KKwkJCQkJYXRvbWljX2xvbmdfcmVhZCgmYWxsb2NhdGVkX3BhZ2VzKSk7CiAK IAltdXRleF91bmxvY2soJnNocmlua2VyX2xvY2spOwogCkBAIC02MTksMjggKzU0Niw2IEBAIEVY UE9SVF9TWU1CT0wodHRtX3Bvb2xfZGVidWdmcyk7CiAKICNlbmRpZgogCi0vKiBBcyBsb25nIGFz IHBhZ2VzIGFyZSBhdmFpbGFibGUgbWFrZSBzdXJlIHRvIHJlbGVhc2UgYXQgbGVhc3Qgb25lICov Ci1zdGF0aWMgdW5zaWduZWQgbG9uZyB0dG1fcG9vbF9zaHJpbmtlcl9zY2FuKHN0cnVjdCBzaHJp bmtlciAqc2hyaW5rLAotCQkJCQkgICAgc3RydWN0IHNocmlua19jb250cm9sICpzYykKLXsKLQl1 bnNpZ25lZCBsb25nIG51bV9mcmVlZCA9IDA7Ci0KLQlkbwotCQludW1fZnJlZWQgKz0gdHRtX3Bv b2xfc2hyaW5rKCk7Ci0Jd2hpbGUgKCFudW1fZnJlZWQgJiYgYXRvbWljX2xvbmdfcmVhZCgmYWxs b2NhdGVkX3BhZ2VzKSk7Ci0KLQlyZXR1cm4gbnVtX2ZyZWVkOwotfQotCi0vKiBSZXR1cm4gdGhl IG51bWJlciBvZiBwYWdlcyBhdmFpbGFibGUgb3IgU0hSSU5LX0VNUFRZIGlmIHdlIGhhdmUgbm9u ZSAqLwotc3RhdGljIHVuc2lnbmVkIGxvbmcgdHRtX3Bvb2xfc2hyaW5rZXJfY291bnQoc3RydWN0 IHNocmlua2VyICpzaHJpbmssCi0JCQkJCSAgICAgc3RydWN0IHNocmlua19jb250cm9sICpzYykK LXsKLQl1bnNpZ25lZCBsb25nIG51bV9wYWdlcyA9IGF0b21pY19sb25nX3JlYWQoJmFsbG9jYXRl ZF9wYWdlcyk7Ci0KLQlyZXR1cm4gbnVtX3BhZ2VzID8gbnVtX3BhZ2VzIDogU0hSSU5LX0VNUFRZ OwotfQotCiAvKioKICAqIHR0bV9wb29sX21ncl9pbml0IC0gSW5pdGlhbGl6ZSBnbG9iYWxzCiAg KgpAQCAtNjU1LDggKzU2MCw5IEBAIGludCB0dG1fcG9vbF9tZ3JfaW5pdCh1bnNpZ25lZCBsb25n IG51bV9wYWdlcykKIAlpZiAoIXBhZ2VfcG9vbF9zaXplKQogCQlwYWdlX3Bvb2xfc2l6ZSA9IG51 bV9wYWdlczsKIAorCWRybV9wYWdlX3Bvb2xfc2V0X21heChwYWdlX3Bvb2xfc2l6ZSk7CisKIAlt dXRleF9pbml0KCZzaHJpbmtlcl9sb2NrKTsKLQlJTklUX0xJU1RfSEVBRCgmc2hyaW5rZXJfbGlz dCk7CiAKIAlmb3IgKGkgPSAwOyBpIDwgTUFYX09SREVSOyArK2kpIHsKIAkJdHRtX3Bvb2xfdHlw ZV9pbml0KCZnbG9iYWxfd3JpdGVfY29tYmluZWRbaV0sIE5VTEwsCkBAIC02NjksMTAgKzU3NSw3 IEBAIGludCB0dG1fcG9vbF9tZ3JfaW5pdCh1bnNpZ25lZCBsb25nIG51bV9wYWdlcykKIAkJCQkg ICB0dG1fdW5jYWNoZWQsIGkpOwogCX0KIAotCW1tX3Nocmlua2VyLmNvdW50X29iamVjdHMgPSB0 dG1fcG9vbF9zaHJpbmtlcl9jb3VudDsKLQltbV9zaHJpbmtlci5zY2FuX29iamVjdHMgPSB0dG1f cG9vbF9zaHJpbmtlcl9zY2FuOwotCW1tX3Nocmlua2VyLnNlZWtzID0gMTsKLQlyZXR1cm4gcmVn aXN0ZXJfc2hyaW5rZXIoJm1tX3Nocmlua2VyKTsKKwlyZXR1cm4gMDsKIH0KIAogLyoqCkBAIC02 OTEsNyArNTk0LDQgQEAgdm9pZCB0dG1fcG9vbF9tZ3JfZmluaSh2b2lkKQogCQl0dG1fcG9vbF90 eXBlX2ZpbmkoJmdsb2JhbF9kbWEzMl93cml0ZV9jb21iaW5lZFtpXSk7CiAJCXR0bV9wb29sX3R5 cGVfZmluaSgmZ2xvYmFsX2RtYTMyX3VuY2FjaGVkW2ldKTsKIAl9Ci0KLQl1bnJlZ2lzdGVyX3No cmlua2VyKCZtbV9zaHJpbmtlcik7Ci0JV0FSTl9PTighbGlzdF9lbXB0eSgmc2hyaW5rZXJfbGlz dCkpOwogfQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vdHRtL3R0bV9wb29sLmggYi9pbmNsdWRl L2RybS90dG0vdHRtX3Bvb2wuaAppbmRleCA0MzIxNzI4YmRkMTEuLjNkOTc1ODg4Y2U0NyAxMDA2 NDQKLS0tIGEvaW5jbHVkZS9kcm0vdHRtL3R0bV9wb29sLmgKKysrIGIvaW5jbHVkZS9kcm0vdHRt L3R0bV9wb29sLmgKQEAgLTMwLDYgKzMwLDcgQEAKICNpbmNsdWRlIDxsaW51eC9sbGlzdC5oPgog I2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CiAjaW5jbHVkZSA8ZHJtL3R0bS90dG1fY2FjaGlu Zy5oPgorI2luY2x1ZGUgPGRybS9wYWdlX3Bvb2wuaD4KIAogc3RydWN0IGRldmljZTsKIHN0cnVj dCB0dG1fdHQ7CkBAIC01MSwxMCArNTIsNyBAQCBzdHJ1Y3QgdHRtX3Bvb2xfdHlwZSB7CiAJdW5z aWduZWQgaW50IG9yZGVyOwogCWVudW0gdHRtX2NhY2hpbmcgY2FjaGluZzsKIAotCXN0cnVjdCBs aXN0X2hlYWQgc2hyaW5rZXJfbGlzdDsKLQotCXNwaW5sb2NrX3QgbG9jazsKLQlzdHJ1Y3QgbGlz dF9oZWFkIHBhZ2VzOworCXN0cnVjdCBkcm1fcGFnZV9wb29sIHN1YnBvb2w7CiB9OwogCiAvKioK LS0gCjIuMjUuMQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3Jn Cmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVs Cg== 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 X-Spam-Level: X-Spam-Status: No, score=-18.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 527C5C4332B for ; Thu, 4 Mar 2021 23:20:20 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 22F5365000 for ; Thu, 4 Mar 2021 23:20:20 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233019AbhCDXUT (ORCPT ); Thu, 4 Mar 2021 18:20:19 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:36972 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233032AbhCDXUS (ORCPT ); Thu, 4 Mar 2021 18:20:18 -0500 Received: from mail-pj1-x1032.google.com (mail-pj1-x1032.google.com [IPv6:2607:f8b0:4864:20::1032]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 61FFEC061574 for ; Thu, 4 Mar 2021 15:20:18 -0800 (PST) Received: by mail-pj1-x1032.google.com with SMTP id i14so371711pjz.4 for ; Thu, 04 Mar 2021 15:20:18 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=FiKbNF6sIsDFllVX3gZjMXu3m0TjzXNAhqpgm5/+cRY=; b=vMzeNpoKj+AWkNj1Sl0naujTZGOZ/Kd7M8pxVCcQ/geVFWfX9PusFkmpilFBZjEbhf /CmiI/RwQdWjgC1kRvbSjGQ8EdH9S6OXx8JzMfOuHnv+OJsy4nTtWLm4oViJJtwV/ykJ b71l7eMzLaiaFg6t5ebIYh3mgZJxZaVhGeG1tP73aW5gpCGPNuHcLWf7q/s+RvU2IQda uNi8HJnZ7vcyhNapadVbMcduwumQJf/OZ5Mjf4BiTU7LiNbNh+ZgyDamqaiecnvHT33y Ir4CH5oYx8yIDwHIWeW1gMW++1Qf3akAz+kNzQjspA5l/eK+rgMy57iFcl+0eqRRaSD4 BxbA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=FiKbNF6sIsDFllVX3gZjMXu3m0TjzXNAhqpgm5/+cRY=; b=Ne4PiH7HsXdPRl9LEhaydFcy/FUqNOMBfhO4VRrjSfL3Y6rdhYELWy1cqpMifFEO5O /i3Cvo7B/UgGfg0i2OlUzAv6cBOyz48yjBGk6HsqkMBG1R0JU2OJfiJltEFN5Mbet7Pd J+r5z5zTwSj2BC5T5P7Dpe7lXHwagEBpBkMkUHB3/kMcSkaipSZypahNpUqjqWPygjHM yJXygHSUmAYH1TCsM1cmL5bWHJgW4BRVfxR5LOqIZ+cP7SYV4AhzBx/WZnvX84Up57VJ Ji7mYwaVmSdcvmDYdtMIMfbKfKE4xzBCLyTY0l9McNx+OTY8fLwgsNWpG9gbaf/Ihoya wiSQ== X-Gm-Message-State: AOAM532xr9DWHo+3XTT5adHsKelaRj4MxR7fzLbwxvfVPGcSPuH7YqRn dsN+xSADt5YbC/nfz2kG3yyZ8g== X-Google-Smtp-Source: ABdhPJzaPXe0BX4p/OHpQUy/ewFyfYq+is8O0jHSW93qyBaAZlEvtzKM4hvHDE9/7CV7ZKdlubEr/g== X-Received: by 2002:a17:902:6b43:b029:df:fb48:aece with SMTP id g3-20020a1709026b43b02900dffb48aecemr5995966plt.59.1614900017933; Thu, 04 Mar 2021 15:20:17 -0800 (PST) Received: from localhost.localdomain ([2601:1c2:680:1319:692:26ff:feda:3a81]) by smtp.gmail.com with ESMTPSA id u66sm429290pfc.72.2021.03.04.15.20.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 04 Mar 2021 15:20:17 -0800 (PST) From: John Stultz To: lkml Cc: John Stultz , Daniel Vetter , Christian Koenig , Sumit Semwal , Liam Mark , Chris Goldsworthy , Laura Abbott , Brian Starkey , Hridya Valsaraju , Suren Baghdasaryan , Sandeep Patil , Daniel Mentz , =?UTF-8?q?=C3=98rjan=20Eide?= , Robin Murphy , Ezequiel Garcia , Simon Ser , James Jones , linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org Subject: [PATCH v8 2/5] drm: ttm_pool: Rework ttm_pool to use drm_page_pool Date: Thu, 4 Mar 2021 23:20:08 +0000 Message-Id: <20210304232011.1479036-3-john.stultz@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210304232011.1479036-1-john.stultz@linaro.org> References: <20210304232011.1479036-1-john.stultz@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-media@vger.kernel.org This patch reworks the ttm_pool logic to utilize the recently added drm_page_pool code. This adds drm_page_pool structures to the ttm_pool_type structures, and then removes all the ttm_pool_type shrinker logic (as its handled in the drm_page_pool shrinker). NOTE: There is one mismatch in the interfaces I'm not totally happy with. The ttm_pool tracks all of its pooled pages across a number of different pools, and tries to keep this size under the specified page_pool_size value. With the drm_page_pool, there may other users, however there is still one global shrinker list of pools. So we can't easily reduce the ttm pool under the ttm specified size without potentially doing a lot of shrinking to other non-ttm pools. So either we can: 1) Try to split it so each user of drm_page_pools manages its own pool shrinking. 2) Push the max value into the drm_page_pool, and have it manage shrinking to fit under that global max. Then share those size/max values out so the ttm_pool debug output can have more context. I've taken the second path in this patch set, but wanted to call it out so folks could look closely. Thoughts would be greatly appreciated here! Cc: Daniel Vetter Cc: Christian Koenig Cc: Sumit Semwal Cc: Liam Mark Cc: Chris Goldsworthy Cc: Laura Abbott Cc: Brian Starkey Cc: Hridya Valsaraju Cc: Suren Baghdasaryan Cc: Sandeep Patil Cc: Daniel Mentz Cc: Ørjan Eide Cc: Robin Murphy Cc: Ezequiel Garcia Cc: Simon Ser Cc: James Jones Cc: linux-media@vger.kernel.org Cc: dri-devel@lists.freedesktop.org Signed-off-by: John Stultz --- v7: * Major refactoring to use drm_page_pools inside the ttm_pool_type structure. This allows us to use container_of to get the needed context to free a page. This also means less code is changed overall. v8: * Reworked to use the new cleanly rewritten drm_page_pool logic --- drivers/gpu/drm/Kconfig | 1 + drivers/gpu/drm/ttm/ttm_pool.c | 156 ++++++--------------------------- include/drm/ttm/ttm_pool.h | 6 +- 3 files changed, 31 insertions(+), 132 deletions(-) diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig index 7cbcecb8f7df..a6cbdb63f6c7 100644 --- a/drivers/gpu/drm/Kconfig +++ b/drivers/gpu/drm/Kconfig @@ -184,6 +184,7 @@ config DRM_PAGE_POOL config DRM_TTM tristate depends on DRM && MMU + select DRM_PAGE_POOL help GPU memory management subsystem for devices with multiple GPU memory types. Will be enabled automatically if a device driver diff --git a/drivers/gpu/drm/ttm/ttm_pool.c b/drivers/gpu/drm/ttm/ttm_pool.c index 6e27cb1bf48b..f74ea801d7ab 100644 --- a/drivers/gpu/drm/ttm/ttm_pool.c +++ b/drivers/gpu/drm/ttm/ttm_pool.c @@ -39,6 +39,7 @@ #include #endif +#include #include #include #include @@ -68,8 +69,6 @@ static struct ttm_pool_type global_dma32_write_combined[MAX_ORDER]; static struct ttm_pool_type global_dma32_uncached[MAX_ORDER]; static struct mutex shrinker_lock; -static struct list_head shrinker_list; -static struct shrinker mm_shrinker; /* Allocate pages of size 1 << order with the given gfp_flags */ static struct page *ttm_pool_alloc_page(struct ttm_pool *pool, gfp_t gfp_flags, @@ -125,8 +124,9 @@ static struct page *ttm_pool_alloc_page(struct ttm_pool *pool, gfp_t gfp_flags, } /* Reset the caching and pages of size 1 << order */ -static void ttm_pool_free_page(struct ttm_pool *pool, enum ttm_caching caching, - unsigned int order, struct page *p) +static unsigned long ttm_pool_free_page(struct ttm_pool *pool, + enum ttm_caching caching, + unsigned int order, struct page *p) { unsigned long attr = DMA_ATTR_FORCE_CONTIGUOUS; struct ttm_pool_dma *dma; @@ -142,7 +142,7 @@ static void ttm_pool_free_page(struct ttm_pool *pool, enum ttm_caching caching, if (!pool || !pool->use_dma_alloc) { __free_pages(p, order); - return; + return 1UL << order; } if (order) @@ -153,6 +153,16 @@ static void ttm_pool_free_page(struct ttm_pool *pool, enum ttm_caching caching, dma_free_attrs(pool->dev, (1UL << order) * PAGE_SIZE, vaddr, dma->addr, attr); kfree(dma); + return 1UL << order; +} + +static unsigned long ttm_subpool_free_page(struct drm_page_pool *subpool, + struct page *p) +{ + struct ttm_pool_type *pt; + + pt = container_of(subpool, struct ttm_pool_type, subpool); + return ttm_pool_free_page(pt->pool, pt->caching, pt->order, p); } /* Apply a new caching to an array of pages */ @@ -216,40 +226,6 @@ static void ttm_pool_unmap(struct ttm_pool *pool, dma_addr_t dma_addr, DMA_BIDIRECTIONAL); } -/* Give pages into a specific pool_type */ -static void ttm_pool_type_give(struct ttm_pool_type *pt, struct page *p) -{ - unsigned int i, num_pages = 1 << pt->order; - - for (i = 0; i < num_pages; ++i) { - if (PageHighMem(p)) - clear_highpage(p + i); - else - clear_page(page_address(p + i)); - } - - spin_lock(&pt->lock); - list_add(&p->lru, &pt->pages); - spin_unlock(&pt->lock); - atomic_long_add(1 << pt->order, &allocated_pages); -} - -/* Take pages from a specific pool_type, return NULL when nothing available */ -static struct page *ttm_pool_type_take(struct ttm_pool_type *pt) -{ - struct page *p; - - spin_lock(&pt->lock); - p = list_first_entry_or_null(&pt->pages, typeof(*p), lru); - if (p) { - atomic_long_sub(1 << pt->order, &allocated_pages); - list_del(&p->lru); - } - spin_unlock(&pt->lock); - - return p; -} - /* Initialize and add a pool type to the global shrinker list */ static void ttm_pool_type_init(struct ttm_pool_type *pt, struct ttm_pool *pool, enum ttm_caching caching, unsigned int order) @@ -257,25 +233,14 @@ static void ttm_pool_type_init(struct ttm_pool_type *pt, struct ttm_pool *pool, pt->pool = pool; pt->caching = caching; pt->order = order; - spin_lock_init(&pt->lock); - INIT_LIST_HEAD(&pt->pages); - mutex_lock(&shrinker_lock); - list_add_tail(&pt->shrinker_list, &shrinker_list); - mutex_unlock(&shrinker_lock); + drm_page_pool_init(&pt->subpool, order, ttm_subpool_free_page); } /* Remove a pool_type from the global shrinker list and free all pages */ static void ttm_pool_type_fini(struct ttm_pool_type *pt) { - struct page *p, *tmp; - - mutex_lock(&shrinker_lock); - list_del(&pt->shrinker_list); - mutex_unlock(&shrinker_lock); - - list_for_each_entry_safe(p, tmp, &pt->pages, lru) - ttm_pool_free_page(pt->pool, pt->caching, pt->order, p); + drm_page_pool_fini(&pt->subpool); } /* Return the pool_type to use for the given caching and order */ @@ -306,30 +271,6 @@ static struct ttm_pool_type *ttm_pool_select_type(struct ttm_pool *pool, return NULL; } -/* Free pages using the global shrinker list */ -static unsigned int ttm_pool_shrink(void) -{ - struct ttm_pool_type *pt; - unsigned int num_freed; - struct page *p; - - mutex_lock(&shrinker_lock); - pt = list_first_entry(&shrinker_list, typeof(*pt), shrinker_list); - - p = ttm_pool_type_take(pt); - if (p) { - ttm_pool_free_page(pt->pool, pt->caching, pt->order, p); - num_freed = 1 << pt->order; - } else { - num_freed = 0; - } - - list_move_tail(&pt->shrinker_list, &shrinker_list); - mutex_unlock(&shrinker_lock); - - return num_freed; -} - /* Return the allocation order based for a page */ static unsigned int ttm_pool_page_order(struct ttm_pool *pool, struct page *p) { @@ -386,7 +327,7 @@ int ttm_pool_alloc(struct ttm_pool *pool, struct ttm_tt *tt, struct ttm_pool_type *pt; pt = ttm_pool_select_type(pool, tt->caching, order); - p = pt ? ttm_pool_type_take(pt) : NULL; + p = pt ? drm_page_pool_remove(&pt->subpool) : NULL; if (p) { apply_caching = true; } else { @@ -479,16 +420,13 @@ void ttm_pool_free(struct ttm_pool *pool, struct ttm_tt *tt) pt = ttm_pool_select_type(pool, tt->caching, order); if (pt) - ttm_pool_type_give(pt, tt->pages[i]); + drm_page_pool_add(&pt->subpool, tt->pages[i]); else ttm_pool_free_page(pool, tt->caching, order, tt->pages[i]); i += num_pages; } - - while (atomic_long_read(&allocated_pages) > page_pool_size) - ttm_pool_shrink(); } EXPORT_SYMBOL(ttm_pool_free); @@ -537,21 +475,6 @@ void ttm_pool_fini(struct ttm_pool *pool) } #ifdef CONFIG_DEBUG_FS -/* Count the number of pages available in a pool_type */ -static unsigned int ttm_pool_type_count(struct ttm_pool_type *pt) -{ - unsigned int count = 0; - struct page *p; - - spin_lock(&pt->lock); - /* Only used for debugfs, the overhead doesn't matter */ - list_for_each_entry(p, &pt->pages, lru) - ++count; - spin_unlock(&pt->lock); - - return count; -} - /* Dump information about the different pool types */ static void ttm_pool_debugfs_orders(struct ttm_pool_type *pt, struct seq_file *m) @@ -559,7 +482,8 @@ static void ttm_pool_debugfs_orders(struct ttm_pool_type *pt, unsigned int i; for (i = 0; i < MAX_ORDER; ++i) - seq_printf(m, " %8u", ttm_pool_type_count(&pt[i])); + seq_printf(m, " %8lu", + drm_page_pool_get_size(&pt[i].subpool)); seq_puts(m, "\n"); } @@ -609,7 +533,10 @@ int ttm_pool_debugfs(struct ttm_pool *pool, struct seq_file *m) } seq_printf(m, "\ntotal\t: %8lu of %8lu\n", - atomic_long_read(&allocated_pages), page_pool_size); + atomic_long_read(&allocated_pages), + drm_page_pool_get_max()); + seq_printf(m, "(%8lu in non-ttm pools)\n", drm_page_pool_get_total() - + atomic_long_read(&allocated_pages)); mutex_unlock(&shrinker_lock); @@ -619,28 +546,6 @@ EXPORT_SYMBOL(ttm_pool_debugfs); #endif -/* As long as pages are available make sure to release at least one */ -static unsigned long ttm_pool_shrinker_scan(struct shrinker *shrink, - struct shrink_control *sc) -{ - unsigned long num_freed = 0; - - do - num_freed += ttm_pool_shrink(); - while (!num_freed && atomic_long_read(&allocated_pages)); - - return num_freed; -} - -/* Return the number of pages available or SHRINK_EMPTY if we have none */ -static unsigned long ttm_pool_shrinker_count(struct shrinker *shrink, - struct shrink_control *sc) -{ - unsigned long num_pages = atomic_long_read(&allocated_pages); - - return num_pages ? num_pages : SHRINK_EMPTY; -} - /** * ttm_pool_mgr_init - Initialize globals * @@ -655,8 +560,9 @@ int ttm_pool_mgr_init(unsigned long num_pages) if (!page_pool_size) page_pool_size = num_pages; + drm_page_pool_set_max(page_pool_size); + mutex_init(&shrinker_lock); - INIT_LIST_HEAD(&shrinker_list); for (i = 0; i < MAX_ORDER; ++i) { ttm_pool_type_init(&global_write_combined[i], NULL, @@ -669,10 +575,7 @@ int ttm_pool_mgr_init(unsigned long num_pages) ttm_uncached, i); } - mm_shrinker.count_objects = ttm_pool_shrinker_count; - mm_shrinker.scan_objects = ttm_pool_shrinker_scan; - mm_shrinker.seeks = 1; - return register_shrinker(&mm_shrinker); + return 0; } /** @@ -691,7 +594,4 @@ void ttm_pool_mgr_fini(void) ttm_pool_type_fini(&global_dma32_write_combined[i]); ttm_pool_type_fini(&global_dma32_uncached[i]); } - - unregister_shrinker(&mm_shrinker); - WARN_ON(!list_empty(&shrinker_list)); } diff --git a/include/drm/ttm/ttm_pool.h b/include/drm/ttm/ttm_pool.h index 4321728bdd11..3d975888ce47 100644 --- a/include/drm/ttm/ttm_pool.h +++ b/include/drm/ttm/ttm_pool.h @@ -30,6 +30,7 @@ #include #include #include +#include struct device; struct ttm_tt; @@ -51,10 +52,7 @@ struct ttm_pool_type { unsigned int order; enum ttm_caching caching; - struct list_head shrinker_list; - - spinlock_t lock; - struct list_head pages; + struct drm_page_pool subpool; }; /** -- 2.25.1