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=-12.6 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,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 3537BC47425 for ; Sat, 26 Sep 2020 04:25:03 +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 D16DE207C4 for ; Sat, 26 Sep 2020 04:25:02 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="qYnAL5+5" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D16DE207C4 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 994086E133; Sat, 26 Sep 2020 04:25:01 +0000 (UTC) Received: from mail-pl1-x643.google.com (mail-pl1-x643.google.com [IPv6:2607:f8b0:4864:20::643]) by gabe.freedesktop.org (Postfix) with ESMTPS id D9C956E133 for ; Sat, 26 Sep 2020 04:24:58 +0000 (UTC) Received: by mail-pl1-x643.google.com with SMTP id bb1so356617plb.2 for ; Fri, 25 Sep 2020 21:24:58 -0700 (PDT) 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=NEH7dSpxqauBk78qE1pmPtBx4lDfCsXkpGiAZ8uIYoU=; b=qYnAL5+5YevrqN1Msnjai60b/eeSbfx4+aAdG1jq+kWoKGB5iX+IJHR2gapx9udbGB oyJwv7pmiTIzpMSE/mDQoYU9AqpaGzogty93KtTaw++bljZMr3NrVaL90mW4ww5Sd3D0 K01vIfSy/CNgnkUuLHgiKenT1urK4e6V7qwo5IjqEAymLlaqgZ6u7ZFfK0oRiytkTsbI iXSA/LCin6mqBpDfNlr9VY/mKWmschenAgLKR4bcVjgyJmbOAuShUl+B5Unj4uIqHVF1 8anJbl4ObNCpffkq1qEinuche4DSddCl1cPtq3ayZuokY33zv38QrK2d0F1X/BVW20Qf K6zg== 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=NEH7dSpxqauBk78qE1pmPtBx4lDfCsXkpGiAZ8uIYoU=; b=bJGo7wIGs6313iNgAYhJkv664ojKzfkQqQusS61D4vSe+gUf5uSJm/pzPinW177R7I Y+IWQCE+zbWSCUom+v4HSQzWb5XzVVSsynBEsKSte+6uUz4ybMtQ3pKDGiO7pL9qD91K dCf3Q2eKRs0/qli/4eLoinDmTqf9Kxvcl4tGjriUpAJAIQ6gogfk0n+eCAit48z3Sy16 xZ0F9h1jFlW0W8jSBSYH1bDI+Lx4Bb9oRVECFxHjSsGcKuNdk2XAplWZIwsSmDOXydpn Y3AnQEjqfm5XOLIIZT9YNMfpd7huCR1nDmKpoVsLmW3Y9DeYRugVOLU4wCSCAEwLL46O FM8Q== X-Gm-Message-State: AOAM533GLLlvDKLy4QCwAHIDPI1GSx9TlVjekKgbRGZ4XPw2x/DfaCMS KdegzDz0LqjISx4Ev1VMwfXEpg== X-Google-Smtp-Source: ABdhPJwetII4Mw9P6pPBXOCqMXrXkdH0dbYKAMabb15GOX4+ef7pGIUAr10E9lRSd+VVywrZzwLRLA== X-Received: by 2002:a17:90a:f407:: with SMTP id ch7mr694079pjb.142.1601094298340; Fri, 25 Sep 2020 21:24:58 -0700 (PDT) Received: from localhost.localdomain ([2601:1c2:680:1319:692:26ff:feda:3a81]) by smtp.gmail.com with ESMTPSA id a5sm3585886pgk.13.2020.09.25.21.24.56 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 25 Sep 2020 21:24:57 -0700 (PDT) From: John Stultz To: lkml Subject: [RFC][PATCH 1/6] dma-buf: system_heap: Rework system heap to use sgtables instead of pagelists Date: Sat, 26 Sep 2020 04:24:48 +0000 Message-Id: <20200926042453.67517-2-john.stultz@linaro.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200926042453.67517-1-john.stultz@linaro.org> References: <20200926042453.67517-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: Sandeep Patil , dri-devel@lists.freedesktop.org, Ezequiel Garcia , Robin Murphy , James Jones , Liam Mark , Laura Abbott , Hridya Valsaraju , =?UTF-8?q?=C3=98rjan=20Eide?= , Suren Baghdasaryan , linux-media@vger.kernel.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" SW4gcHJlcGFyYXRpb24gZm9yIHNvbWUgcGF0Y2hlcyB0byBvcHRtaXplIHRoZSBzeXN0ZW0KaGVh cCBjb2RlLCByZXdvcmsgdGhlIGRtYWJ1ZiBleHBvcnRlciB0byB1dGlsaXplIHNndGFibGVzIHJh dGhlcgp0aGVuIHBhZ2VzbGlzdHMgZm9yIHRyYWNraW5nIHRoZSBhc3NvY2lhdGVkIHBhZ2VzLgoK VGhpcyB3aWxsIGFsbG93IGZvciBsYXJnZSBvcmRlciBwYWdlIGFsbG9jYXRpb25zLCBhcyB3ZWxs IGFzCm1vcmUgZWZmaWNpZW50IHBhZ2UgcG9vbGluZy4KCkluIGRvaW5nIHNvLCB0aGUgc3lzdGVt IGhlYXAgc3RvcHMgdXNpbmcgdGhlIGhlYXAtaGVscGVycyBsb2dpYwp3aGljaCBzYWRseSBpcyBu b3QgcXVpdGUgYXMgZ2VuZXJpYyBhcyBJIHdhcyBob3BpbmcgaXQgdG8gYmUsIHNvCnRoaXMgcGF0 Y2ggYWRkcyBoZWFwIHNwZWNpZmljIGltcGxlbWVudGF0aW9ucyBvZiB0aGUgZG1hX2J1Zl9vcHMK ZnVuY3Rpb24gaGFuZGxlcnMuCgpDYzogU3VtaXQgU2Vtd2FsIDxzdW1pdC5zZW13YWxAbGluYXJv Lm9yZz4KQ2M6IExpYW0gTWFyayA8bG1hcmtAY29kZWF1cm9yYS5vcmc+CkNjOiBMYXVyYSBBYmJv dHQgPGxhYmJvdHRAa2VybmVsLm9yZz4KQ2M6IEJyaWFuIFN0YXJrZXkgPEJyaWFuLlN0YXJrZXlA YXJtLmNvbT4KQ2M6IEhyaWR5YSBWYWxzYXJhanUgPGhyaWR5YUBnb29nbGUuY29tPgpDYzogU3Vy ZW4gQmFnaGRhc2FyeWFuIDxzdXJlbmJAZ29vZ2xlLmNvbT4KQ2M6IFNhbmRlZXAgUGF0aWwgPHNz cGF0aWxAZ29vZ2xlLmNvbT4KQ2M6IMOYcmphbiBFaWRlIDxvcmphbi5laWRlQGFybS5jb20+CkNj OiBSb2JpbiBNdXJwaHkgPHJvYmluLm11cnBoeUBhcm0uY29tPgpDYzogRXplcXVpZWwgR2FyY2lh IDxlemVxdWllbEBjb2xsYWJvcmEuY29tPgpDYzogU2ltb24gU2VyIDxjb250YWN0QGVtZXJzaW9u LmZyPgpDYzogSmFtZXMgSm9uZXMgPGpham9uZXNAbnZpZGlhLmNvbT4KQ2M6IGxpbnV4LW1lZGlh QHZnZXIua2VybmVsLm9yZwpDYzogZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpTaWdu ZWQtb2ZmLWJ5OiBKb2huIFN0dWx0eiA8am9obi5zdHVsdHpAbGluYXJvLm9yZz4KLS0tCiBkcml2 ZXJzL2RtYS1idWYvaGVhcHMvc3lzdGVtX2hlYXAuYyB8IDM0MyArKysrKysrKysrKysrKysrKysr KysrKystLS0tCiAxIGZpbGUgY2hhbmdlZCwgMjk3IGluc2VydGlvbnMoKyksIDQ2IGRlbGV0aW9u cygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hLWJ1Zi9oZWFwcy9zeXN0ZW1faGVhcC5jIGIv ZHJpdmVycy9kbWEtYnVmL2hlYXBzL3N5c3RlbV9oZWFwLmMKaW5kZXggMGJmNjg4ZTNjMDIzLi5k ZGZhMTdkYzQ4YTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZG1hLWJ1Zi9oZWFwcy9zeXN0ZW1faGVh cC5jCisrKyBiL2RyaXZlcnMvZG1hLWJ1Zi9oZWFwcy9zeXN0ZW1faGVhcC5jCkBAIC0zLDcgKzMs MTEgQEAKICAqIERNQUJVRiBTeXN0ZW0gaGVhcCBleHBvcnRlcgogICoKICAqIENvcHlyaWdodCAo QykgMjAxMSBHb29nbGUsIEluYy4KLSAqIENvcHlyaWdodCAoQykgMjAxOSBMaW5hcm8gTHRkLgor ICogQ29weXJpZ2h0IChDKSAyMDE5LCAyMDIwIExpbmFybyBMdGQuCisgKgorICogUG9ydGlvbnMg YmFzZWQgb2ZmIG9mIEFuZHJldyBEYXZpcycgU1JBTSBoZWFwOgorICogQ29weXJpZ2h0IChDKSAy MDE5IFRleGFzIEluc3RydW1lbnRzIEluY29ycG9yYXRlZCAtIGh0dHA6Ly93d3cudGkuY29tLwor ICoJQW5kcmV3IEYuIERhdmlzIDxhZmRAdGkuY29tPgogICovCiAKICNpbmNsdWRlIDxsaW51eC9k bWEtYnVmLmg+CkBAIC0xNSw3MiArMTksMzIwIEBACiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+ CiAjaW5jbHVkZSA8bGludXgvc2NhdHRlcmxpc3QuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+ Ci0jaW5jbHVkZSA8bGludXgvc2NoZWQvc2lnbmFsLmg+Ci0jaW5jbHVkZSA8YXNtL3BhZ2UuaD4K LQotI2luY2x1ZGUgImhlYXAtaGVscGVycy5oIgorI2luY2x1ZGUgPGxpbnV4L3ZtYWxsb2MuaD4K IAogc3RydWN0IGRtYV9oZWFwICpzeXNfaGVhcDsKIAotc3RhdGljIHZvaWQgc3lzdGVtX2hlYXBf ZnJlZShzdHJ1Y3QgaGVhcF9oZWxwZXJfYnVmZmVyICpidWZmZXIpCitzdHJ1Y3Qgc3lzdGVtX2hl YXBfYnVmZmVyIHsKKwlzdHJ1Y3QgZG1hX2hlYXAgKmhlYXA7CisJc3RydWN0IGxpc3RfaGVhZCBh dHRhY2htZW50czsKKwlzdHJ1Y3QgbXV0ZXggbG9jazsKKwl1bnNpZ25lZCBsb25nIGxlbjsKKwlz dHJ1Y3Qgc2dfdGFibGUgc2dfdGFibGU7CisJaW50IHZtYXBfY250OworCXZvaWQgKnZhZGRyOwor fTsKKworc3RydWN0IGRtYV9oZWFwX2F0dGFjaG1lbnQgeworCXN0cnVjdCBkZXZpY2UgKmRldjsK KwlzdHJ1Y3Qgc2dfdGFibGUgKnRhYmxlOworCXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsKK307CisK K3N0YXRpYyBzdHJ1Y3Qgc2dfdGFibGUgKmR1cF9zZ190YWJsZShzdHJ1Y3Qgc2dfdGFibGUgKnRh YmxlKQogewotCXBnb2ZmX3QgcGc7CisJc3RydWN0IHNnX3RhYmxlICpuZXdfdGFibGU7CisJaW50 IHJldCwgaTsKKwlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnLCAqbmV3X3NnOworCisJbmV3X3RhYmxl ID0ga3phbGxvYyhzaXplb2YoKm5ld190YWJsZSksIEdGUF9LRVJORUwpOworCWlmICghbmV3X3Rh YmxlKQorCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKKworCXJldCA9IHNnX2FsbG9jX3RhYmxl KG5ld190YWJsZSwgdGFibGUtPm5lbnRzLCBHRlBfS0VSTkVMKTsKKwlpZiAocmV0KSB7CisJCWtm cmVlKG5ld190YWJsZSk7CisJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOworCX0KKworCW5ld19z ZyA9IG5ld190YWJsZS0+c2dsOworCWZvcl9lYWNoX3NndGFibGVfc2codGFibGUsIHNnLCBpKSB7 CisJCXNnX3NldF9wYWdlKG5ld19zZywgc2dfcGFnZShzZyksIHNnLT5sZW5ndGgsIHNnLT5vZmZz ZXQpOworCQluZXdfc2cgPSBzZ19uZXh0KG5ld19zZyk7CisJfQorCisJcmV0dXJuIG5ld190YWJs ZTsKK30KKworc3RhdGljIGludCBzeXN0ZW1faGVhcF9hdHRhY2goc3RydWN0IGRtYV9idWYgKmRt YWJ1ZiwKKwkJCSAgICAgIHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaG1lbnQpCit7 CisJc3RydWN0IHN5c3RlbV9oZWFwX2J1ZmZlciAqYnVmZmVyID0gZG1hYnVmLT5wcml2OworCXN0 cnVjdCBkbWFfaGVhcF9hdHRhY2htZW50ICphOworCXN0cnVjdCBzZ190YWJsZSAqdGFibGU7CisK KwlhID0ga3phbGxvYyhzaXplb2YoKmEpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWEpCisJCXJldHVy biAtRU5PTUVNOworCisJdGFibGUgPSBkdXBfc2dfdGFibGUoJmJ1ZmZlci0+c2dfdGFibGUpOwor CWlmIChJU19FUlIodGFibGUpKSB7CisJCWtmcmVlKGEpOworCQlyZXR1cm4gLUVOT01FTTsKKwl9 CisKKwlhLT50YWJsZSA9IHRhYmxlOworCWEtPmRldiA9IGF0dGFjaG1lbnQtPmRldjsKKwlJTklU X0xJU1RfSEVBRCgmYS0+bGlzdCk7CisKKwlhdHRhY2htZW50LT5wcml2ID0gYTsKKworCW11dGV4 X2xvY2soJmJ1ZmZlci0+bG9jayk7CisJbGlzdF9hZGQoJmEtPmxpc3QsICZidWZmZXItPmF0dGFj aG1lbnRzKTsKKwltdXRleF91bmxvY2soJmJ1ZmZlci0+bG9jayk7CisKKwlyZXR1cm4gMDsKK30K Kworc3RhdGljIHZvaWQgc3lzdGVtX2hlYXBfZGV0YXRjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVm LAorCQkJCXN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaG1lbnQpCit7CisJc3RydWN0 IHN5c3RlbV9oZWFwX2J1ZmZlciAqYnVmZmVyID0gZG1hYnVmLT5wcml2OworCXN0cnVjdCBkbWFf aGVhcF9hdHRhY2htZW50ICphID0gYXR0YWNobWVudC0+cHJpdjsKKworCW11dGV4X2xvY2soJmJ1 ZmZlci0+bG9jayk7CisJbGlzdF9kZWwoJmEtPmxpc3QpOworCW11dGV4X3VubG9jaygmYnVmZmVy LT5sb2NrKTsKKworCXNnX2ZyZWVfdGFibGUoYS0+dGFibGUpOworCWtmcmVlKGEtPnRhYmxlKTsK KwlrZnJlZShhKTsKK30KKworc3RhdGljIHN0cnVjdCBzZ190YWJsZSAqc3lzdGVtX2hlYXBfbWFw X2RtYV9idWYoc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNobWVudCwKKwkJCQkJCWVu dW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpcmVjdGlvbikKK3sKKwlzdHJ1Y3QgZG1hX2hlYXBfYXR0 YWNobWVudCAqYSA9IGF0dGFjaG1lbnQtPnByaXY7CisJc3RydWN0IHNnX3RhYmxlICp0YWJsZSA9 IGEtPnRhYmxlOworCisJaWYgKCFkbWFfbWFwX3NnKGF0dGFjaG1lbnQtPmRldiwgdGFibGUtPnNn bCwgdGFibGUtPm5lbnRzLCBkaXJlY3Rpb24pKQorCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsK KworCXJldHVybiB0YWJsZTsKK30KKworc3RhdGljIHZvaWQgc3lzdGVtX2hlYXBfdW5tYXBfZG1h X2J1ZihzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2htZW50LAorCQkJCSAgICAgIHN0 cnVjdCBzZ190YWJsZSAqdGFibGUsCisJCQkJICAgICAgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24g ZGlyZWN0aW9uKQoreworCWRtYV91bm1hcF9zZyhhdHRhY2htZW50LT5kZXYsIHRhYmxlLT5zZ2ws IHRhYmxlLT5uZW50cywgZGlyZWN0aW9uKTsKK30KKworc3RhdGljIGludCBzeXN0ZW1faGVhcF9k bWFfYnVmX2JlZ2luX2NwdV9hY2Nlc3Moc3RydWN0IGRtYV9idWYgKmRtYWJ1ZiwKKwkJCQkJCWVu dW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpcmVjdGlvbikKK3sKKwlzdHJ1Y3Qgc3lzdGVtX2hlYXBf YnVmZmVyICpidWZmZXIgPSBkbWFidWYtPnByaXY7CisJc3RydWN0IGRtYV9oZWFwX2F0dGFjaG1l bnQgKmE7CisJaW50IHJldCA9IDA7CisKKwltdXRleF9sb2NrKCZidWZmZXItPmxvY2spOworCisJ aWYgKGJ1ZmZlci0+dm1hcF9jbnQpCisJCWludmFsaWRhdGVfa2VybmVsX3ZtYXBfcmFuZ2UoYnVm ZmVyLT52YWRkciwgYnVmZmVyLT5sZW4pOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShhLCAmYnVm ZmVyLT5hdHRhY2htZW50cywgbGlzdCkgeworCQlkbWFfc3luY19zZ19mb3JfY3B1KGEtPmRldiwg YS0+dGFibGUtPnNnbCwgYS0+dGFibGUtPm5lbnRzLAorCQkJCSAgICBkaXJlY3Rpb24pOworCX0K KwltdXRleF91bmxvY2soJmJ1ZmZlci0+bG9jayk7CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0 aWMgaW50IHN5c3RlbV9oZWFwX2RtYV9idWZfZW5kX2NwdV9hY2Nlc3Moc3RydWN0IGRtYV9idWYg KmRtYWJ1ZiwKKwkJCQkJICAgICAgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyZWN0aW9uKQor eworCXN0cnVjdCBzeXN0ZW1faGVhcF9idWZmZXIgKmJ1ZmZlciA9IGRtYWJ1Zi0+cHJpdjsKKwlz dHJ1Y3QgZG1hX2hlYXBfYXR0YWNobWVudCAqYTsKKworCW11dGV4X2xvY2soJmJ1ZmZlci0+bG9j ayk7CisKKwlpZiAoYnVmZmVyLT52bWFwX2NudCkKKwkJZmx1c2hfa2VybmVsX3ZtYXBfcmFuZ2Uo YnVmZmVyLT52YWRkciwgYnVmZmVyLT5sZW4pOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShhLCAm YnVmZmVyLT5hdHRhY2htZW50cywgbGlzdCkgeworCQlkbWFfc3luY19zZ19mb3JfZGV2aWNlKGEt PmRldiwgYS0+dGFibGUtPnNnbCwgYS0+dGFibGUtPm5lbnRzLAorCQkJCSAgICAgICBkaXJlY3Rp b24pOworCX0KKwltdXRleF91bmxvY2soJmJ1ZmZlci0+bG9jayk7CisKKwlyZXR1cm4gMDsKK30K Kworc3RhdGljIGludCBzeXN0ZW1faGVhcF9tbWFwKHN0cnVjdCBkbWFfYnVmICpkbWFidWYsIHN0 cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hKQoreworCXN0cnVjdCBzeXN0ZW1faGVhcF9idWZmZXIg KmJ1ZmZlciA9IGRtYWJ1Zi0+cHJpdjsKKwlzdHJ1Y3Qgc2dfdGFibGUgKnRhYmxlID0gJmJ1ZmZl ci0+c2dfdGFibGU7CisJdW5zaWduZWQgbG9uZyBhZGRyID0gdm1hLT52bV9zdGFydDsKKwlzdHJ1 Y3Qgc2dfcGFnZV9pdGVyIHBpdGVyOworCWludCByZXQ7CisKKwlmb3JfZWFjaF9zZ3RhYmxlX3Bh Z2UodGFibGUsICZwaXRlciwgdm1hLT52bV9wZ29mZikgeworCQlzdHJ1Y3QgcGFnZSAqcGFnZSA9 IHNnX3BhZ2VfaXRlcl9wYWdlKCZwaXRlcik7CisKKwkJcmV0ID0gcmVtYXBfcGZuX3JhbmdlKHZt YSwgYWRkciwgcGFnZV90b19wZm4ocGFnZSksIFBBR0VfU0laRSwKKwkJCQkgICAgICB2bWEtPnZt X3BhZ2VfcHJvdCk7CisJCWlmIChyZXQpCisJCQlyZXR1cm4gcmV0OworCQlhZGRyICs9IFBBR0Vf U0laRTsKKwkJaWYgKGFkZHIgPj0gdm1hLT52bV9lbmQpCisJCQlyZXR1cm4gMDsKKwl9CisJcmV0 dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkICpzeXN0ZW1faGVhcF9kb192bWFwKHN0cnVjdCBzeXN0 ZW1faGVhcF9idWZmZXIgKmJ1ZmZlcikKK3sKKwlzdHJ1Y3Qgc2dfdGFibGUgKnRhYmxlID0gJmJ1 ZmZlci0+c2dfdGFibGU7CisJaW50IG5wYWdlcyA9IFBBR0VfQUxJR04oYnVmZmVyLT5sZW4pIC8g UEFHRV9TSVpFOworCXN0cnVjdCBwYWdlICoqcGFnZXMgPSB2bWFsbG9jKHNpemVvZihzdHJ1Y3Qg cGFnZSAqKSAqIG5wYWdlcyk7CisJc3RydWN0IHBhZ2UgKip0bXAgPSBwYWdlczsKKwlzdHJ1Y3Qg c2dfcGFnZV9pdGVyIHBpdGVyOworCXZvaWQgKnZhZGRyOworCisJaWYgKCFwYWdlcykKKwkJcmV0 dXJuIEVSUl9QVFIoLUVOT01FTSk7CisKKwlmb3JfZWFjaF9zZ3RhYmxlX3BhZ2UodGFibGUsICZw aXRlciwgMCkgeworCQlXQVJOX09OKHRtcCAtIHBhZ2VzID49IG5wYWdlcyk7CisJCSp0bXArKyA9 IHNnX3BhZ2VfaXRlcl9wYWdlKCZwaXRlcik7CisJfQorCisJdmFkZHIgPSB2bWFwKHBhZ2VzLCBu cGFnZXMsIFZNX01BUCwgUEFHRV9LRVJORUwpOworCXZmcmVlKHBhZ2VzKTsKKworCWlmICghdmFk ZHIpCisJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOworCisJcmV0dXJuIHZhZGRyOworfQogCi0J Zm9yIChwZyA9IDA7IHBnIDwgYnVmZmVyLT5wYWdlY291bnQ7IHBnKyspCi0JCV9fZnJlZV9wYWdl KGJ1ZmZlci0+cGFnZXNbcGddKTsKLQlrZnJlZShidWZmZXItPnBhZ2VzKTsKK3N0YXRpYyB2b2lk ICpzeXN0ZW1faGVhcF92bWFwKHN0cnVjdCBkbWFfYnVmICpkbWFidWYpCit7CisJc3RydWN0IHN5 c3RlbV9oZWFwX2J1ZmZlciAqYnVmZmVyID0gZG1hYnVmLT5wcml2OworCXZvaWQgKnZhZGRyOwor CisJbXV0ZXhfbG9jaygmYnVmZmVyLT5sb2NrKTsKKwlpZiAoYnVmZmVyLT52bWFwX2NudCkgewor CQlidWZmZXItPnZtYXBfY250Kys7CisJCXJldHVybiBidWZmZXItPnZhZGRyOworCX0KKworCXZh ZGRyID0gc3lzdGVtX2hlYXBfZG9fdm1hcChidWZmZXIpOworCWlmIChJU19FUlIodmFkZHIpKQor CQlyZXR1cm4gdmFkZHI7CisKKwlidWZmZXItPnZhZGRyID0gdmFkZHI7CisJYnVmZmVyLT52bWFw X2NudCsrOworCW11dGV4X3VubG9jaygmYnVmZmVyLT5sb2NrKTsKKworCXJldHVybiB2YWRkcjsK K30KKworc3RhdGljIHZvaWQgc3lzdGVtX2hlYXBfdnVubWFwKHN0cnVjdCBkbWFfYnVmICpkbWFi dWYsIHZvaWQgKnZhZGRyKQoreworCXN0cnVjdCBzeXN0ZW1faGVhcF9idWZmZXIgKmJ1ZmZlciA9 IGRtYWJ1Zi0+cHJpdjsKKworCW11dGV4X2xvY2soJmJ1ZmZlci0+bG9jayk7CisJaWYgKCEtLWJ1 ZmZlci0+dm1hcF9jbnQpIHsKKwkJdnVubWFwKGJ1ZmZlci0+dmFkZHIpOworCQlidWZmZXItPnZh ZGRyID0gTlVMTDsKKwl9CisJbXV0ZXhfdW5sb2NrKCZidWZmZXItPmxvY2spOworfQorCitzdGF0 aWMgdm9pZCBzeXN0ZW1faGVhcF9kbWFfYnVmX3JlbGVhc2Uoc3RydWN0IGRtYV9idWYgKmRtYWJ1 ZikKK3sKKwlzdHJ1Y3Qgc3lzdGVtX2hlYXBfYnVmZmVyICpidWZmZXIgPSBkbWFidWYtPnByaXY7 CisJc3RydWN0IHNnX3RhYmxlICp0YWJsZTsKKwlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnOworCWlu dCBpOworCisJdGFibGUgPSAmYnVmZmVyLT5zZ190YWJsZTsKKwlmb3JfZWFjaF9zZ3RhYmxlX3Nn KHRhYmxlLCBzZywgaSkKKwkJX19mcmVlX3BhZ2Uoc2dfcGFnZShzZykpOworCXNnX2ZyZWVfdGFi bGUodGFibGUpOwogCWtmcmVlKGJ1ZmZlcik7CiB9CiAKK2NvbnN0IHN0cnVjdCBkbWFfYnVmX29w cyBzeXN0ZW1faGVhcF9idWZfb3BzID0geworCS5hdHRhY2ggPSBzeXN0ZW1faGVhcF9hdHRhY2gs CisJLmRldGFjaCA9IHN5c3RlbV9oZWFwX2RldGF0Y2gsCisJLm1hcF9kbWFfYnVmID0gc3lzdGVt X2hlYXBfbWFwX2RtYV9idWYsCisJLnVubWFwX2RtYV9idWYgPSBzeXN0ZW1faGVhcF91bm1hcF9k bWFfYnVmLAorCS5iZWdpbl9jcHVfYWNjZXNzID0gc3lzdGVtX2hlYXBfZG1hX2J1Zl9iZWdpbl9j cHVfYWNjZXNzLAorCS5lbmRfY3B1X2FjY2VzcyA9IHN5c3RlbV9oZWFwX2RtYV9idWZfZW5kX2Nw dV9hY2Nlc3MsCisJLm1tYXAgPSBzeXN0ZW1faGVhcF9tbWFwLAorCS52bWFwID0gc3lzdGVtX2hl YXBfdm1hcCwKKwkudnVubWFwID0gc3lzdGVtX2hlYXBfdnVubWFwLAorCS5yZWxlYXNlID0gc3lz dGVtX2hlYXBfZG1hX2J1Zl9yZWxlYXNlLAorfTsKKwogc3RhdGljIGludCBzeXN0ZW1faGVhcF9h bGxvY2F0ZShzdHJ1Y3QgZG1hX2hlYXAgKmhlYXAsCiAJCQkJdW5zaWduZWQgbG9uZyBsZW4sCiAJ CQkJdW5zaWduZWQgbG9uZyBmZF9mbGFncywKIAkJCQl1bnNpZ25lZCBsb25nIGhlYXBfZmxhZ3Mp CiB7Ci0Jc3RydWN0IGhlYXBfaGVscGVyX2J1ZmZlciAqaGVscGVyX2J1ZmZlcjsKKwlzdHJ1Y3Qg c3lzdGVtX2hlYXBfYnVmZmVyICpidWZmZXI7CisJREVGSU5FX0RNQV9CVUZfRVhQT1JUX0lORk8o ZXhwX2luZm8pOwogCXN0cnVjdCBkbWFfYnVmICpkbWFidWY7Ci0JaW50IHJldCA9IC1FTk9NRU07 CisJc3RydWN0IHNnX3RhYmxlICp0YWJsZTsKKwlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnOworCXBn b2ZmX3QgcGFnZWNvdW50OwogCXBnb2ZmX3QgcGc7CisJaW50IGksIHJldCA9IC1FTk9NRU07CiAK LQloZWxwZXJfYnVmZmVyID0ga3phbGxvYyhzaXplb2YoKmhlbHBlcl9idWZmZXIpLCBHRlBfS0VS TkVMKTsKLQlpZiAoIWhlbHBlcl9idWZmZXIpCisJYnVmZmVyID0ga3phbGxvYyhzaXplb2YoKmJ1 ZmZlciksIEdGUF9LRVJORUwpOworCWlmICghYnVmZmVyKQogCQlyZXR1cm4gLUVOT01FTTsKIAot CWluaXRfaGVhcF9oZWxwZXJfYnVmZmVyKGhlbHBlcl9idWZmZXIsIHN5c3RlbV9oZWFwX2ZyZWUp OwotCWhlbHBlcl9idWZmZXItPmhlYXAgPSBoZWFwOwotCWhlbHBlcl9idWZmZXItPnNpemUgPSBs ZW47Ci0KLQloZWxwZXJfYnVmZmVyLT5wYWdlY291bnQgPSBsZW4gLyBQQUdFX1NJWkU7Ci0JaGVs cGVyX2J1ZmZlci0+cGFnZXMgPSBrbWFsbG9jX2FycmF5KGhlbHBlcl9idWZmZXItPnBhZ2Vjb3Vu dCwKLQkJCQkJICAgICBzaXplb2YoKmhlbHBlcl9idWZmZXItPnBhZ2VzKSwKLQkJCQkJICAgICBH RlBfS0VSTkVMKTsKLQlpZiAoIWhlbHBlcl9idWZmZXItPnBhZ2VzKSB7Ci0JCXJldCA9IC1FTk9N RU07Ci0JCWdvdG8gZXJyMDsKLQl9CisJSU5JVF9MSVNUX0hFQUQoJmJ1ZmZlci0+YXR0YWNobWVu dHMpOworCW11dGV4X2luaXQoJmJ1ZmZlci0+bG9jayk7CisJYnVmZmVyLT5oZWFwID0gaGVhcDsK KwlidWZmZXItPmxlbiA9IGxlbjsKIAotCWZvciAocGcgPSAwOyBwZyA8IGhlbHBlcl9idWZmZXIt PnBhZ2Vjb3VudDsgcGcrKykgeworCXRhYmxlID0gJmJ1ZmZlci0+c2dfdGFibGU7CisJcGFnZWNv dW50ID0gbGVuIC8gUEFHRV9TSVpFOworCWlmIChzZ19hbGxvY190YWJsZSh0YWJsZSwgcGFnZWNv dW50LCBHRlBfS0VSTkVMKSkKKwkJZ290byBmcmVlX2J1ZmZlcjsKKworCXNnID0gdGFibGUtPnNn bDsKKwlmb3IgKHBnID0gMDsgcGcgPCBwYWdlY291bnQ7IHBnKyspIHsKKwkJc3RydWN0IHBhZ2Ug KnBhZ2U7CiAJCS8qCiAJCSAqIEF2b2lkIHRyeWluZyB0byBhbGxvY2F0ZSBtZW1vcnkgaWYgdGhl IHByb2Nlc3MKLQkJICogaGFzIGJlZW4ga2lsbGVkIGJ5IGJ5IFNJR0tJTEwKKwkJICogaGFzIGJl ZW4ga2lsbGVkIGJ5IFNJR0tJTEwKIAkJICovCiAJCWlmIChmYXRhbF9zaWduYWxfcGVuZGluZyhj dXJyZW50KSkKLQkJCWdvdG8gZXJyMTsKLQotCQloZWxwZXJfYnVmZmVyLT5wYWdlc1twZ10gPSBh bGxvY19wYWdlKEdGUF9LRVJORUwgfCBfX0dGUF9aRVJPKTsKLQkJaWYgKCFoZWxwZXJfYnVmZmVy LT5wYWdlc1twZ10pCi0JCQlnb3RvIGVycjE7CisJCQlnb3RvIGZyZWVfcGFnZXM7CisJCXBhZ2Ug PSBhbGxvY19wYWdlKEdGUF9LRVJORUwgfCBfX0dGUF9aRVJPKTsKKwkJaWYgKCFwYWdlKQorCQkJ Z290byBmcmVlX3BhZ2VzOworCQlzZ19zZXRfcGFnZShzZywgcGFnZSwgcGFnZV9zaXplKHBhZ2Up LCAwKTsKKwkJc2cgPSBzZ19uZXh0KHNnKTsKIAl9CiAKIAkvKiBjcmVhdGUgdGhlIGRtYWJ1ZiAq LwotCWRtYWJ1ZiA9IGhlYXBfaGVscGVyX2V4cG9ydF9kbWFidWYoaGVscGVyX2J1ZmZlciwgZmRf ZmxhZ3MpOworCWV4cF9pbmZvLm9wcyA9ICZzeXN0ZW1faGVhcF9idWZfb3BzOworCWV4cF9pbmZv LnNpemUgPSBidWZmZXItPmxlbjsKKwlleHBfaW5mby5mbGFncyA9IGZkX2ZsYWdzOworCWV4cF9p bmZvLnByaXYgPSBidWZmZXI7CisJZG1hYnVmID0gZG1hX2J1Zl9leHBvcnQoJmV4cF9pbmZvKTsK IAlpZiAoSVNfRVJSKGRtYWJ1ZikpIHsKIAkJcmV0ID0gUFRSX0VSUihkbWFidWYpOwotCQlnb3Rv IGVycjE7CisJCWdvdG8gZnJlZV9wYWdlczsKIAl9CiAKLQloZWxwZXJfYnVmZmVyLT5kbWFidWYg PSBkbWFidWY7Ci0KIAlyZXQgPSBkbWFfYnVmX2ZkKGRtYWJ1ZiwgZmRfZmxhZ3MpOwogCWlmIChy ZXQgPCAwKSB7CiAJCWRtYV9idWZfcHV0KGRtYWJ1Zik7CkBAIC05MCwxMiArMzQyLDEyIEBAIHN0 YXRpYyBpbnQgc3lzdGVtX2hlYXBfYWxsb2NhdGUoc3RydWN0IGRtYV9oZWFwICpoZWFwLAogCiAJ cmV0dXJuIHJldDsKIAotZXJyMToKLQl3aGlsZSAocGcgPiAwKQotCQlfX2ZyZWVfcGFnZShoZWxw ZXJfYnVmZmVyLT5wYWdlc1stLXBnXSk7Ci0Ja2ZyZWUoaGVscGVyX2J1ZmZlci0+cGFnZXMpOwot ZXJyMDoKLQlrZnJlZShoZWxwZXJfYnVmZmVyKTsKK2ZyZWVfcGFnZXM6CisJZm9yX2VhY2hfc2d0 YWJsZV9zZyh0YWJsZSwgc2csIGkpCisJCV9fZnJlZV9wYWdlKHNnX3BhZ2Uoc2cpKTsKKwlzZ19m cmVlX3RhYmxlKHRhYmxlKTsKK2ZyZWVfYnVmZmVyOgorCWtmcmVlKGJ1ZmZlcik7CiAKIAlyZXR1 cm4gcmV0OwogfQpAQCAtMTA3LDcgKzM1OSw2IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZG1hX2hl YXBfb3BzIHN5c3RlbV9oZWFwX29wcyA9IHsKIHN0YXRpYyBpbnQgc3lzdGVtX2hlYXBfY3JlYXRl KHZvaWQpCiB7CiAJc3RydWN0IGRtYV9oZWFwX2V4cG9ydF9pbmZvIGV4cF9pbmZvOwotCWludCBy ZXQgPSAwOwogCiAJZXhwX2luZm8ubmFtZSA9ICJzeXN0ZW0iOwogCWV4cF9pbmZvLm9wcyA9ICZz eXN0ZW1faGVhcF9vcHM7CkBAIC0xMTUsOSArMzY2LDkgQEAgc3RhdGljIGludCBzeXN0ZW1faGVh cF9jcmVhdGUodm9pZCkKIAogCXN5c19oZWFwID0gZG1hX2hlYXBfYWRkKCZleHBfaW5mbyk7CiAJ aWYgKElTX0VSUihzeXNfaGVhcCkpCi0JCXJldCA9IFBUUl9FUlIoc3lzX2hlYXApOworCQlyZXR1 cm4gUFRSX0VSUihzeXNfaGVhcCk7CiAKLQlyZXR1cm4gcmV0OworCXJldHVybiAwOwogfQogbW9k dWxlX2luaXQoc3lzdGVtX2hlYXBfY3JlYXRlKTsKIE1PRFVMRV9MSUNFTlNFKCJHUEwgdjIiKTsK LS0gCjIuMTcuMQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f 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=-12.9 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,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 AE792C4741F for ; Sat, 26 Sep 2020 04:25:00 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 5A9BD2080A for ; Sat, 26 Sep 2020 04:25:00 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="qYnAL5+5" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1730003AbgIZEY7 (ORCPT ); Sat, 26 Sep 2020 00:24:59 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42196 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727495AbgIZEY7 (ORCPT ); Sat, 26 Sep 2020 00:24:59 -0400 Received: from mail-pj1-x1042.google.com (mail-pj1-x1042.google.com [IPv6:2607:f8b0:4864:20::1042]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E09CBC0613CE for ; Fri, 25 Sep 2020 21:24:58 -0700 (PDT) Received: by mail-pj1-x1042.google.com with SMTP id kk9so488835pjb.2 for ; Fri, 25 Sep 2020 21:24:58 -0700 (PDT) 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=NEH7dSpxqauBk78qE1pmPtBx4lDfCsXkpGiAZ8uIYoU=; b=qYnAL5+5YevrqN1Msnjai60b/eeSbfx4+aAdG1jq+kWoKGB5iX+IJHR2gapx9udbGB oyJwv7pmiTIzpMSE/mDQoYU9AqpaGzogty93KtTaw++bljZMr3NrVaL90mW4ww5Sd3D0 K01vIfSy/CNgnkUuLHgiKenT1urK4e6V7qwo5IjqEAymLlaqgZ6u7ZFfK0oRiytkTsbI iXSA/LCin6mqBpDfNlr9VY/mKWmschenAgLKR4bcVjgyJmbOAuShUl+B5Unj4uIqHVF1 8anJbl4ObNCpffkq1qEinuche4DSddCl1cPtq3ayZuokY33zv38QrK2d0F1X/BVW20Qf K6zg== 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=NEH7dSpxqauBk78qE1pmPtBx4lDfCsXkpGiAZ8uIYoU=; b=Y6PzdBA47MyMXceXQKaEoJbkW6Zvd/jXTMdCnDZ2DBeCZOtpYeMGweSqXNkpXo8ehs FGcog8yeDZM73AZL26IMT/CTTjkeO/bfyQ7MiTa7m48DWkD2duTj8hsNWGJCMfaUxTKh 9PabznaBCGlxmvyJbcvk3ijIAc0jKjop0rcO5fDU8xBZmcULgdEq8zucBMoyknkw+JT0 Nq6sMxkoaGtdsYBQMVQpQ8wZ9TaTAsOPCjNOCnyNpzlOdyh4KaD1/D7Pu/odQEdU/+RG fwKVJelZe/c72LV/Z5nkxyQ7dsVZq1HLEzAZjikKiKKpTg28f5N7m3c1DjAUPqYUgIjQ Wyaw== X-Gm-Message-State: AOAM531UU8d5ynDoUlTQ8gRIbmiWKHdDKWsOgdm9rKOgES0YtoS13UJ5 wKlkFs9vptKVZWWL0SvFEx53MA== X-Google-Smtp-Source: ABdhPJwetII4Mw9P6pPBXOCqMXrXkdH0dbYKAMabb15GOX4+ef7pGIUAr10E9lRSd+VVywrZzwLRLA== X-Received: by 2002:a17:90a:f407:: with SMTP id ch7mr694079pjb.142.1601094298340; Fri, 25 Sep 2020 21:24:58 -0700 (PDT) Received: from localhost.localdomain ([2601:1c2:680:1319:692:26ff:feda:3a81]) by smtp.gmail.com with ESMTPSA id a5sm3585886pgk.13.2020.09.25.21.24.56 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 25 Sep 2020 21:24:57 -0700 (PDT) From: John Stultz To: lkml Cc: John Stultz , Sumit Semwal , Liam Mark , Laura Abbott , Brian Starkey , Hridya Valsaraju , Suren Baghdasaryan , Sandeep Patil , =?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: [RFC][PATCH 1/6] dma-buf: system_heap: Rework system heap to use sgtables instead of pagelists Date: Sat, 26 Sep 2020 04:24:48 +0000 Message-Id: <20200926042453.67517-2-john.stultz@linaro.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200926042453.67517-1-john.stultz@linaro.org> References: <20200926042453.67517-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 In preparation for some patches to optmize the system heap code, rework the dmabuf exporter to utilize sgtables rather then pageslists for tracking the associated pages. This will allow for large order page allocations, as well as more efficient page pooling. In doing so, the system heap stops using the heap-helpers logic which sadly is not quite as generic as I was hoping it to be, so this patch adds heap specific implementations of the dma_buf_ops function handlers. Cc: Sumit Semwal Cc: Liam Mark Cc: Laura Abbott Cc: Brian Starkey Cc: Hridya Valsaraju Cc: Suren Baghdasaryan Cc: Sandeep Patil 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 --- drivers/dma-buf/heaps/system_heap.c | 343 ++++++++++++++++++++++++---- 1 file changed, 297 insertions(+), 46 deletions(-) diff --git a/drivers/dma-buf/heaps/system_heap.c b/drivers/dma-buf/heaps/system_heap.c index 0bf688e3c023..ddfa17dc48a8 100644 --- a/drivers/dma-buf/heaps/system_heap.c +++ b/drivers/dma-buf/heaps/system_heap.c @@ -3,7 +3,11 @@ * DMABUF System heap exporter * * Copyright (C) 2011 Google, Inc. - * Copyright (C) 2019 Linaro Ltd. + * Copyright (C) 2019, 2020 Linaro Ltd. + * + * Portions based off of Andrew Davis' SRAM heap: + * Copyright (C) 2019 Texas Instruments Incorporated - http://www.ti.com/ + * Andrew F. Davis */ #include @@ -15,72 +19,320 @@ #include #include #include -#include -#include - -#include "heap-helpers.h" +#include struct dma_heap *sys_heap; -static void system_heap_free(struct heap_helper_buffer *buffer) +struct system_heap_buffer { + struct dma_heap *heap; + struct list_head attachments; + struct mutex lock; + unsigned long len; + struct sg_table sg_table; + int vmap_cnt; + void *vaddr; +}; + +struct dma_heap_attachment { + struct device *dev; + struct sg_table *table; + struct list_head list; +}; + +static struct sg_table *dup_sg_table(struct sg_table *table) { - pgoff_t pg; + struct sg_table *new_table; + int ret, i; + struct scatterlist *sg, *new_sg; + + new_table = kzalloc(sizeof(*new_table), GFP_KERNEL); + if (!new_table) + return ERR_PTR(-ENOMEM); + + ret = sg_alloc_table(new_table, table->nents, GFP_KERNEL); + if (ret) { + kfree(new_table); + return ERR_PTR(-ENOMEM); + } + + new_sg = new_table->sgl; + for_each_sgtable_sg(table, sg, i) { + sg_set_page(new_sg, sg_page(sg), sg->length, sg->offset); + new_sg = sg_next(new_sg); + } + + return new_table; +} + +static int system_heap_attach(struct dma_buf *dmabuf, + struct dma_buf_attachment *attachment) +{ + struct system_heap_buffer *buffer = dmabuf->priv; + struct dma_heap_attachment *a; + struct sg_table *table; + + a = kzalloc(sizeof(*a), GFP_KERNEL); + if (!a) + return -ENOMEM; + + table = dup_sg_table(&buffer->sg_table); + if (IS_ERR(table)) { + kfree(a); + return -ENOMEM; + } + + a->table = table; + a->dev = attachment->dev; + INIT_LIST_HEAD(&a->list); + + attachment->priv = a; + + mutex_lock(&buffer->lock); + list_add(&a->list, &buffer->attachments); + mutex_unlock(&buffer->lock); + + return 0; +} + +static void system_heap_detatch(struct dma_buf *dmabuf, + struct dma_buf_attachment *attachment) +{ + struct system_heap_buffer *buffer = dmabuf->priv; + struct dma_heap_attachment *a = attachment->priv; + + mutex_lock(&buffer->lock); + list_del(&a->list); + mutex_unlock(&buffer->lock); + + sg_free_table(a->table); + kfree(a->table); + kfree(a); +} + +static struct sg_table *system_heap_map_dma_buf(struct dma_buf_attachment *attachment, + enum dma_data_direction direction) +{ + struct dma_heap_attachment *a = attachment->priv; + struct sg_table *table = a->table; + + if (!dma_map_sg(attachment->dev, table->sgl, table->nents, direction)) + return ERR_PTR(-ENOMEM); + + return table; +} + +static void system_heap_unmap_dma_buf(struct dma_buf_attachment *attachment, + struct sg_table *table, + enum dma_data_direction direction) +{ + dma_unmap_sg(attachment->dev, table->sgl, table->nents, direction); +} + +static int system_heap_dma_buf_begin_cpu_access(struct dma_buf *dmabuf, + enum dma_data_direction direction) +{ + struct system_heap_buffer *buffer = dmabuf->priv; + struct dma_heap_attachment *a; + int ret = 0; + + mutex_lock(&buffer->lock); + + if (buffer->vmap_cnt) + invalidate_kernel_vmap_range(buffer->vaddr, buffer->len); + + list_for_each_entry(a, &buffer->attachments, list) { + dma_sync_sg_for_cpu(a->dev, a->table->sgl, a->table->nents, + direction); + } + mutex_unlock(&buffer->lock); + + return ret; +} + +static int system_heap_dma_buf_end_cpu_access(struct dma_buf *dmabuf, + enum dma_data_direction direction) +{ + struct system_heap_buffer *buffer = dmabuf->priv; + struct dma_heap_attachment *a; + + mutex_lock(&buffer->lock); + + if (buffer->vmap_cnt) + flush_kernel_vmap_range(buffer->vaddr, buffer->len); + + list_for_each_entry(a, &buffer->attachments, list) { + dma_sync_sg_for_device(a->dev, a->table->sgl, a->table->nents, + direction); + } + mutex_unlock(&buffer->lock); + + return 0; +} + +static int system_heap_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma) +{ + struct system_heap_buffer *buffer = dmabuf->priv; + struct sg_table *table = &buffer->sg_table; + unsigned long addr = vma->vm_start; + struct sg_page_iter piter; + int ret; + + for_each_sgtable_page(table, &piter, vma->vm_pgoff) { + struct page *page = sg_page_iter_page(&piter); + + ret = remap_pfn_range(vma, addr, page_to_pfn(page), PAGE_SIZE, + vma->vm_page_prot); + if (ret) + return ret; + addr += PAGE_SIZE; + if (addr >= vma->vm_end) + return 0; + } + return 0; +} + +static void *system_heap_do_vmap(struct system_heap_buffer *buffer) +{ + struct sg_table *table = &buffer->sg_table; + int npages = PAGE_ALIGN(buffer->len) / PAGE_SIZE; + struct page **pages = vmalloc(sizeof(struct page *) * npages); + struct page **tmp = pages; + struct sg_page_iter piter; + void *vaddr; + + if (!pages) + return ERR_PTR(-ENOMEM); + + for_each_sgtable_page(table, &piter, 0) { + WARN_ON(tmp - pages >= npages); + *tmp++ = sg_page_iter_page(&piter); + } + + vaddr = vmap(pages, npages, VM_MAP, PAGE_KERNEL); + vfree(pages); + + if (!vaddr) + return ERR_PTR(-ENOMEM); + + return vaddr; +} - for (pg = 0; pg < buffer->pagecount; pg++) - __free_page(buffer->pages[pg]); - kfree(buffer->pages); +static void *system_heap_vmap(struct dma_buf *dmabuf) +{ + struct system_heap_buffer *buffer = dmabuf->priv; + void *vaddr; + + mutex_lock(&buffer->lock); + if (buffer->vmap_cnt) { + buffer->vmap_cnt++; + return buffer->vaddr; + } + + vaddr = system_heap_do_vmap(buffer); + if (IS_ERR(vaddr)) + return vaddr; + + buffer->vaddr = vaddr; + buffer->vmap_cnt++; + mutex_unlock(&buffer->lock); + + return vaddr; +} + +static void system_heap_vunmap(struct dma_buf *dmabuf, void *vaddr) +{ + struct system_heap_buffer *buffer = dmabuf->priv; + + mutex_lock(&buffer->lock); + if (!--buffer->vmap_cnt) { + vunmap(buffer->vaddr); + buffer->vaddr = NULL; + } + mutex_unlock(&buffer->lock); +} + +static void system_heap_dma_buf_release(struct dma_buf *dmabuf) +{ + struct system_heap_buffer *buffer = dmabuf->priv; + struct sg_table *table; + struct scatterlist *sg; + int i; + + table = &buffer->sg_table; + for_each_sgtable_sg(table, sg, i) + __free_page(sg_page(sg)); + sg_free_table(table); kfree(buffer); } +const struct dma_buf_ops system_heap_buf_ops = { + .attach = system_heap_attach, + .detach = system_heap_detatch, + .map_dma_buf = system_heap_map_dma_buf, + .unmap_dma_buf = system_heap_unmap_dma_buf, + .begin_cpu_access = system_heap_dma_buf_begin_cpu_access, + .end_cpu_access = system_heap_dma_buf_end_cpu_access, + .mmap = system_heap_mmap, + .vmap = system_heap_vmap, + .vunmap = system_heap_vunmap, + .release = system_heap_dma_buf_release, +}; + static int system_heap_allocate(struct dma_heap *heap, unsigned long len, unsigned long fd_flags, unsigned long heap_flags) { - struct heap_helper_buffer *helper_buffer; + struct system_heap_buffer *buffer; + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); struct dma_buf *dmabuf; - int ret = -ENOMEM; + struct sg_table *table; + struct scatterlist *sg; + pgoff_t pagecount; pgoff_t pg; + int i, ret = -ENOMEM; - helper_buffer = kzalloc(sizeof(*helper_buffer), GFP_KERNEL); - if (!helper_buffer) + buffer = kzalloc(sizeof(*buffer), GFP_KERNEL); + if (!buffer) return -ENOMEM; - init_heap_helper_buffer(helper_buffer, system_heap_free); - helper_buffer->heap = heap; - helper_buffer->size = len; - - helper_buffer->pagecount = len / PAGE_SIZE; - helper_buffer->pages = kmalloc_array(helper_buffer->pagecount, - sizeof(*helper_buffer->pages), - GFP_KERNEL); - if (!helper_buffer->pages) { - ret = -ENOMEM; - goto err0; - } + INIT_LIST_HEAD(&buffer->attachments); + mutex_init(&buffer->lock); + buffer->heap = heap; + buffer->len = len; - for (pg = 0; pg < helper_buffer->pagecount; pg++) { + table = &buffer->sg_table; + pagecount = len / PAGE_SIZE; + if (sg_alloc_table(table, pagecount, GFP_KERNEL)) + goto free_buffer; + + sg = table->sgl; + for (pg = 0; pg < pagecount; pg++) { + struct page *page; /* * Avoid trying to allocate memory if the process - * has been killed by by SIGKILL + * has been killed by SIGKILL */ if (fatal_signal_pending(current)) - goto err1; - - helper_buffer->pages[pg] = alloc_page(GFP_KERNEL | __GFP_ZERO); - if (!helper_buffer->pages[pg]) - goto err1; + goto free_pages; + page = alloc_page(GFP_KERNEL | __GFP_ZERO); + if (!page) + goto free_pages; + sg_set_page(sg, page, page_size(page), 0); + sg = sg_next(sg); } /* create the dmabuf */ - dmabuf = heap_helper_export_dmabuf(helper_buffer, fd_flags); + exp_info.ops = &system_heap_buf_ops; + exp_info.size = buffer->len; + exp_info.flags = fd_flags; + exp_info.priv = buffer; + dmabuf = dma_buf_export(&exp_info); if (IS_ERR(dmabuf)) { ret = PTR_ERR(dmabuf); - goto err1; + goto free_pages; } - helper_buffer->dmabuf = dmabuf; - ret = dma_buf_fd(dmabuf, fd_flags); if (ret < 0) { dma_buf_put(dmabuf); @@ -90,12 +342,12 @@ static int system_heap_allocate(struct dma_heap *heap, return ret; -err1: - while (pg > 0) - __free_page(helper_buffer->pages[--pg]); - kfree(helper_buffer->pages); -err0: - kfree(helper_buffer); +free_pages: + for_each_sgtable_sg(table, sg, i) + __free_page(sg_page(sg)); + sg_free_table(table); +free_buffer: + kfree(buffer); return ret; } @@ -107,7 +359,6 @@ static const struct dma_heap_ops system_heap_ops = { static int system_heap_create(void) { struct dma_heap_export_info exp_info; - int ret = 0; exp_info.name = "system"; exp_info.ops = &system_heap_ops; @@ -115,9 +366,9 @@ static int system_heap_create(void) sys_heap = dma_heap_add(&exp_info); if (IS_ERR(sys_heap)) - ret = PTR_ERR(sys_heap); + return PTR_ERR(sys_heap); - return ret; + return 0; } module_init(system_heap_create); MODULE_LICENSE("GPL v2"); -- 2.17.1