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.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,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 D1699C47098 for ; Thu, 3 Jun 2021 04:59:06 +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 A2747613F0 for ; Thu, 3 Jun 2021 04:59:06 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org A2747613F0 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=intel-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id CB3656F3D0; Thu, 3 Jun 2021 04:58:44 +0000 (UTC) Received: from mga06.intel.com (mga06.intel.com [134.134.136.31]) by gabe.freedesktop.org (Postfix) with ESMTPS id D49936F3A0; Thu, 3 Jun 2021 04:58:42 +0000 (UTC) IronPort-SDR: /T3rbgvxD7ak0aC9ZWz7/dWMl4OKxAna9harWajE5Y/Zd775UYv/1cAgh0ID8XnGMQxLo0UC/S IWHYL36RrXkQ== X-IronPort-AV: E=McAfee;i="6200,9189,10003"; a="265138297" X-IronPort-AV: E=Sophos;i="5.83,244,1616482800"; d="scan'208";a="265138297" Received: from orsmga001.jf.intel.com ([10.7.209.18]) by orsmga104.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 02 Jun 2021 21:58:41 -0700 IronPort-SDR: TG2t9nmQU7Vn/XPy3BPWvwoPr+Bh/2swECxmDTeOOWkxMVmZXNM9+JFS1bx0j9002I/iagLmS2 qDxwkdoinWvQ== X-IronPort-AV: E=Sophos;i="5.83,244,1616482800"; d="scan'208";a="480020040" Received: from dhiatt-server.jf.intel.com ([10.54.81.3]) by orsmga001-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 02 Jun 2021 21:58:41 -0700 From: Matthew Brost To: , Date: Wed, 2 Jun 2021 22:16:28 -0700 Message-Id: <20210603051630.2635-19-matthew.brost@intel.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20210603051630.2635-1-matthew.brost@intel.com> References: <20210603051630.2635-1-matthew.brost@intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH 18/20] drm/i915/guc: Always copy CT message to new allocation X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: daniel.vetter@intel.com Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" RnJvbTogTWljaGFsIFdhamRlY3prbyA8bWljaGFsLndhamRlY3prb0BpbnRlbC5jb20+CgpTaW5j ZSBtb3N0IG9mIGZ1dHVyZSBDVCB0cmFmZmljIHdpbGwgYmUgYmFzZWQgb24gRzJIIHJlcXVlc3Rz LAppbnN0ZWFkIG9mIGNvcHlpbmcgaW5jb21pbmcgQ1QgbWVzc2FnZSB0byBzdGF0aWMgYnVmZmVy IGFuZCB0aGVuCmNyZWF0ZSBuZXcgYWxsb2NhdGlvbiBmb3Igc3VjaCByZXF1ZXN0LCBhbHdheXMg Y29weSBpbmNvbWluZyBDVAptZXNzYWdlIHRvIG5ldyBhbGxvY2F0aW9uLiBBbHNvIGJ5IGRvaW5n IGl0IHdoaWxlIHJlYWRpbmcgQ1QKaGVhZGVyLCB3ZSBjYW4gc2FmZWx5IGZhbGxiYWNrIGlmIHRo YXQgYXRvbWljIGFsbG9jYXRpb24gZmFpbHMuCgpTaWduZWQtb2ZmLWJ5OiBNaWNoYWwgV2FqZGVj emtvIDxtaWNoYWwud2FqZGVjemtvQGludGVsLmNvbT4KU2lnbmVkLW9mZi1ieTogTWF0dGhldyBC cm9zdCA8bWF0dGhldy5icm9zdEBpbnRlbC5jb20+ClJldmlld2VkLWJ5OiBNYXR0aGV3IEJyb3N0 IDxtYXR0aGV3LmJyb3N0QGludGVsLmNvbT4KQ2M6IFBpb3RyIFBpw7Nya293c2tpIDxwaW90ci5w aW9ya293c2tpQGludGVsLmNvbT4KLS0tCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRl bF9ndWNfY3QuYyB8IDE4MCArKysrKysrKysrKysrKy0tLS0tLS0tCiAxIGZpbGUgY2hhbmdlZCwg MTIwIGluc2VydGlvbnMoKyksIDYwIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19jdC5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv Z3QvdWMvaW50ZWxfZ3VjX2N0LmMKaW5kZXggNGZhYzllNGJjZWQ0Li44ODY5ZjllYmI0YzggMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19jdC5jCisrKyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19jdC5jCkBAIC03Miw4ICs3Miw5 IEBAIHN0cnVjdCBjdF9yZXF1ZXN0IHsKIAl1MzIgKnJlc3BvbnNlX2J1ZjsKIH07CiAKLXN0cnVj dCBjdF9pbmNvbWluZ19yZXF1ZXN0IHsKK3N0cnVjdCBjdF9pbmNvbWluZ19tc2cgewogCXN0cnVj dCBsaXN0X2hlYWQgbGluazsKKwl1MzIgc2l6ZTsKIAl1MzIgbXNnW107CiB9OwogCkBAIC02MDAs NyArNjAxLDI2IEBAIHN0YXRpYyBpbmxpbmUgYm9vbCBjdF9oZWFkZXJfaXNfcmVzcG9uc2UodTMy IGhlYWRlcikKIAlyZXR1cm4gISEoaGVhZGVyICYgR1VDX0NUX01TR19JU19SRVNQT05TRSk7CiB9 CiAKLXN0YXRpYyBpbnQgY3RfcmVhZChzdHJ1Y3QgaW50ZWxfZ3VjX2N0ICpjdCwgdTMyICpkYXRh KQorc3RhdGljIHN0cnVjdCBjdF9pbmNvbWluZ19tc2cgKmN0X2FsbG9jX21zZyh1MzIgbnVtX2R3 b3JkcykKK3sKKwlzdHJ1Y3QgY3RfaW5jb21pbmdfbXNnICptc2c7CisKKwltc2cgPSBrbWFsbG9j KHNpemVvZigqbXNnKSArIHNpemVvZih1MzIpICogbnVtX2R3b3JkcywgR0ZQX0FUT01JQyk7CisJ aWYgKG1zZykKKwkJbXNnLT5zaXplID0gbnVtX2R3b3JkczsKKwlyZXR1cm4gbXNnOworfQorCitz dGF0aWMgdm9pZCBjdF9mcmVlX21zZyhzdHJ1Y3QgY3RfaW5jb21pbmdfbXNnICptc2cpCit7CisJ a2ZyZWUobXNnKTsKK30KKworLyoKKyAqIFJldHVybjogbnVtYmVyIGF2YWlsYWJsZSByZW1haW5p bmcgZHdvcmRzIHRvIHJlYWQgKDAgaWYgZW1wdHkpCisgKiAgICAgICAgIG9yIGEgbmVnYXRpdmUg ZXJyb3IgY29kZSBvbiBmYWlsdXJlCisgKi8KK3N0YXRpYyBpbnQgY3RfcmVhZChzdHJ1Y3QgaW50 ZWxfZ3VjX2N0ICpjdCwgc3RydWN0IGN0X2luY29taW5nX21zZyAqKm1zZykKIHsKIAlzdHJ1Y3Qg aW50ZWxfZ3VjX2N0X2J1ZmZlciAqY3RiID0gJmN0LT5jdGJzLnJlY3Y7CiAJc3RydWN0IGd1Y19j dF9idWZmZXJfZGVzYyAqZGVzYyA9IGN0Yi0+ZGVzYzsKQEAgLTYxMSw2ICs2MzEsNyBAQCBzdGF0 aWMgaW50IGN0X3JlYWQoc3RydWN0IGludGVsX2d1Y19jdCAqY3QsIHUzMiAqZGF0YSkKIAlzMzIg YXZhaWxhYmxlOwogCXVuc2lnbmVkIGludCBsZW47CiAJdW5zaWduZWQgaW50IGk7CisJdTMyIGhl YWRlcjsKIAogCWlmICh1bmxpa2VseShkZXNjLT5pc19pbl9lcnJvcikpCiAJCXJldHVybiAtRVBJ UEU7CkBAIC02MjYsOCArNjQ3LDEwIEBAIHN0YXRpYyBpbnQgY3RfcmVhZChzdHJ1Y3QgaW50ZWxf Z3VjX2N0ICpjdCwgdTMyICpkYXRhKQogCiAJLyogdGFpbCA9PSBoZWFkIGNvbmRpdGlvbiBpbmRp Y2F0ZXMgZW1wdHkgKi8KIAlhdmFpbGFibGUgPSB0YWlsIC0gaGVhZDsKLQlpZiAodW5saWtlbHko YXZhaWxhYmxlID09IDApKQotCQlyZXR1cm4gLUVOT0RBVEE7CisJaWYgKHVubGlrZWx5KGF2YWls YWJsZSA9PSAwKSkgeworCQkqbXNnID0gTlVMTDsKKwkJcmV0dXJuIDA7CisJfQogCiAJLyogYmV3 YXJlIG9mIGJ1ZmZlciB3cmFwIGNhc2UgKi8KIAlpZiAodW5saWtlbHkoYXZhaWxhYmxlIDwgMCkp CkBAIC02MzUsMTQgKzY1OCwxNCBAQCBzdGF0aWMgaW50IGN0X3JlYWQoc3RydWN0IGludGVsX2d1 Y19jdCAqY3QsIHUzMiAqZGF0YSkKIAlDVF9ERUJVRyhjdCwgImF2YWlsYWJsZSAlZCAoJXU6JXUp XG4iLCBhdmFpbGFibGUsIGhlYWQsIHRhaWwpOwogCUdFTV9CVUdfT04oYXZhaWxhYmxlIDwgMCk7 CiAKLQlkYXRhWzBdID0gY21kc1toZWFkXTsKKwloZWFkZXIgPSBjbWRzW2hlYWRdOwogCWhlYWQg PSAoaGVhZCArIDEpICUgc2l6ZTsKIAogCS8qIG1lc3NhZ2UgbGVuIHdpdGggaGVhZGVyICovCi0J bGVuID0gY3RfaGVhZGVyX2dldF9sZW4oZGF0YVswXSkgKyAxOworCWxlbiA9IGN0X2hlYWRlcl9n ZXRfbGVuKGhlYWRlcikgKyAxOwogCWlmICh1bmxpa2VseShsZW4gPiAodTMyKWF2YWlsYWJsZSkp IHsKIAkJQ1RfRVJST1IoY3QsICJJbmNvbXBsZXRlIG1lc3NhZ2UgJSpwaCAlKnBoICUqcGhcbiIs Ci0JCQkgNCwgZGF0YSwKKwkJCSA0LCAmaGVhZGVyLAogCQkJIDQgKiAoaGVhZCArIGF2YWlsYWJs ZSAtIDEgPiBzaXplID8KIAkJCSAgICAgIHNpemUgLSBoZWFkIDogYXZhaWxhYmxlIC0gMSksICZj bWRzW2hlYWRdLAogCQkJIDQgKiAoaGVhZCArIGF2YWlsYWJsZSAtIDEgPiBzaXplID8KQEAgLTY1 MCwxMSArNjczLDI0IEBAIHN0YXRpYyBpbnQgY3RfcmVhZChzdHJ1Y3QgaW50ZWxfZ3VjX2N0ICpj dCwgdTMyICpkYXRhKQogCQlnb3RvIGNvcnJ1cHRlZDsKIAl9CiAKKwkqbXNnID0gY3RfYWxsb2Nf bXNnKGxlbik7CisJaWYgKCEqbXNnKSB7CisJCUNUX0VSUk9SKGN0LCAiTm8gbWVtb3J5IGZvciBt ZXNzYWdlICUqcGggJSpwaCAlKnBoXG4iLAorCQkJIDQsICZoZWFkZXIsCisJCQkgNCAqIChoZWFk ICsgYXZhaWxhYmxlIC0gMSA+IHNpemUgPworCQkJICAgICAgc2l6ZSAtIGhlYWQgOiBhdmFpbGFi bGUgLSAxKSwgJmNtZHNbaGVhZF0sCisJCQkgNCAqIChoZWFkICsgYXZhaWxhYmxlIC0gMSA+IHNp emUgPworCQkJICAgICAgYXZhaWxhYmxlIC0gMSAtIHNpemUgKyBoZWFkIDogMCksICZjbWRzWzBd KTsKKwkJcmV0dXJuIGF2YWlsYWJsZTsKKwl9CisKKwkoKm1zZyktPm1zZ1swXSA9IGhlYWRlcjsK KwogCWZvciAoaSA9IDE7IGkgPCBsZW47IGkrKykgewotCQlkYXRhW2ldID0gY21kc1toZWFkXTsK KwkJKCptc2cpLT5tc2dbaV0gPSBjbWRzW2hlYWRdOwogCQloZWFkID0gKGhlYWQgKyAxKSAlIHNp emU7CiAJfQotCUNUX0RFQlVHKGN0LCAicmVjZWl2ZWQgJSpwaFxuIiwgNCAqIGxlbiwgZGF0YSk7 CisJQ1RfREVCVUcoY3QsICJyZWNlaXZlZCAlKnBoXG4iLCA0ICogbGVuLCAoKm1zZyktPm1zZyk7 CiAKIAlkZXNjLT5oZWFkID0gaGVhZCAqIDQ7CiAJcmV0dXJuIGF2YWlsYWJsZSAtIGxlbjsKQEAg LTY4NCwzMyArNzIwLDMzIEBAIHN0YXRpYyBpbnQgY3RfcmVhZChzdHJ1Y3QgaW50ZWxfZ3VjX2N0 ICpjdCwgdTMyICpkYXRhKQogICogICAgICAgICAgICAgICAgICAgXi0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tbGVuLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS1eCiAgKi8KIAotc3RhdGljIGludCBjdF9o YW5kbGVfcmVzcG9uc2Uoc3RydWN0IGludGVsX2d1Y19jdCAqY3QsIGNvbnN0IHUzMiAqbXNnKQor c3RhdGljIGludCBjdF9oYW5kbGVfcmVzcG9uc2Uoc3RydWN0IGludGVsX2d1Y19jdCAqY3QsIHN0 cnVjdCBjdF9pbmNvbWluZ19tc2cgKnJlc3BvbnNlKQogewotCXUzMiBoZWFkZXIgPSBtc2dbMF07 CisJdTMyIGhlYWRlciA9IHJlc3BvbnNlLT5tc2dbMF07CiAJdTMyIGxlbiA9IGN0X2hlYWRlcl9n ZXRfbGVuKGhlYWRlcik7Ci0JdTMyIG1zZ3NpemUgPSAobGVuICsgMSkgKiBzaXplb2YodTMyKTsg LyogbXNnIHNpemUgaW4gYnl0ZXMgdy9oZWFkZXIgKi8KIAl1MzIgZmVuY2U7CiAJdTMyIHN0YXR1 czsKIAl1MzIgZGF0YWxlbjsKIAlzdHJ1Y3QgY3RfcmVxdWVzdCAqcmVxOwogCXVuc2lnbmVkIGxv bmcgZmxhZ3M7CiAJYm9vbCBmb3VuZCA9IGZhbHNlOworCWludCBlcnIgPSAwOwogCiAJR0VNX0JV R19PTighY3RfaGVhZGVyX2lzX3Jlc3BvbnNlKGhlYWRlcikpOwogCiAJLyogUmVzcG9uc2UgcGF5 bG9hZCBzaGFsbCBhdCBsZWFzdCBpbmNsdWRlIGZlbmNlIGFuZCBzdGF0dXMgKi8KIAlpZiAodW5s aWtlbHkobGVuIDwgMikpIHsKLQkJQ1RfRVJST1IoY3QsICJDb3JydXB0ZWQgcmVzcG9uc2UgJSpw aFxuIiwgbXNnc2l6ZSwgbXNnKTsKKwkJQ1RfRVJST1IoY3QsICJDb3JydXB0ZWQgcmVzcG9uc2Ug KGxlbiAldSlcbiIsIGxlbik7CiAJCXJldHVybiAtRVBST1RPOwogCX0KIAotCWZlbmNlID0gbXNn WzFdOwotCXN0YXR1cyA9IG1zZ1syXTsKKwlmZW5jZSA9IHJlc3BvbnNlLT5tc2dbMV07CisJc3Rh dHVzID0gcmVzcG9uc2UtPm1zZ1syXTsKIAlkYXRhbGVuID0gbGVuIC0gMjsKIAogCS8qIEZvcm1h dCBvZiB0aGUgc3RhdHVzIGZvbGxvd3MgUkVTUE9OU0UgbWVzc2FnZSAqLwogCWlmICh1bmxpa2Vs eSghSU5URUxfR1VDX01TR19JU19SRVNQT05TRShzdGF0dXMpKSkgewotCQlDVF9FUlJPUihjdCwg IkNvcnJ1cHRlZCByZXNwb25zZSAlKnBoXG4iLCBtc2dzaXplLCBtc2cpOworCQlDVF9FUlJPUihj dCwgIkNvcnJ1cHRlZCByZXNwb25zZSAoc3RhdHVzICUjeClcbiIsIHN0YXR1cyk7CiAJCXJldHVy biAtRVBST1RPOwogCX0KIApAQCAtNzI0LDEyICs3NjAsMTMgQEAgc3RhdGljIGludCBjdF9oYW5k bGVfcmVzcG9uc2Uoc3RydWN0IGludGVsX2d1Y19jdCAqY3QsIGNvbnN0IHUzMiAqbXNnKQogCQkJ Y29udGludWU7CiAJCX0KIAkJaWYgKHVubGlrZWx5KGRhdGFsZW4gPiByZXEtPnJlc3BvbnNlX2xl bikpIHsKLQkJCUNUX0VSUk9SKGN0LCAiUmVzcG9uc2UgZm9yICV1IGlzIHRvbyBsb25nICUqcGhc biIsCi0JCQkJIHJlcS0+ZmVuY2UsIG1zZ3NpemUsIG1zZyk7Ci0JCQlkYXRhbGVuID0gMDsKKwkJ CUNUX0VSUk9SKGN0LCAiUmVzcG9uc2UgJXUgdG9vIGxvbmcgKGRhdGFsZW4gJXUgPiAldSlcbiIs CisJCQkJIHJlcS0+ZmVuY2UsIGRhdGFsZW4sIHJlcS0+cmVzcG9uc2VfbGVuKTsKKwkJCWRhdGFs ZW4gPSBtaW4oZGF0YWxlbiwgcmVxLT5yZXNwb25zZV9sZW4pOworCQkJZXJyID0gLUVNU0dTSVpF OwogCQl9CiAJCWlmIChkYXRhbGVuKQotCQkJbWVtY3B5KHJlcS0+cmVzcG9uc2VfYnVmLCBtc2cg KyAzLCA0ICogZGF0YWxlbik7CisJCQltZW1jcHkocmVxLT5yZXNwb25zZV9idWYsIHJlc3BvbnNl LT5tc2cgKyAzLCA0ICogZGF0YWxlbik7CiAJCXJlcS0+cmVzcG9uc2VfbGVuID0gZGF0YWxlbjsK IAkJV1JJVEVfT05DRShyZXEtPnN0YXR1cywgc3RhdHVzKTsKIAkJZm91bmQgPSB0cnVlOwpAQCAt NzM3LDQ1ICs3NzQsNjEgQEAgc3RhdGljIGludCBjdF9oYW5kbGVfcmVzcG9uc2Uoc3RydWN0IGlu dGVsX2d1Y19jdCAqY3QsIGNvbnN0IHUzMiAqbXNnKQogCX0KIAlzcGluX3VubG9ja19pcnFyZXN0 b3JlKCZjdC0+cmVxdWVzdHMubG9jaywgZmxhZ3MpOwogCi0JaWYgKCFmb3VuZCkKLQkJQ1RfRVJS T1IoY3QsICJVbnNvbGljaXRlZCByZXNwb25zZSAlKnBoXG4iLCBtc2dzaXplLCBtc2cpOworCWlm ICghZm91bmQpIHsKKwkJQ1RfRVJST1IoY3QsICJVbnNvbGljaXRlZCByZXNwb25zZSAoZmVuY2Ug JXUpXG4iLCBmZW5jZSk7CisJCXJldHVybiAtRU5PS0VZOworCX0KKworCWlmICh1bmxpa2VseShl cnIpKQorCQlyZXR1cm4gZXJyOworCisJY3RfZnJlZV9tc2cocmVzcG9uc2UpOwogCXJldHVybiAw OwogfQogCi1zdGF0aWMgdm9pZCBjdF9wcm9jZXNzX3JlcXVlc3Qoc3RydWN0IGludGVsX2d1Y19j dCAqY3QsCi0JCQkgICAgICAgdTMyIGFjdGlvbiwgdTMyIGxlbiwgY29uc3QgdTMyICpwYXlsb2Fk KQorc3RhdGljIGludCBjdF9wcm9jZXNzX3JlcXVlc3Qoc3RydWN0IGludGVsX2d1Y19jdCAqY3Qs IHN0cnVjdCBjdF9pbmNvbWluZ19tc2cgKnJlcXVlc3QpCiB7CiAJc3RydWN0IGludGVsX2d1YyAq Z3VjID0gY3RfdG9fZ3VjKGN0KTsKKwl1MzIgaGVhZGVyLCBhY3Rpb24sIGxlbjsKKwljb25zdCB1 MzIgKnBheWxvYWQ7CiAJaW50IHJldDsKIAorCWhlYWRlciA9IHJlcXVlc3QtPm1zZ1swXTsKKwlw YXlsb2FkID0gJnJlcXVlc3QtPm1zZ1sxXTsKKwlhY3Rpb24gPSBjdF9oZWFkZXJfZ2V0X2FjdGlv bihoZWFkZXIpOworCWxlbiA9IGN0X2hlYWRlcl9nZXRfbGVuKGhlYWRlcik7CisKIAlDVF9ERUJV RyhjdCwgInJlcXVlc3QgJXggJSpwaFxuIiwgYWN0aW9uLCA0ICogbGVuLCBwYXlsb2FkKTsKIAog CXN3aXRjaCAoYWN0aW9uKSB7CiAJY2FzZSBJTlRFTF9HVUNfQUNUSU9OX0RFRkFVTFQ6CiAJCXJl dCA9IGludGVsX2d1Y190b19ob3N0X3Byb2Nlc3NfcmVjdl9tc2coZ3VjLCBwYXlsb2FkLCBsZW4p OwotCQlpZiAodW5saWtlbHkocmV0KSkKLQkJCWdvdG8gZmFpbF91bmV4cGVjdGVkOwogCQlicmVh azsKLQogCWRlZmF1bHQ6Ci1mYWlsX3VuZXhwZWN0ZWQ6Ci0JCUNUX0VSUk9SKGN0LCAiVW5leHBl Y3RlZCByZXF1ZXN0ICV4ICUqcGhcbiIsCi0JCQkgYWN0aW9uLCA0ICogbGVuLCBwYXlsb2FkKTsK KwkJcmV0ID0gLUVPUE5PVFNVUFA7CiAJCWJyZWFrOwogCX0KKworCWlmICh1bmxpa2VseShyZXQp KSB7CisJCUNUX0VSUk9SKGN0LCAiRmFpbGVkIHRvIHByb2Nlc3MgcmVxdWVzdCAlMDR4ICglcGUp XG4iLAorCQkJIGFjdGlvbiwgRVJSX1BUUihyZXQpKTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlj dF9mcmVlX21zZyhyZXF1ZXN0KTsKKwlyZXR1cm4gMDsKIH0KIAogc3RhdGljIGJvb2wgY3RfcHJv Y2Vzc19pbmNvbWluZ19yZXF1ZXN0cyhzdHJ1Y3QgaW50ZWxfZ3VjX2N0ICpjdCkKIHsKIAl1bnNp Z25lZCBsb25nIGZsYWdzOwotCXN0cnVjdCBjdF9pbmNvbWluZ19yZXF1ZXN0ICpyZXF1ZXN0Owot CXUzMiBoZWFkZXI7Ci0JdTMyICpwYXlsb2FkOworCXN0cnVjdCBjdF9pbmNvbWluZ19tc2cgKnJl cXVlc3Q7CiAJYm9vbCBkb25lOworCWludCBlcnI7CiAKIAlzcGluX2xvY2tfaXJxc2F2ZSgmY3Qt PnJlcXVlc3RzLmxvY2ssIGZsYWdzKTsKIAlyZXF1ZXN0ID0gbGlzdF9maXJzdF9lbnRyeV9vcl9u dWxsKCZjdC0+cmVxdWVzdHMuaW5jb21pbmcsCi0JCQkJCSAgIHN0cnVjdCBjdF9pbmNvbWluZ19y ZXF1ZXN0LCBsaW5rKTsKKwkJCQkJICAgc3RydWN0IGN0X2luY29taW5nX21zZywgbGluayk7CiAJ aWYgKHJlcXVlc3QpCiAJCWxpc3RfZGVsKCZyZXF1ZXN0LT5saW5rKTsKIAlkb25lID0gISFsaXN0 X2VtcHR5KCZjdC0+cmVxdWVzdHMuaW5jb21pbmcpOwpAQCAtNzg0LDE0ICs4MzcsMTMgQEAgc3Rh dGljIGJvb2wgY3RfcHJvY2Vzc19pbmNvbWluZ19yZXF1ZXN0cyhzdHJ1Y3QgaW50ZWxfZ3VjX2N0 ICpjdCkKIAlpZiAoIXJlcXVlc3QpCiAJCXJldHVybiB0cnVlOwogCi0JaGVhZGVyID0gcmVxdWVz dC0+bXNnWzBdOwotCXBheWxvYWQgPSAmcmVxdWVzdC0+bXNnWzFdOwotCWN0X3Byb2Nlc3NfcmVx dWVzdChjdCwKLQkJCSAgIGN0X2hlYWRlcl9nZXRfYWN0aW9uKGhlYWRlciksCi0JCQkgICBjdF9o ZWFkZXJfZ2V0X2xlbihoZWFkZXIpLAotCQkJICAgcGF5bG9hZCk7CisJZXJyID0gY3RfcHJvY2Vz c19yZXF1ZXN0KGN0LCByZXF1ZXN0KTsKKwlpZiAodW5saWtlbHkoZXJyKSkgeworCQlDVF9FUlJP UihjdCwgIkZhaWxlZCB0byBwcm9jZXNzIENUIG1lc3NhZ2UgKCVwZSkgJSpwaFxuIiwKKwkJCSBF UlJfUFRSKGVyciksIDQgKiByZXF1ZXN0LT5zaXplLCByZXF1ZXN0LT5tc2cpOworCQljdF9mcmVl X21zZyhyZXF1ZXN0KTsKKwl9CiAKLQlrZnJlZShyZXF1ZXN0KTsKIAlyZXR1cm4gZG9uZTsKIH0K IApAQCAtODI0LDIyICs4NzYsMTEgQEAgc3RhdGljIHZvaWQgY3RfaW5jb21pbmdfcmVxdWVzdF93 b3JrZXJfZnVuYyhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKncpCiAgKiAgICAgICAgICAgICAgICAgICBe LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS1sZW4tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLV4KICAqLwog Ci1zdGF0aWMgaW50IGN0X2hhbmRsZV9yZXF1ZXN0KHN0cnVjdCBpbnRlbF9ndWNfY3QgKmN0LCBj b25zdCB1MzIgKm1zZykKK3N0YXRpYyBpbnQgY3RfaGFuZGxlX3JlcXVlc3Qoc3RydWN0IGludGVs X2d1Y19jdCAqY3QsIHN0cnVjdCBjdF9pbmNvbWluZ19tc2cgKnJlcXVlc3QpCiB7Ci0JdTMyIGhl YWRlciA9IG1zZ1swXTsKLQl1MzIgbGVuID0gY3RfaGVhZGVyX2dldF9sZW4oaGVhZGVyKTsKLQl1 MzIgbXNnc2l6ZSA9IChsZW4gKyAxKSAqIHNpemVvZih1MzIpOyAvKiBtc2cgc2l6ZSBpbiBieXRl cyB3L2hlYWRlciAqLwotCXN0cnVjdCBjdF9pbmNvbWluZ19yZXF1ZXN0ICpyZXF1ZXN0OwogCXVu c2lnbmVkIGxvbmcgZmxhZ3M7CiAKLQlHRU1fQlVHX09OKGN0X2hlYWRlcl9pc19yZXNwb25zZSho ZWFkZXIpKTsKLQotCXJlcXVlc3QgPSBrbWFsbG9jKHNpemVvZigqcmVxdWVzdCkgKyBtc2dzaXpl LCBHRlBfQVRPTUlDKTsKLQlpZiAodW5saWtlbHkoIXJlcXVlc3QpKSB7Ci0JCUNUX0VSUk9SKGN0 LCAiRHJvcHBpbmcgcmVxdWVzdCAlKnBoXG4iLCBtc2dzaXplLCBtc2cpOwotCQlyZXR1cm4gMDsg LyogWFhYOiAtRU5PTUVNID8gKi8KLQl9Ci0JbWVtY3B5KHJlcXVlc3QtPm1zZywgbXNnLCBtc2dz aXplKTsKKwlHRU1fQlVHX09OKGN0X2hlYWRlcl9pc19yZXNwb25zZShyZXF1ZXN0LT5tc2dbMF0p KTsKIAogCXNwaW5fbG9ja19pcnFzYXZlKCZjdC0+cmVxdWVzdHMubG9jaywgZmxhZ3MpOwogCWxp c3RfYWRkX3RhaWwoJnJlcXVlc3QtPmxpbmssICZjdC0+cmVxdWVzdHMuaW5jb21pbmcpOwpAQCAt ODQ5LDIyICs4OTAsNDEgQEAgc3RhdGljIGludCBjdF9oYW5kbGVfcmVxdWVzdChzdHJ1Y3QgaW50 ZWxfZ3VjX2N0ICpjdCwgY29uc3QgdTMyICptc2cpCiAJcmV0dXJuIDA7CiB9CiAKK3N0YXRpYyB2 b2lkIGN0X2hhbmRsZV9tc2coc3RydWN0IGludGVsX2d1Y19jdCAqY3QsIHN0cnVjdCBjdF9pbmNv bWluZ19tc2cgKm1zZykKK3sKKwl1MzIgaGVhZGVyID0gbXNnLT5tc2dbMF07CisJaW50IGVycjsK KworCWlmIChjdF9oZWFkZXJfaXNfcmVzcG9uc2UoaGVhZGVyKSkKKwkJZXJyID0gY3RfaGFuZGxl X3Jlc3BvbnNlKGN0LCBtc2cpOworCWVsc2UKKwkJZXJyID0gY3RfaGFuZGxlX3JlcXVlc3QoY3Qs IG1zZyk7CisKKwlpZiAodW5saWtlbHkoZXJyKSkgeworCQlDVF9FUlJPUihjdCwgIkZhaWxlZCB0 byBwcm9jZXNzIENUIG1lc3NhZ2UgKCVwZSkgJSpwaFxuIiwKKwkJCSBFUlJfUFRSKGVyciksIDQg KiBtc2ctPnNpemUsIG1zZy0+bXNnKTsKKwkJY3RfZnJlZV9tc2cobXNnKTsKKwl9Cit9CisKKy8q CisgKiBSZXR1cm46IG51bWJlciBhdmFpbGFibGUgcmVtYWluaW5nIGR3b3JkcyB0byByZWFkICgw IGlmIGVtcHR5KQorICogICAgICAgICBvciBhIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24gZmFpbHVy ZQorICovCiBzdGF0aWMgaW50IGN0X3JlY2VpdmUoc3RydWN0IGludGVsX2d1Y19jdCAqY3QpCiB7 Ci0JdTMyIG1zZ1tHVUNfQ1RfTVNHX0xFTl9NQVNLICsgMV07IC8qIG9uZSBleHRyYSBkdyBmb3Ig dGhlIGhlYWRlciAqLworCXN0cnVjdCBjdF9pbmNvbWluZ19tc2cgKm1zZyA9IE5VTEw7CiAJdW5z aWduZWQgbG9uZyBmbGFnczsKIAlpbnQgcmV0OwogCiAJc3Bpbl9sb2NrX2lycXNhdmUoJmN0LT5j dGJzLnJlY3YubG9jaywgZmxhZ3MpOwotCXJldCA9IGN0X3JlYWQoY3QsIG1zZyk7CisJcmV0ID0g Y3RfcmVhZChjdCwgJm1zZyk7CiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY3QtPmN0YnMucmVj di5sb2NrLCBmbGFncyk7CiAJaWYgKHJldCA8IDApCiAJCXJldHVybiByZXQ7CiAKLQlpZiAoY3Rf aGVhZGVyX2lzX3Jlc3BvbnNlKG1zZ1swXSkpCi0JCWN0X2hhbmRsZV9yZXNwb25zZShjdCwgbXNn KTsKLQllbHNlCi0JCWN0X2hhbmRsZV9yZXF1ZXN0KGN0LCBtc2cpOworCWlmIChtc2cpCisJCWN0 X2hhbmRsZV9tc2coY3QsIG1zZyk7CiAKIAlyZXR1cm4gcmV0OwogfQotLSAKMi4yOC4wCgpfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFp bGluZyBsaXN0CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5m cmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK 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.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,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 12337C47082 for ; Thu, 3 Jun 2021 04:59:21 +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 D5B61613F0 for ; Thu, 3 Jun 2021 04:59:20 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D5B61613F0 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com 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 DFDF26F3C9; Thu, 3 Jun 2021 04:58:50 +0000 (UTC) Received: from mga06.intel.com (mga06.intel.com [134.134.136.31]) by gabe.freedesktop.org (Postfix) with ESMTPS id D49936F3A0; Thu, 3 Jun 2021 04:58:42 +0000 (UTC) IronPort-SDR: /T3rbgvxD7ak0aC9ZWz7/dWMl4OKxAna9harWajE5Y/Zd775UYv/1cAgh0ID8XnGMQxLo0UC/S IWHYL36RrXkQ== X-IronPort-AV: E=McAfee;i="6200,9189,10003"; a="265138297" X-IronPort-AV: E=Sophos;i="5.83,244,1616482800"; d="scan'208";a="265138297" Received: from orsmga001.jf.intel.com ([10.7.209.18]) by orsmga104.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 02 Jun 2021 21:58:41 -0700 IronPort-SDR: TG2t9nmQU7Vn/XPy3BPWvwoPr+Bh/2swECxmDTeOOWkxMVmZXNM9+JFS1bx0j9002I/iagLmS2 qDxwkdoinWvQ== X-IronPort-AV: E=Sophos;i="5.83,244,1616482800"; d="scan'208";a="480020040" Received: from dhiatt-server.jf.intel.com ([10.54.81.3]) by orsmga001-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 02 Jun 2021 21:58:41 -0700 From: Matthew Brost To: , Subject: [PATCH 18/20] drm/i915/guc: Always copy CT message to new allocation Date: Wed, 2 Jun 2021 22:16:28 -0700 Message-Id: <20210603051630.2635-19-matthew.brost@intel.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20210603051630.2635-1-matthew.brost@intel.com> References: <20210603051630.2635-1-matthew.brost@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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: daniel.vetter@intel.com Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" From: Michal Wajdeczko Since most of future CT traffic will be based on G2H requests, instead of copying incoming CT message to static buffer and then create new allocation for such request, always copy incoming CT message to new allocation. Also by doing it while reading CT header, we can safely fallback if that atomic allocation fails. Signed-off-by: Michal Wajdeczko Signed-off-by: Matthew Brost Reviewed-by: Matthew Brost Cc: Piotr Piórkowski --- drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c | 180 ++++++++++++++-------- 1 file changed, 120 insertions(+), 60 deletions(-) diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c b/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c index 4fac9e4bced4..8869f9ebb4c8 100644 --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c @@ -72,8 +72,9 @@ struct ct_request { u32 *response_buf; }; -struct ct_incoming_request { +struct ct_incoming_msg { struct list_head link; + u32 size; u32 msg[]; }; @@ -600,7 +601,26 @@ static inline bool ct_header_is_response(u32 header) return !!(header & GUC_CT_MSG_IS_RESPONSE); } -static int ct_read(struct intel_guc_ct *ct, u32 *data) +static struct ct_incoming_msg *ct_alloc_msg(u32 num_dwords) +{ + struct ct_incoming_msg *msg; + + msg = kmalloc(sizeof(*msg) + sizeof(u32) * num_dwords, GFP_ATOMIC); + if (msg) + msg->size = num_dwords; + return msg; +} + +static void ct_free_msg(struct ct_incoming_msg *msg) +{ + kfree(msg); +} + +/* + * Return: number available remaining dwords to read (0 if empty) + * or a negative error code on failure + */ +static int ct_read(struct intel_guc_ct *ct, struct ct_incoming_msg **msg) { struct intel_guc_ct_buffer *ctb = &ct->ctbs.recv; struct guc_ct_buffer_desc *desc = ctb->desc; @@ -611,6 +631,7 @@ static int ct_read(struct intel_guc_ct *ct, u32 *data) s32 available; unsigned int len; unsigned int i; + u32 header; if (unlikely(desc->is_in_error)) return -EPIPE; @@ -626,8 +647,10 @@ static int ct_read(struct intel_guc_ct *ct, u32 *data) /* tail == head condition indicates empty */ available = tail - head; - if (unlikely(available == 0)) - return -ENODATA; + if (unlikely(available == 0)) { + *msg = NULL; + return 0; + } /* beware of buffer wrap case */ if (unlikely(available < 0)) @@ -635,14 +658,14 @@ static int ct_read(struct intel_guc_ct *ct, u32 *data) CT_DEBUG(ct, "available %d (%u:%u)\n", available, head, tail); GEM_BUG_ON(available < 0); - data[0] = cmds[head]; + header = cmds[head]; head = (head + 1) % size; /* message len with header */ - len = ct_header_get_len(data[0]) + 1; + len = ct_header_get_len(header) + 1; if (unlikely(len > (u32)available)) { CT_ERROR(ct, "Incomplete message %*ph %*ph %*ph\n", - 4, data, + 4, &header, 4 * (head + available - 1 > size ? size - head : available - 1), &cmds[head], 4 * (head + available - 1 > size ? @@ -650,11 +673,24 @@ static int ct_read(struct intel_guc_ct *ct, u32 *data) goto corrupted; } + *msg = ct_alloc_msg(len); + if (!*msg) { + CT_ERROR(ct, "No memory for message %*ph %*ph %*ph\n", + 4, &header, + 4 * (head + available - 1 > size ? + size - head : available - 1), &cmds[head], + 4 * (head + available - 1 > size ? + available - 1 - size + head : 0), &cmds[0]); + return available; + } + + (*msg)->msg[0] = header; + for (i = 1; i < len; i++) { - data[i] = cmds[head]; + (*msg)->msg[i] = cmds[head]; head = (head + 1) % size; } - CT_DEBUG(ct, "received %*ph\n", 4 * len, data); + CT_DEBUG(ct, "received %*ph\n", 4 * len, (*msg)->msg); desc->head = head * 4; return available - len; @@ -684,33 +720,33 @@ static int ct_read(struct intel_guc_ct *ct, u32 *data) * ^-----------------------len-----------------------^ */ -static int ct_handle_response(struct intel_guc_ct *ct, const u32 *msg) +static int ct_handle_response(struct intel_guc_ct *ct, struct ct_incoming_msg *response) { - u32 header = msg[0]; + u32 header = response->msg[0]; u32 len = ct_header_get_len(header); - u32 msgsize = (len + 1) * sizeof(u32); /* msg size in bytes w/header */ u32 fence; u32 status; u32 datalen; struct ct_request *req; unsigned long flags; bool found = false; + int err = 0; GEM_BUG_ON(!ct_header_is_response(header)); /* Response payload shall at least include fence and status */ if (unlikely(len < 2)) { - CT_ERROR(ct, "Corrupted response %*ph\n", msgsize, msg); + CT_ERROR(ct, "Corrupted response (len %u)\n", len); return -EPROTO; } - fence = msg[1]; - status = msg[2]; + fence = response->msg[1]; + status = response->msg[2]; datalen = len - 2; /* Format of the status follows RESPONSE message */ if (unlikely(!INTEL_GUC_MSG_IS_RESPONSE(status))) { - CT_ERROR(ct, "Corrupted response %*ph\n", msgsize, msg); + CT_ERROR(ct, "Corrupted response (status %#x)\n", status); return -EPROTO; } @@ -724,12 +760,13 @@ static int ct_handle_response(struct intel_guc_ct *ct, const u32 *msg) continue; } if (unlikely(datalen > req->response_len)) { - CT_ERROR(ct, "Response for %u is too long %*ph\n", - req->fence, msgsize, msg); - datalen = 0; + CT_ERROR(ct, "Response %u too long (datalen %u > %u)\n", + req->fence, datalen, req->response_len); + datalen = min(datalen, req->response_len); + err = -EMSGSIZE; } if (datalen) - memcpy(req->response_buf, msg + 3, 4 * datalen); + memcpy(req->response_buf, response->msg + 3, 4 * datalen); req->response_len = datalen; WRITE_ONCE(req->status, status); found = true; @@ -737,45 +774,61 @@ static int ct_handle_response(struct intel_guc_ct *ct, const u32 *msg) } spin_unlock_irqrestore(&ct->requests.lock, flags); - if (!found) - CT_ERROR(ct, "Unsolicited response %*ph\n", msgsize, msg); + if (!found) { + CT_ERROR(ct, "Unsolicited response (fence %u)\n", fence); + return -ENOKEY; + } + + if (unlikely(err)) + return err; + + ct_free_msg(response); return 0; } -static void ct_process_request(struct intel_guc_ct *ct, - u32 action, u32 len, const u32 *payload) +static int ct_process_request(struct intel_guc_ct *ct, struct ct_incoming_msg *request) { struct intel_guc *guc = ct_to_guc(ct); + u32 header, action, len; + const u32 *payload; int ret; + header = request->msg[0]; + payload = &request->msg[1]; + action = ct_header_get_action(header); + len = ct_header_get_len(header); + CT_DEBUG(ct, "request %x %*ph\n", action, 4 * len, payload); switch (action) { case INTEL_GUC_ACTION_DEFAULT: ret = intel_guc_to_host_process_recv_msg(guc, payload, len); - if (unlikely(ret)) - goto fail_unexpected; break; - default: -fail_unexpected: - CT_ERROR(ct, "Unexpected request %x %*ph\n", - action, 4 * len, payload); + ret = -EOPNOTSUPP; break; } + + if (unlikely(ret)) { + CT_ERROR(ct, "Failed to process request %04x (%pe)\n", + action, ERR_PTR(ret)); + return ret; + } + + ct_free_msg(request); + return 0; } static bool ct_process_incoming_requests(struct intel_guc_ct *ct) { unsigned long flags; - struct ct_incoming_request *request; - u32 header; - u32 *payload; + struct ct_incoming_msg *request; bool done; + int err; spin_lock_irqsave(&ct->requests.lock, flags); request = list_first_entry_or_null(&ct->requests.incoming, - struct ct_incoming_request, link); + struct ct_incoming_msg, link); if (request) list_del(&request->link); done = !!list_empty(&ct->requests.incoming); @@ -784,14 +837,13 @@ static bool ct_process_incoming_requests(struct intel_guc_ct *ct) if (!request) return true; - header = request->msg[0]; - payload = &request->msg[1]; - ct_process_request(ct, - ct_header_get_action(header), - ct_header_get_len(header), - payload); + err = ct_process_request(ct, request); + if (unlikely(err)) { + CT_ERROR(ct, "Failed to process CT message (%pe) %*ph\n", + ERR_PTR(err), 4 * request->size, request->msg); + ct_free_msg(request); + } - kfree(request); return done; } @@ -824,22 +876,11 @@ static void ct_incoming_request_worker_func(struct work_struct *w) * ^-----------------------len-----------------------^ */ -static int ct_handle_request(struct intel_guc_ct *ct, const u32 *msg) +static int ct_handle_request(struct intel_guc_ct *ct, struct ct_incoming_msg *request) { - u32 header = msg[0]; - u32 len = ct_header_get_len(header); - u32 msgsize = (len + 1) * sizeof(u32); /* msg size in bytes w/header */ - struct ct_incoming_request *request; unsigned long flags; - GEM_BUG_ON(ct_header_is_response(header)); - - request = kmalloc(sizeof(*request) + msgsize, GFP_ATOMIC); - if (unlikely(!request)) { - CT_ERROR(ct, "Dropping request %*ph\n", msgsize, msg); - return 0; /* XXX: -ENOMEM ? */ - } - memcpy(request->msg, msg, msgsize); + GEM_BUG_ON(ct_header_is_response(request->msg[0])); spin_lock_irqsave(&ct->requests.lock, flags); list_add_tail(&request->link, &ct->requests.incoming); @@ -849,22 +890,41 @@ static int ct_handle_request(struct intel_guc_ct *ct, const u32 *msg) return 0; } +static void ct_handle_msg(struct intel_guc_ct *ct, struct ct_incoming_msg *msg) +{ + u32 header = msg->msg[0]; + int err; + + if (ct_header_is_response(header)) + err = ct_handle_response(ct, msg); + else + err = ct_handle_request(ct, msg); + + if (unlikely(err)) { + CT_ERROR(ct, "Failed to process CT message (%pe) %*ph\n", + ERR_PTR(err), 4 * msg->size, msg->msg); + ct_free_msg(msg); + } +} + +/* + * Return: number available remaining dwords to read (0 if empty) + * or a negative error code on failure + */ static int ct_receive(struct intel_guc_ct *ct) { - u32 msg[GUC_CT_MSG_LEN_MASK + 1]; /* one extra dw for the header */ + struct ct_incoming_msg *msg = NULL; unsigned long flags; int ret; spin_lock_irqsave(&ct->ctbs.recv.lock, flags); - ret = ct_read(ct, msg); + ret = ct_read(ct, &msg); spin_unlock_irqrestore(&ct->ctbs.recv.lock, flags); if (ret < 0) return ret; - if (ct_header_is_response(msg[0])) - ct_handle_response(ct, msg); - else - ct_handle_request(ct, msg); + if (msg) + ct_handle_msg(ct, msg); return ret; } -- 2.28.0