October 2021 - Linux-kselftest-mirror

[PATCH RESEND 3 00/16] Bitmap patches for 5.15

by Yury Norov

Hi Stephen, Please pull this bitmap series. The git tree is here: https://github.com/norov/linux/tree/bitmap-master-5.15 Thanks, Yury Yury Norov (16): bitops: protect find_first_{,zero}_bit properly bitops: move find_bit_*_le functions from le.h to find.h include: move find.h from asm_generic to linux arch: remove GENERIC_FIND_FIRST_BIT entirely lib: add find_first_and_bit() cpumask: use find_first_and_bit() all: replace find_next{,_zero}_bit with find_first{,_zero}_bit where appropriate tools: sync tools/bitmap with mother linux cpumask: replace cpumask_next_* with cpumask_first_* where appropriate include/linux: move for_each_bit() macros from bitops.h to find.h find: micro-optimize for_each_{set,clear}_bit() Replace for_each_*_bit_from() with for_each_*_bit() where appropriate mm/percpu: micro-optimize pcpu_is_populated() bitmap: unify find_bit operations lib: bitmap: add performance test for bitmap_print_to_pagebuf vsprintf: rework bitmap_list_string MAINTAINERS | 4 +- arch/alpha/include/asm/bitops.h | 2 - arch/arc/Kconfig | 1 - arch/arc/include/asm/bitops.h | 1 - arch/arm/include/asm/bitops.h | 1 - arch/arm64/Kconfig | 1 - arch/arm64/include/asm/bitops.h | 1 - arch/csky/include/asm/bitops.h | 1 - arch/h8300/include/asm/bitops.h | 1 - arch/hexagon/include/asm/bitops.h | 1 - arch/ia64/include/asm/bitops.h | 2 - arch/m68k/include/asm/bitops.h | 2 - arch/mips/Kconfig | 1 - arch/mips/include/asm/bitops.h | 1 - arch/openrisc/include/asm/bitops.h | 1 - arch/parisc/include/asm/bitops.h | 2 - arch/powerpc/include/asm/bitops.h | 2 - arch/powerpc/include/asm/cputhreads.h | 2 +- arch/powerpc/platforms/pasemi/dma_lib.c | 4 +- arch/riscv/include/asm/bitops.h | 1 - arch/s390/Kconfig | 1 - arch/s390/include/asm/bitops.h | 1 - arch/s390/kvm/kvm-s390.c | 2 +- arch/sh/include/asm/bitops.h | 1 - arch/sparc/include/asm/bitops_32.h | 1 - arch/sparc/include/asm/bitops_64.h | 2 - arch/x86/Kconfig | 1 - arch/x86/include/asm/bitops.h | 2 - arch/x86/kernel/apic/vector.c | 4 +- arch/x86/um/Kconfig | 1 - arch/xtensa/include/asm/bitops.h | 1 - block/blk-mq.c | 2 +- drivers/block/rnbd/rnbd-clt.c | 2 +- drivers/dma/ti/edma.c | 2 +- drivers/gpu/drm/etnaviv/etnaviv_gpu.c | 4 +- drivers/hwmon/ltc2992.c | 3 +- drivers/iio/adc/ad7124.c | 2 +- drivers/infiniband/hw/irdma/hw.c | 16 +- drivers/media/cec/core/cec-core.c | 2 +- drivers/media/mc/mc-devnode.c | 2 +- drivers/mmc/host/renesas_sdhi_core.c | 2 +- drivers/net/virtio_net.c | 2 +- drivers/pci/controller/dwc/pci-dra7xx.c | 2 +- drivers/scsi/lpfc/lpfc_sli.c | 10 +- drivers/soc/fsl/qbman/bman_portal.c | 2 +- drivers/soc/fsl/qbman/qman_portal.c | 2 +- drivers/soc/ti/k3-ringacc.c | 4 +- drivers/tty/n_tty.c | 2 +- drivers/virt/acrn/ioreq.c | 3 +- fs/f2fs/segment.c | 8 +- fs/ocfs2/cluster/heartbeat.c | 2 +- fs/ocfs2/dlm/dlmdomain.c | 4 +- fs/ocfs2/dlm/dlmmaster.c | 18 +- fs/ocfs2/dlm/dlmrecovery.c | 2 +- fs/ocfs2/dlm/dlmthread.c | 2 +- include/asm-generic/bitops.h | 1 - include/asm-generic/bitops/le.h | 64 --- include/linux/bitmap.h | 34 +- include/linux/bitops.h | 34 -- include/linux/cpumask.h | 46 ++- include/linux/find.h | 372 ++++++++++++++++++ kernel/time/clocksource.c | 4 +- lib/Kconfig | 3 - lib/find_bit.c | 21 + lib/find_bit_benchmark.c | 21 + lib/genalloc.c | 2 +- lib/test_bitmap.c | 37 ++ lib/vsprintf.c | 24 +- mm/percpu.c | 35 +- net/ncsi/ncsi-manage.c | 4 +- tools/include/asm-generic/bitops.h | 1 - tools/include/asm-generic/bitops/find.h | 145 ------- tools/include/linux/bitmap.h | 7 +- .../bitops => tools/include/linux}/find.h | 54 ++- tools/lib/find_bit.c | 20 + 75 files changed, 637 insertions(+), 441 deletions(-) create mode 100644 include/linux/find.h delete mode 100644 tools/include/asm-generic/bitops/find.h rename {include/asm-generic/bitops => tools/include/linux}/find.h (83%) -- 2.30.2

3 years, 2 months

2
17
0 0

[PATCH] kunit: tool: yield output from run_kernel in real time

by Daniel Latypov

Currently, `run_kernel()` dumps all the kernel output to a file (.kunit/test.log) and then opens the file and yields it to callers. This made it easier to respect the requested timeout, if any. But it means that we can't yield the results in real time, either to the parser or to stdout (if --raw_output is set). This change spins up a background thread to enforce the timeout, which allows us to yield the kernel output in real time, while also copying it to the .kunit/test.log file. It's also careful to ensure that the .kunit/test.log file is complete, even in the kunit_parser throws an exception/otherwise doesn't consume every line, see the new `finally` block and unit test. For example: $ ./tools/testing/kunit/kunit.py run --arch=x86_64 --raw_output <configure + build steps> ... <can now see output from QEMU in real time> This does not currently have a visible effect when --raw_output is not passed, as kunit_parser.py currently only outputs everything at the end. But that could change, and this patch is a necessary step towards showing parsed test results in real time. Signed-off-by: Daniel Latypov <dlatypov(a)google.com> --- tools/testing/kunit/kunit_kernel.py | 73 +++++++++++++++----------- tools/testing/kunit/kunit_tool_test.py | 17 ++++++ 2 files changed, 60 insertions(+), 30 deletions(-) diff --git a/tools/testing/kunit/kunit_kernel.py b/tools/testing/kunit/kunit_kernel.py index 2c6f916ccbaf..b8cba8123aa3 100644 --- a/tools/testing/kunit/kunit_kernel.py +++ b/tools/testing/kunit/kunit_kernel.py @@ -12,7 +12,8 @@ import subprocess import os import shutil import signal -from typing import Iterator, Optional, Tuple +import threading +from typing import Iterator, List, Optional, Tuple from contextlib import ExitStack @@ -103,8 +104,8 @@ class LinuxSourceTreeOperations(object): if stderr: # likely only due to build warnings print(stderr.decode()) - def run(self, params, timeout, build_dir, outfile) -> None: - pass + def start(self, params: List[str], build_dir: str) -> subprocess.Popen: + raise RuntimeError('not implemented!') class LinuxSourceTreeOperationsQemu(LinuxSourceTreeOperations): @@ -123,7 +124,7 @@ class LinuxSourceTreeOperationsQemu(LinuxSourceTreeOperations): kconfig.parse_from_string(self._kconfig) base_kunitconfig.merge_in_entries(kconfig) - def run(self, params, timeout, build_dir, outfile): + def start(self, params: List[str], build_dir: str) -> subprocess.Popen: kernel_path = os.path.join(build_dir, self._kernel_path) qemu_command = ['qemu-system-' + self._qemu_arch, '-nodefaults', @@ -134,18 +135,10 @@ class LinuxSourceTreeOperationsQemu(LinuxSourceTreeOperations): '-nographic', '-serial stdio'] + self._extra_qemu_params print('Running tests with:\n$', ' '.join(qemu_command)) - with open(outfile, 'w') as output: - process = subprocess.Popen(' '.join(qemu_command), - stdin=subprocess.PIPE, - stdout=output, - stderr=subprocess.STDOUT, - text=True, shell=True) - try: - process.wait(timeout=timeout) - except Exception as e: - print(e) - process.terminate() - return process + return subprocess.Popen(' '.join(qemu_command), + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + text=True, shell=True) class LinuxSourceTreeOperationsUml(LinuxSourceTreeOperations): """An abstraction over command line operations performed on a source tree.""" @@ -175,17 +168,13 @@ class LinuxSourceTreeOperationsUml(LinuxSourceTreeOperations): kunit_parser.print_with_timestamp( 'Starting Kernel with all configs takes a few minutes...') - def run(self, params, timeout, build_dir, outfile): + def start(self, params: List[str], build_dir: str) -> subprocess.Popen: """Runs the Linux UML binary. Must be named 'linux'.""" linux_bin = get_file_path(build_dir, 'linux') - outfile = get_outfile_path(build_dir) - with open(outfile, 'w') as output: - process = subprocess.Popen([linux_bin] + params, - stdin=subprocess.PIPE, - stdout=output, - stderr=subprocess.STDOUT, - text=True) - process.wait(timeout) + return subprocess.Popen([linux_bin] + params, + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + text=True) def get_kconfig_path(build_dir) -> str: return get_file_path(build_dir, KCONFIG_PATH) @@ -330,12 +319,36 @@ class LinuxSourceTree(object): args.extend(['mem=1G', 'console=tty', 'kunit_shutdown=halt']) if filter_glob: args.append('kunit.filter_glob='+filter_glob) - outfile = get_outfile_path(build_dir) - self._ops.run(args, timeout, build_dir, outfile) - subprocess.call(['stty', 'sane']) - with open(outfile, 'r') as file: - for line in file: + + process = self._ops.start(args, build_dir) + assert process.stdout is not None # tell mypy it's set + + # Enforce the timeout in a background thread. + def _wait_proc(): + try: + process.wait(timeout=timeout) + except Exception as e: + print(e) + process.terminate() + process.wait() + waiter = threading.Thread(target=_wait_proc) + waiter.start() + + output = open(get_outfile_path(build_dir), 'w') + try: + # Tee the output to the file and to our caller in real time. + for line in process.stdout: + output.write(line) yield line + # This runs even if our caller doesn't consume every line. + finally: + # Flush any leftover output to the file + output.write(process.stdout.read()) + output.close() + process.stdout.close() + + waiter.join() + subprocess.call(['stty', 'sane']) def signal_handler(self, sig, frame) -> None: logging.error('Build interruption occurred. Cleaning console.') diff --git a/tools/testing/kunit/kunit_tool_test.py b/tools/testing/kunit/kunit_tool_test.py index 619c4554cbff..f9a7398a9584 100755 --- a/tools/testing/kunit/kunit_tool_test.py +++ b/tools/testing/kunit/kunit_tool_test.py @@ -14,6 +14,7 @@ import tempfile, shutil # Handling test_tmpdir import itertools import json import signal +import subprocess import os import kunit_config @@ -291,6 +292,22 @@ class LinuxSourceTreeTest(unittest.TestCase): pass tree = kunit_kernel.LinuxSourceTree('', kunitconfig_path=dir) + def test_run_kernel_hits_exception(self): + def fake_start(unused_args, unused_build_dir): + return subprocess.Popen(['echo "hi\nbye"'], shell=True, text=True, stdout=subprocess.PIPE) + + with tempfile.TemporaryDirectory('') as build_dir: + tree = kunit_kernel.LinuxSourceTree(build_dir, load_config=False) + mock.patch.object(tree._ops, 'start', side_effect=fake_start).start() + + with self.assertRaises(ValueError): + for line in tree.run_kernel(build_dir=build_dir): + self.assertEqual(line, 'hi\n') + raise ValueError('uh oh, did not read all output') + + with open(kunit_kernel.get_outfile_path(build_dir), 'rt') as outfile: + self.assertEqual(outfile.read(), 'hi\nbye\n', msg='Missing some output') + # TODO: add more test cases. base-commit: 3b29021ddd10cfb6b2565c623595bd3b02036f33 -- 2.33.0.800.g4c38ced690-goog

3 years, 2 months

2
6
0 0

[PATCH] kunit: tool: misc fixes (unused vars, imports, leaked files)

by Daniel Latypov

Drop some variables in unit tests that were unused and/or add assertions based on them. For ExitStack, it was imported, but the `es` variable wasn't used so it didn't do anything, and we were leaking the file objects. Refactor it to just use nested `with` statements to properly close them. And drop the direct use of .close() on file objects in the kunit tool unit test, as these can be leaked if test assertions fail. Signed-off-by: Daniel Latypov <dlatypov(a)google.com> --- tools/testing/kunit/kunit.py | 1 - tools/testing/kunit/kunit_kernel.py | 12 ++++-------- tools/testing/kunit/kunit_tool_test.py | 18 ++++++++---------- 3 files changed, 12 insertions(+), 19 deletions(-) diff --git a/tools/testing/kunit/kunit.py b/tools/testing/kunit/kunit.py index 66f67af97971..1b2b7f06bb8c 100755 --- a/tools/testing/kunit/kunit.py +++ b/tools/testing/kunit/kunit.py @@ -18,7 +18,6 @@ from collections import namedtuple from enum import Enum, auto from typing import Iterable -import kunit_config import kunit_json import kunit_kernel import kunit_parser diff --git a/tools/testing/kunit/kunit_kernel.py b/tools/testing/kunit/kunit_kernel.py index 2c6f916ccbaf..1870e75ff153 100644 --- a/tools/testing/kunit/kunit_kernel.py +++ b/tools/testing/kunit/kunit_kernel.py @@ -14,10 +14,6 @@ import shutil import signal from typing import Iterator, Optional, Tuple -from contextlib import ExitStack - -from collections import namedtuple - import kunit_config import kunit_parser import qemu_config @@ -168,10 +164,10 @@ class LinuxSourceTreeOperationsUml(LinuxSourceTreeOperations): process.wait() kunit_parser.print_with_timestamp( 'Disabling broken configs to run KUnit tests...') - with ExitStack() as es: - config = open(get_kconfig_path(build_dir), 'a') - disable = open(BROKEN_ALLCONFIG_PATH, 'r').read() - config.write(disable) + + with open(get_kconfig_path(build_dir), 'a') as config: + with open(BROKEN_ALLCONFIG_PATH, 'r') as disable: + config.write(disable.read()) kunit_parser.print_with_timestamp( 'Starting Kernel with all configs takes a few minutes...') diff --git a/tools/testing/kunit/kunit_tool_test.py b/tools/testing/kunit/kunit_tool_test.py index 619c4554cbff..cad37a98e599 100755 --- a/tools/testing/kunit/kunit_tool_test.py +++ b/tools/testing/kunit/kunit_tool_test.py @@ -185,7 +185,7 @@ class KUnitParserTest(unittest.TestCase): kunit_parser.extract_tap_lines(file.readlines())) print_mock.assert_any_call(StrContains('could not parse test results!')) print_mock.stop() - file.close() + self.assertEqual(0, len(result.suites)) def test_crashed_test(self): crashed_log = test_data_path('test_is_test_passed-crash.log') @@ -197,24 +197,22 @@ class KUnitParserTest(unittest.TestCase): def test_skipped_test(self): skipped_log = test_data_path('test_skip_tests.log') - file = open(skipped_log) - result = kunit_parser.parse_run_tests(file.readlines()) + with open(skipped_log) as file: + result = kunit_parser.parse_run_tests(file.readlines()) # A skipped test does not fail the whole suite. self.assertEqual( kunit_parser.TestStatus.SUCCESS, result.status) - file.close() def test_skipped_all_tests(self): skipped_log = test_data_path('test_skip_all_tests.log') - file = open(skipped_log) - result = kunit_parser.parse_run_tests(file.readlines()) + with open(skipped_log) as file: + result = kunit_parser.parse_run_tests(file.readlines()) self.assertEqual( kunit_parser.TestStatus.SKIPPED, result.status) - file.close() def test_ignores_prefix_printk_time(self): @@ -283,13 +281,13 @@ class LinuxSourceTreeTest(unittest.TestCase): def test_valid_kunitconfig(self): with tempfile.NamedTemporaryFile('wt') as kunitconfig: - tree = kunit_kernel.LinuxSourceTree('', kunitconfig_path=kunitconfig.name) + kunit_kernel.LinuxSourceTree('', kunitconfig_path=kunitconfig.name) def test_dir_kunitconfig(self): with tempfile.TemporaryDirectory('') as dir: - with open(os.path.join(dir, '.kunitconfig'), 'w') as f: + with open(os.path.join(dir, '.kunitconfig'), 'w'): pass - tree = kunit_kernel.LinuxSourceTree('', kunitconfig_path=dir) + kunit_kernel.LinuxSourceTree('', kunitconfig_path=dir) # TODO: add more test cases. base-commit: 3b29021ddd10cfb6b2565c623595bd3b02036f33 -- 2.33.0.685.g46640cef36-goog

3 years, 2 months

3
3
0 0

[GIT PULL] Kselftest fixes update for Linux 5.15-rc5

by Shuah Khan

Hi Linus, Please pull the following Kselftest fixes update for Linux 5.15-rc5. This Kselftest fixes update for Linux 5.15-rc5 consists of a fix to implicit declaration warns in drivers/dma-buf test. I have been seeing this for a while and managed to fix it. diff is attached. thanks, -- Shuah ---------------------------------------------------------------- The following changes since commit f5013d412a43662b63f3d5f3a804d63213acd471: selftests: kvm: fix get_run_delay() ignoring fscanf() return warn (2021-09-16 12:57:32 -0600) are available in the Git repository at: git://git.kernel.org/pub/scm/linux/kernel/git/shuah/linux-kselftest tags/linux-kselftest-fixes-5.15-rc5 for you to fetch changes up to 2f9602870886af74d97bac23ee6db5f5466d0a49: selftests: drivers/dma-buf: Fix implicit declaration warns (2021-09-27 09:52:29 -0600) ---------------------------------------------------------------- linux-kselftest-fixes-5.15-rc5 This Kselftest fixes update for Linux 5.15-rc5 consists of a fix to implicit declaration warns in drivers/dma-buf test. ---------------------------------------------------------------- Shuah Khan (1): selftests: drivers/dma-buf: Fix implicit declaration warns tools/testing/selftests/drivers/dma-buf/udmabuf.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) ----------------------------------------------------------------

3 years, 2 months

2
1
0 0

[PATCH] kunit: fix too small allocation when using suite-only kunit.filter_glob

by Daniel Latypov

When a user filters by a suite and not a test, e.g. $ ./tools/testing/kunit/kunit.py run 'suite_name' it hits this code const int len = strlen(filter_glob); ... parsed->suite_glob = kmalloc(len, GFP_KERNEL); which fails to allocate space for the terminating NULL. Somehow, it seems like we can't easily reproduce this under UML, so the existing `parse_filter_test()` didn't catch this. Fix this by allocating `len + 1` and switch to kzalloc() just to be a bit more defensive. We're only going to run this code once per kernel boot, and it should never be very long. Also update the unit tests to be a bit more cautious. This bug showed up as a NULL pointer dereference here: > KUNIT_EXPECT_STREQ(test, (const char *)filtered.start[0][0]->name, "suite0"); `filtered.start[0][0]` was NULL, and `name` is at offset 0 in the struct, so `...->name` was also NULL. Fixes: 3b29021ddd10 ("kunit: tool: allow filtering test cases via glob") Reported-by: kernel test robot <oliver.sang(a)intel.com> Signed-off-by: Daniel Latypov <dlatypov(a)google.com> --- lib/kunit/executor.c | 2 +- lib/kunit/executor_test.c | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/lib/kunit/executor.c b/lib/kunit/executor.c index bab3ab940acc..1d7fecd33261 100644 --- a/lib/kunit/executor.c +++ b/lib/kunit/executor.c @@ -33,7 +33,7 @@ static void kunit_parse_filter_glob(struct kunit_test_filter *parsed, const char *period = strchr(filter_glob, '.'); if (!period) { - parsed->suite_glob = kmalloc(len, GFP_KERNEL); + parsed->suite_glob = kzalloc(len + 1, GFP_KERNEL); parsed->test_glob = NULL; strcpy(parsed->suite_glob, filter_glob); return; diff --git a/lib/kunit/executor_test.c b/lib/kunit/executor_test.c index e6323f398dfa..7d2b8dc668b1 100644 --- a/lib/kunit/executor_test.c +++ b/lib/kunit/executor_test.c @@ -149,6 +149,7 @@ static void filter_suites_test(struct kunit *test) KUNIT_ASSERT_NOT_ERR_OR_NULL(test, filtered.start); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, filtered.start[0]); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, filtered.start[0][0]); KUNIT_EXPECT_STREQ(test, (const char *)filtered.start[0][0]->name, "suite0"); } base-commit: 3b29021ddd10cfb6b2565c623595bd3b02036f33 -- 2.33.0.800.g4c38ced690-goog

3 years, 2 months

3
2
0 0

[PATCH net-next v2 0/5] MCTP kunit tests

by Jeremy Kerr

This change adds some initial kunit tests for the MCTP core. We'll expand the coverage in a future series, and augment with a few selftests, but this establishes a baseline set of tests for now. Thanks to the kunit folks for the framework! Cheers, Jeremy --- v2: - fix MCTP=m, KUNIT={y,m} breakage - fix mctp test netdev initialisation - strict route reference count checking --- Jeremy Kerr (5): mctp: Add initial test structure and fragmentation test mctp: Add test utils mctp: Add packet rx tests mctp: Add route input to socket tests mctp: Add input reassembly tests net/mctp/Kconfig | 5 + net/mctp/Makefile | 3 + net/mctp/route.c | 5 + net/mctp/test/route-test.c | 544 +++++++++++++++++++++++++++++++++++++ net/mctp/test/utils.c | 67 +++++ net/mctp/test/utils.h | 20 ++ 6 files changed, 644 insertions(+) create mode 100644 net/mctp/test/route-test.c create mode 100644 net/mctp/test/utils.c create mode 100644 net/mctp/test/utils.h -- 2.33.0

3 years, 2 months

2
6
0 0

[PATCH RESEND 2 00/16] Resend bitmap patches

by Yury Norov

Hi Stephen, Can you please take this series into the next tree? It has been already in next-tree for 5.14: https://lore.kernel.org/linux-mmc/YSeduU41Ef568xhS@alley/T/ But it was damaged and we decided to merge it in 5.15 cycle. No changes comparing to 5.14, except for Andy's patch that was already upstreamed and therefore removed from here. The git tree is here: https://github.com/norov/linux/tree/bitmap-20210929 Thanks, Yury Yury Norov (16): bitops: protect find_first_{,zero}_bit properly bitops: move find_bit_*_le functions from le.h to find.h include: move find.h from asm_generic to linux arch: remove GENERIC_FIND_FIRST_BIT entirely lib: add find_first_and_bit() cpumask: use find_first_and_bit() all: replace find_next{,_zero}_bit with find_first{,_zero}_bit where appropriate tools: sync tools/bitmap with mother linux cpumask: replace cpumask_next_* with cpumask_first_* where appropriate include/linux: move for_each_bit() macros from bitops.h to find.h find: micro-optimize for_each_{set,clear}_bit() Replace for_each_*_bit_from() with for_each_*_bit() where appropriate mm/percpu: micro-optimize pcpu_is_populated() bitmap: unify find_bit operations lib: bitmap: add performance test for bitmap_print_to_pagebuf vsprintf: rework bitmap_list_string MAINTAINERS | 4 +- arch/alpha/include/asm/bitops.h | 2 - arch/arc/Kconfig | 1 - arch/arc/include/asm/bitops.h | 1 - arch/arm/include/asm/bitops.h | 1 - arch/arm64/Kconfig | 1 - arch/arm64/include/asm/bitops.h | 1 - arch/csky/include/asm/bitops.h | 1 - arch/h8300/include/asm/bitops.h | 1 - arch/hexagon/include/asm/bitops.h | 1 - arch/ia64/include/asm/bitops.h | 2 - arch/m68k/include/asm/bitops.h | 2 - arch/mips/Kconfig | 1 - arch/mips/include/asm/bitops.h | 1 - arch/openrisc/include/asm/bitops.h | 1 - arch/parisc/include/asm/bitops.h | 2 - arch/powerpc/include/asm/bitops.h | 2 - arch/powerpc/include/asm/cputhreads.h | 2 +- arch/powerpc/platforms/pasemi/dma_lib.c | 4 +- arch/riscv/include/asm/bitops.h | 1 - arch/s390/Kconfig | 1 - arch/s390/include/asm/bitops.h | 1 - arch/s390/kvm/kvm-s390.c | 2 +- arch/sh/include/asm/bitops.h | 1 - arch/sparc/include/asm/bitops_32.h | 1 - arch/sparc/include/asm/bitops_64.h | 2 - arch/x86/Kconfig | 1 - arch/x86/include/asm/bitops.h | 2 - arch/x86/kernel/apic/vector.c | 4 +- arch/x86/um/Kconfig | 1 - arch/xtensa/include/asm/bitops.h | 1 - block/blk-mq.c | 2 +- drivers/block/rnbd/rnbd-clt.c | 2 +- drivers/dma/ti/edma.c | 2 +- drivers/gpu/drm/etnaviv/etnaviv_gpu.c | 4 +- drivers/hwmon/ltc2992.c | 3 +- drivers/iio/adc/ad7124.c | 2 +- drivers/infiniband/hw/irdma/hw.c | 16 +- drivers/media/cec/core/cec-core.c | 2 +- drivers/media/mc/mc-devnode.c | 2 +- drivers/mmc/host/renesas_sdhi_core.c | 2 +- drivers/net/virtio_net.c | 2 +- drivers/pci/controller/dwc/pci-dra7xx.c | 2 +- drivers/scsi/lpfc/lpfc_sli.c | 10 +- drivers/soc/fsl/qbman/bman_portal.c | 2 +- drivers/soc/fsl/qbman/qman_portal.c | 2 +- drivers/soc/ti/k3-ringacc.c | 4 +- drivers/tty/n_tty.c | 2 +- drivers/virt/acrn/ioreq.c | 3 +- fs/f2fs/segment.c | 8 +- fs/ocfs2/cluster/heartbeat.c | 2 +- fs/ocfs2/dlm/dlmdomain.c | 4 +- fs/ocfs2/dlm/dlmmaster.c | 18 +- fs/ocfs2/dlm/dlmrecovery.c | 2 +- fs/ocfs2/dlm/dlmthread.c | 2 +- include/asm-generic/bitops.h | 1 - include/asm-generic/bitops/le.h | 64 --- include/linux/bitmap.h | 34 +- include/linux/bitops.h | 34 -- include/linux/cpumask.h | 46 ++- include/linux/find.h | 372 ++++++++++++++++++ kernel/time/clocksource.c | 4 +- lib/Kconfig | 3 - lib/find_bit.c | 21 + lib/find_bit_benchmark.c | 21 + lib/genalloc.c | 2 +- lib/test_bitmap.c | 37 ++ lib/vsprintf.c | 24 +- mm/percpu.c | 35 +- net/ncsi/ncsi-manage.c | 4 +- tools/include/asm-generic/bitops.h | 1 - tools/include/asm-generic/bitops/find.h | 145 ------- tools/include/linux/bitmap.h | 7 +- .../bitops => tools/include/linux}/find.h | 54 ++- tools/lib/find_bit.c | 20 + 75 files changed, 637 insertions(+), 441 deletions(-) create mode 100644 include/linux/find.h delete mode 100644 tools/include/asm-generic/bitops/find.h rename {include/asm-generic/bitops => tools/include/linux}/find.h (83%) -- 2.30.2

3 years, 2 months

3
22
0 0

[PATCH net-next 0/5] MCTP kunit tests

by Jeremy Kerr

This change adds some initial kunit tests for the MCTP core. We'll expand the coverage in a future series, and augment with a few selftests, but this establishes a baseline set of tests for now. Thanks to the kunit folks for the framework! Cheers, Jeremy --- Jeremy Kerr (5): mctp: Add initial test structure and fragmentation test mctp: Add test utils mctp: Add packet rx tests mctp: Add route input to socket tests mctp: Add input reassembly tests net/mctp/Kconfig | 5 + net/mctp/Makefile | 3 + net/mctp/route.c | 5 + net/mctp/test/route-test.c | 532 +++++++++++++++++++++++++++++++++++++ net/mctp/test/utils.c | 67 +++++ net/mctp/test/utils.h | 20 ++ 6 files changed, 632 insertions(+) create mode 100644 net/mctp/test/route-test.c create mode 100644 net/mctp/test/utils.c create mode 100644 net/mctp/test/utils.h -- 2.33.0

3 years, 2 months

4
10
0 0

[PATCH v11 24/29] selftest/x86/amx: Test cases for the AMX state management

by Chang S. Bae

This selftest verifies that the XSTATE arch_prctl works for AMX state and that a forked task has the AMX state in the INIT-state. In addition, this test verifies that the kernel correctly context switches unique AMX data, when multiple threads are using AMX. The test also verifies that ptrace() can insert data into existing threads. Finally, add a test case to verify that unused states are excluded, by leaving a known pattern on the signal stack and verifying that it is still intact after taking a subsequent signal. These test cases do not depend on AMX compiler support, as they employ userspace-XSAVE directly to access AMX state. Signed-off-by: Chang S. Bae <chang.seok.bae(a)intel.com> Reviewed-by: Len Brown <len.brown(a)intel.com> Cc: linux-kernel(a)vger.kernel.org Cc: linux-kselftest(a)vger.kernel.org --- Changes from v10: * Update the selftest for v11 (e.g. signal delivery changes for XTILECFG state). Changes from v9: * Minor cleanup on the ptrace test code. Changes from v8: * Adjust for the arch_prctl change. * Assure XTILECFG is recovered upon sigreturn. Changes from v7: * Adjust for SIGILL. * Test XTILECFG for legacy signal delivery. Changes from v6: * Adjust for the syscall and ptrace path changes. Changes from v5: * Adjusted arch_prctl for the updated ABI. * Added test for the dynamic signal xstate buffer. * Fixed XSAVE buffer's header data. Changes from v4: * Added test for arch_prctl. * Excluded tile config details to focus on testing the kernel's ability to manage dynamic user state. * Removed tile instructions. * Simplified the fork() and ptrace() test routine. * Massaged the changelog. Changes from v2: * Updated the test messages and the changelog as tile data is not inherited to a child anymore. * Removed bytecode for the instructions already supported by binutils. * Changed to check the XSAVE availability in a reliable way. Changes from v1: * Removed signal testing code --- tools/testing/selftests/x86/Makefile | 2 +- tools/testing/selftests/x86/amx.c | 1048 ++++++++++++++++++++++++++ 2 files changed, 1049 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/x86/amx.c diff --git a/tools/testing/selftests/x86/Makefile b/tools/testing/selftests/x86/Makefile index b4142cd1c5c2..8a1f62ab3c8e 100644 --- a/tools/testing/selftests/x86/Makefile +++ b/tools/testing/selftests/x86/Makefile @@ -18,7 +18,7 @@ TARGETS_C_32BIT_ONLY := entry_from_vm86 test_syscall_vdso unwind_vdso \ test_FCMOV test_FCOMI test_FISTTP \ vdso_restorer TARGETS_C_64BIT_ONLY := fsgsbase sysret_rip syscall_numbering \ - corrupt_xstate_header + corrupt_xstate_header amx # Some selftests require 32bit support enabled also on 64bit systems TARGETS_C_32BIT_NEEDED := ldt_gdt ptrace_syscall diff --git a/tools/testing/selftests/x86/amx.c b/tools/testing/selftests/x86/amx.c new file mode 100644 index 000000000000..ee18697b08ee --- /dev/null +++ b/tools/testing/selftests/x86/amx.c @@ -0,0 +1,1048 @@ +// SPDX-License-Identifier: GPL-2.0 + +#define _GNU_SOURCE +#include <err.h> +#include <errno.h> +#include <elf.h> +#include <pthread.h> +#include <setjmp.h> +#include <stdio.h> +#include <string.h> +#include <stdbool.h> +#include <unistd.h> +#include <x86intrin.h> + +#include <linux/futex.h> + +#include <sys/auxv.h> +#include <sys/mman.h> +#include <sys/ptrace.h> +#include <sys/shm.h> +#include <sys/syscall.h> +#include <sys/wait.h> +#include <sys/uio.h> + +#ifndef __x86_64__ +# error This test is 64-bit only +#endif + +static inline uint64_t xgetbv(uint32_t index) +{ + uint32_t eax, edx; + + asm volatile("xgetbv;" + : "=a" (eax), "=d" (edx) + : "c" (index)); + return eax + ((uint64_t)edx << 32); +} + +static inline void cpuid(uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx) +{ + asm volatile("cpuid;" + : "=a" (*eax), "=b" (*ebx), "=c" (*ecx), "=d" (*edx) + : "0" (*eax), "2" (*ecx)); +} + +static inline void xsave(void *xbuf, uint32_t lo, uint32_t hi) +{ + asm volatile("xsave (%%rdi)" + : : "D" (xbuf), "a" (lo), "d" (hi) + : "memory"); +} + +static inline void xrstor(void *xbuf, uint32_t lo, uint32_t hi) +{ + asm volatile("xrstor (%%rdi)" + : : "D" (xbuf), "a" (lo), "d" (hi)); +} + +static void sethandler(int sig, void (*handler)(int, siginfo_t *, void *), + int flags) +{ + struct sigaction sa; + + memset(&sa, 0, sizeof(sa)); + sa.sa_sigaction = handler; + sa.sa_flags = SA_SIGINFO | flags; + sigemptyset(&sa.sa_mask); + if (sigaction(sig, &sa, 0)) + err(1, "sigaction"); +} + +static void clearhandler(int sig) +{ + struct sigaction sa; + + memset(&sa, 0, sizeof(sa)); + sa.sa_handler = SIG_DFL; + sigemptyset(&sa.sa_mask); + if (sigaction(sig, &sa, 0)) + err(1, "sigaction"); +} + +static jmp_buf jmpbuf; + +/* Hardware info check: */ + +static bool noxsave; + +static void handle_noxsave(int sig, siginfo_t *si, void *ctx_void) +{ + noxsave = true; + siglongjmp(jmpbuf, 1); +} + +#define XFEATURE_XTILECFG 17 +#define XFEATURE_XTILEDATA 18 +#define XFEATURE_MASK_XTILECFG (1 << XFEATURE_XTILECFG) +#define XFEATURE_MASK_XTILEDATA (1 << XFEATURE_XTILEDATA) +#define XFEATURE_MASK_XTILE (XFEATURE_MASK_XTILECFG | XFEATURE_MASK_XTILEDATA) + +static inline bool check_xtile(void) +{ + bool xtile_enable; + + sethandler(SIGILL, handle_noxsave, 0); + + if ((!sigsetjmp(jmpbuf, 1)) && (xgetbv(0) & XFEATURE_MASK_XTILE)) { + xtile_enable = true; + goto out; + } + xtile_enable = false; +out: + clearhandler(SIGILL); + return xtile_enable; +} + +static uint32_t xsave_size; +static uint32_t xsave_xtiledata_offset, xsave_xtilecfg_offset; +static uint32_t xtiledata_size, xtilecfg_size; + +static struct _tile_spec { + uint16_t bytes_per_row; + uint16_t max_names; + uint16_t max_rows; +} tile_spec; + +#define XSTATE_CPUID 0xd +#define XSTATE_USER_STATE_SUBLEAVE 0x0 +#define TILE_CPUID 0x1d +#define TILE_PALETTE_ID 0x1 + +static void check_cpuid(void) +{ + uint32_t eax, ebx, ecx, edx; + + eax = XSTATE_CPUID; + ecx = XSTATE_USER_STATE_SUBLEAVE; + + cpuid(&eax, &ebx, &ecx, &edx); + if (!ebx) + err(1, "xstate cpuid: xsave size"); + + xsave_size = ebx; + + eax = XSTATE_CPUID; + ecx = XFEATURE_XTILECFG; + + cpuid(&eax, &ebx, &ecx, &edx); + if (!eax || !ebx) + err(1, "xstate cpuid: tile config state"); + + xtilecfg_size = eax; + xsave_xtilecfg_offset = ebx; + + eax = XSTATE_CPUID; + ecx = XFEATURE_XTILEDATA; + + cpuid(&eax, &ebx, &ecx, &edx); + if (!eax || !ebx) + err(1, "xstate cpuid: tile data state"); + + xtiledata_size = eax; + xsave_xtiledata_offset = ebx; + + eax = TILE_CPUID; + ecx = TILE_PALETTE_ID; + + cpuid(&eax, &ebx, &ecx, &edx); + if (!eax || !ebx || !ecx) + err(1, "tile cpuid: palette 1"); + + tile_spec.max_names = ebx >> 16; + tile_spec.bytes_per_row = ebx; + tile_spec.max_rows = ecx; +} + +/* The helpers for managing XSAVE buffer and tile states: */ + +void *alloc_xsave_buffer(void) +{ + void *xbuf; + + /* XSAVE buffer should be 64B-aligned. */ + xbuf = aligned_alloc(64, xsave_size); + if (!xbuf) + err(1, "aligned_alloc()"); + return xbuf; +} + +#define XSAVE_HDR_OFFSET 512 +#define XSAVE_HDR_SIZE 64 + +static inline void clear_xstate_header(void *buffer) +{ + memset(buffer + XSAVE_HDR_OFFSET, 0, XSAVE_HDR_SIZE); +} + +static inline uint64_t get_xstatebv(void *buffer) +{ + return *(uint64_t *)(buffer + XSAVE_HDR_OFFSET); +} + +static inline void set_xstatebv(void *buffer, uint64_t bv) +{ + *(uint64_t *)(buffer + XSAVE_HDR_OFFSET) = bv; +} + +static void set_rand_tiledata(void *tiledata) +{ + int *ptr = tiledata; + int data = rand(); + int i; + + for (i = 0; i < xtiledata_size / sizeof(int); i++, ptr++) + *ptr = data; +} + +#define MAX_TILES 16 +#define RESERVED_BYTES 14 + +struct tile_config { + uint8_t palette_id; + uint8_t start_row; + uint8_t reserved[RESERVED_BYTES]; + uint16_t colsb[MAX_TILES]; + uint8_t rows[MAX_TILES]; +}; + +static void set_tilecfg(void *tilecfg) +{ + struct tile_config *cfg = tilecfg; + int i; + + memset(cfg, 0, sizeof(*cfg)); + cfg->palette_id = TILE_PALETTE_ID; + for (i = 0; i < tile_spec.max_names; i++) { + cfg->colsb[i] = tile_spec.bytes_per_row; + cfg->rows[i] = tile_spec.max_rows; + } +} + +static void *xsave_buffer, *tiledata, *tilecfg; +static int nerrs, errs; + +/* See 'struct _fpx_sw_bytes' at sigcontext.h */ +#define SW_BYTES_OFFSET 464 +/* N.B. The struct's field name varies so read from the offset. */ +#define SW_BYTES_BV_OFFSET (SW_BYTES_OFFSET + 8) + +static inline struct _fpx_sw_bytes *get_fpx_sw_bytes(void *buffer) +{ + return (struct _fpx_sw_bytes *)(buffer + SW_BYTES_OFFSET); +} + +static inline uint64_t get_fpx_sw_bytes_xstatebv(void *buffer) +{ + return *(uint64_t *)(buffer + SW_BYTES_BV_OFFSET); +} + +static volatile bool noperm; +static bool check_tilecfg_sigframe; + +static void handle_noperm(int sig, siginfo_t *si, void *ctx_void) +{ + ucontext_t *ctx = (ucontext_t *)ctx_void; + void *xbuf = ctx->uc_mcontext.fpregs; + struct _fpx_sw_bytes *sw_bytes; + + printf("\tAt SIGILL handler,\n"); + + if (si->si_code != ILL_ILLOPC) { + errs++; + printf("[FAIL]\tInvalid signal code (%x).\n", si->si_code); + } else { + printf("[OK]\tValid signal code (ILL_ILLOPC).\n"); + } + + sw_bytes = get_fpx_sw_bytes(xbuf); + if ((sw_bytes->xstate_size < xsave_xtiledata_offset) && + !(get_fpx_sw_bytes_xstatebv(xbuf) & XFEATURE_MASK_XTILEDATA)) { + printf("[OK]\tValid xstate size and mask in the SW data of xstate buffer.\n"); + } else { + errs++; + printf("[FAIL]\tInvalid xstate size and/or mask in the SW data of xstate buf.\n"); + } + + if (check_tilecfg_sigframe) { + if (memcmp(tilecfg, xbuf + xsave_xtilecfg_offset, xtilecfg_size)) { + printf("[OK]\tTILECFG state is not copied.\n"); + } else { + errs++; + printf("[FAIL]\tTILECFG state is copied.\n"); + } + } + + noperm = true; + ctx->uc_mcontext.gregs[REG_RIP] += 3; /* Skip the faulting XRSTOR */ +} + +/* Return true if XRSTOR is successful; otherwise, false. */ +static inline bool xrstor_safe(void *buffer, uint32_t lo, uint32_t hi) +{ + noperm = false; + xrstor(buffer, lo, hi); + return !noperm; +} + +/* arch_prctl test */ + +#define ARCH_SET_STATE_ENABLE 0x1021 +#define ARCH_GET_STATE_ENABLE 0x1022 + +static bool perm_fail_expected; + +static void enable_tiledata(void) +{ + unsigned long bitmask; + long rc; + + rc = syscall(SYS_arch_prctl, ARCH_SET_STATE_ENABLE, XFEATURE_MASK_XTILEDATA); + + if (perm_fail_expected) { + if (rc) { + printf("[OK]\tARCH_SET_STATE_ENABLE failed.\n"); + return; + } + + nerrs++; + printf("[FAIL]\tARCH_SET_STATE_ENABLE succeeded.\n"); + } + } else if (rc) { + goto fail; + } + + rc = syscall(SYS_arch_prctl, ARCH_GET_STATE_ENABLE, &bitmask); + if (rc) { + err(1, "ARCH_GET_STATE_ENABLE"); + } else if (bitmask & XFEATURE_MASK_XTILEDATA) { + printf("\t\tARCH_SET_STATE_ENABLE succeeded.\n"); + return; + } + +fail: + err(1, "ARCH_SET_STATE_ENABLE"); +} + +#define TEST_EXECV_ARG "nested" + +#ifndef AT_MINSIGSTKSZ +# define AT_MINSIGSTKSZ 51 +#endif + +static bool sigaltstack_fail_expected; + +static void setup_altstack(void *addr, unsigned long size) +{ + stack_t ss; + int rc; + + memset(&ss, 0, sizeof(ss)); + ss.ss_size = size; + ss.ss_sp = addr; + + rc = sigaltstack(&ss, NULL); + + if (sigaltstack_fail_expected) { + if (rc) { + printf("[OK]\tsigaltstack() failed.\n"); + } else { + nerrs++; + printf("[FAIL]\tsigaltstack() succeeded.\n"); + } + } else if (rc) { + err(1, "sigaltstack()"); + } +} + +static void test_arch_prctl(int argc, char **argv) +{ + pid_t parent, child, grandchild; + void *altstack; + + parent = fork(); + if (parent < 0) { + err(1, "fork"); + } else if (parent > 0) { + int status; + + wait(&status); + if (!WIFEXITED(status) || WEXITSTATUS(status)) + err(1, "arch_prctl test parent exit"); + return; + } + + printf("[RUN]\tCheck ARCH_SET_STATE_ENABLE around process fork() and sigaltack() test.\n"); + + printf("\tFork a child.\n"); + child = fork(); + if (child < 0) { + err(1, "fork"); + } else if (child > 0) { + int status; + + perm_fail_expected = false; + printf("\tDo ARCH_SET_STATE_ENABLE at parent:\n"); + enable_tiledata(); + + wait(&status); + if (!WIFEXITED(status) || WEXITSTATUS(status)) + err(1, "arch_prctl test child exit"); + _exit(0); + } + + clear_xstate_header(xsave_buffer); + + /* Scribble XTILECFG */ + set_xstatebv(xsave_buffer, XFEATURE_MASK_XTILECFG); + set_tilecfg(xsave_buffer + xsave_xtilecfg_offset); + xrstor(xsave_buffer, -1, -1); + memcpy(tilecfg, xsave_buffer + xsave_xtilecfg_offset, xtilecfg_size); + + set_xstatebv(xsave_buffer, XFEATURE_MASK_XTILEDATA); + set_rand_tiledata(xsave_buffer + xsave_xtiledata_offset); + + printf("\tLoad tile data without ARCH_SET_STATE_ENABLE at child.\n"); + /* + * Test XTILECFG state delivery via signal, when XTILEDATA is not + * permitted. It should be also prevented. + */ + check_tilecfg_sigframe = true; + if (xrstor_safe(xsave_buffer, -1, -1)) { + nerrs++; + printf("[FAIL]\tSucceeded at child.\n"); + } else { + printf("[OK]\tBlocked at child.\n"); + + /* Assure XTILECFG state recovery at sigreturn. */ + printf("\tReturn from signal handler,\n"); + xsave(xsave_buffer, XFEATURE_MASK_XTILECFG, 0); + if (memcmp(tilecfg, xsave_buffer + xsave_xtilecfg_offset, xtilecfg_size)) { + printf("[OK]\tTilecfg is not restored.\n"); + } else { + nerrs++; + printf("[FAIL]\tTilecfg is restored.\n"); + } + } + + printf("\tARCH_SET_STATE_ENABLE failure test at child:\n"); + printf("\t(after sigaltstack() with small size)\n"); + + altstack = mmap(NULL, getauxval(AT_MINSIGSTKSZ) * 2, + PROT_READ | PROT_WRITE, + MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0); + if (altstack == MAP_FAILED) + err(1, "mmap()"); + + sigaltstack_fail_expected = false; + setup_altstack(altstack, getauxval(AT_MINSIGSTKSZ) - 1); + perm_fail_expected = true; + enable_tiledata(); + + printf("\tARCH_SET_STATE_ENABLE again with enough altstack at child:\n"); + sigaltstack_fail_expected = false; + setup_altstack(&altstack, getauxval(AT_MINSIGSTKSZ) + 1); + perm_fail_expected = false; + enable_tiledata(); + + printf("\tsigaltstack() failure test at child:\n"); + printf("\t(with small altstack after ARCH_SET_STATE_ENABLE)\n"); + sigaltstack_fail_expected = true; + setup_altstack(altstack, getauxval(AT_MINSIGSTKSZ) - 1); + + printf("\tLoad tile data with ARCH_SET_STATE_ENABLE at child:\n"); + check_tilecfg_sigframe = false; + if (xrstor_safe(xsave_buffer, -1, -1)) { + printf("[OK]\tSucceeded at child.\n"); + } else { + nerrs++; + printf("[FAIL]\tBlocked at child.\n"); + } + + printf("\tFork a grandchild.\n"); + grandchild = fork(); + if (grandchild < 0) { + err(1, "fork"); + } else if (!grandchild) { + char *args[] = {argv[0], TEST_EXECV_ARG, NULL}; + + printf("\tLoad tile data at grandchild before execv():\n"); + if (xrstor_safe(xsave_buffer, -1, -1)) { + printf("[OK]\tSucceeded at grandchild.\n"); + } else { + nerrs++; + printf("[FAIL]\tBlocked at grandchild.\n"); + } + nerrs += execv(args[0], args); + } else { + int status; + + wait(&status); + if (!WIFEXITED(status) || WEXITSTATUS(status)) + err(1, "fork test grandchild"); + } + _exit(0); +} + +/* Testing tile data inheritance */ + +static void test_fork(void) +{ + pid_t child, grandchild; + + child = fork(); + if (child < 0) { + err(1, "fork"); + } else if (child > 0) { + int status; + + wait(&status); + if (!WIFEXITED(status) || WEXITSTATUS(status)) + err(1, "fork test child"); + return; + } + + printf("[RUN]\tCheck tile data inheritance.\n\tBefore fork(), load tile data -- yes:\n"); + + clear_xstate_header(xsave_buffer); + set_xstatebv(xsave_buffer, XFEATURE_MASK_XTILE); + set_tilecfg(xsave_buffer + xsave_xtilecfg_offset); + set_rand_tiledata(xsave_buffer + xsave_xtiledata_offset); + xrstor_safe(xsave_buffer, -1, -1); + + grandchild = fork(); + if (grandchild < 0) { + err(1, "fork"); + } else if (grandchild > 0) { + int status; + + wait(&status); + if (!WIFEXITED(status) || WEXITSTATUS(status)) + err(1, "fork test grand child"); + _exit(0); + } + + if (xgetbv(1) & XFEATURE_MASK_XTILE) { + nerrs++; + printf("[FAIL]\tIn a child, AMX state is not initialized.\n"); + } else { + printf("[OK]\tIn a child, AMX state is initialized.\n"); + } + _exit(0); +} + +/* Context switching test */ + +#define ITERATIONS 10 +#define NUM_THREADS 5 + +struct futex_info { + int current; + int *futex; + int next; +}; + +static inline void command_wait(struct futex_info *info, int value) +{ + do { + sched_yield(); + } while (syscall(SYS_futex, info->futex, FUTEX_WAIT, value, 0, 0, 0)); +} + +static inline void command_wake(struct futex_info *info, int value) +{ + do { + *info->futex = value; + while (!syscall(SYS_futex, info->futex, FUTEX_WAKE, 1, 0, 0, 0)) + sched_yield(); + } while (0); +} + +static inline int get_iterative_value(int id) +{ + return ((id << 1) & ~0x1); +} + +static inline int get_endpoint_value(int id) +{ + return ((id << 1) | 0x1); +} + +static void *check_tiledata(void *info) +{ + struct futex_info *finfo = (struct futex_info *)info; + void *xbuf, *tdata; + int i; + + xbuf = alloc_xsave_buffer(); + tdata = malloc(xtiledata_size); + if (!tdata) + err(1, "malloc()"); + + set_xstatebv(xbuf, XFEATURE_MASK_XTILEDATA); + set_rand_tiledata(xbuf + xsave_xtiledata_offset); + xrstor_safe(xbuf, -1, -1); + memcpy(tdata, xbuf + xsave_xtiledata_offset, xtiledata_size); + + for (i = 0; i < ITERATIONS; i++) { + command_wait(finfo, get_iterative_value(finfo->current)); + + xsave(xbuf, XFEATURE_MASK_XTILEDATA, 0); + if (memcmp(tdata, xbuf + xsave_xtiledata_offset, xtiledata_size)) + errs++; + + set_rand_tiledata(xbuf + xsave_xtiledata_offset); + xrstor_safe(xbuf, -1, -1); + memcpy(tdata, xbuf + xsave_xtiledata_offset, xtiledata_size); + + command_wake(finfo, get_iterative_value(finfo->next)); + } + + command_wait(finfo, get_endpoint_value(finfo->current)); + + free(xbuf); + free(tdata); + return NULL; +} + +static int create_threads(int num, struct futex_info *finfo) +{ + const int shm_id = shmget(IPC_PRIVATE, sizeof(int), IPC_CREAT | 0666); + int *futex = shmat(shm_id, NULL, 0); + pthread_t thread; + int i; + + for (i = 0; i < num; i++) { + finfo[i].futex = futex; + finfo[i].current = i + 1; + finfo[i].next = (i + 2) % (num + 1); + + if (pthread_create(&thread, NULL, check_tiledata, &finfo[i])) + err(1, "pthread_create()"); + } + return 0; +} + +static void test_context_switch(void) +{ + struct futex_info *finfo; + int i; + + printf("[RUN]\tCheck tile data context switches.\n"); + printf("\t# of context switches -- %u, # of threads -- %d:\n", + ITERATIONS * NUM_THREADS, NUM_THREADS); + + errs = 0; + + finfo = malloc(sizeof(*finfo) * NUM_THREADS); + if (!finfo) + err(1, "malloc()"); + + create_threads(NUM_THREADS, finfo); + + for (i = 0; i < ITERATIONS; i++) { + command_wake(finfo, get_iterative_value(1)); + command_wait(finfo, get_iterative_value(0)); + } + + for (i = 1; i <= NUM_THREADS; i++) + command_wake(finfo, get_endpoint_value(i)); + + if (errs) { + nerrs += errs; + printf("[FAIL]\tIncorrect cases were found -- (%d / %u).\n", + errs, ITERATIONS * NUM_THREADS); + } else { + printf("[OK]\tNo incorrect case was found.\n"); + } + + free(finfo); +} + +/* Ptrace test */ + +static bool ptracee_state_perm; + +static int inject_tiledata(pid_t target) +{ + struct iovec iov; + + iov.iov_base = xsave_buffer; + iov.iov_len = xsave_size; + + clear_xstate_header(xsave_buffer); + set_xstatebv(xsave_buffer, XFEATURE_MASK_XTILEDATA); + set_rand_tiledata(xsave_buffer + xsave_xtiledata_offset); + memcpy(tiledata, xsave_buffer + xsave_xtiledata_offset, xtiledata_size); + + if (ptrace(PTRACE_SETREGSET, target, (uint32_t)NT_X86_XSTATE, &iov)) { + if (errno != EFAULT) + err(1, "PTRACE_SETREGSET"); + else + return errno; + } + + if (ptrace(PTRACE_GETREGSET, target, (uint32_t)NT_X86_XSTATE, &iov)) + err(1, "PTRACE_GETREGSET"); + + if (!memcmp(tiledata, xsave_buffer + xsave_xtiledata_offset, xtiledata_size)) + return 0; + else + return -1; +} + +static void test_tile_write(void) +{ + int status, rc; + pid_t child; + + child = fork(); + if (child < 0) { + err(1, "fork"); + } else if (!child) { + if (ptracee_state_perm) { + printf("\tARCH_SET_STATE_ENABLE at ptracee:\n"); + perm_fail_expected = false; + enable_tiledata(); + } + + if (ptrace(PTRACE_TRACEME, 0, NULL, NULL)) + err(1, "PTRACE_TRACEME"); + + raise(SIGTRAP); + _exit(0); + } + + do { + wait(&status); + } while (WSTOPSIG(status) != SIGTRAP); + + printf("\tInject tile data with%s ARCH_SET_STATE_ENABLE\n", + ptracee_state_perm ? "" : "out"); + + rc = inject_tiledata(child); + if (rc == EFAULT && !ptracee_state_perm) { + printf("[OK]\tTile data was not written on ptracee.\n"); + } else if (!rc && ptracee_state_perm) { + printf("[OK]\tTile data was written on ptracee.\n"); + } else { + nerrs++; + printf("[FAIL]\tTile data was %swritten on ptracee.\n", + rc ? "not " : ""); + } + + ptrace(PTRACE_DETACH, child, NULL, NULL); + wait(&status); + if (!WIFEXITED(status) || WEXITSTATUS(status)) + err(1, "ptrace test"); +} + +static void test_ptrace(void) +{ + printf("[RUN]\tCheck ptrace() to inject tile data.\n"); + + ptracee_state_perm = false; + test_tile_write(); + + ptracee_state_perm = true; + test_tile_write(); +} + +/* Signal handling test */ + +static bool init_tiledata, load_tiledata; +static volatile bool signaled, sigstk_prefill; + +#define SIGFRAME_TILEDATA_SIGNATURE 0xEE + +static void handle_sigstk_prefill(int sig, siginfo_t *info, void *ctx_void) +{ + void *xbuf = ((ucontext_t *)ctx_void)->uc_mcontext.fpregs; + struct _fpx_sw_bytes *sw_bytes = get_fpx_sw_bytes(xsave); + + if (sw_bytes->xstate_size >= (xsave_xtiledata_offset + xtiledata_size)) { + memset(xbuf + xsave_xtiledata_offset, SIGFRAME_TILEDATA_SIGNATURE, + xtiledata_size); + } + + sigstk_prefill = true; +} + +static void handle_signal(int sig, siginfo_t *info, void *ctx_void) +{ + bool tiledata_area, tiledata_bit, tiledata_inuse; + void *xbuf = ((ucontext_t *)ctx_void)->uc_mcontext.fpregs; + struct _fpx_sw_bytes *sw_bytes = get_fpx_sw_bytes(xbuf); + char d = SIGFRAME_TILEDATA_SIGNATURE; + int i; + + printf("\tAt signal delivery,\n"); + + /* Check SW reserved data in the buffer: */ + if ((sw_bytes->xstate_size >= (xsave_xtiledata_offset + xtiledata_size)) && + (get_fpx_sw_bytes_xstatebv(xbuf) & XFEATURE_MASK_XTILEDATA)) { + printf("[OK]\tValid xstate size and mask in the SW data of xstate buffer\n"); + } else { + errs++; + printf("[FAIL]\tInvalid xstate size and/or mask in the SW data of xstate buffer\n"); + } + + /* Check XSAVE buffer header: */ + tiledata_inuse = (load_tiledata && !init_tiledata); + tiledata_bit = get_xstatebv(xbuf) & XFEATURE_MASK_XTILEDATA; + + if (tiledata_bit == tiledata_inuse) { + printf("[OK]\tTiledata bit is %sset in XSTATE_BV of xstate buffer.\n", + tiledata_bit ? "" : "not "); + } else { + errs++; + printf("[FAIL]\tTiledata bit is %sset in XSTATE_BV of xstate buffer.\n", + tiledata_bit ? "" : "not "); + } + + /* + * Check the sigframe data: + */ + + tiledata_inuse = (load_tiledata && !init_tiledata); + tiledata_area = false; + if (sw_bytes->xstate_size >= (xsave_xtiledata_offset + xtiledata_size)) { + for (i = 0; i < xtiledata_size; i++) { + if (memcmp(xbuf + xsave_xtiledata_offset + i, &d, 1)) { + tiledata_area = true; + break; + } + } + } + + if (tiledata_area == tiledata_inuse) { + printf("[OK]\tTiledata is %ssaved in signal buffer.\n", + tiledata_area ? "" : "not "); + } else { + errs++; + printf("[FAIL]\tTiledata is %ssaved in signal buffer.\n", + tiledata_area ? "" : "not "); + } + + /* Load random tiledata to test sigreturn: */ + clear_xstate_header(xsave_buffer); + set_xstatebv(xsave_buffer, XFEATURE_MASK_XTILEDATA); + set_rand_tiledata(xsave_buffer + xsave_xtiledata_offset); + xrstor_safe(xsave_buffer, -1, -1); + signaled = true; +} + +static void test_signal_handling(void) +{ + pid_t child; + + signaled = false; + sigstk_prefill = false; + + child = fork(); + if (child < 0) { + err(1, "fork"); + } else if (child > 0) { + do { + int status; + + wait(&status); + if (WIFSTOPPED(status)) + kill(child, SIGCONT); + else if (!WIFEXITED(status) || WEXITSTATUS(status)) + err(1, "signal test child"); + else + break; + } while (1); + return; + } + + printf("\tBefore signal, load tile data -- %s", load_tiledata ? "yes, " : "no:\n"); + if (load_tiledata) + printf("re-initialized -- %s:\n", init_tiledata ? "yes" : "no"); + + /* + * Raise SIGUSR1 to pre-fill sig stack. Also, load tiledata to size the pre-fill. + */ + + if (load_tiledata) { + clear_xstate_header(xsave_buffer); + set_xstatebv(xsave_buffer, XFEATURE_MASK_XTILEDATA); + xrstor_safe(xsave_buffer, -1, -1); + } + + raise(SIGUSR1); + if (!sigstk_prefill) + err(1, "SIGUSR1"); + + /* + * Raise SIGALRM to test AMX state handling in signal delivery. Set up the state and + * data before the test. + */ + + if (load_tiledata) { + clear_xstate_header(xsave_buffer); + set_xstatebv(xsave_buffer, XFEATURE_MASK_XTILEDATA); + set_rand_tiledata(xsave_buffer + xsave_xtiledata_offset); + xrstor_safe(xsave_buffer, -1, -1); + + if (init_tiledata) { + clear_xstate_header(xsave_buffer); + set_xstatebv(xsave_buffer, 0); + xrstor_safe(xsave_buffer, -1, -1); + memset(tiledata, 0, xtiledata_size); + } else { + memcpy(tiledata, xsave_buffer + xsave_xtiledata_offset, + xtiledata_size); + } + } else { + memset(tiledata, 0, xtiledata_size); + } + + raise(SIGALRM); + if (!signaled) + err(1, "SIGALRM"); + + printf("\tReturn from signal handler,\n"); + xsave(xsave_buffer, XFEATURE_MASK_XTILEDATA, 0); + if (memcmp(tiledata, xsave_buffer + xsave_xtiledata_offset, xtiledata_size)) { + errs++; + printf("[FAIL]\tTiledata is not restored.\n"); + } else { + printf("[OK]\tTiledata is restored.\n"); + } + + if (errs) + nerrs++; + _exit(0); +} + +static void test_signal(void) +{ + printf("[RUN]\tCheck tile data state in signal path:\n"); + + sethandler(SIGALRM, handle_signal, 0); + sethandler(SIGUSR1, handle_sigstk_prefill, 0); + + load_tiledata = false; + init_tiledata = false; + errs = 0; + test_signal_handling(); + + load_tiledata = true; + init_tiledata = false; + errs = 0; + test_signal_handling(); + + load_tiledata = true; + init_tiledata = true; + errs = 0; + test_signal_handling(); + + clearhandler(SIGALRM); + clearhandler(SIGUSR1); +} + +int main(int argc, char **argv) +{ + cpu_set_t cpuset; + + if (argc == 2) { + int ret; + + if (strcmp(argv[1], TEST_EXECV_ARG)) + return 0; + + check_cpuid(); + + printf("\tLoad tile data after execv().\n"); + + xsave_buffer = alloc_xsave_buffer(); + clear_xstate_header(xsave_buffer); + + set_xstatebv(xsave_buffer, XFEATURE_MASK_XTILE); + set_rand_tiledata(xsave_buffer + xsave_xtiledata_offset); + + sethandler(SIGILL, handle_noperm, 0); + + if (xrstor_safe(xsave_buffer, -1, -1)) { + printf("[FAIL]\tSucceeded after execv().\n"); + ret = 1; + } else { + printf("[OK]\tBlocked after execv().\n"); + ret = 0; + } + + clearhandler(SIGILL); + free(xsave_buffer); + _exit(ret); + } + + /* Check hardware availability at first */ + + if (!check_xtile()) { + printf("%s is disabled.\n", noxsave ? "XSAVE" : "AMX"); + return 0; + } + + check_cpuid(); + + xsave_buffer = alloc_xsave_buffer(); + clear_xstate_header(xsave_buffer); + + tiledata = malloc(xtiledata_size); + if (!tiledata) + err(1, "malloc()"); + + tilecfg = malloc(xtilecfg_size); + if (!tilecfg) + err(1, "malloc()"); + set_tilecfg(tilecfg); + + nerrs = 0; + + sethandler(SIGILL, handle_noperm, 0); + + CPU_ZERO(&cpuset); + CPU_SET(0, &cpuset); + + if (sched_setaffinity(0, sizeof(cpuset), &cpuset) != 0) + err(1, "sched_setaffinity to CPU 0"); + + test_arch_prctl(argc, argv); + test_ptrace(); + + perm_fail_expected = false; + printf("\tARCH_SET_STATE_ENABLE for the following tests:\n"); + enable_tiledata(); + test_context_switch(); + test_fork(); + test_signal(); + + clearhandler(SIGILL); + + free(tilecfg); + free(tiledata); + free(xsave_buffer); + return nerrs ? 1 : 0; +} -- 2.17.1

3 years, 2 months

1
0
0 0

[PATCH v2] kunit: fix reference count leak in kfree_at_end

by Xiyu Yang

The reference counting issue happens in the normal path of kfree_at_end(). When kunit_alloc_and_get_resource() is invoked, the function forgets to handle the returned resource object, whose refcount increased inside, causing a refcount leak. Fix this issue by calling kunit_alloc_resource() instead of kunit_alloc_and_get_resource(). Signed-off-by: Xiyu Yang <xiyuyang19(a)fudan.edu.cn> Signed-off-by: Xin Tan <tanxin.ctf(a)gmail.com> --- lib/kunit/executor_test.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/kunit/executor_test.c b/lib/kunit/executor_test.c index cdbe54b16501..c2dcfb1f6e97 100644 --- a/lib/kunit/executor_test.c +++ b/lib/kunit/executor_test.c @@ -116,7 +116,7 @@ static void kfree_at_end(struct kunit *test, const void *to_free) /* kfree() handles NULL already, but avoid allocating a no-op cleanup. */ if (IS_ERR_OR_NULL(to_free)) return; - kunit_alloc_and_get_resource(test, NULL, kfree_res_free, GFP_KERNEL, + kunit_alloc_resource(test, NULL, kfree_res_free, GFP_KERNEL, (void *)to_free); } -- 2.7.4

3 years, 2 months

4
4
0 0

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror October 2021