From patchwork Tue Jul 27 18:06:47 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mark Brown X-Patchwork-Id: 486743 Delivered-To: patch@linaro.org Received: by 2002:a05:6638:1185:0:0:0:0 with SMTP id f5csp458526jas; Tue, 27 Jul 2021 11:12:27 -0700 (PDT) X-Google-Smtp-Source: ABdhPJxlBrAW6i9/Mo9wYFhSsKOJctLt7VMtKOq7IGQAoT/igd689svAX454uhrY7Wovw6w7DF7B X-Received: by 2002:a5d:9c4a:: with SMTP id 10mr19918130iof.23.1627409547062; Tue, 27 Jul 2021 11:12:27 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1627409547; cv=none; d=google.com; s=arc-20160816; b=FqfaKHvBzwgKdO+o64HCkltVH5C7w5nVkmpaZHqRHuDj2sfc70Eiyo4e1aOLLKQa/6 pbC54/zHCeNeT49oecgA+ZraLElBpeGa28PQDuMVLew0aQSHoSXGVtDDlkZqAPxUKM8J G9Cf9CYZJrRtzcnlAHQsdG0imBZif6USUvK8ej0JrqiS/pUKuNLtnL8ZaaLeKHmFW7Us rlRnp2J6yA928Aa0mknbLOAP3EV0TkaBS/CglK+Uh69Wa9jfhOyOS56aQj/CnLW7fGPZ UU30S8ozMNqL3qQUAiX6xiU6G2OVI9dNR3Qfo2uYnTWztIrafedXP6Rq/FFZ3z38XwPb m4bg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=q3zIj63zHcNF1ZXggxhoNqMziCqmY8El7Cy1T2GKjLU=; b=0Bmbi6vU5BQ8ti2uTcLdLXQCEyubmq1zDaV5MGw8yklB9bg1L9uHlQGjDYARjcnlAx R+4QY1Gsc5T9lpTTofTd2cKnqFic/U5zUmEx3OQgUcSSAyC/hqDk47NY9VMeWieIPeKw mJE4hz61d38YDKcwKbVioUiuC570Bio/tKm5uoT5mIWxf00O16EJH1Id0sik8LnOdvek WLRcsnba9ALEWEsTpjwtUAlRB6a81SEA0KRPOctH4Lp+hkww8gm26TaznBWp+rvfTnn2 cOrW6JN9qcU/JQ4x0AavAv6lDaFizsMb56QLMDhXrXD29TJyPw50zwBU57kvsCzMxyH5 bA/A== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@kernel.org header.s=k20201202 header.b=qfYrpzOF; spf=pass (google.com: domain of linux-kselftest-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-kselftest-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=kernel.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [23.128.96.18]) by mx.google.com with ESMTP id n14si4577533ilk.78.2021.07.27.11.12.26; Tue, 27 Jul 2021 11:12:27 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kselftest-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18; Authentication-Results: mx.google.com; dkim=pass header.i=@kernel.org header.s=k20201202 header.b=qfYrpzOF; spf=pass (google.com: domain of linux-kselftest-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-kselftest-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229801AbhG0SM0 (ORCPT + 5 others); Tue, 27 Jul 2021 14:12:26 -0400 Received: from mail.kernel.org ([198.145.29.99]:55096 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229716AbhG0SM0 (ORCPT ); Tue, 27 Jul 2021 14:12:26 -0400 Received: by mail.kernel.org (Postfix) with ESMTPSA id 716CE60F8F; Tue, 27 Jul 2021 18:12:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1627409546; bh=RCUI82H/4W6FmihK1AkpRMF/AXitVCXzKcuEuGl6Cws=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=qfYrpzOFiclHXLc3NqAlAi8Tdy1qoaX7rF31MBTBvrdkj85EaPkrjgkECV8hYM6Xb fl2aN5G5U07MkK4XFeZbCK35uVcnacBpk7SYtCc4jL/0NNGZMPCNAh7VvUzRwsr96R En3cV0EkkGt+NFh4Ib4j+c9HO99q7kvWewwQaC8KCFf2y6AbB2/mva9Q05hdSy/xLY YW4C6jWKL0YXzw5H8mGBO/I1rttvqWQIie6s5EHYFumEjFLLWuxRha6vo4bpQZo4zg a1yD/kcWcW/D5UtMgUL3cTy+DQrwa6pVOILXYc95uM2R/lhwDMguWrFn/fEyuHfEWf UFxzb3u8rKAwg== From: Mark Brown To: Catalin Marinas , Will Deacon , Shuah Khan Cc: Dave Martin , linux-arm-kernel@lists.infradead.org, linux-kselftest@vger.kernel.org, Mark Brown Subject: [PATCH v1 1/3] kselftest/arm64: Provide a helper binary and "library" for SVE RDVL Date: Tue, 27 Jul 2021 19:06:47 +0100 Message-Id: <20210727180649.12943-2-broonie@kernel.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210727180649.12943-1-broonie@kernel.org> References: <20210727180649.12943-1-broonie@kernel.org> MIME-Version: 1.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=3690; h=from:subject; bh=RCUI82H/4W6FmihK1AkpRMF/AXitVCXzKcuEuGl6Cws=; b=owEBbQGS/pANAwAKASTWi3JdVIfQAcsmYgBhAEs2Mq3zDnqSnFUJ1lvpDawfFS3yduzdzxjq60HD 0JBiBAOJATMEAAEKAB0WIQSt5miqZ1cYtZ/in+ok1otyXVSH0AUCYQBLNgAKCRAk1otyXVSH0AFrB/ 0QCP3wT2npf1UclpRSCIYsykb431h/S27r0l1MJksGNS2ZweG+jA3q84D0POpHmjvWGVeSErJ8GDEn DJdxiO6of7P+aRLxFKSGUA/ZatOi2vhRUkXjHpjJNsI6NIqpiMpa51zw5QkpkqDwZO+3i0zN2gRuDy Y5UG9kx9Fl42R9TJ4jpzblZLiSbAtLaAm9ERFsGLbNAfmzXn/T0SVdTFbFPs+tVa0ilxguNJdyf+Vu 6HC26YU6LSJAtP18Xf8afCQtWl5Sv1n+tX2cd9Eba5EqXjmaTvSHRua5n/V2imZIucNYb2w5ilnqtd 3k9kOpHC6cCrBBDjm+ovr4UYp2C8gS X-Developer-Key: i=broonie@kernel.org; a=openpgp; fpr=3F2568AAC26998F9E813A1C5C3F436CA30F5D8EB Precedence: bulk List-ID: X-Mailing-List: linux-kselftest@vger.kernel.org SVE provides an instruction RDVL which reports the currently configured vector length. In order to validate that our vector length configuration interfaces are working correctly without having to build the C code for our test programs with SVE enabled provide a trivial assembly library with a C callable function that executes RDVL. Since these interfaces also control behaviour on exec*() provide a trivial wrapper program which reports the currently configured vector length on stdout, tests can use this to verify that behaviour on exec*() is as expected. In preparation for providing similar helper functionality for SME, the Scalable Matrix Extension, which allows separately configured vector lengths to be read back both the assembler function and wrapper binary have SVE included in their name. Signed-off-by: Mark Brown --- tools/testing/selftests/arm64/fp/.gitignore | 1 + tools/testing/selftests/arm64/fp/Makefile | 6 +++++- tools/testing/selftests/arm64/fp/rdvl-sve.c | 14 ++++++++++++++ tools/testing/selftests/arm64/fp/rdvl.S | 9 +++++++++ tools/testing/selftests/arm64/fp/rdvl.h | 8 ++++++++ 5 files changed, 37 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/arm64/fp/rdvl-sve.c create mode 100644 tools/testing/selftests/arm64/fp/rdvl.S create mode 100644 tools/testing/selftests/arm64/fp/rdvl.h -- 2.20.1 diff --git a/tools/testing/selftests/arm64/fp/.gitignore b/tools/testing/selftests/arm64/fp/.gitignore index d66f76d2a650..6b53a7b60fee 100644 --- a/tools/testing/selftests/arm64/fp/.gitignore +++ b/tools/testing/selftests/arm64/fp/.gitignore @@ -1,4 +1,5 @@ fpsimd-test +rdvl-sve sve-probe-vls sve-ptrace sve-test diff --git a/tools/testing/selftests/arm64/fp/Makefile b/tools/testing/selftests/arm64/fp/Makefile index a57009d3a0dc..ed62e7003b96 100644 --- a/tools/testing/selftests/arm64/fp/Makefile +++ b/tools/testing/selftests/arm64/fp/Makefile @@ -2,12 +2,16 @@ CFLAGS += -I../../../../../usr/include/ TEST_GEN_PROGS := sve-ptrace sve-probe-vls -TEST_PROGS_EXTENDED := fpsimd-test fpsimd-stress sve-test sve-stress vlset +TEST_PROGS_EXTENDED := fpsimd-test fpsimd-stress \ + rdvl-sve \ + sve-test sve-stress \ + vlset all: $(TEST_GEN_PROGS) $(TEST_PROGS_EXTENDED) fpsimd-test: fpsimd-test.o $(CC) -nostdlib $^ -o $@ +rdvl-sve: rdvl-sve.o rdvl.o sve-ptrace: sve-ptrace.o sve-ptrace-asm.o sve-probe-vls: sve-probe-vls.o sve-test: sve-test.o diff --git a/tools/testing/selftests/arm64/fp/rdvl-sve.c b/tools/testing/selftests/arm64/fp/rdvl-sve.c new file mode 100644 index 000000000000..7f8a13a18f5d --- /dev/null +++ b/tools/testing/selftests/arm64/fp/rdvl-sve.c @@ -0,0 +1,14 @@ +// SPDX-License-Identifier: GPL-2.0-only + +#include + +#include "rdvl.h" + +int main(void) +{ + int vl = rdvl_sve(); + + printf("%d\n", vl); + + return 0; +} diff --git a/tools/testing/selftests/arm64/fp/rdvl.S b/tools/testing/selftests/arm64/fp/rdvl.S new file mode 100644 index 000000000000..6e76dd720b87 --- /dev/null +++ b/tools/testing/selftests/arm64/fp/rdvl.S @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: GPL-2.0-only +// Copyright (C) 2021 ARM Limited. + +.arch_extension sve + +.globl rdvl_sve +rdvl_sve: + rdvl x0, #1 + ret diff --git a/tools/testing/selftests/arm64/fp/rdvl.h b/tools/testing/selftests/arm64/fp/rdvl.h new file mode 100644 index 000000000000..7c9d953fc9e7 --- /dev/null +++ b/tools/testing/selftests/arm64/fp/rdvl.h @@ -0,0 +1,8 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ + +#ifndef RDVL_H +#define RDVL_H + +int rdvl_sve(void); + +#endif From patchwork Tue Jul 27 18:06:48 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mark Brown X-Patchwork-Id: 486744 Delivered-To: patch@linaro.org Received: by 2002:a05:6638:1185:0:0:0:0 with SMTP id f5csp458566jas; Tue, 27 Jul 2021 11:12:31 -0700 (PDT) X-Google-Smtp-Source: ABdhPJwnqYicQI18s0VNAD6GbAGxKrtUOR41YoECay7+cNdVzLBCBHii24d4pz7e7BUco+o6UGDG X-Received: by 2002:a02:cc41:: with SMTP id i1mr274912jaq.42.1627409551302; Tue, 27 Jul 2021 11:12:31 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1627409551; cv=none; d=google.com; s=arc-20160816; b=b8kqPZZEnXfgqGUXiXf/leICHS1ZLNORQkW7lHHrdx9x2z7FdmnrIU2Qq2PHNzd5fO m/MFryn2KYgKuduHqVokR/ErP+L/EWPueQpN7vjmcS6ABZLGHl28bT/JaY0eWWaHRoGO 5sArxl7bd0ZhWva27pSdCjUBv4eVqsV7MGls5Aq1umdmYukvuAPmw7oOxeZ1g7Vmhc/N 5Kn3PcwCDogc1Mz3fQ9zjXfCTZ5uFEW4d4wBuND8aCslU669PThz9DoYa6yQ7GmQuSe9 08MfltKxss9a4M9IZ5Ho/nLU1ATCVLalxZhX4APYX7gD7JEE6XKALy07MEHHxg8oLy84 Da2A== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=THcrfdMvfhpDQv1scEEE8SuGz90JdKwDKrN8YZEsb8g=; b=OOh6H531me5y6t9CZBb412706B/hhsY+8HP2WOH567paL5F9FijRKKWWfQoXUrQx8q fwAIuas/PWTx+wZih10sZ72N3gYQVytmK0Ahoi6RSFMJEA59B18ensxOqBaZJlxIrkPy Z+l/qnot8X1p8YQDk8w07gse8EMQ3i8ioloMOVZ1Njy2I7iF1prCuSO+BjtAiq1kY1t5 M3AddrQzjpFaYKYDsPuUXnvIVhZMUMLHFu7uYZ2Cjd7xJa7os/aNdwDv5P59j9NHu5+I RR/uRVXqKC5cqLeBz6eJ31awVjGehT8e6utEVwZsZH9EnQtYI9XXyW0eGlY6TSscrJOZ b9VA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@kernel.org header.s=k20201202 header.b=ohDamLSv; spf=pass (google.com: domain of linux-kselftest-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-kselftest-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=kernel.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [23.128.96.18]) by mx.google.com with ESMTP id n14si4577533ilk.78.2021.07.27.11.12.31; Tue, 27 Jul 2021 11:12:31 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kselftest-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18; Authentication-Results: mx.google.com; dkim=pass header.i=@kernel.org header.s=k20201202 header.b=ohDamLSv; spf=pass (google.com: domain of linux-kselftest-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-kselftest-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230139AbhG0SMa (ORCPT + 5 others); Tue, 27 Jul 2021 14:12:30 -0400 Received: from mail.kernel.org ([198.145.29.99]:55130 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229716AbhG0SM3 (ORCPT ); Tue, 27 Jul 2021 14:12:29 -0400 Received: by mail.kernel.org (Postfix) with ESMTPSA id 71D9B6056B; Tue, 27 Jul 2021 18:12:28 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1627409549; bh=Yogziv8PBor2Z+LTr480PcDONcJAPIutmJu/cs7cZNo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=ohDamLSvQj4DYIQYad/tLVBerRQWMe69569RKqwxKQbkVh6ByFqHom9jhbOY2jGD5 LD3bJpG6EEK2ZE9nrBqOfd4K9nGeij8sqZ6UIM/19ErJLiWCYUWlBVhdiJRnNg6slC 67QU4PUpz9KE2YgVpNHNyKU38VEgpJ4C8On6jFbixWayv2n+fR7kvbnMrcMVfBN1C9 cJahCyCuJI9qrCJFZhftfeOYnLOvUNFCzUlYAl1X0M0mCICrP2oJNi4wFOwoiAzV/Z VwUbdxdOfY3XPWbaLwaa0whgXpzl0SxsInNAYR0AYFBF1R31RclxvgoMreYGNoj9HQ cXxgHzDotIEqw== From: Mark Brown To: Catalin Marinas , Will Deacon , Shuah Khan Cc: Dave Martin , linux-arm-kernel@lists.infradead.org, linux-kselftest@vger.kernel.org, Mark Brown Subject: [PATCH v1 2/3] kselftest/arm64: Validate vector lengths are set in sve-probe-vls Date: Tue, 27 Jul 2021 19:06:48 +0100 Message-Id: <20210727180649.12943-3-broonie@kernel.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210727180649.12943-1-broonie@kernel.org> References: <20210727180649.12943-1-broonie@kernel.org> MIME-Version: 1.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=1670; h=from:subject; bh=Yogziv8PBor2Z+LTr480PcDONcJAPIutmJu/cs7cZNo=; b=owEBbQGS/pANAwAKASTWi3JdVIfQAcsmYgBhAEs3KQJ/yaogg10mK29zjdVxMAETaLlSzXfmk+GF siJf8J6JATMEAAEKAB0WIQSt5miqZ1cYtZ/in+ok1otyXVSH0AUCYQBLNwAKCRAk1otyXVSH0MULB/ 0ZSdCFGTQsIEQZPmYE3sLhSdwynr3ZUYEinmcduIVnXelz+95fe4ntXlScZ8nZRbPdoZuNs2s1rS8t oG9+snltXTGkqDjPEEgvk4xn4vFYJzhbyGJ5OW5YUYioKEmYqSYULGJ2ScbU/MwbNlWGF3GX2x2BZp vRgY9oZ+gZE9/+mJVkUk3yFVmq6U24WTzK5KTMyINQztqx+ugHNB+OMD458WB+xN34+/jliTK3/pGY 4S7zarAyO+7LSWSnaaWOp6sY/fpIy0C5yuRYRpUp5iaV+Xkam6lVvTvSpHqEQexufatIqdYGGQT+W/ +n3PMqYe9sGcFCA8DyzkfLGvcHuHPu X-Developer-Key: i=broonie@kernel.org; a=openpgp; fpr=3F2568AAC26998F9E813A1C5C3F436CA30F5D8EB Precedence: bulk List-ID: X-Mailing-List: linux-kselftest@vger.kernel.org Currently sve-probe-vls does not verify that the vector lengths reported by the prctl() interface are actually what is reported by the architecture, use the rdvl_sve() helper to validate this. Signed-off-by: Mark Brown --- tools/testing/selftests/arm64/fp/Makefile | 2 +- tools/testing/selftests/arm64/fp/sve-probe-vls.c | 5 +++++ 2 files changed, 6 insertions(+), 1 deletion(-) -- 2.20.1 diff --git a/tools/testing/selftests/arm64/fp/Makefile b/tools/testing/selftests/arm64/fp/Makefile index ed62e7003b96..fa3a0167db2d 100644 --- a/tools/testing/selftests/arm64/fp/Makefile +++ b/tools/testing/selftests/arm64/fp/Makefile @@ -13,7 +13,7 @@ fpsimd-test: fpsimd-test.o $(CC) -nostdlib $^ -o $@ rdvl-sve: rdvl-sve.o rdvl.o sve-ptrace: sve-ptrace.o sve-ptrace-asm.o -sve-probe-vls: sve-probe-vls.o +sve-probe-vls: sve-probe-vls.o rdvl.o sve-test: sve-test.o $(CC) -nostdlib $^ -o $@ vlset: vlset.o diff --git a/tools/testing/selftests/arm64/fp/sve-probe-vls.c b/tools/testing/selftests/arm64/fp/sve-probe-vls.c index 76e138525d55..a6cd1bd6e515 100644 --- a/tools/testing/selftests/arm64/fp/sve-probe-vls.c +++ b/tools/testing/selftests/arm64/fp/sve-probe-vls.c @@ -13,6 +13,7 @@ #include #include "../../kselftest.h" +#include "rdvl.h" int main(int argc, char **argv) { @@ -38,6 +39,10 @@ int main(int argc, char **argv) vl &= PR_SVE_VL_LEN_MASK; + if (rdvl_sve() != vl) + ksft_exit_fail_msg("Set VL %d, RDVL %d\n", + vl, rdvl_sve()); + if (!sve_vl_valid(vl)) ksft_exit_fail_msg("VL %d invalid\n", vl); vq = sve_vq_from_vl(vl); From patchwork Tue Jul 27 18:06:49 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mark Brown X-Patchwork-Id: 486745 Delivered-To: patch@linaro.org Received: by 2002:a05:6638:1185:0:0:0:0 with SMTP id f5csp458627jas; Tue, 27 Jul 2021 11:12:35 -0700 (PDT) X-Google-Smtp-Source: ABdhPJwr4HemN6r7dyUMrghWINt2bEXLdaexHeSlgu2PRduGqFmbRQZU2QoU5HzuHnOcIS+j2pn4 X-Received: by 2002:a92:d4c4:: with SMTP id o4mr16706046ilm.39.1627409555506; Tue, 27 Jul 2021 11:12:35 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1627409555; cv=none; d=google.com; s=arc-20160816; b=abJyj6OH0Nzp5gXqpH4yKI/fsZBDtQgC15uYT9aUEML4iAoybmRcJ0NhYhQ1YLyYH8 j+SyR/PW6LtrL7Q4vONQ4OgMY7U7hl8Da206H2fCRQCwcDYeAXxPZPVbfBucdj990ckF rjKGlQ/vu7MUwUAdF94uRtyZvsioBy/PZd+gPOsmB9q00rQJT85XM5j7eUE7Be/HrQ2U SBzpfGs5JlktsOEI9dxq3pOGdBgzlmnf1T0ULnb9afw9w+AQTdkWCrZfE67HunEldLRy 8+foGgaxS8DeDNxpKfUfSpGqZ8hOKaGxs2lyR6HfiyGTqnw225ioUkl2Swu9FwHWRMs6 62cA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=PItHZN+vM5cDhvlDfXusPHQIXZjrPu0vzSSG5i2uqqU=; b=BF/tmOrf6yLQN+7LCK+/LsHM5MDTxoC/eCaLgEf5pCkSpBi5lPDFyedCEEm+tGJpYd HDtmA1RKUyNFvCXh0LUkhyeaRkFBdxqb9+qE8YqRkYL0EMV9S88WlKHmjxHt8N+U8qzA F16ChWcPtmpcvUpDluPVNIFFPucMDihOAf63neNYU8x3B8sadWGCqqzLL2WYI14kXoMq 8LD2Juu29/QbD1cbRok+oyVurZtX0XaA0iePNOiLLTLMX0iKkRL4UdhVn9Xs819MLI8D 5PRjnYpZMuEN5UwtqrvMbXtNIp2IHj4IdsTHymodsMq3v9C2Gm0U/Y8W1KZylIci/Tmx Zpdw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@kernel.org header.s=k20201202 header.b=hLwv12Wt; spf=pass (google.com: domain of linux-kselftest-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-kselftest-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=kernel.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [23.128.96.18]) by mx.google.com with ESMTP id n14si4577533ilk.78.2021.07.27.11.12.35; Tue, 27 Jul 2021 11:12:35 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kselftest-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18; Authentication-Results: mx.google.com; dkim=pass header.i=@kernel.org header.s=k20201202 header.b=hLwv12Wt; spf=pass (google.com: domain of linux-kselftest-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-kselftest-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231820AbhG0SMd (ORCPT + 5 others); Tue, 27 Jul 2021 14:12:33 -0400 Received: from mail.kernel.org ([198.145.29.99]:55164 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229716AbhG0SMb (ORCPT ); Tue, 27 Jul 2021 14:12:31 -0400 Received: by mail.kernel.org (Postfix) with ESMTPSA id 0374260F59; Tue, 27 Jul 2021 18:12:30 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1627409551; bh=qYDWXA9T4dyfo9+LQ1CIaz2a08yTYZ0UNqnIfRE/wR0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=hLwv12WtlrbdEsL/mSjWaX6ugSA8y6tMg2FXORi15vn7+fLAququOAi4Nv7bF0//o Nzxe40IktE+L1Ve1qz4Y4OCXGXyxAUgfRdBDg1o8g5L/GV+GmEzePMpZ31k8BUSW1D vYfRpXDl+jieJGC4c9I/8kypRwRKN22lubq4KQmVuAFidvoIwBexyh90C+w6MVV9Xr Dc2cpioWLt49NcAguFeE+UrfaPFQmUbsw76nh0Y6WKx8wmOMboAVpS7x0ud8ZDVcHg 3mkN1fxMuCtuWLozL6VkOSweBWO4Tq/eTIEwHvXYHtm8ZEVRfz7GNzUsVeaFF2MXPw kw/bKygbbZbfw== From: Mark Brown To: Catalin Marinas , Will Deacon , Shuah Khan Cc: Dave Martin , linux-arm-kernel@lists.infradead.org, linux-kselftest@vger.kernel.org, Mark Brown Subject: [PATCH v1 3/3] kselftest/arm64: Add tests for SVE vector configuration Date: Tue, 27 Jul 2021 19:06:49 +0100 Message-Id: <20210727180649.12943-4-broonie@kernel.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210727180649.12943-1-broonie@kernel.org> References: <20210727180649.12943-1-broonie@kernel.org> MIME-Version: 1.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=17369; h=from:subject; bh=qYDWXA9T4dyfo9+LQ1CIaz2a08yTYZ0UNqnIfRE/wR0=; b=owEBbQGS/pANAwAKASTWi3JdVIfQAcsmYgBhAEs3YaRWxTo2UugDIddzA/cXFEjtvuQiFi/kEPcO jLBOMd2JATMEAAEKAB0WIQSt5miqZ1cYtZ/in+ok1otyXVSH0AUCYQBLNwAKCRAk1otyXVSH0BM4B/ 41g7s77R0X6DKx2gjMpWiaGXbKxAncs/w3ZYZfy0yPOPZURvrZ8GcfuknZq7BY1UrjdhQx3Yirehua RQ8Mkc84OtFWRnMPeMGXYd9vsT+U5kidajnokKJ6Pq7mFozWTB9/cXZS+/L2ebuAqN4EI7OePiYMe1 9xW2r9APKXu00lw9mVYcYdOsKuWqg0pgB1/cOwr3zh1XR47fa+9yqLwX2sSepTtEK6buCP+FtPfO97 8wO7sSZEMqFUj+wTFJuJ3zO+GyrFu1bkE2vP7U+sfUr684cYbSudjG9CJP/xXH0CvU3YSCJ/M1wScf l/yNwj43sh4hzDTVYct44TeNuZRuc8 X-Developer-Key: i=broonie@kernel.org; a=openpgp; fpr=3F2568AAC26998F9E813A1C5C3F436CA30F5D8EB Precedence: bulk List-ID: X-Mailing-List: linux-kselftest@vger.kernel.org We provide interfaces for configuring the SVE vector length seen by processes using prctl and also via /proc for configuring the default values. Provide tests that exercise all these interfaces and verify that they take effect as expected, though at present no test fully enumerates all the possible vector lengths. A subset of this is already tested via sve-probe-vls but the /proc interfaces are not currently covered at all. In preparation for the forthcoming support for SME, the Scalable Matrix Extension, which has separately but similarly configured vector lengths which we expect to offer similar userspace interfaces for, all the actual files and prctls used are parameterised and we don't validate that the architectural minimum vector length is the minimum we see. Signed-off-by: Mark Brown --- tools/testing/selftests/arm64/fp/.gitignore | 1 + tools/testing/selftests/arm64/fp/Makefile | 3 +- tools/testing/selftests/arm64/fp/vec-syscfg.c | 578 ++++++++++++++++++ 3 files changed, 581 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/arm64/fp/vec-syscfg.c -- 2.20.1 diff --git a/tools/testing/selftests/arm64/fp/.gitignore b/tools/testing/selftests/arm64/fp/.gitignore index 6b53a7b60fee..b67395903b9b 100644 --- a/tools/testing/selftests/arm64/fp/.gitignore +++ b/tools/testing/selftests/arm64/fp/.gitignore @@ -3,4 +3,5 @@ rdvl-sve sve-probe-vls sve-ptrace sve-test +vec-syscfg vlset diff --git a/tools/testing/selftests/arm64/fp/Makefile b/tools/testing/selftests/arm64/fp/Makefile index fa3a0167db2d..f2abdd6ba12e 100644 --- a/tools/testing/selftests/arm64/fp/Makefile +++ b/tools/testing/selftests/arm64/fp/Makefile @@ -1,7 +1,7 @@ # SPDX-License-Identifier: GPL-2.0 CFLAGS += -I../../../../../usr/include/ -TEST_GEN_PROGS := sve-ptrace sve-probe-vls +TEST_GEN_PROGS := sve-ptrace sve-probe-vls vec-syscfg TEST_PROGS_EXTENDED := fpsimd-test fpsimd-stress \ rdvl-sve \ sve-test sve-stress \ @@ -16,6 +16,7 @@ sve-ptrace: sve-ptrace.o sve-ptrace-asm.o sve-probe-vls: sve-probe-vls.o rdvl.o sve-test: sve-test.o $(CC) -nostdlib $^ -o $@ +vec-syscfg: vec-syscfg.o rdvl.o vlset: vlset.o include ../../lib.mk diff --git a/tools/testing/selftests/arm64/fp/vec-syscfg.c b/tools/testing/selftests/arm64/fp/vec-syscfg.c new file mode 100644 index 000000000000..360c3a7cae26 --- /dev/null +++ b/tools/testing/selftests/arm64/fp/vec-syscfg.c @@ -0,0 +1,578 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2021 ARM Limited. + * Original author: Mark Brown + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "../../kselftest.h" +#include "rdvl.h" + +#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) + +#define MIN_VL 16 + +struct vec_data { + const char *name; + unsigned long hwcap_type; + unsigned long hwcap; + const char *rdvl_binary; + int (*rdvl)(void); + + int prctl_get; + int prctl_set; + const char *default_vl_file; + + int default_vl; + int min_vl; + int max_vl; +} vec_data[] = { + { + .name = "SVE", + .hwcap_type = AT_HWCAP, + .hwcap = HWCAP_SVE, + .rdvl = rdvl_sve, + .rdvl_binary = "./rdvl-sve", + .prctl_get = PR_SVE_GET_VL, + .prctl_set = PR_SVE_SET_VL, + .default_vl_file = "/proc/sys/abi/sve_default_vector_length", + }, +}; + +/* Start a new process and return the vector length it sees */ +int get_child_rdvl(struct vec_data *data) +{ + char buf[10]; + int pipefd[2]; + pid_t pid, child; + int read_vl, ret; + + ret = pipe(pipefd); + if (ret == -1) { + ksft_print_msg("pipe() failed: %d (%s)\n", + errno, strerror(errno)); + return -1; + } + + child = fork(); + if (child == -1) { + ksft_print_msg("fork() failed: %d (%s)\n", + errno, strerror(errno)); + return -1; + } + + /* Child: put vector length on the pipe */ + if (child == 0) { + /* + * Replace stdout with the pipe, errors to stderr from + * here as kselftest prints to stdout. + */ + ret = dup2(pipefd[1], 1); + if (ret == -1) { + fprintf(stderr, "dup2() %d\n", errno); + exit(-1); + } + + /* exec() a new binary which puts the VL on stdout */ + ret = execl(data->rdvl_binary, data->rdvl_binary, NULL); + fprintf(stderr, "execl(%s) failed: %d\n", + data->rdvl_binary, errno, strerror(errno)); + + exit(-1); + } + + close(pipefd[1]); + + /* Parent; wait for the exit status from the child & verify it */ + while (1) { + pid = wait(&ret); + if (pid == -1) { + ksft_print_msg("wait() failed: %d (%s)\n", + errno, strerror(errno)); + return -1; + } + + if (pid != child) + continue; + + if (!WIFEXITED(ret)) { + ksft_print_msg("child exited abnormally\n"); + return -1; + } + + if (WEXITSTATUS(ret) != 0) { + ksft_print_msg("child returned error %d\n", + WEXITSTATUS(ret)); + return -1; + } + + memset(buf, 0, sizeof(buf)); + ret = read(pipefd[0], buf, sizeof(buf) - 1); + if (ret <= 0) { + ksft_print_msg("read() failed: %d (%s)\n", + errno, strerror(errno)); + return -1; + } + close(pipefd[0]); + + ret = sscanf(buf, "%d", &read_vl); + if (ret != 1) { + ksft_print_msg("failed to parse VL from '%s'\n", + buf); + return -1; + } + + return read_vl; + } +} + +int file_read_integer(const char *name, int *val) +{ + char buf[40]; + int f, ret; + + f = open(name, O_RDONLY); + if (f < 0) { + ksft_test_result_fail("Unable to open %s: %d (%s)\n", + name, errno, + strerror(errno)); + return -1; + } + + memset(buf, 0, sizeof(buf)); + ret = read(f, buf, sizeof(buf) - 1); + if (ret < 0) { + ksft_test_result_fail("Error reading %s: %d (%s)\n", + name, errno, strerror(errno)); + return -1; + } + close(f); + + ret = sscanf(buf, "%d", val); + if (ret != 1) { + ksft_test_result_fail("Failed to parse %s\n", name); + return -1; + } + + return 0; +} + +int file_write_integer(const char *name, int val) +{ + char buf[40]; + int f, ret; + + f = open(name, O_WRONLY); + if (f < 0) { + ksft_test_result_fail("Unable to open %s: %d (%s)\n", + name, errno, + strerror(errno)); + return -1; + } + + snprintf(buf, sizeof(buf), "%d", val); + ret = write(f, buf, strlen(buf)); + if (ret < 0) { + ksft_test_result_fail("Error writing %d to %s: %d (%s)\n", + val, name, errno, strerror(errno)); + return -1; + } + close(f); + + return 0; +} + +/* + * Verify that we can read the default VL via proc, checking that it + * is set in a freshly spawned child. + */ +void proc_read_default(struct vec_data *data) +{ + int default_vl, child_vl, ret; + + ret = file_read_integer(data->default_vl_file, &default_vl); + if (ret != 0) + return; + + /* Is this the actual default seen by new processes? */ + child_vl = get_child_rdvl(data); + if (child_vl != default_vl) { + ksft_test_result_fail("%s is %d but child VL is %d\n", + data->default_vl_file, + default_vl, child_vl); + return; + } + + ksft_test_result_pass("%s default vector length %d\n", data->name, + default_vl); + data->default_vl = default_vl; +} + +/* Verify that we can write a minimum value and have it take effect */ +void proc_write_min(struct vec_data *data) +{ + int ret, new_default, child_vl; + + ret = file_write_integer(data->default_vl_file, MIN_VL); + if (ret != 0) + return; + + /* What was the new value? */ + ret = file_read_integer(data->default_vl_file, &new_default); + if (ret != 0) + return; + + /* Did it take effect in a new process? */ + child_vl = get_child_rdvl(data); + if (child_vl != new_default) { + ksft_test_result_fail("%s is %d but child VL is %d\n", + data->default_vl_file, + new_default, child_vl); + return; + } + + ksft_test_result_pass("%s minimum vector length %d\n", data->name, + new_default); + data->min_vl = new_default; + + file_write_integer(data->default_vl_file, data->default_vl); +} + +/* Verify that we can write a maximum value and have it take effect */ +void proc_write_max(struct vec_data *data) +{ + int ret, new_default, child_vl; + + /* -1 is accepted by the /proc interface as the maximum VL */ + ret = file_write_integer(data->default_vl_file, -1); + if (ret != 0) + return; + + /* What was the new value? */ + ret = file_read_integer(data->default_vl_file, &new_default); + if (ret != 0) + return; + + /* Did it take effect in a new process? */ + child_vl = get_child_rdvl(data); + if (child_vl != new_default) { + ksft_test_result_fail("%s is %d but child VL is %d\n", + data->default_vl_file, + new_default, child_vl); + return; + } + + ksft_test_result_pass("%s maximum vector length %d\n", data->name, + new_default); + data->max_vl = new_default; + + file_write_integer(data->default_vl_file, data->default_vl); +} + +/* Can we read back a VL from prctl? */ +void prctl_get(struct vec_data *data) +{ + int ret; + + ret = prctl(data->prctl_get); + if (ret == -1) { + ksft_test_result_fail("%s prctl() read failed: %d (%s)\n", + data->name, errno, strerror(errno)); + return; + } + + /* Mask out any flags */ + ret &= PR_SVE_VL_LEN_MASK; + + /* Is that what we can read back directly? */ + if (ret == data->rdvl()) + ksft_test_result_pass("%s current VL is %d\n", + data->name, ret); + else + ksft_test_result_fail("%s prctl() VL %d but RDVL is %d\n", + data->name, ret, data->rdvl()); +} + +/* Does the prctl let us set the VL we already have? */ +void prctl_set_same(struct vec_data *data) +{ + int cur_vl = data->rdvl(); + int ret; + + ret = prctl(data->prctl_set, cur_vl); + if (ret < 0) { + ksft_test_result_fail("%s prctl set failed: %d (%s)\n", + data->name, errno, strerror(errno)); + return; + } + + if (cur_vl != data->rdvl()) + ksft_test_result_pass("%s current VL is %d\n", + data->name, ret); + else + ksft_test_result_fail("%s prctl() VL %d but RDVL is %d\n", + data->name, ret, data->rdvl()); +} + +/* Can we set a new VL for this process? */ +void prctl_set(struct vec_data *data) +{ + int ret; + + if (data->min_vl == data->max_vl) { + ksft_test_result_skip("%s only one VL supported\n", + data->name); + return; + } + + /* Try to set the minimum VL */ + ret = prctl(data->prctl_set, data->min_vl); + if (ret < 0) { + ksft_test_result_fail("%s prctl set failed for %d: %d (%s)\n", + data->name, data->min_vl, + errno, strerror(errno)); + return; + } + + if ((ret & PR_SVE_VL_LEN_MASK) != data->min_vl) { + ksft_test_result_fail("%s prctl set %d but return value is %d\n", + data->name, data->min_vl, data->rdvl()); + return; + } + + if (data->rdvl() != data->min_vl) { + ksft_test_result_fail("%s set %d but RDVL is %d\n", + data->name, data->min_vl, data->rdvl()); + return; + } + + /* Try to set the maximum VL */ + ret = prctl(data->prctl_set, data->max_vl); + if (ret < 0) { + ksft_test_result_fail("%s prctl set failed for %d: %d (%s)\n", + data->name, data->max_vl, + errno, strerror(errno)); + return; + } + + if ((ret & PR_SVE_VL_LEN_MASK) != data->max_vl) { + ksft_test_result_fail("%s prctl() set %d but return value is %d\n", + data->name, data->max_vl, data->rdvl()); + return; + } + + /* The _INHERIT flag should not be present when we read the VL */ + ret = prctl(data->prctl_get); + if (ret == -1) { + ksft_test_result_fail("%s prctl() read failed: %d (%s)\n", + data->name, errno, strerror(errno)); + return; + } + + if (ret & PR_SVE_VL_INHERIT) { + ksft_test_result_fail("%s prctl() reports _INHERIT\n", + data->name); + return; + } + + ksft_test_result_pass("%s prctl() set min/max\n", data->name); +} + +/* If we didn't request it a new VL shouldn't affect the child */ +void prctl_set_no_child(struct vec_data *data) +{ + int ret, child_vl; + + if (data->min_vl == data->max_vl) { + ksft_test_result_skip("%s only one VL supported\n", + data->name); + return; + } + + ret = prctl(data->prctl_set, data->min_vl); + if (ret < 0) { + ksft_test_result_fail("%s prctl set failed for %d: %d (%s)\n", + data->name, data->min_vl, + errno, strerror(errno)); + return; + } + + /* Ensure the default VL is different */ + ret = file_write_integer(data->default_vl_file, data->max_vl); + if (ret != 0) + return; + + /* Check that the child has the default we just set */ + child_vl = get_child_rdvl(data); + if (child_vl != data->max_vl) { + ksft_test_result_fail("%s is %d but child VL is %d\n", + data->default_vl_file, + data->max_vl, child_vl); + return; + } + + ksft_test_result_pass("%s vector length used default\n", data->name); + + file_write_integer(data->default_vl_file, data->default_vl); +} + +/* If we didn't request it a new VL shouldn't affect the child */ +void prctl_set_for_child(struct vec_data *data) +{ + int ret, child_vl; + + if (data->min_vl == data->max_vl) { + ksft_test_result_skip("%s only one VL supported\n", + data->name); + return; + } + + ret = prctl(data->prctl_set, data->min_vl | PR_SVE_VL_INHERIT); + if (ret < 0) { + ksft_test_result_fail("%s prctl set failed for %d: %d (%s)\n", + data->name, data->min_vl, + errno, strerror(errno)); + return; + } + + /* The _INHERIT flag should be present when we read the VL */ + ret = prctl(data->prctl_get); + if (ret == -1) { + ksft_test_result_fail("%s prctl() read failed: %d (%s)\n", + data->name, errno, strerror(errno)); + return; + } + if (!(ret & PR_SVE_VL_INHERIT)) { + ksft_test_result_fail("%s prctl() does not report _INHERIT\n", + data->name); + return; + } + + /* Ensure the default VL is different */ + ret = file_write_integer(data->default_vl_file, data->max_vl); + if (ret != 0) + return; + + /* Check that the child inherited our VL */ + child_vl = get_child_rdvl(data); + if (child_vl != data->min_vl) { + ksft_test_result_fail("%s is %d but child VL is %d\n", + data->default_vl_file, + data->min_vl, child_vl); + return; + } + + ksft_test_result_pass("%s vector length was inherited\n", data->name); + + file_write_integer(data->default_vl_file, data->default_vl); +} + +/* _ONEXEC takes effect only in the child process */ +void prctl_set_onexec(struct vec_data *data) +{ + int ret, child_vl; + + if (data->min_vl == data->max_vl) { + ksft_test_result_skip("%s only one VL supported\n", + data->name); + return; + } + + /* Set a known value for the default and our current VL */ + ret = file_write_integer(data->default_vl_file, data->max_vl); + if (ret != 0) + return; + + ret = prctl(data->prctl_set, data->max_vl); + if (ret < 0) { + ksft_test_result_fail("%s prctl set failed for %d: %d (%s)\n", + data->name, data->min_vl, + errno, strerror(errno)); + return; + } + + /* Set a different value for the child to have on exec */ + ret = prctl(data->prctl_set, data->min_vl | PR_SVE_SET_VL_ONEXEC); + if (ret < 0) { + ksft_test_result_fail("%s prctl set failed for %d: %d (%s)\n", + data->name, data->min_vl, + errno, strerror(errno)); + return; + } + + /* Our current VL should stay the same */ + if (data->rdvl() != data->max_vl) { + ksft_test_result_fail("%s VL changed by _ONEXEC prctl()\n", + data->name); + return; + } + + /* Check that the child inherited our VL */ + child_vl = get_child_rdvl(data); + if (child_vl != data->min_vl) { + ksft_test_result_fail("%s is %d but child VL is %d\n", + data->default_vl_file, + data->min_vl, child_vl); + return; + } + + ksft_test_result_pass("%s vector length set on exec\n", data->name); + + file_write_integer(data->default_vl_file, data->default_vl); +} + +typedef void (*test_type)(struct vec_data *); + +test_type tests[] = { + /* + * The default/min/max tests must be first to provide data for + * other tests. + */ + proc_read_default, + proc_write_min, + proc_write_max, + + prctl_get, + prctl_set, + prctl_set_no_child, + prctl_set_for_child, + prctl_set_onexec, +}; + +int main(void) +{ + int i, j; + + ksft_print_header(); + ksft_set_plan(ARRAY_SIZE(tests) * ARRAY_SIZE(vec_data)); + + for (i = 0; i < ARRAY_SIZE(vec_data); i++) { + struct vec_data *data = &vec_data[i]; + int supported = getauxval(data->hwcap_type) & data->hwcap; + + for (j = 0; j < ARRAY_SIZE(tests); j++) { + if (supported) + tests[j](data); + else + ksft_test_result_skip("%s not supported\n", + data->name); + } + } + + ksft_exit_pass(); +}