- Linux-kselftest-mirror - lists.linaro.org

next-20250804 Unable to handle kernel execute from non-executable memory at virtual address idem_hash

by Naresh Kamboju

While booting and testing selftest cgroups and filesystem testing on arm64 dragonboard-410c the following kernel warnings / errors noticed and system halted and did not recover with selftests Kconfig enabled running the kernel Linux next tag next-20250804. Regression Analysis: - New regression? Yes - Reproducibility? Re-validation is in progress First seen on the next-20250804 Good: next-20250801 Bad: next-20250804 Test regression: next-20250804 Unable to handle kernel execute from non-executable memory at virtual address idem_hash Test regression: next-20250804 refcount_t: addition on 0; use-after-free refcount_warn_saturate Reported-by: Linux Kernel Functional Testing <lkft(a)linaro.org> ## Test crash log [ 9.811341] Unable to handle kernel NULL pointer dereference at virtual address 000000000000002e [ 9.811444] Mem abort info: [ 9.821150] ESR = 0x0000000096000004 [ 9.833499] SET = 0, FnV = 0 [ 9.833566] EA = 0, S1PTW = 0 [ 9.835511] FSC = 0x04: level 0 translation fault [ 9.838901] Data abort info: [ 9.843788] ISV = 0, ISS = 0x00000004, ISS2 = 0x00000000 [ 9.846565] CM = 0, WnR = 0, TnD = 0, TagAccess = 0 [ 9.851938] GCS = 0, Overlay = 0, DirtyBit = 0, Xs = 0 [ 9.853510] rtc-pm8xxx 200f000.spmi:pmic@0:rtc@6000: registered as rtc0 [ 9.856992] user pgtable: 4k pages, 48-bit VAs, pgdp=00000000856f8000 [ 9.862446] rtc-pm8xxx 200f000.spmi:pmic@0:rtc@6000: setting system clock to 1970-01-01T00:00:31 UTC (31) [ 9.868789] [000000000000002e] pgd=0000000000000000, p4d=0000000000000000 [ 9.875459] Internal error: Oops: 0000000096000004 [#1] SMP [ 9.889547] input: pm8941_pwrkey as /devices/platform/soc@0/200f000.spmi/spmi-0/0-00/200f000.spmi:pmic@0:pon@800/200f000.spmi:pmic@0:pon@800:pwrkey/input/input1 [ 9.891545] Modules linked in: qcom_spmi_temp_alarm rtc_pm8xxx qcom_pon(+) qcom_pil_info videobuf2_dma_sg ubwc_config qcom_q6v5 venus_core(+) qcom_sysmon qcom_spmi_vadc v4l2_fwnode llcc_qcom v4l2_async qcom_vadc_common qcom_common ocmem v4l2_mem2mem drm_gpuvm videobuf2_memops qcom_glink_smem videobuf2_v4l2 drm_exec mdt_loader qmi_helpers gpu_sched drm_dp_aux_bus qnoc_msm8916 videodev drm_display_helper qcom_stats videobuf2_common cec qcom_rng drm_client_lib mc phy_qcom_usb_hs socinfo rpmsg_ctrl display_connector rpmsg_char ramoops rmtfs_mem reed_solomon drm_kms_helper fuse drm backlight [ 9.912286] input: pm8941_resin as /devices/platform/soc@0/200f000.spmi/spmi-0/0-00/200f000.spmi:pmic@0:pon@800/200f000.spmi:pmic@0:pon@800:resin/input/input2 [ 9.941186] CPU: 2 UID: 0 PID: 221 Comm: (udev-worker) Not tainted 6.16.0-next-20250804 #1 PREEMPT [ 9.941200] Hardware name: Qualcomm Technologies, Inc. APQ 8016 SBC (DT) [ 9.941206] pstate: 60000005 (nZCv daif -PAN -UAO -TCO -DIT -SSBS BTYPE=--) [ 9.941215] pc : dev_pm_opp_put (/builds/linux/drivers/opp/core.c:1685) [ 9.941233] lr : core_clks_enable+0x54/0x148 venus_core [ 10.004266] sp : ffff8000842b35f0 [ 10.004273] x29: ffff8000842b35f0 x28: ffff8000842b3ba0 x27: ffff0000047be938 [ 10.004289] x26: 0000000000000000 x25: 0000000000000000 x24: ffff80007b350ba0 [ 10.004303] x23: ffff00000ba380c8 x22: ffff00000ba38080 x21: 0000000000000000 [ 10.004316] x20: 0000000000000000 x19: ffffffffffffffee x18: 00000000ffffffff [ 10.004330] x17: 0000000000000000 x16: 1fffe000017541a1 x15: ffff8000842b3560 [ 10.004344] x14: 0000000000000000 x13: 007473696c5f7974 x12: 696e696666615f65 [ 10.004358] x11: 00000000000000c0 x10: 0000000000000020 x9 : ffff80007b33f2bc [ 10.004371] x8 : ffffffffffffffde x7 : ffff0000044a4800 x6 : 0000000000000000 [ 10.004384] x5 : 0000000000000002 x4 : 00000000c0000000 x3 : 0000000000000001 [ 10.004397] x2 : 0000000000000002 x1 : ffffffffffffffde x0 : ffffffffffffffee [ 10.004412] Call trace: [ 10.004417] dev_pm_opp_put (/builds/linux/drivers/opp/core.c:1685) (P) [ 10.004435] core_clks_enable+0x54/0x148 venus_core [ 10.004504] core_power_v1+0x78/0x90 venus_core [ 10.004560] venus_runtime_resume+0x6c/0x98 venus_core [ 10.004616] pm_generic_runtime_resume (/builds/linux/drivers/base/power/generic_ops.c:47) [ 10.004630] __genpd_runtime_resume (/builds/linux/drivers/pmdomain/core.c:1203) [ 10.004645] genpd_runtime_resume (/builds/linux/drivers/pmdomain/core.c:1329) [ 10.004656] __rpm_callback (/builds/linux/drivers/base/power/runtime.c:406) [ 10.004668] rpm_callback (/builds/linux/drivers/base/power/runtime.c:460) [ 10.004680] rpm_resume (/builds/linux/drivers/base/power/runtime.c:934) [ 10.004692] __pm_runtime_resume (/builds/linux/drivers/base/power/runtime.c:1192) [ 10.004704] venus_probe+0x2d8/0x588 venus_core [ 10.004761] platform_probe (/builds/linux/drivers/base/platform.c:1408 (discriminator 1)) [ 10.004776] really_probe (/builds/linux/drivers/base/dd.c:581 /builds/linux/drivers/base/dd.c:659) [ 10.004788] __driver_probe_device (/builds/linux/drivers/base/dd.c:801) [ 10.004800] driver_probe_device (/builds/linux/drivers/base/dd.c:831) [ 10.004812] __driver_attach (/builds/linux/drivers/base/dd.c:1218 /builds/linux/drivers/base/dd.c:1157) [ 10.004824] bus_for_each_dev (/builds/linux/drivers/base/bus.c:370) [ 10.004835] driver_attach (/builds/linux/drivers/base/dd.c:1236) [ 10.004847] bus_add_driver (/builds/linux/drivers/base/bus.c:678) [ 10.004859] driver_register (/builds/linux/drivers/base/driver.c:249) [ 10.004871] __platform_driver_register (/builds/linux/drivers/base/platform.c:868) [ 10.004885] qcom_venus_driver_init+0x28/0xfb8 venus_core [ 10.004942] do_one_initcall (/builds/linux/init/main.c:1269) [ 10.004954] do_init_module (/builds/linux/kernel/module/main.c:3039) [ 10.004967] load_module (/builds/linux/kernel/module/main.c:3509) [ 10.004979] init_module_from_file (/builds/linux/kernel/module/main.c:3702) [ 10.004991] __arm64_sys_finit_module (/builds/linux/kernel/module/main.c:3713 /builds/linux/kernel/module/main.c:3739 /builds/linux/kernel/module/main.c:3723 /builds/linux/kernel/module/main.c:3723) [ 10.005004] invoke_syscall (/builds/linux/arch/arm64/include/asm/current.h:19 /builds/linux/arch/arm64/kernel/syscall.c:54) [ 10.005014] el0_svc_common.constprop.0 (/builds/linux/arch/arm64/kernel/syscall.c:139) [ 10.005023] do_el0_svc (/builds/linux/arch/arm64/kernel/syscall.c:152) [ 10.005032] el0_svc (/builds/linux/arch/arm64/include/asm/irqflags.h:82 (discriminator 1) /builds/linux/arch/arm64/include/asm/irqflags.h:123 (discriminator 1) /builds/linux/arch/arm64/include/asm/irqflags.h:136 (discriminator 1) /builds/linux/arch/arm64/kernel/entry-common.c:169 (discriminator 1) /builds/linux/arch/arm64/kernel/entry-common.c:182 (discriminator 1) /builds/linux/arch/arm64/kernel/entry-common.c:880 (discriminator 1)) [ 10.005045] el0t_64_sync_handler (/builds/linux/arch/arm64/kernel/entry-common.c:899) [ 10.005058] el0t_64_sync (/builds/linux/arch/arm64/kernel/entry.S:596) [ 10.005073] Code: 910003fd f9000bf3 91004013 aa1303e0 (f9402821) All code ======== 0: 910003fd mov x29, sp 4: f9000bf3 str x19, [sp, #16] 8: 91004013 add x19, x0, #0x10 c: aa1303e0 mov x0, x19 10:* f9402821 ldr x1, [x1, #80] <-- trapping instruction Code starting with the faulting instruction =========================================== 0: f9402821 ldr x1, [x1, #80] [ 10.005082] ---[ end trace 0000000000000000 ]--- [ 10.089433] systemd-journald[147]: Time jumped backwards, rotating. ## Test cgroup crash log selftests: cgroup: test_cpu ok 1 test_cpucg_subtree_control ok 2 test_cpucg_stats ok 3 test_cpucg_nice not ok 4 test_cpucg_weight_overprovisioned not ok 5 test_cpucg_weight_underprovisioned ok 6 test_cpucg_nested_weight_overprovisioned [ 60.273474] Unable to handle kernel execute from non-executable memory at virtual address ffff800082f89d50 [ 60.273547] Mem abort info: [ 60.282111] ESR = 0x000000008600000e [ 60.284730] EC = 0x21: IABT (current EL), IL = 32 bits [ 60.288616] SET = 0, FnV = 0 [ 60.294041] EA = 0, S1PTW = 0 [ 60.296880] FSC = 0x0e: level 2 permission fault [ 60.299953] swapper pgtable: 4k pages, 48-bit VAs, pgdp=0000000082485000 [ 60.304828] [ffff800082f89d50] pgd=0000000000000000, p4d=100000008300c003, pud=100000008300d003, pmd=0068000082e00701 [ 60.311682] Internal error: Oops: 000000008600000e [#2] SMP [ 60.322146] Modules linked in: pm8916_wdt qcom_wcnss_pil snd_soc_lpass_apq8016 snd_soc_msm8916_analog snd_soc_lpass_cpu snd_soc_apq8016_sbc snd_soc_msm8916_digital snd_soc_lpass_platform snd_soc_qcom_common coresight_cpu_debug snd_soc_core coresight_tmc coresight_replicator snd_compress coresight_funnel snd_pcm_dmaengine coresight_stm stm_core coresight_cti coresight_tpiu snd_pcm coresight snd_timer qrtr msm snd adv7511 qcom_camss qcom_q6v5_mss soundcore qcom_spmi_temp_alarm rtc_pm8xxx qcom_pon qcom_pil_info videobuf2_dma_sg ubwc_config qcom_q6v5 venus_core(+) qcom_sysmon qcom_spmi_vadc v4l2_fwnode llcc_qcom v4l2_async qcom_vadc_common qcom_common ocmem v4l2_mem2mem drm_gpuvm videobuf2_memops qcom_glink_smem videobuf2_v4l2 drm_exec mdt_loader qmi_helpers gpu_sched drm_dp_aux_bus qnoc_msm8916 videodev drm_display_helper qcom_stats videobuf2_common cec qcom_rng drm_client_lib mc phy_qcom_usb_hs socinfo rpmsg_ctrl display_connector rpmsg_char ramoops rmtfs_mem reed_solomon drm_kms_helper fuse drm backlight [ 60.394361] CPU: 3 UID: 0 PID: 252 Comm: kworker/u16:7 Tainted: G D 6.16.0-next-20250804 #1 PREEMPT [ 60.416518] Tainted: [D]=DIE [ 60.427172] Hardware name: Qualcomm Technologies, Inc. APQ 8016 SBC (DT) [ 60.430139] Workqueue: 0x0 (async) [ 60.436813] pstate: 60000005 (nZCv daif -PAN -UAO -TCO -DIT -SSBS BTYPE=--) [ 60.440027] pc : idem_hash+0x58/0x800 [ 60.446967] lr : idem_hash+0x58/0x800 [ 60.450785] sp : ffff8000842b3dd0 [ 60.454429] x29: ffff8000842b3dd0 x28: 0000000000000000 x27: 0000000000000000 [ 60.457737] x26: 0000000000000000 x25: ffff000010127880 x24: ffff000010127840 [ 60.464856] x23: ffff8000828cf000 x22: 61c8864680b583eb x21: ffff000003418c28 [ 60.471973] x20: ffff0000044a4800 x19: ffff0000044a4800 x18: 0000000000000000 [ 60.479090] x17: ffff7fffbd4dd000 x16: ffff800080018000 x15: 0000000000000000 [ 60.486208] x14: 0000000000000000 x13: 0000000000000000 x12: 0000000000000000 [ 60.493327] x11: 00000000000000c0 x10: 0000000000000b50 x9 : ffff80008163543c [ 60.500444] x8 : ffff8000842b3bd8 x7 : 0000000000000001 x6 : ffff8000828ab000 [ 60.507563] x5 : ffff0000044a4800 x4 : ffff8000828ab3e0 x3 : 0000000000000000 [ 60.514680] x2 : 0000000000000000 x1 : 0000000000000000 x0 : ffff0000044a4800 [ 60.521800] Call trace: [ 60.528909] idem_hash+0x58/0x800 (P) [ 60.531168] worker_thread (/builds/linux/kernel/workqueue.c:3353) [ 60.534987] kthread (/builds/linux/kernel/kthread.c:463) [ 60.538631] ret_from_fork (/builds/linux/arch/arm64/kernel/entry.S:861) [ 60.542023] Code: 00000000 00000000 00000000 00000000 (842b3d70) All code ======== ... 10: 842b3d70 .inst 0x842b3d70 ; undefined Code starting with the faulting instruction =========================================== 0: 842b3d70 .inst 0x842b3d70 ; undefined [ 60.545587] ---[ end trace 0000000000000000 ]--- [ 60.561661] note: kworker/u16:7[252] exited with preempt_count 1 ok 7 test_cpucg_nested_weight_underprovisioned # not ok 2 selftests: cgroup: test_cpu TIMEOUT 45 seconds ## Test filesystems crash log selftests: filesystems: file_stressor TAP version 13 1..1 Starting 1 tests from 1 test cases. RUN file_stressor.slab_typesafe_by_rcu ... [ 316.785677] ------------[ cut here ]------------ [ 316.785733] refcount_t: addition on 0; use-after-free. [ 316.789429] WARNING: lib/refcount.c:25 at refcount_warn_saturate+0x120/0x148, CPU#0: 5/88 [ 316.794336] Modules linked in: pm8916_wdt qcom_wcnss_pil snd_soc_lpass_apq8016 snd_soc_msm8916_analog snd_soc_lpass_cpu snd_soc_apq8016_sbc snd_soc_msm8916_digital snd_soc_lpass_platform snd_soc_qcom_common coresight_cpu_debug snd_soc_core coresight_tmc coresight_replicator snd_compress coresight_funnel snd_pcm_dmaengine coresight_stm stm_core coresight_cti coresight_tpiu snd_pcm coresight snd_timer qrtr msm snd adv7511 qcom_camss qcom_q6v5_mss soundcore qcom_spmi_temp_alarm rtc_pm8xxx qcom_pon qcom_pil_info videobuf2_dma_sg ubwc_config qcom_q6v5 venus_core(+) qcom_sysmon qcom_spmi_vadc v4l2_fwnode llcc_qcom v4l2_async qcom_vadc_common qcom_common ocmem v4l2_mem2mem drm_gpuvm videobuf2_memops qcom_glink_smem videobuf2_v4l2 drm_exec mdt_loader qmi_helpers gpu_sched drm_dp_aux_bus qnoc_msm8916 videodev drm_display_helper qcom_stats videobuf2_common cec qcom_rng drm_client_lib mc phy_qcom_usb_hs socinfo rpmsg_ctrl display_connector rpmsg_char ramoops rmtfs_mem reed_solomon drm_kms_helper fuse drm backlight [ 316.870196] CPU: 0 UID: 0 PID: 88 Comm: kworker/u16:5 Tainted: G D 6.16.0-next-20250804 #1 PREEMPT [ 316.892345] Tainted: [D]=DIE [ 316.903000] Hardware name: Qualcomm Technologies, Inc. APQ 8016 SBC (DT) [ 316.905873] Workqueue: events_unbound idle_cull_fn [ 316.912553] pstate: 600000c5 (nZCv daIF -PAN -UAO -TCO -DIT -SSBS BTYPE=--) [ 316.917156] pc : refcount_warn_saturate (/builds/linux/lib/refcount.c:25 (discriminator 1)) [ 316.924010] lr : refcount_warn_saturate (/builds/linux/lib/refcount.c:25 (discriminator 1)) [ 316.928870] sp : ffff8000839dbd10 [ 316.933727] x29: ffff8000839dbd10 x28: 0000000000000000 x27: 0000000000000000 [ 316.937208] x26: ffff000003418c28 x25: 0000000000000000 x24: ffff000003418c78 [ 316.944327] x23: 00000000000124f8 x22: ffff8000828a8000 x21: ffff8000839dbd38 [ 316.951444] x20: ffff8000828cf108 x19: ffff000003418c00 x18: 0000000000000006 [ 316.958563] x17: 0000000000000000 x16: 0000000000000000 x15: 0765076507720766 [ 316.965680] x14: 072d077207650774 x13: 0765076507720766 x12: 072d077207650774 [ 316.972799] x11: 0720072007200720 x10: ffff800082931cc0 x9 : ffff8000801ce594 [ 316.979918] x8 : 00000000ffffefff x7 : ffff800082931cc0 x6 : 80000000fffff000 [ 316.987035] x5 : 0000000000000566 x4 : 0000000000000000 x3 : 0000000000000027 [ 316.994153] x2 : 0000000000000000 x1 : 0000000000000000 x0 : ffff0000059e0000 [ 317.001272] Call trace: [ 317.008380] refcount_warn_saturate (/builds/linux/lib/refcount.c:25 (discriminator 1)) (P) [ 317.010642] set_worker_dying (/builds/linux/include/linux/refcount.h:289 /builds/linux/include/linux/refcount.h:366 /builds/linux/include/linux/refcount.h:383 /builds/linux/include/linux/sched/task.h:116 /builds/linux/kernel/workqueue.c:2895) [ 317.015500] idle_cull_fn (/builds/linux/kernel/workqueue.c:962 /builds/linux/kernel/workqueue.c:2961) [ 317.019666] process_one_work (/builds/linux/kernel/workqueue.c:3241) [ 317.023225] worker_thread (/builds/linux/kernel/workqueue.c:3313 (discriminator 2) /builds/linux/kernel/workqueue.c:3400 (discriminator 2)) [ 317.027217] kthread (/builds/linux/kernel/kthread.c:463) [ 317.030862] ret_from_fork (/builds/linux/arch/arm64/kernel/entry.S:861) [ 317.034249] ---[ end trace 0000000000000000 ]--- [ 317.047081] ------------[ cut here ]------------ [ 317.047142] refcount_t: saturated; leaking memory. [ 317.051602] WARNING: lib/refcount.c:22 at refcount_warn_saturate+0x74/0x148, CPU#0: 5/88 [ 317.055397] Modules linked in: pm8916_wdt qcom_wcnss_pil snd_soc_lpass_apq8016 snd_soc_msm8916_analog snd_soc_lpass_cpu snd_soc_apq8016_sbc snd_soc_msm8916_digital snd_soc_lpass_platform snd_soc_qcom_common coresight_cpu_debug snd_soc_core coresight_tmc coresight_replicator snd_compress coresight_funnel snd_pcm_dmaengine coresight_stm stm_core coresight_cti coresight_tpiu snd_pcm coresight snd_timer qrtr msm snd adv7511 qcom_camss qcom_q6v5_mss soundcore qcom_spmi_temp_alarm rtc_pm8xxx qcom_pon qcom_pil_info videobuf2_dma_sg ubwc_config qcom_q6v5 venus_core(+) qcom_sysmon qcom_spmi_vadc v4l2_fwnode llcc_qcom v4l2_async qcom_vadc_common qcom_common ocmem v4l2_mem2mem drm_gpuvm videobuf2_memops qcom_glink_smem videobuf2_v4l2 drm_exec mdt_loader qmi_helpers gpu_sched drm_dp_aux_bus qnoc_msm8916 videodev drm_display_helper qcom_stats videobuf2_common cec qcom_rng drm_client_lib mc phy_qcom_usb_hs socinfo rpmsg_ctrl display_connector rpmsg_char ramoops rmtfs_mem reed_solomon drm_kms_helper fuse drm backlight [ 317.131166] CPU: 0 UID: 0 PID: 88 Comm: kworker/u16:5 Tainted: G D W 6.16.0-next-20250804 #1 PREEMPT [ 317.153317] Tainted: [D]=DIE, [W]=WARN [ 317.163972] Hardware name: Qualcomm Technologies, Inc. APQ 8016 SBC (DT) [ 317.167536] Workqueue: events_unbound idle_cull_fn [ 317.174392] pstate: 60000005 (nZCv daif -PAN -UAO -TCO -DIT -SSBS BTYPE=--) [ 317.178993] pc : refcount_warn_saturate (/builds/linux/lib/refcount.c:22 (discriminator 1)) [ 317.185848] lr : refcount_warn_saturate (/builds/linux/lib/refcount.c:22 (discriminator 1)) [ 317.190708] sp : ffff8000839dbcd0 [ 317.195478] x29: ffff8000839dbcd0 x28: 0000000000000000 x27: 0000000000000000 [ 317.198871] x26: ffff000003418c28 x25: 0000000000000000 x24: ffff000003418c78 [ 317.205990] x23: dead000000000122 x22: dead000000000100 x21: ffff8000839dbd38 [ 317.213109] x20: ffff0000044a4828 x19: ffff0000044a4800 x18: 0000000000000000 [ 317.220226] x17: 0000000000000000 x16: 0000000000000000 x15: 0000000000000000 [ 317.227345] x14: 0000000000000000 x13: 0000000000000000 x12: 0000000000000000 [ 317.234463] x11: 00000000000000c0 x10: 0000000000000b50 x9 : ffff80008163543c [ 317.241581] x8 : ffff8000839db9e8 x7 : 0000000000000001 x6 : 0000000000000001 [ 317.248699] x5 : ffff8000828ab000 x4 : ffff8000828ab3e0 x3 : 0000000000000000 [ 317.255817] x2 : 0000000000000000 x1 : 0000000000000000 x0 : ffff0000059e0000 [ 317.262936] Call trace: [ 317.270045] refcount_warn_saturate (/builds/linux/lib/refcount.c:22 (discriminator 1)) (P) [ 317.272306] kthread_stop (/builds/linux/include/linux/refcount.h:291 /builds/linux/include/linux/refcount.h:366 /builds/linux/include/linux/refcount.h:383 /builds/linux/include/linux/sched/task.h:116 /builds/linux/kernel/kthread.c:784) [ 317.277163] kthread_stop_put (/builds/linux/include/linux/sched/task.h:130 /builds/linux/kernel/kthread.c:812) [ 317.280897] idle_cull_fn (/builds/linux/kernel/workqueue.c:2859 /builds/linux/kernel/workqueue.c:2980) [ 317.284541] process_one_work (/builds/linux/kernel/workqueue.c:3241) [ 317.288361] worker_thread (/builds/linux/kernel/workqueue.c:3313 (discriminator 2) /builds/linux/kernel/workqueue.c:3400 (discriminator 2)) [ 317.292353] kthread (/builds/linux/kernel/kthread.c:463) [ 317.295999] ret_from_fork (/builds/linux/arch/arm64/kernel/entry.S:861) [ 317.299386] ---[ end trace 0000000000000000 ]--- [ 317.303294] Unable to handle kernel NULL pointer dereference at virtual address 0000000000000000 [ 317.307630] Mem abort info: [ 317.316403] ESR = 0x0000000096000004 [ 317.318879] EC = 0x25: DABT (current EL), IL = 32 bits [ 317.322723] SET = 0, FnV = 0 [ 317.328194] EA = 0, S1PTW = 0 [ 317.331025] FSC = 0x04: level 0 translation fault [ 317.334121] Data abort info: [ 317.338933] ISV = 0, ISS = 0x00000004, ISS2 = 0x00000000 [ 317.342061] CM = 0, WnR = 0, TnD = 0, TagAccess = 0 [ 317.347364] GCS = 0, Overlay = 0, DirtyBit = 0, Xs = 0 [ 317.352515] user pgtable: 4k pages, 48-bit VAs, pgdp=000000008a592000 [ 317.357892] [0000000000000000] pgd=0000000000000000, p4d=0000000000000000 [ 317.364247] Internal error: Oops: 0000000096000004 [#3] SMP [ 317.370923] Modules linked in: pm8916_wdt qcom_wcnss_pil snd_soc_lpass_apq8016 snd_soc_msm8916_analog snd_soc_lpass_cpu snd_soc_apq8016_sbc snd_soc_msm8916_digital snd_soc_lpass_platform snd_soc_qcom_common coresight_cpu_debug snd_soc_core coresight_tmc coresight_replicator snd_compress coresight_funnel snd_pcm_dmaengine coresight_stm stm_core coresight_cti coresight_tpiu snd_pcm coresight snd_timer qrtr msm snd adv7511 qcom_camss qcom_q6v5_mss soundcore qcom_spmi_temp_alarm rtc_pm8xxx qcom_pon qcom_pil_info videobuf2_dma_sg ubwc_config qcom_q6v5 venus_core(+) qcom_sysmon qcom_spmi_vadc v4l2_fwnode llcc_qcom v4l2_async qcom_vadc_common qcom_common ocmem v4l2_mem2mem drm_gpuvm videobuf2_memops qcom_glink_smem videobuf2_v4l2 drm_exec mdt_loader qmi_helpers gpu_sched drm_dp_aux_bus qnoc_msm8916 videodev drm_display_helper qcom_stats videobuf2_common cec qcom_rng drm_client_lib mc phy_qcom_usb_hs socinfo rpmsg_ctrl display_connector rpmsg_char ramoops rmtfs_mem reed_solomon drm_kms_helper fuse drm backlight [ 317.443145] CPU: 0 UID: 0 PID: 88 Comm: kworker/u16:5 Tainted: G D W 6.16.0-next-20250804 #1 PREEMPT [ 317.465294] Tainted: [D]=DIE, [W]=WARN [ 317.475949] Hardware name: Qualcomm Technologies, Inc. APQ 8016 SBC (DT) [ 317.479516] Workqueue: events_unbound idle_cull_fn [ 317.486370] pstate: 60000005 (nZCv daif -PAN -UAO -TCO -DIT -SSBS BTYPE=--) [ 317.490972] pc : kthread_stop (/builds/linux/arch/arm64/include/asm/atomic_ll_sc.h:203 (discriminator 2) /builds/linux/arch/arm64/include/asm/atomic.h:65 (discriminator 2) /builds/linux/include/linux/atomic/atomic-arch-fallback.h:3798 (discriminator 2) /builds/linux/include/linux/atomic/atomic-long.h:1069 (discriminator 2) /builds/linux/include/asm-generic/bitops/atomic.h:18 (discriminator 2) /builds/linux/include/asm-generic/bitops/instrumented-atomic.h:29 (discriminator 2) /builds/linux/kernel/kthread.c:786 (discriminator 2)) [ 317.497825] lr : kthread_stop (/builds/linux/include/linux/refcount.h:291 /builds/linux/include/linux/refcount.h:366 /builds/linux/include/linux/refcount.h:383 /builds/linux/include/linux/sched/task.h:116 /builds/linux/kernel/kthread.c:784) [ 317.501989] sp : ffff8000839dbce0 [ 317.505981] x29: ffff8000839dbce0 x28: 0000000000000000 x27: 0000000000000000 [ 317.509288] x26: ffff000003418c28 x25: 0000000000000000 x24: ffff000003418c78 [ 317.516405] x23: dead000000000122 x22: dead000000000100 x21: 0000000000000000 [ 317.523526] x20: ffff0000044a4828 x19: ffff0000044a4800 x18: 0000000000000000 [ 317.530642] x17: 0000000000000000 x16: 0000000000000000 x15: 0000000000000000 [ 317.537762] x14: 0000000000000000 x13: 0000000000000000 x12: 0000000000000000 [ 317.544879] x11: 00000000000000c0 x10: 0000000000000b50 x9 : ffff80008163543c [ 317.551996] x8 : ffff8000839db9e8 x7 : 0000000000000001 x6 : 0000000000000001 [ 317.559116] x5 : ffff8000828ab000 x4 : ffff8000828ab3e0 x3 : 0000000000000000 [ 317.566232] x2 : 0000000000000000 x1 : 0000000000000000 x0 : 000000000020804c [ 317.573353] Call trace: [ 317.580461] kthread_stop (/builds/linux/arch/arm64/include/asm/atomic_ll_sc.h:203 (discriminator 2) /builds/linux/arch/arm64/include/asm/atomic.h:65 (discriminator 2) /builds/linux/include/linux/atomic/atomic-arch-fallback.h:3798 (discriminator 2) /builds/linux/include/linux/atomic/atomic-long.h:1069 (discriminator 2) /builds/linux/include/asm-generic/bitops/atomic.h:18 (discriminator 2) /builds/linux/include/asm-generic/bitops/instrumented-atomic.h:29 (discriminator 2) /builds/linux/kernel/kthread.c:786 (discriminator 2)) (P) [ 317.582720] kthread_stop_put (/builds/linux/include/linux/sched/task.h:130 /builds/linux/kernel/kthread.c:812) [ 317.586884] idle_cull_fn (/builds/linux/kernel/workqueue.c:2859 /builds/linux/kernel/workqueue.c:2980) [ 317.590531] process_one_work (/builds/linux/kernel/workqueue.c:3241) [ 317.594351] worker_thread (/builds/linux/kernel/workqueue.c:3313 (discriminator 2) /builds/linux/kernel/workqueue.c:3400 (discriminator 2)) [ 317.598345] kthread (/builds/linux/kernel/kthread.c:463) [ 317.601988] ret_from_fork (/builds/linux/arch/arm64/kernel/entry.S:861) [ 317.605380] Code: c8017e60 35ffffa1 17ffffaf f98002b1 (c85f7ea0) All code ======== 0: c8017e60 stxr w1, x0, [x19] 4: 35ffffa1 cbnz w1, 0xfffffffffffffff8 8: 17ffffaf b 0xfffffffffffffec4 c: f98002b1 prfm pstl1strm, [x21] 10:* c85f7ea0 ldxr x0, [x21] <-- trapping instruction Code starting with the faulting instruction =========================================== 0: c85f7ea0 ldxr x0, [x21] [ 317.608944] ---[ end trace 0000000000000000 ]--- ## Source * Git tree: https://kernel.googlesource.com/pub/scm/linux/kernel/git/next/linux-next.git * Git sha: 5c5a10f0be967a8950a2309ea965bae54251b50e * Git describe: next-20250804 * Project details: https://qa-reports.linaro.org/lkft/linux-next-master/build/next-20250804 * Architectures: arm64 Dragonboard-410c * Toolchains: gcc-13 * Kconfigs: selftests/*/configs ## Build * Test log: https://qa-reports.linaro.org/lkft/linux-next-master/build/next-20250804/te… * Test details: https://qa-reports.linaro.org/lkft/linux-next-master/build/next-20250804/te… * Test history: https://qa-reports.linaro.org/lkft/linux-next-master/build/next-20250804/te… * Test plan: https://tuxapi.tuxsuite.com/v1/groups/linaro/projects/lkft/tests/30oCAeKlwl… * Build link: https://storage.tuxsuite.com/public/linaro/lkft/builds/30oC7ut8e7yXWPAtJXay… * Kernel config: https://storage.tuxsuite.com/public/linaro/lkft/builds/30oC7ut8e7yXWPAtJXay… -- Linaro LKFT https://lkft.linaro.org

4 months, 1 week

2
3
0 0

[PATCH] selftests/futex: Check for shmget support at runtime

by Wake Liu

The futex tests `futex_wait.c` and `futex_waitv.c` rely on the `shmget()` syscall, which may not be available if the kernel is built without System V IPC support (CONFIG_SYSVIPC=n). This can lead to test failures on such systems. This patch modifies the tests to check for `shmget()` support at runtime by calling it and checking for an `ENOSYS` error. If `shmget()` is not supported, the tests are skipped with a clear message, improving the user experience and preventing false negatives. This approach is more robust than relying on compile-time checks and ensures that the tests run only when the required kernel features are present. Signed-off-by: Wake Liu <wakel(a)google.com> --- .../selftests/futex/functional/futex_wait.c | 49 ++++++------ .../selftests/futex/functional/futex_waitv.c | 78 +++++++++++-------- 2 files changed, 72 insertions(+), 55 deletions(-) diff --git a/tools/testing/selftests/futex/functional/futex_wait.c b/tools/testing/selftests/futex/functional/futex_wait.c index 685140d9b93d..17a465313a59 100644 --- a/tools/testing/selftests/futex/functional/futex_wait.c +++ b/tools/testing/selftests/futex/functional/futex_wait.c @@ -48,7 +48,7 @@ static void *waiterfn(void *arg) int main(int argc, char *argv[]) { int res, ret = RET_PASS, fd, c, shm_id; - u_int32_t f_private = 0, *shared_data; + u_int32_t f_private = 0, *shared_data = NULL; unsigned int flags = FUTEX_PRIVATE_FLAG; pthread_t waiter; void *shm; @@ -96,32 +96,35 @@ int main(int argc, char *argv[]) /* Testing an anon page shared memory */ shm_id = shmget(IPC_PRIVATE, 4096, IPC_CREAT | 0666); if (shm_id < 0) { - perror("shmget"); - exit(1); - } - - shared_data = shmat(shm_id, NULL, 0); + if (errno == ENOSYS) { + ksft_test_result_skip("Kernel does not support System V shared memory\n"); + } else { + ksft_test_result_fail("shmget() failed with error: %s\n", strerror(errno)); + ret = RET_FAIL; + } + } else { + shared_data = shmat(shm_id, NULL, 0); - *shared_data = 0; - futex = shared_data; + *shared_data = 0; + futex = shared_data; - info("Calling shared (page anon) futex_wait on futex: %p\n", futex); - if (pthread_create(&waiter, NULL, waiterfn, NULL)) - error("pthread_create failed\n", errno); + info("Calling shared (page anon) futex_wait on futex: %p\n", futex); + if (pthread_create(&waiter, NULL, waiterfn, NULL)) + error("pthread_create failed\n", errno); - usleep(WAKE_WAIT_US); + usleep(WAKE_WAIT_US); - info("Calling shared (page anon) futex_wake on futex: %p\n", futex); - res = futex_wake(futex, 1, 0); - if (res != 1) { - ksft_test_result_fail("futex_wake shared (page anon) returned: %d %s\n", - errno, strerror(errno)); - ret = RET_FAIL; - } else { - ksft_test_result_pass("futex_wake shared (page anon) succeeds\n"); + info("Calling shared (page anon) futex_wake on futex: %p\n", futex); + res = futex_wake(futex, 1, 0); + if (res != 1) { + ksft_test_result_fail("futex_wake shared (page anon) returned: %d %s\n", + errno, strerror(errno)); + ret = RET_FAIL; + } else { + ksft_test_result_pass("futex_wake shared (page anon) succeeds\n"); + } } - /* Testing a file backed shared memory */ fd = open(SHM_PATH, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR); if (fd < 0) { @@ -161,7 +164,8 @@ int main(int argc, char *argv[]) } /* Freeing resources */ - shmdt(shared_data); + if (shared_data) + shmdt(shared_data); munmap(shm, sizeof(f_private)); remove(SHM_PATH); close(fd); @@ -169,3 +173,4 @@ int main(int argc, char *argv[]) ksft_print_cnts(); return ret; } + diff --git a/tools/testing/selftests/futex/functional/futex_waitv.c b/tools/testing/selftests/futex/functional/futex_waitv.c index a94337f677e1..3baf5142b434 100644 --- a/tools/testing/selftests/futex/functional/futex_waitv.c +++ b/tools/testing/selftests/futex/functional/futex_waitv.c @@ -104,46 +104,62 @@ int main(int argc, char *argv[]) ksft_test_result_fail("futex_wake private returned: %d %s\n", res ? errno : res, res ? strerror(errno) : ""); - ret = RET_FAIL; } else { ksft_test_result_pass("futex_waitv private\n"); } /* Shared waitv */ - for (i = 0; i < NR_FUTEXES; i++) { - int shm_id = shmget(IPC_PRIVATE, 4096, IPC_CREAT | 0666); - - if (shm_id < 0) { - perror("shmget"); - exit(1); + bool shm_supported = true; + int shm_id = shmget(IPC_PRIVATE, 4096, IPC_CREAT | 0666); + + if (shm_id < 0) { + if (errno == ENOSYS) { + shm_supported = false; + ksft_test_result_skip("Kernel does not support System V shared memory\n"); + } else { + ksft_test_result_fail("shmget() failed with error: %s\n", strerror(errno)); + ret = RET_FAIL; + shm_supported = false; } + } else { + shmctl(shm_id, IPC_RMID, NULL); + } - unsigned int *shared_data = shmat(shm_id, NULL, 0); + if (shm_supported) { + for (i = 0; i < NR_FUTEXES; i++) { + int shm_id = shmget(IPC_PRIVATE, 4096, IPC_CREAT | 0666); - *shared_data = 0; - waitv[i].uaddr = (uintptr_t)shared_data; - waitv[i].flags = FUTEX_32; - waitv[i].val = 0; - waitv[i].__reserved = 0; - } + if (shm_id < 0) { + perror("shmget"); + exit(1); + } - if (pthread_create(&waiter, NULL, waiterfn, NULL)) - error("pthread_create failed\n", errno); + unsigned int *shared_data = shmat(shm_id, NULL, 0); - usleep(WAKE_WAIT_US); + *shared_data = 0; + waitv[i].uaddr = (uintptr_t)shared_data; + waitv[i].flags = FUTEX_32; + waitv[i].val = 0; + waitv[i].__reserved = 0; + } - res = futex_wake(u64_to_ptr(waitv[NR_FUTEXES - 1].uaddr), 1, 0); - if (res != 1) { - ksft_test_result_fail("futex_wake shared returned: %d %s\n", - res ? errno : res, - res ? strerror(errno) : ""); - ret = RET_FAIL; - } else { - ksft_test_result_pass("futex_waitv shared\n"); - } + if (pthread_create(&waiter, NULL, waiterfn, NULL)) + error("pthread_create failed\n", errno); - for (i = 0; i < NR_FUTEXES; i++) - shmdt(u64_to_ptr(waitv[i].uaddr)); + usleep(WAKE_WAIT_US); + + res = futex_wake(u64_to_ptr(waitv[NR_FUTEXES - 1].uaddr), 1, 0); + if (res != 1) { + ksft_test_result_fail("futex_wake shared returned: %d %s\n", + res ? errno : res, + res ? strerror(errno) : ""); + } else { + ksft_test_result_pass("futex_waitv shared\n"); + } + + for (i = 0; i < NR_FUTEXES; i++) + shmdt(u64_to_ptr(waitv[i].uaddr)); + } /* Testing a waiter without FUTEX_32 flag */ waitv[0].flags = FUTEX_PRIVATE_FLAG; @@ -158,7 +174,6 @@ int main(int argc, char *argv[]) ksft_test_result_fail("futex_waitv private returned: %d %s\n", res ? errno : res, res ? strerror(errno) : ""); - ret = RET_FAIL; } else { ksft_test_result_pass("futex_waitv without FUTEX_32\n"); } @@ -177,7 +192,6 @@ int main(int argc, char *argv[]) ksft_test_result_fail("futex_wake private returned: %d %s\n", res ? errno : res, res ? strerror(errno) : ""); - ret = RET_FAIL; } else { ksft_test_result_pass("futex_waitv with an unaligned address\n"); } @@ -195,7 +209,6 @@ int main(int argc, char *argv[]) ksft_test_result_fail("futex_waitv private returned: %d %s\n", res ? errno : res, res ? strerror(errno) : ""); - ret = RET_FAIL; } else { ksft_test_result_pass("futex_waitv NULL address in waitv.uaddr\n"); } @@ -211,7 +224,6 @@ int main(int argc, char *argv[]) ksft_test_result_fail("futex_waitv private returned: %d %s\n", res ? errno : res, res ? strerror(errno) : ""); - ret = RET_FAIL; } else { ksft_test_result_pass("futex_waitv NULL address in *waiters\n"); } @@ -227,7 +239,6 @@ int main(int argc, char *argv[]) ksft_test_result_fail("futex_waitv private returned: %d %s\n", res ? errno : res, res ? strerror(errno) : ""); - ret = RET_FAIL; } else { ksft_test_result_pass("futex_waitv invalid clockid\n"); } @@ -235,3 +246,4 @@ int main(int argc, char *argv[]) ksft_print_cnts(); return ret; } + -- 2.50.1.703.g449372360f-goog

4 months, 1 week

1
0
0 0

[PATCH] selftests/net: Ensure assert() triggers in psock_tpacket.c

by Wake Liu

The get_next_frame() function in psock_tpacket.c was missing a return statement in its default switch case, leading to a compiler warning. This was caused by a `bug_on(1)` call, which is defined as an `assert()`, being compiled out because NDEBUG is defined during the build. Instead of adding a `return NULL;` which would silently hide the error and could lead to crashes later, this change restores the original author's intent. By adding `#undef NDEBUG` before including <assert.h>, we ensure the assertion is active and will cause the test to abort if this unreachable code is ever executed. Signed-off-by: Wake Liu <wakel(a)google.com> --- tools/testing/selftests/net/psock_tpacket.c | 1 + 1 file changed, 1 insertion(+) diff --git a/tools/testing/selftests/net/psock_tpacket.c b/tools/testing/selftests/net/psock_tpacket.c index 0dd909e325d9..a54f2eb754ce 100644 --- a/tools/testing/selftests/net/psock_tpacket.c +++ b/tools/testing/selftests/net/psock_tpacket.c @@ -38,6 +38,7 @@ #include <arpa/inet.h> #include <stdint.h> #include <string.h> +#undef NDEBUG #include <assert.h> #include <net/if.h> #include <inttypes.h> -- 2.50.1.703.g449372360f-goog

4 months, 2 weeks

1
0
0 0

[PATCH v3 0/3] execute PROCMAP_QUERY ioctl under per-vma lock

by Suren Baghdasaryan

With /proc/pid/maps now being read under per-vma lock protection we can reuse parts of that code to execute PROCMAP_QUERY ioctl also without taking mmap_lock. The change is designed to reduce mmap_lock contention and prevent PROCMAP_QUERY ioctl calls from blocking address space updates. This patchset was split out of the original patchset [1] that introduced per-vma lock usage for /proc/pid/maps reading. It contains PROCMAP_QUERY tests, code refactoring patch to simplify the main change and the actual transition to per-vma lock. Changes since v2 [2] - Added Reviewed-by, per Vlastimil Babka - Fixed query_vma_find_by_addr() to handle lock_ctx->mmap_locked case, per Vlastimil Babka [1] https://lore.kernel.org/all/20250704060727.724817-1-surenb@google.com/ [2] https://lore.kernel.org/all/20250804231552.1217132-1-surenb@google.com/ Suren Baghdasaryan (3): selftests/proc: test PROCMAP_QUERY ioctl while vma is concurrently modified fs/proc/task_mmu: factor out proc_maps_private fields used by PROCMAP_QUERY fs/proc/task_mmu: execute PROCMAP_QUERY ioctl under per-vma locks fs/proc/internal.h | 15 +- fs/proc/task_mmu.c | 152 ++++++++++++------ fs/proc/task_nommu.c | 14 +- tools/testing/selftests/proc/proc-maps-race.c | 65 ++++++++ 4 files changed, 184 insertions(+), 62 deletions(-) base-commit: 8e7e0c6d09502e44aa7a8fce0821e042a6ec03d1 -- 2.50.1.565.gc32cd1483b-goog

4 months, 2 weeks

3
10
0 0

[PATCH -next] selftests/bpf: Fix warning comparing pointer to 0

by Jiapeng Chong

Avoid pointer type value compared with 0 to make code clear. ./tools/testing/selftests/bpf/progs/mem_rdonly_untrusted.c:221:10-11: WARNING comparing pointer to 0. Reported-by: Abaci Robot <abaci(a)linux.alibaba.com> Closes: https://bugzilla.openanolis.cn/show_bug.cgi?id=23403 Signed-off-by: Jiapeng Chong <jiapeng.chong(a)linux.alibaba.com> --- tools/testing/selftests/bpf/progs/mem_rdonly_untrusted.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/testing/selftests/bpf/progs/mem_rdonly_untrusted.c b/tools/testing/selftests/bpf/progs/mem_rdonly_untrusted.c index 4f94c971ae86..6b725725b2bf 100644 --- a/tools/testing/selftests/bpf/progs/mem_rdonly_untrusted.c +++ b/tools/testing/selftests/bpf/progs/mem_rdonly_untrusted.c @@ -218,7 +218,7 @@ int null_check(void *ctx) int *p; p = bpf_rdonly_cast(0, 0); - if (p == 0) + if (!p) /* make this a function call to avoid compiler * moving r0 assignment before check. */ -- 2.43.5

4 months, 2 weeks

2
1
0 0

[PATCH v5] selftests: riscv: add misaligned access testing

by Clément Léger

This selftest tests all the currently emulated instructions (except for the RV32 compressed ones which are left as a future exercise for a RV32 user). For the FPU instructions, all the FPU registers are tested. Signed-off-by: Clément Léger <cleger(a)rivosinc.com> --- This commits needs [1] for the test to be passed or it will fail due to missing sign extension. Note: This test can be executed using an SBI that support FWFT or that delegates misaligned traps by default. If using QEMU, you will need the patches mentioned at [2] so that misaligned accesses will generate a trap. Note: This commit was part of a series [3] that was partially merged. Note: the remaining checkpatch errors are not applicable to this tests which is a userspace one and does not use the kernel headers. Macros with complex values can not be enclosed in do while loop since they are generating functions. Link: https://lore.kernel.org/linux-riscv/mvmikk0goil.fsf@suse.de/ [1] Link: https://lore.kernel.org/all/20241211211933.198792-1-fkonrad@amd.com/ [2] Link: https://lore.kernel.org/linux-riscv/20250422162324.956065-1-cleger@rivosinc… [3] V5: - Sign extend LWU return value - Added sign extensions tests - Tests multiples values for GP load/store V4: - Fixed a typo in test name s/load/store V3: - Fixed a segfault and a sign extension error found when compiling with -O<x>, x != 0 (Alex) - Use inline assembly to generate the sigbus and avoid GCC optimizations V2: - Fix commit description - Fix a few errors reported by checkpatch.pl --- tools/testing/selftests/riscv/Makefile | 2 +- .../selftests/riscv/misaligned/.gitignore | 1 + .../selftests/riscv/misaligned/Makefile | 12 + .../selftests/riscv/misaligned/common.S | 33 ++ .../testing/selftests/riscv/misaligned/fpu.S | 180 +++++++++++ tools/testing/selftests/riscv/misaligned/gp.S | 113 +++++++ .../selftests/riscv/misaligned/misaligned.c | 288 ++++++++++++++++++ 7 files changed, 628 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/riscv/misaligned/.gitignore create mode 100644 tools/testing/selftests/riscv/misaligned/Makefile create mode 100644 tools/testing/selftests/riscv/misaligned/common.S create mode 100644 tools/testing/selftests/riscv/misaligned/fpu.S create mode 100644 tools/testing/selftests/riscv/misaligned/gp.S create mode 100644 tools/testing/selftests/riscv/misaligned/misaligned.c diff --git a/tools/testing/selftests/riscv/Makefile b/tools/testing/selftests/riscv/Makefile index 099b8c1f46f8..95a98ceeb3b3 100644 --- a/tools/testing/selftests/riscv/Makefile +++ b/tools/testing/selftests/riscv/Makefile @@ -5,7 +5,7 @@ ARCH ?= $(shell uname -m 2>/dev/null || echo not) ifneq (,$(filter $(ARCH),riscv)) -RISCV_SUBTARGETS ?= abi hwprobe mm sigreturn vector +RISCV_SUBTARGETS ?= abi hwprobe mm sigreturn vector misaligned else RISCV_SUBTARGETS := endif diff --git a/tools/testing/selftests/riscv/misaligned/.gitignore b/tools/testing/selftests/riscv/misaligned/.gitignore new file mode 100644 index 000000000000..5eff15a1f981 --- /dev/null +++ b/tools/testing/selftests/riscv/misaligned/.gitignore @@ -0,0 +1 @@ +misaligned diff --git a/tools/testing/selftests/riscv/misaligned/Makefile b/tools/testing/selftests/riscv/misaligned/Makefile new file mode 100644 index 000000000000..1aa40110c50d --- /dev/null +++ b/tools/testing/selftests/riscv/misaligned/Makefile @@ -0,0 +1,12 @@ +# SPDX-License-Identifier: GPL-2.0 +# Copyright (C) 2021 ARM Limited +# Originally tools/testing/arm64/abi/Makefile + +CFLAGS += -I$(top_srcdir)/tools/include + +TEST_GEN_PROGS := misaligned + +include ../../lib.mk + +$(OUTPUT)/misaligned: misaligned.c fpu.S gp.S + $(CC) -g3 -static -o$@ -march=rv64imafdc $(CFLAGS) $(LDFLAGS) $^ diff --git a/tools/testing/selftests/riscv/misaligned/common.S b/tools/testing/selftests/riscv/misaligned/common.S new file mode 100644 index 000000000000..8fa00035bd5d --- /dev/null +++ b/tools/testing/selftests/riscv/misaligned/common.S @@ -0,0 +1,33 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2025 Rivos Inc. + * + * Authors: + * Clément Léger <cleger(a)rivosinc.com> + */ + +.macro lb_sb temp, offset, src, dst + lb \temp, \offset(\src) + sb \temp, \offset(\dst) +.endm + +.macro copy_long_to temp, src, dst + lb_sb \temp, 0, \src, \dst, + lb_sb \temp, 1, \src, \dst, + lb_sb \temp, 2, \src, \dst, + lb_sb \temp, 3, \src, \dst, + lb_sb \temp, 4, \src, \dst, + lb_sb \temp, 5, \src, \dst, + lb_sb \temp, 6, \src, \dst, + lb_sb \temp, 7, \src, \dst, +.endm + +.macro sp_stack_prologue offset + addi sp, sp, -8 + sub sp, sp, \offset +.endm + +.macro sp_stack_epilogue offset + add sp, sp, \offset + addi sp, sp, 8 +.endm diff --git a/tools/testing/selftests/riscv/misaligned/fpu.S b/tools/testing/selftests/riscv/misaligned/fpu.S new file mode 100644 index 000000000000..a7ad4430a424 --- /dev/null +++ b/tools/testing/selftests/riscv/misaligned/fpu.S @@ -0,0 +1,180 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2025 Rivos Inc. + * + * Authors: + * Clément Léger <cleger(a)rivosinc.com> + */ + +#include "common.S" + +#define CASE_ALIGN 4 + +.macro fpu_load_inst fpreg, inst, precision, load_reg +.align CASE_ALIGN + \inst \fpreg, 0(\load_reg) + fmv.\precision fa0, \fpreg + j 2f +.endm + +#define flw(__fpreg) fpu_load_inst __fpreg, flw, s, a4 +#define fld(__fpreg) fpu_load_inst __fpreg, fld, d, a4 +#define c_flw(__fpreg) fpu_load_inst __fpreg, c.flw, s, a4 +#define c_fld(__fpreg) fpu_load_inst __fpreg, c.fld, d, a4 +#define c_fldsp(__fpreg) fpu_load_inst __fpreg, c.fldsp, d, sp + +.macro fpu_store_inst fpreg, inst, precision, store_reg +.align CASE_ALIGN + fmv.\precision \fpreg, fa0 + \inst \fpreg, 0(\store_reg) + j 2f +.endm + +#define fsw(__fpreg) fpu_store_inst __fpreg, fsw, s, a4 +#define fsd(__fpreg) fpu_store_inst __fpreg, fsd, d, a4 +#define c_fsw(__fpreg) fpu_store_inst __fpreg, c.fsw, s, a4 +#define c_fsd(__fpreg) fpu_store_inst __fpreg, c.fsd, d, a4 +#define c_fsdsp(__fpreg) fpu_store_inst __fpreg, c.fsdsp, d, sp + +.macro fp_test_prologue + move a4, a1 + /* + * Compute jump offset to store the correct FP register since we don't + * have indirect FP register access (or at least we don't use this + * extension so that works on all archs) + */ + sll t0, a0, CASE_ALIGN + la t2, 1f + add t0, t0, t2 + jr t0 +.align CASE_ALIGN +1: +.endm + +.macro fp_test_prologue_compressed + /* FP registers for compressed instructions starts from 8 to 16 */ + addi a0, a0, -8 + fp_test_prologue +.endm + +#define fp_test_body_compressed(__inst_func) \ + __inst_func(f8); \ + __inst_func(f9); \ + __inst_func(f10); \ + __inst_func(f11); \ + __inst_func(f12); \ + __inst_func(f13); \ + __inst_func(f14); \ + __inst_func(f15); \ +2: + +#define fp_test_body(__inst_func) \ + __inst_func(f0); \ + __inst_func(f1); \ + __inst_func(f2); \ + __inst_func(f3); \ + __inst_func(f4); \ + __inst_func(f5); \ + __inst_func(f6); \ + __inst_func(f7); \ + __inst_func(f8); \ + __inst_func(f9); \ + __inst_func(f10); \ + __inst_func(f11); \ + __inst_func(f12); \ + __inst_func(f13); \ + __inst_func(f14); \ + __inst_func(f15); \ + __inst_func(f16); \ + __inst_func(f17); \ + __inst_func(f18); \ + __inst_func(f19); \ + __inst_func(f20); \ + __inst_func(f21); \ + __inst_func(f22); \ + __inst_func(f23); \ + __inst_func(f24); \ + __inst_func(f25); \ + __inst_func(f26); \ + __inst_func(f27); \ + __inst_func(f28); \ + __inst_func(f29); \ + __inst_func(f30); \ + __inst_func(f31); \ +2: +.text + +#define __gen_test_inst(__inst, __suffix) \ +.global test_ ## __inst; \ +test_ ## __inst:; \ + fp_test_prologue ## __suffix; \ + fp_test_body ## __suffix(__inst); \ + ret + +#define gen_test_inst_compressed(__inst) \ + .option arch,+c; \ + __gen_test_inst(c_ ## __inst, _compressed) + +#define gen_test_inst(__inst) \ + .balign 16; \ + .option push; \ + .option arch,-c; \ + __gen_test_inst(__inst, ); \ + .option pop + +.macro fp_test_prologue_load_compressed_sp + copy_long_to t0, a1, sp +.endm + +.macro fp_test_epilogue_load_compressed_sp +.endm + +.macro fp_test_prologue_store_compressed_sp +.endm + +.macro fp_test_epilogue_store_compressed_sp + copy_long_to t0, sp, a1 +.endm + +#define gen_inst_compressed_sp(__inst, __type) \ + .global test_c_ ## __inst ## sp; \ + test_c_ ## __inst ## sp:; \ + sp_stack_prologue a2; \ + fp_test_prologue_## __type ## _compressed_sp; \ + fp_test_prologue_compressed; \ + fp_test_body_compressed(c_ ## __inst ## sp); \ + fp_test_epilogue_## __type ## _compressed_sp; \ + sp_stack_epilogue a2; \ + ret + +#define gen_test_load_compressed_sp(__inst) gen_inst_compressed_sp(__inst, load) +#define gen_test_store_compressed_sp(__inst) gen_inst_compressed_sp(__inst, store) + +/* + * float_fsw_reg - Set a FP register from a register containing the value + * a0 = FP register index to be set + * a1 = addr where to store register value + * a2 = address offset + * a3 = value to be store + */ +gen_test_inst(fsw) + +/* + * float_flw_reg - Get a FP register value and return it + * a0 = FP register index to be retrieved + * a1 = addr to load register from + * a2 = address offset + */ +gen_test_inst(flw) + +gen_test_inst(fsd) +#ifdef __riscv_compressed +gen_test_inst_compressed(fsd) +gen_test_store_compressed_sp(fsd) +#endif + +gen_test_inst(fld) +#ifdef __riscv_compressed +gen_test_inst_compressed(fld) +gen_test_load_compressed_sp(fld) +#endif diff --git a/tools/testing/selftests/riscv/misaligned/gp.S b/tools/testing/selftests/riscv/misaligned/gp.S new file mode 100644 index 000000000000..5abec5ccc828 --- /dev/null +++ b/tools/testing/selftests/riscv/misaligned/gp.S @@ -0,0 +1,113 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2025 Rivos Inc. + * + * Authors: + * Clément Léger <cleger(a)rivosinc.com> + */ + +#include "common.S" + +.text + +.macro __gen_test_inst inst, src_reg + \inst a2, 0(\src_reg) + move a0, a2 +.endm + +.macro gen_func_header func_name, rvc + .option arch,\rvc + .global test_\func_name + test_\func_name: +.endm + +.macro gen_test_inst inst + .option push + gen_func_header \inst, -c + __gen_test_inst \inst, a0 + .option pop + ret +.endm + +.macro gen_test_lwu + .option push + gen_func_header lwu, -c + __gen_test_inst lwu, a0 + .option pop + # RISC-V ABI states that C expect a sign extended 32 bits integer + sext.w a0, a0 + ret +.endm + +.macro __gen_test_inst_c name, src_reg + .option push + gen_func_header c_\name, +c + __gen_test_inst c.\name, \src_reg + .option pop + ret +.endm + +.macro gen_test_inst_c name + __gen_test_inst_c \name, a0 +.endm + + +.macro gen_test_inst_c_ldsp + .option push + gen_func_header c_ldsp, +c + sp_stack_prologue a1 + copy_long_to t0, a0, sp + c.ldsp a0, 0(sp) + sp_stack_epilogue a1 + .option pop + ret +.endm + +.macro lb_sp_sb_a0 reg, offset + lb_sb \reg, \offset, sp, a0 +.endm + +.macro gen_test_inst_c_sdsp + .option push + gen_func_header c_sdsp, +c + /* Misalign stack pointer */ + sp_stack_prologue a1 + /* Misalign access */ + c.sdsp a2, 0(sp) + copy_long_to t0, sp, a0 + sp_stack_epilogue a1 + .option pop + ret +.endm + + + /* + * a0 = addr to load from + * a1 = address offset + * a2 = value to be loaded + */ +gen_test_inst lh +gen_test_inst lhu +gen_test_inst lw +gen_test_lwu +gen_test_inst ld +#ifdef __riscv_compressed +gen_test_inst_c lw +gen_test_inst_c ld +gen_test_inst_c_ldsp +#endif + +/* + * a0 = addr where to store value + * a1 = address offset + * a2 = value to be stored + */ +gen_test_inst sh +gen_test_inst sw +gen_test_inst sd +#ifdef __riscv_compressed +gen_test_inst_c sw +gen_test_inst_c sd +gen_test_inst_c_sdsp +#endif + diff --git a/tools/testing/selftests/riscv/misaligned/misaligned.c b/tools/testing/selftests/riscv/misaligned/misaligned.c new file mode 100644 index 000000000000..57ddcbdc947c --- /dev/null +++ b/tools/testing/selftests/riscv/misaligned/misaligned.c @@ -0,0 +1,288 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2025 Rivos Inc. + * + * Authors: + * Clément Léger <cleger(a)rivosinc.com> + */ +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include <linux/ptrace.h> +#include "../../kselftest_harness.h" + +#include <stdlib.h> +#include <stdio.h> +#include <stdint.h> +#include <float.h> +#include <errno.h> +#include <math.h> +#include <string.h> +#include <signal.h> +#include <stdbool.h> +#include <unistd.h> +#include <inttypes.h> +#include <ucontext.h> + +#include <sys/prctl.h> + +#define stringify(s) __stringify(s) +#define __stringify(s) #s + +#define U8_MAX ((u8)~0U) +#define S8_MAX ((s8)(U8_MAX >> 1)) +#define S8_MIN ((s8)(-S8_MAX - 1)) +#define U16_MAX ((u16)~0U) +#define S16_MAX ((s16)(U16_MAX >> 1)) +#define S16_MIN ((s16)(-S16_MAX - 1)) +#define U32_MAX ((u32)~0U) +#define U32_MIN ((u32)0) +#define S32_MAX ((s32)(U32_MAX >> 1)) +#define S32_MIN ((s32)(-S32_MAX - 1)) +#define U64_MAX ((u64)~0ULL) +#define S64_MAX ((s64)(U64_MAX >> 1)) +#define S64_MIN ((s64)(-S64_MAX - 1)) + +#define int16_TEST_VALUES {S16_MIN, S16_MIN/2, -1, 1, S16_MAX/2, S16_MAX} +#define int32_TEST_VALUES {S32_MIN, S32_MIN/2, -1, 1, S32_MAX/2, S32_MAX} +#define int64_TEST_VALUES {S64_MIN, S64_MIN/2, -1, 1, S64_MAX/2, S64_MAX} +#define uint16_TEST_VALUES {0, U16_MAX/2, U16_MAX} +#define uint32_TEST_VALUES {0, U32_MAX/2, U32_MAX} + +#define float_TEST_VALUES {FLT_MIN, FLT_MIN/2, FLT_MAX/2, FLT_MAX} +#define double_TEST_VALUES {DBL_MIN, DBL_MIN/2, DBL_MAX/2, DBL_MAX} + +static bool float_equal(float a, float b) +{ + float scaled_epsilon; + float difference = fabsf(a - b); + + // Scale to the largest value. + a = fabsf(a); + b = fabsf(b); + if (a > b) + scaled_epsilon = FLT_EPSILON * a; + else + scaled_epsilon = FLT_EPSILON * b; + + return difference <= scaled_epsilon; +} + +static bool double_equal(double a, double b) +{ + double scaled_epsilon; + double difference = fabsl(a - b); + + // Scale to the largest value. + a = fabs(a); + b = fabs(b); + if (a > b) + scaled_epsilon = DBL_EPSILON * a; + else + scaled_epsilon = DBL_EPSILON * b; + + return difference <= scaled_epsilon; +} + +#define fpu_load_proto(__inst, __type) \ +extern __type test_ ## __inst(unsigned long fp_reg, void *addr, unsigned long offset, __type value) + +fpu_load_proto(flw, float); +fpu_load_proto(fld, double); +fpu_load_proto(c_flw, float); +fpu_load_proto(c_fld, double); +fpu_load_proto(c_fldsp, double); + +#define fpu_store_proto(__inst, __type) \ +extern void test_ ## __inst(unsigned long fp_reg, void *addr, unsigned long offset, __type value) + +fpu_store_proto(fsw, float); +fpu_store_proto(fsd, double); +fpu_store_proto(c_fsw, float); +fpu_store_proto(c_fsd, double); +fpu_store_proto(c_fsdsp, double); + +#define gp_load_proto(__inst, __type) \ +extern __type test_ ## __inst(void *addr, unsigned long offset, __type value) + +gp_load_proto(lh, int16_t); +gp_load_proto(lhu, uint16_t); +gp_load_proto(lw, int32_t); +gp_load_proto(lwu, uint32_t); +gp_load_proto(ld, int64_t); +gp_load_proto(c_lw, int32_t); +gp_load_proto(c_ld, int64_t); +gp_load_proto(c_ldsp, int64_t); + +#define gp_store_proto(__inst, __type) \ +extern void test_ ## __inst(void *addr, unsigned long offset, __type value) + +gp_store_proto(sh, int16_t); +gp_store_proto(sw, int32_t); +gp_store_proto(sd, int64_t); +gp_store_proto(c_sw, int32_t); +gp_store_proto(c_sd, int64_t); +gp_store_proto(c_sdsp, int64_t); + +#define TEST_GP_LOAD(__inst, __type_size, __type) \ +TEST(gp_load_ ## __inst) \ +{ \ + int offset, ret, val_i; \ + uint8_t buf[16] __attribute__((aligned(16))); \ + __type ## __type_size ## _t test_val[] = __type ## __type_size ## _TEST_VALUES; \ + \ + ret = prctl(PR_SET_UNALIGN, PR_UNALIGN_NOPRINT); \ + ASSERT_EQ(ret, 0); \ + \ + for (offset = 1; offset < (__type_size) / 8; offset++) { \ + for (val_i = 0; val_i < ARRAY_SIZE(test_val); val_i++) { \ + __type ## __type_size ## _t ref_val = test_val[val_i]; \ + __type ## __type_size ## _t *ptr = \ + (__type ## __type_size ## _t *)(buf + offset); \ + memcpy(ptr, &ref_val, sizeof(ref_val)); \ + __type ## __type_size ## _t val = \ + test_ ## __inst(ptr, offset, ref_val); \ + EXPECT_EQ(ref_val, val); \ + } \ + } \ +} + +TEST_GP_LOAD(lh, 16, int) +TEST_GP_LOAD(lhu, 16, uint) +TEST_GP_LOAD(lw, 32, int) +TEST_GP_LOAD(lwu, 32, uint) +TEST_GP_LOAD(ld, 64, int) +#ifdef __riscv_compressed +TEST_GP_LOAD(c_lw, 32, int) +TEST_GP_LOAD(c_ld, 64, int) +TEST_GP_LOAD(c_ldsp, 64, int) +#endif + +#define TEST_GP_STORE(__inst, __type_size, __type) \ +TEST(gp_store_ ## __inst) \ +{ \ + int offset, ret, val_i; \ + uint8_t buf[16] __attribute__((aligned(16))); \ + __type ## __type_size ## _t test_val[] = \ + __type ## __type_size ## _TEST_VALUES; \ + \ + ret = prctl(PR_SET_UNALIGN, PR_UNALIGN_NOPRINT); \ + ASSERT_EQ(ret, 0); \ + \ + for (val_i = 0; val_i < ARRAY_SIZE(test_val); val_i++) { \ + __type ## __type_size ## _t ref_val = test_val[val_i]; \ + for (offset = 1; offset < (__type_size) / 8; offset++) { \ + __type ## __type_size ## _t val = ref_val; \ + __type ## __type_size ## _t *ptr = \ + (__type ## __type_size ## _t *)(buf + offset); \ + memset(ptr, 0, sizeof(val)); \ + test_ ## __inst(ptr, offset, val); \ + memcpy(&val, ptr, sizeof(val)); \ + EXPECT_EQ(ref_val, val); \ + } \ + } \ +} + +TEST_GP_STORE(sh, 16, int) +TEST_GP_STORE(sw, 32, int) +TEST_GP_STORE(sd, 64, int) +#ifdef __riscv_compressed +TEST_GP_STORE(c_sw, 32, int) +TEST_GP_STORE(c_sd, 64, int) +TEST_GP_STORE(c_sdsp, 64, int) +#endif + +#define __TEST_FPU_LOAD(__type, __inst, __reg_start, __reg_end) \ +TEST(fpu_load_ ## __inst) \ +{ \ + int ret, offset, fp_reg, val_i; \ + uint8_t buf[16] __attribute__((aligned(16))); \ + __type test_val[] = __type ## _TEST_VALUES; \ + \ + ret = prctl(PR_SET_UNALIGN, PR_UNALIGN_NOPRINT); \ + ASSERT_EQ(ret, 0); \ + \ + for (fp_reg = __reg_start; fp_reg < __reg_end; fp_reg++) { \ + for (offset = 1; offset < 4; offset++) { \ + for (val_i = 0; val_i < ARRAY_SIZE(test_val); val_i++) { \ + __type val, ref_val = test_val[val_i]; \ + void *load_addr = (buf + offset); \ + \ + memcpy(load_addr, &ref_val, sizeof(ref_val)); \ + val = test_ ## __inst(fp_reg, load_addr, offset, ref_val); \ + EXPECT_TRUE(__type ##_equal(val, ref_val)); \ + } \ + } \ + } \ +} + +#define TEST_FPU_LOAD(__type, __inst) \ + __TEST_FPU_LOAD(__type, __inst, 0, 32) +#define TEST_FPU_LOAD_COMPRESSED(__type, __inst) \ + __TEST_FPU_LOAD(__type, __inst, 8, 16) + +TEST_FPU_LOAD(float, flw) +TEST_FPU_LOAD(double, fld) +#ifdef __riscv_compressed +TEST_FPU_LOAD_COMPRESSED(double, c_fld) +TEST_FPU_LOAD_COMPRESSED(double, c_fldsp) +#endif + +#define __TEST_FPU_STORE(__type, __inst, __reg_start, __reg_end) \ +TEST(fpu_store_ ## __inst) \ +{ \ + int ret, offset, fp_reg, val_i; \ + uint8_t buf[16] __attribute__((aligned(16))); \ + __type test_val[] = __type ## _TEST_VALUES; \ + \ + ret = prctl(PR_SET_UNALIGN, PR_UNALIGN_NOPRINT); \ + ASSERT_EQ(ret, 0); \ + \ + for (fp_reg = __reg_start; fp_reg < __reg_end; fp_reg++) { \ + for (offset = 1; offset < 4; offset++) { \ + for (val_i = 0; val_i < ARRAY_SIZE(test_val); val_i++) { \ + __type val, ref_val = test_val[val_i]; \ + \ + void *store_addr = (buf + offset); \ + \ + test_ ## __inst(fp_reg, store_addr, offset, ref_val); \ + memcpy(&val, store_addr, sizeof(val)); \ + EXPECT_TRUE(__type ## _equal(val, ref_val)); \ + } \ + } \ + } \ +} +#define TEST_FPU_STORE(__type, __inst) \ + __TEST_FPU_STORE(__type, __inst, 0, 32) +#define TEST_FPU_STORE_COMPRESSED(__type, __inst) \ + __TEST_FPU_STORE(__type, __inst, 8, 16) + +TEST_FPU_STORE(float, fsw) +TEST_FPU_STORE(double, fsd) +#ifdef __riscv_compressed +TEST_FPU_STORE_COMPRESSED(double, c_fsd) +TEST_FPU_STORE_COMPRESSED(double, c_fsdsp) +#endif + +TEST_SIGNAL(gen_sigbus, SIGBUS) +{ + uint32_t val = 0xDEADBEEF; + uint8_t buf[16] __attribute__((aligned(16))); + int ret; + + ret = prctl(PR_SET_UNALIGN, PR_UNALIGN_SIGBUS); + ASSERT_EQ(ret, 0); + + asm volatile("sw %0, 1(%1)" : : "r"(val), "r"(buf) : "memory"); +} + +int main(int argc, char **argv) +{ + int ret, val; + + ret = prctl(PR_GET_UNALIGN, &val); + if (ret == -1 && errno == EINVAL) + ksft_exit_skip("SKIP GET_UNALIGN_CTL not supported\n"); + + exit(test_harness_run(argc, argv)); +} -- 2.43.0

4 months, 2 weeks

3
2
0 0

[PATCH] selftests/drivers/net: replace typeof() with __auto_type

by Pranav Tyagi

Replace typeof() with __auto_type in iou-zcrx.c. __auto_type was introduced in GCC 4.9 and reduces the compile time for all compilers. No functional changes intended. Signed-off-by: Pranav Tyagi <pranav.tyagi03(a)gmail.com> --- tools/testing/selftests/drivers/net/hw/iou-zcrx.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tools/testing/selftests/drivers/net/hw/iou-zcrx.c b/tools/testing/selftests/drivers/net/hw/iou-zcrx.c index 62456df947bc..85551594bf0f 100644 --- a/tools/testing/selftests/drivers/net/hw/iou-zcrx.c +++ b/tools/testing/selftests/drivers/net/hw/iou-zcrx.c @@ -42,8 +42,8 @@ static long page_size; #define SEND_SIZE (512 * 4096) #define min(a, b) \ ({ \ - typeof(a) _a = (a); \ - typeof(b) _b = (b); \ + __auto_type _a = (a); \ + __auto_type _b = (b); \ _a < _b ? _a : _b; \ }) #define min_t(t, a, b) \ -- 2.49.0

4 months, 2 weeks

2
2
0 0

[PATCH] selftests/bpf/progs: use __auto_type in swap() macro

by Pranav Tyagi

Replace typeof() with __auto_type in xdp_synproxy_kern.c. __auto_type was introduced in GCC 4.9 and reduces the compile time for all compilers. No functional changes intended. Signed-off-by: Pranav Tyagi <pranav.tyagi03(a)gmail.com> --- tools/testing/selftests/bpf/progs/xdp_synproxy_kern.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/testing/selftests/bpf/progs/xdp_synproxy_kern.c b/tools/testing/selftests/bpf/progs/xdp_synproxy_kern.c index 62b8e29ced9f..b08738f9a0e6 100644 --- a/tools/testing/selftests/bpf/progs/xdp_synproxy_kern.c +++ b/tools/testing/selftests/bpf/progs/xdp_synproxy_kern.c @@ -58,7 +58,7 @@ #define MAX_PACKET_OFF 0xffff #define swap(a, b) \ - do { typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0) + do { __auto_type __tmp = (a); (a) = (b); (b) = __tmp; } while (0) #define __get_unaligned_t(type, ptr) ({ \ const struct { type x; } __attribute__((__packed__)) *__pptr = (typeof(__pptr))(ptr); \ -- 2.49.0

4 months, 2 weeks

2
2
0 0

[PATCH] selftests/mm: fix FORCE_READ to read input value correctly.

by Zi Yan

FORCE_READ() converts input value x to its pointer type then reads from address x. This is wrong. If x is a non-pointer, it would be caught it easily. But all FORCE_READ() callers are trying to read from a pointer and FORCE_READ() basically reads a pointer to a pointer instead of the original typed pointer. Almost no access violation was found, except the one from split_huge_page_test. Fix it by implementing a simplified READ_ONCE() instead. Fixes: 3f6bfd4789a0 ("selftests/mm: reuse FORCE_READ to replace "asm volatile("" : "+r" (XXX));"") Signed-off-by: Zi Yan <ziy(a)nvidia.com> --- FORCE_READ() comes from commit 876320d71f51 ("selftests/mm: add self tests for guard page feature"). I will a separate patch to stable tree. tools/testing/selftests/mm/cow.c | 4 ++-- tools/testing/selftests/mm/guard-regions.c | 2 +- tools/testing/selftests/mm/hugetlb-madvise.c | 4 +++- tools/testing/selftests/mm/migration.c | 2 +- tools/testing/selftests/mm/pagemap_ioctl.c | 2 +- tools/testing/selftests/mm/split_huge_page_test.c | 7 +++++-- tools/testing/selftests/mm/vm_util.h | 2 +- 7 files changed, 14 insertions(+), 9 deletions(-) diff --git a/tools/testing/selftests/mm/cow.c b/tools/testing/selftests/mm/cow.c index d30625c18259..c744c603d688 100644 --- a/tools/testing/selftests/mm/cow.c +++ b/tools/testing/selftests/mm/cow.c @@ -1554,8 +1554,8 @@ static void run_with_zeropage(non_anon_test_fn fn, const char *desc) } /* Read from the page to populate the shared zeropage. */ - FORCE_READ(mem); - FORCE_READ(smem); + FORCE_READ(*mem); + FORCE_READ(*smem); fn(mem, smem, pagesize); munmap: diff --git a/tools/testing/selftests/mm/guard-regions.c b/tools/testing/selftests/mm/guard-regions.c index b0d42eb04e3a..8dd81c0a4a5a 100644 --- a/tools/testing/selftests/mm/guard-regions.c +++ b/tools/testing/selftests/mm/guard-regions.c @@ -145,7 +145,7 @@ static bool try_access_buf(char *ptr, bool write) if (write) *ptr = 'x'; else - FORCE_READ(ptr); + FORCE_READ(*ptr); } signal_jump_set = false; diff --git a/tools/testing/selftests/mm/hugetlb-madvise.c b/tools/testing/selftests/mm/hugetlb-madvise.c index 1afe14b9dc0c..c5940c0595be 100644 --- a/tools/testing/selftests/mm/hugetlb-madvise.c +++ b/tools/testing/selftests/mm/hugetlb-madvise.c @@ -50,8 +50,10 @@ void read_fault_pages(void *addr, unsigned long nr_pages) unsigned long i; for (i = 0; i < nr_pages; i++) { + unsigned long *addr2 = + ((unsigned long *)(addr + (i * huge_page_size))); /* Prevent the compiler from optimizing out the entire loop: */ - FORCE_READ(((unsigned long *)(addr + (i * huge_page_size)))); + FORCE_READ(*addr2); } } diff --git a/tools/testing/selftests/mm/migration.c b/tools/testing/selftests/mm/migration.c index c5a73617796a..ea945eebec2f 100644 --- a/tools/testing/selftests/mm/migration.c +++ b/tools/testing/selftests/mm/migration.c @@ -110,7 +110,7 @@ void *access_mem(void *ptr) * the memory access actually happens and prevents the compiler * from optimizing away this entire loop. */ - FORCE_READ((uint64_t *)ptr); + FORCE_READ(*(uint64_t *)ptr); } return NULL; diff --git a/tools/testing/selftests/mm/pagemap_ioctl.c b/tools/testing/selftests/mm/pagemap_ioctl.c index 0d4209eef0c3..e6face7c0166 100644 --- a/tools/testing/selftests/mm/pagemap_ioctl.c +++ b/tools/testing/selftests/mm/pagemap_ioctl.c @@ -1525,7 +1525,7 @@ void zeropfn_tests(void) ret = madvise(mem, hpage_size, MADV_HUGEPAGE); if (!ret) { - FORCE_READ(mem); + FORCE_READ(*mem); ret = pagemap_ioctl(mem, hpage_size, &vec, 1, 0, 0, PAGE_IS_PFNZERO, 0, 0, PAGE_IS_PFNZERO); diff --git a/tools/testing/selftests/mm/split_huge_page_test.c b/tools/testing/selftests/mm/split_huge_page_test.c index 718daceb5282..3c761228e451 100644 --- a/tools/testing/selftests/mm/split_huge_page_test.c +++ b/tools/testing/selftests/mm/split_huge_page_test.c @@ -440,8 +440,11 @@ int create_pagecache_thp_and_fd(const char *testfile, size_t fd_size, int *fd, } madvise(*addr, fd_size, MADV_HUGEPAGE); - for (size_t i = 0; i < fd_size; i++) - FORCE_READ((*addr + i)); + for (size_t i = 0; i < fd_size; i++) { + char *addr2 = *addr + i; + + FORCE_READ(*addr2); + } if (!check_huge_file(*addr, fd_size / pmd_pagesize, pmd_pagesize)) { ksft_print_msg("No large pagecache folio generated, please provide a filesystem supporting large folio\n"); diff --git a/tools/testing/selftests/mm/vm_util.h b/tools/testing/selftests/mm/vm_util.h index c20298ae98ea..b55d1809debc 100644 --- a/tools/testing/selftests/mm/vm_util.h +++ b/tools/testing/selftests/mm/vm_util.h @@ -23,7 +23,7 @@ * anything with it in order to trigger a read page fault. We therefore must use * volatile to stop the compiler from optimising this away. */ -#define FORCE_READ(x) (*(volatile typeof(x) *)x) +#define FORCE_READ(x) (*(const volatile typeof(x) *)&(x)) extern unsigned int __page_size; extern unsigned int __page_shift; -- 2.47.2

4 months, 2 weeks

7
11
0 0

[PATCH] selftests/filesystems: replace typeof() with __auto_type

by Pranav Tyagi

Replace typeof() with __auto_type in utils.c. __auto_type was introduced in GCC 4.9 and reduces the compile time for all compilers. No functional changes intended. Signed-off-by: Pranav Tyagi <pranav.tyagi03(a)gmail.com> --- tools/testing/selftests/filesystems/utils.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/testing/selftests/filesystems/utils.c b/tools/testing/selftests/filesystems/utils.c index c43a69dffd83..95f202e2bfb7 100644 --- a/tools/testing/selftests/filesystems/utils.c +++ b/tools/testing/selftests/filesystems/utils.c @@ -34,7 +34,7 @@ #define syserror_set(__ret__, format, ...) \ ({ \ - typeof(__ret__) __internal_ret__ = (__ret__); \ + __auto_type __internal_ret__ = (__ret__); \ errno = labs(__ret__); \ fprintf(stderr, "%m - " format "\n", ##__VA_ARGS__); \ __internal_ret__; \ -- 2.49.0

4 months, 2 weeks

1
0
0 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror