* Re: [PATCH v3 02/10] iov_iter: add iterator type for dmabuf maps
From: David Laight @ 2026-05-13 13:29 UTC (permalink / raw)
To: Pavel Begunkov
Cc: Jens Axboe, Keith Busch, Christoph Hellwig, Sagi Grimberg,
Alexander Viro, Christian Brauner, Andrew Morton, Sumit Semwal,
Christian König, linux-block, linux-kernel, linux-nvme,
linux-fsdevel, io-uring, linux-media, dri-devel, linaro-mm-sig,
Nitesh Shetty, Kanchan Joshi, Anuj Gupta, Tushar Gohad,
William Power, Phil Cayton, Jason Gunthorpe
In-Reply-To: <20260513110557.705bdeed@pumpkin>
On Wed, 13 May 2026 11:05:57 +0100
David Laight <david.laight.linux@gmail.com> wrote:
...
> > @@ -575,7 +575,8 @@ void iov_iter_advance(struct iov_iter *i, size_t size)
> > {
> > if (unlikely(i->count < size))
> > size = i->count;
> > - if (likely(iter_is_ubuf(i)) || unlikely(iov_iter_is_xarray(i))) {
> > + if (likely(iter_is_ubuf(i)) || unlikely(iov_iter_is_xarray(i)) ||
> > + unlikely(iov_iter_is_dmabuf_map(i))) {
>
>
> Doesn't the extra check add more code to all the non-ubuf cases?
> This could be fixed by either making iter_type a bitmask (with one bit set)
> or writing an iter_is_one_of(i, ITER_xxx, ITER_yyy) define that uses
> '(1 << i->iter_type) & ((1 << ITER_xxx) | ...)'
This seems to DTRT:
#define _ITER_IS_ONE_OF(iter, t1, t2, t3, t4, t5, t6, t7, t8, ...) \
((1u << (iter)->iter_type) & ((1u << ITER_##t1) | (1u << ITER_##t2) | \
(1u << ITER_##t3) | (1u << ITER_##t4) | (1u << ITER_##t5) | \
(1u << ITER_##t6) | (1u << ITER_##t7) | (1u << ITER_##t8)))
#define ITER_IS_ONE_OF(iter, t, ...) \
_ITER_IS_ONE_OF(iter, t, ## __VA_ARGS__, t, t, t, t, t, t, t)
int foo(void *);
int f(struct iov_iter *i)
{
return ITER_IS_ONE_OF(i, UBUF, KVEC) ? foo(i) : 0;
}
See https://godbolt.org/z/sMz93zah1
Pasting ITER_ on the front ensures the values are constants of the right type.
OTOH it makes it harder to search for uses of each type.
You could paste _ITER_ on the front, elsewhere define _ITER_ITER_UVEC
to be ITER_UVEC (etc), and require the caller use the full name.
-- David
^ permalink raw reply
* Re: [PATCH] floppy: force media-change checks when clearing events
From: Denis Efremov (Oracle) @ 2026-05-13 12:51 UTC (permalink / raw)
To: Cen Zhang, axboe; +Cc: linux-block, linux-kernel, baijiaju1990
In-Reply-To: <20260506010248.3275696-1-zzzccc427@gmail.com>
Hello,
On 06/05/2026 05:02, Cen Zhang wrote:
> floppy_open() tries to make blocking read/write opens perform a fresh
> media-change check by clearing drive_state[drive].last_checked before
> calling disk_check_media_change(). That timestamp is also updated by
> disk_change() when another FDC operation observes that the disk-change
> line is clear.
>
> The worker path that calls disk_change() is not serialized by the
> floppy_mutex/open_lock pair held by floppy_open(). A worker can therefore
> store a recent jiffies value after floppy_open() stores zero and before the
> synchronous disk_check_media_change() call reaches floppy_check_events().
> The checkfreq throttle can then treat the media-change state as fresh and
> skip the hardware poll that the open path explicitly tried to force.
Thanks for the report and patch. The race you describe is real. However,
the proposed fix introduces a regression on the close path that I don't
think we can take as-is.
>
> Use the block layer's clearing mask instead of a racy timestamp sentinel.
> When DISK_EVENT_MEDIA_CHANGE is being synchronously cleared, bypass the
> checkfreq throttle and poll the drive. Periodic event checks still use
> last_checked to avoid unnecessary polling, and floppy_open() no longer
> needs to write last_checked itself.
bdev_release() unconditionally calls disk_flush_events(disk, DISK_EVENT_MEDIA_CHANGE);
on every final fput() of a block device. disk_flush_events() is not a no-op.
I'm afraid that after this patch every close of /dev/fd0 (or any floppy partition)
forces a synchronous FDC poll.
>
> Signed-off-by: Cen Zhang <zzzccc427@gmail.com>
> ---
> drivers/block/floppy.c | 5 +++--
> 1 file changed, 3 insertions(+), 2 deletions(-)
>
> diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
> index 92e446a643712..7217db0b907b3 100644
> --- a/drivers/block/floppy.c
> +++ b/drivers/block/floppy.c
> @@ -4051,7 +4051,6 @@ static int floppy_open(struct gendisk *disk, blk_mode_t mode)
> fdc_state[FDC(drive)].rawcmd = 2;
> if (!(mode & BLK_OPEN_NDELAY)) {
> if (mode & (BLK_OPEN_READ | BLK_OPEN_WRITE)) {
> - drive_state[drive].last_checked = 0;
> clear_bit(FD_OPEN_SHOULD_FAIL_BIT,
> &drive_state[drive].flags);
> if (disk_check_media_change(disk))
> @@ -4092,7 +4091,9 @@ static unsigned int floppy_check_events(struct gendisk *disk,
> test_bit(FD_VERIFY_BIT, &drive_state[drive].flags))
> return DISK_EVENT_MEDIA_CHANGE;
>
> - if (time_after(jiffies, drive_state[drive].last_checked + drive_params[drive].checkfreq)) {
> + if ((clearing & DISK_EVENT_MEDIA_CHANGE) ||
> + time_after(jiffies, drive_state[drive].last_checked +
> + drive_params[drive].checkfreq)) {
> if (lock_fdc(drive))
> return 0;
> poll_drive(false, 0);
For v2 I think we should avoid using the block-layer clearing mask as a force-poll
signal. We can make floppy_open() do the forced open-time poll directly under
lock_fdc(), then let disk_check_media_change() observe the resulting state.
This code pattern is already lives in FDPOLLDRVSTAT/FDFMTBEG handling branches.
Denis
^ permalink raw reply
* [PATCH blktests 3/3] common/nvme, nvme/rc: use _echo() to trace sysfs attribute writes
From: Shin'ichiro Kawasaki @ 2026-05-13 11:23 UTC (permalink / raw)
To: linux-block; +Cc: Daniel Wagner, John Meneghini, Shin'ichiro Kawasaki
In-Reply-To: <20260513112326.584256-1-shinichiro.kawasaki@wdc.com>
The previous commit introduced the helper function _echo(). Use it in
common/nvme and tests/nvme/rc to trace sysfs attribute writes.
Signed-off-by: Shin'ichiro Kawasaki <shinichiro.kawasaki@wdc.com>
---
common/nvme | 34 ++++++++++++++---------------
tests/nvme/rc | 60 +++++++++++++++++++++++++--------------------------
2 files changed, 46 insertions(+), 48 deletions(-)
diff --git a/common/nvme b/common/nvme
index 565de59..aa44ca6 100644
--- a/common/nvme
+++ b/common/nvme
@@ -570,18 +570,18 @@ _create_nvmet_port() {
traddr=$(_fc_traddr $port)
adrfam="fc"
fi
- echo "${trtype}" > "${portcfs}/addr_trtype"
- echo "${traddr}" > "${portcfs}/addr_traddr"
- echo "${adrfam}" > "${portcfs}/addr_adrfam"
+ _echo "${trtype}" "${portcfs}/addr_trtype"
+ _echo "${traddr}" "${portcfs}/addr_traddr"
+ _echo "${adrfam}" "${portcfs}/addr_adrfam"
if [[ "${adrfam}" != "fc" ]] && \
[[ "${adrfam}" != "loop" ]] ; then
- echo "${trsvcid}" > "${portcfs}/addr_trsvcid"
+ _echo "${trsvcid}" "${portcfs}/addr_trsvcid"
fi
if [[ "${trtype}" == "tcp" ]] && \
[[ "${tls}" != "none" ]]; then
- echo "tls1.3" > "${portcfs}/addr_tsas"
+ _echo "tls1.3" "${portcfs}/addr_tsas"
if [[ "${tls}" != "required" ]]; then
- echo "not required" > "${portcfs}/addr_treq"
+ _echo "not required" "${portcfs}/addr_treq"
fi
fi
echo "${port}"
@@ -601,7 +601,7 @@ _setup_nvmet_port_ana() {
fi
mkdir "${anaport}"
fi
- echo "${anastate}" > "${anaport}/ana_state"
+ _echo "${anastate}" "${anaport}/ana_state"
}
_remove_nvmet_port() {
@@ -722,19 +722,19 @@ _create_nvmet_ns() {
subsys_path="${NVMET_CFS}/subsystems/${subsysnqn}"
ns_path="${subsys_path}/namespaces/${nsid}"
mkdir "${ns_path}"
- printf "%s" "${blkdev}" > "${ns_path}/device_path"
+ _echo "$(printf "%s" "${blkdev}")" "${ns_path}/device_path"
if [[ -f "${ns_path}/resv_enable" && "${resv_enable}" = true ]] ; then
- printf 1 > "${ns_path}/resv_enable"
+ _echo 1 "${ns_path}/resv_enable"
fi
if [[ -n "${uuid}" ]]; then
- printf "%s" "${uuid}" > "${ns_path}/device_uuid"
+ _echo "$(printf "%s" "${uuid}")" "${ns_path}/device_uuid"
else
uuid=$(cat "${ns_path}/device_uuid")
fi
if (( grpid != 1 )); then
- printf "%d" "${grpid}" > "${ns_path}/ana_grpid"
+ _echo "$(printf "%d" "${grpid}")" "${ns_path}/ana_grpid"
fi
- printf 1 > "${ns_path}/enable"
+ _echo 1 "${ns_path}/enable"
echo "${uuid}"
}
@@ -748,7 +748,7 @@ _setup_nvmet_ns_ana() {
if [[ ! -d "${ns_path}" ]]; then
return
fi
- echo "${anagrpid}" > "${ns_path}/anagrpid"
+ _echo "${anagrpid}" "${ns_path}/anagrpid"
}
_create_nvmet_subsystem() {
@@ -786,7 +786,7 @@ _create_nvmet_subsystem() {
cfs_path="${NVMET_CFS}/subsystems/${subsystem}"
mkdir -p "${cfs_path}"
- echo 0 > "${cfs_path}/attr_allow_any_host"
+ _echo 0 "${cfs_path}/attr_allow_any_host"
if [[ -z "${blkdev}" ]]; then
return 0
fi
@@ -825,10 +825,10 @@ _create_nvmet_host() {
mkdir "${host_path}"
_add_nvmet_allow_hosts "${nvmet_subsystem}" "${nvmet_hostnqn}"
if [[ "${nvmet_hostkey}" ]] ; then
- echo "${nvmet_hostkey}" > "${host_path}/dhchap_key"
+ _echo "${nvmet_hostkey}" "${host_path}/dhchap_key"
fi
if [[ "${nvmet_ctrlkey}" ]] ; then
- echo "${nvmet_ctrlkey}" > "${host_path}/dhchap_ctrl_key"
+ _echo "${nvmet_ctrlkey}" "${host_path}/dhchap_ctrl_key"
fi
}
@@ -838,7 +838,7 @@ _remove_nvmet_ns() {
local subsys_path="${NVMET_CFS}/subsystems/${nvmet_subsystem}"
local nvmet_ns_path="${subsys_path}/namespaces/${nsid}"
- echo 0 > "${nvmet_ns_path}/enable"
+ _echo 0 "${nvmet_ns_path}/enable"
rmdir "${nvmet_ns_path}"
}
diff --git a/tests/nvme/rc b/tests/nvme/rc
index a8f80d8..c106359 100644
--- a/tests/nvme/rc
+++ b/tests/nvme/rc
@@ -223,12 +223,12 @@ _create_nvmet_passthru() {
local passthru_path="${subsys_path}/passthru"
mkdir -p "${subsys_path}"
- echo 0 > "${subsys_path}/attr_allow_any_host"
+ _echo 0 "${subsys_path}/attr_allow_any_host"
_test_dev_nvme_ctrl > "${passthru_path}/device_path"
- echo 1 > "${passthru_path}/enable"
+ _echo 1 "${passthru_path}/enable"
if [[ -f "${passthru_path}/clear_ids" ]]; then
- echo 1 > "${passthru_path}/clear_ids"
+ _echo 1 "${passthru_path}/clear_ids"
fi
}
@@ -237,7 +237,7 @@ _remove_nvmet_passhtru() {
local subsys_path="${NVMET_CFS}/subsystems/${nvmet_subsystem}"
local passthru_path="${subsys_path}/passthru"
- echo 0 > "${passthru_path}/enable"
+ _echo 0 "${passthru_path}/enable"
rm -f "${subsys_path}"/allowed_hosts/*
rmdir "${subsys_path}"
}
@@ -247,8 +247,7 @@ _set_nvmet_hostkey() {
local nvmet_hostkey="$2"
local cfs_path="${NVMET_CFS}/hosts/${nvmet_hostnqn}"
- echo "${nvmet_hostkey}" > \
- "${cfs_path}/dhchap_key"
+ _echo "${nvmet_hostkey}" "${cfs_path}/dhchap_key"
}
_set_nvmet_ctrlkey() {
@@ -256,8 +255,7 @@ _set_nvmet_ctrlkey() {
local nvmet_ctrlkey="$2"
local cfs_path="${NVMET_CFS}/hosts/${nvmet_hostnqn}"
- echo "${nvmet_ctrlkey}" > \
- "${cfs_path}/dhchap_ctrl_key"
+ _echo "${nvmet_ctrlkey}" "${cfs_path}/dhchap_ctrl_key"
}
_set_nvmet_hash() {
@@ -265,8 +263,7 @@ _set_nvmet_hash() {
local nvmet_hash="$2"
local cfs_path="${NVMET_CFS}/hosts/${nvmet_hostnqn}"
- echo "${nvmet_hash}" > \
- "${cfs_path}/dhchap_hash"
+ _echo "${nvmet_hash}" "${cfs_path}/dhchap_hash"
}
_set_nvmet_dhgroup() {
@@ -274,8 +271,7 @@ _set_nvmet_dhgroup() {
local nvmet_dhgroup="$2"
local cfs_path="${NVMET_CFS}/hosts/${nvmet_hostnqn}"
- echo "${nvmet_dhgroup}" > \
- "${cfs_path}/dhchap_dhgroup"
+ _echo "${nvmet_dhgroup}" "${cfs_path}/dhchap_dhgroup"
}
_enable_nvmet_ns() {
@@ -285,7 +281,7 @@ _enable_nvmet_ns() {
cfs_path="${NVMET_CFS}/subsystems/${subsysnqn}"
ns_path="${cfs_path}/namespaces/${nsid}"
- echo 1 > "${ns_path}/enable"
+ _echo 1 "${ns_path}/enable"
}
_disable_nvmet_ns() {
@@ -295,7 +291,7 @@ _disable_nvmet_ns() {
cfs_path="${NVMET_CFS}/subsystems/${subsysnqn}"
ns_path="${cfs_path}/namespaces/${nsid}"
- echo 0 > "${ns_path}/enable"
+ _echo 0 "${ns_path}/enable"
}
_set_nvmet_ns_uuid() {
@@ -473,8 +469,10 @@ _nvme_passthru_logging_setup()
_nvme_passthru_logging_cleanup()
{
- echo "$ctrl_dev_passthru_logging" > /sys/class/nvme/"$2"/passthru_err_log_enabled
- echo "$ns_dev_passthru_logging" > /sys/class/nvme/"$2"/"$1"/passthru_err_log_enabled
+ _echo "$ctrl_dev_passthru_logging" \
+ /sys/class/nvme/"$2"/passthru_err_log_enabled
+ _echo "$ns_dev_passthru_logging" \
+ /sys/class/nvme/"$2"/"$1"/passthru_err_log_enabled
}
_nvme_err_inject_setup()
@@ -495,55 +493,55 @@ _nvme_err_inject_cleanup()
local a
for a in /sys/kernel/debug/"$1"/fault_inject/*; do
- echo "${NS_DEV_FAULT_INJECT_SAVE[${a}]}" > "${a}"
+ _echo "${NS_DEV_FAULT_INJECT_SAVE[${a}]}" "${a}"
done
for a in /sys/kernel/debug/"$2"/fault_inject/*; do
- echo "${CTRL_DEV_FAULT_INJECT_SAVE[${a}]}" > "${a}"
+ _echo "${CTRL_DEV_FAULT_INJECT_SAVE[${a}]}" "${a}"
done
}
_nvme_enable_err_inject()
{
- echo "$2" > /sys/kernel/debug/"$1"/fault_inject/verbose
- echo "$3" > /sys/kernel/debug/"$1"/fault_inject/probability
- echo "$4" > /sys/kernel/debug/"$1"/fault_inject/dont_retry
- echo "$5" > /sys/kernel/debug/"$1"/fault_inject/status
- echo "$6" > /sys/kernel/debug/"$1"/fault_inject/times
+ _echo "$2" /sys/kernel/debug/"$1"/fault_inject/verbose
+ _echo "$3" /sys/kernel/debug/"$1"/fault_inject/probability
+ _echo "$4" /sys/kernel/debug/"$1"/fault_inject/dont_retry
+ _echo "$5" /sys/kernel/debug/"$1"/fault_inject/status
+ _echo "$6" /sys/kernel/debug/"$1"/fault_inject/times
}
_nvme_disable_err_inject()
{
- echo 0 > /sys/kernel/debug/"$1"/fault_inject/probability
- echo 0 > /sys/kernel/debug/"$1"/fault_inject/times
+ _echo 0 /sys/kernel/debug/"$1"/fault_inject/probability
+ _echo 0 /sys/kernel/debug/"$1"/fault_inject/times
}
_nvme_enable_passthru_admin_error_logging()
{
- echo on > /sys/class/nvme/"$1"/passthru_err_log_enabled
+ _echo on /sys/class/nvme/"$1"/passthru_err_log_enabled
}
_nvme_enable_passthru_io_error_logging()
{
- echo on > /sys/class/nvme/"$2"/"$1"/passthru_err_log_enabled
+ _echo on /sys/class/nvme/"$2"/"$1"/passthru_err_log_enabled
}
_nvme_disable_passthru_admin_error_logging()
{
- echo off > /sys/class/nvme/"$1"/passthru_err_log_enabled
+ _echo off /sys/class/nvme/"$1"/passthru_err_log_enabled
}
_nvme_disable_passthru_io_error_logging()
{
- echo off > /sys/class/nvme/"$2"/"$1"/passthru_err_log_enabled
+ _echo off /sys/class/nvme/"$2"/"$1"/passthru_err_log_enabled
}
_nvme_reset_ctrl() {
- echo 1 > /sys/class/nvme/"$1"/reset_controller
+ _echo 1 /sys/class/nvme/"$1"/reset_controller
}
_nvme_delete_ctrl() {
- echo 1 > /sys/class/nvme/"$1"/delete_controller
+ _echo 1 /sys/class/nvme/"$1"/delete_controller
}
# Check whether the version of the fio is greater than or equal to $1.$2.$3
--
2.54.0
^ permalink raw reply related
* [PATCH blktests 2/3] common/rc: add _echo() function to trace sysfs attribute writes
From: Shin'ichiro Kawasaki @ 2026-05-13 11:23 UTC (permalink / raw)
To: linux-block; +Cc: Daniel Wagner, John Meneghini, Shin'ichiro Kawasaki
In-Reply-To: <20260513112326.584256-1-shinichiro.kawasaki@wdc.com>
Many test cases write to sysfs attributes, and these writes are
important for understanding test behavior. However, bash's xtrace
feature does not record the target file in commands like `echo X > Y`;
it only records `echo X`.
To capture the write target, introduce `_echo()`, which writes its first
argument to the file specified by its second argument. This allows
xtrace to record the complete operation (e.g., `_echo X Y` instead of
just `echo X`).
Signed-off-by: Shin'ichiro Kawasaki <shinichiro.kawasaki@wdc.com>
---
common/rc | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/common/rc b/common/rc
index d2c1d74..0941678 100644
--- a/common/rc
+++ b/common/rc
@@ -780,3 +780,9 @@ _min() {
done
echo "$ret"
}
+
+# Echo a value to a file. This wrapper is used to trace sysfs attribute writes
+# when the --cmd-trace option is enabled.
+_echo() {
+ echo "$1" > "$2"
+}
--
2.54.0
^ permalink raw reply related
* [PATCH blktests 1/3] check: add --cmd-trace option
From: Shin'ichiro Kawasaki @ 2026-05-13 11:23 UTC (permalink / raw)
To: linux-block; +Cc: Daniel Wagner, John Meneghini, Shin'ichiro Kawasaki
In-Reply-To: <20260513112326.584256-1-shinichiro.kawasaki@wdc.com>
Test cases that use helper functions can be difficult to understand due
to deep nesting. To make test execution easier to follow, add a new
--cmd-trace (or -t) option to record the commands executed during test
runs.
The trace is implemented using bash's xtrace feature. Enable xtrace with
`set -x` before each test case and redirect the trace output to a
`.cmdtrace` file in the result directory.
Signed-off-by: Shin'ichiro Kawasaki <shinichiro.kawasaki@wdc.com>
---
check | 17 ++++++++++++++++-
1 file changed, 16 insertions(+), 1 deletion(-)
diff --git a/check b/check
index c166fae..a68049b 100755
--- a/check
+++ b/check
@@ -458,7 +458,17 @@ _call_test() {
TIMEFORMAT="%Rs"
pushd . >/dev/null || return
+ if ((CMD_TRACE)); then
+ exec 8>"${seqres}.cmdtrace"
+ export BASH_XTRACEFD=8
+ set -x
+ fi
{ time "$test_func" >"${seqres}.out" 2>&1; } 2>"${seqres}.runtime"
+ if ((CMD_TRACE)); then
+ set +x
+ unset BASH_XTRACEFD
+ exec 8>&-
+ fi
TEST_RUN["exit_status"]=$?
popd >/dev/null || return
TEST_RUN["runtime"]="$(cat "${seqres}.runtime")"
@@ -1157,7 +1167,7 @@ Miscellaneous:
_check_dependencies
-if ! TEMP=$(getopt -o 'do:q::x:c:h' --long 'device-only,quick::,exclude:,output:,config:,help' -n "$0" -- "$@"); then
+if ! TEMP=$(getopt -o 'do:q::x:c:th' --long 'device-only,quick::,exclude:,output:,config:,cmd-trace,help' -n "$0" -- "$@"); then
exit 1
fi
@@ -1165,6 +1175,7 @@ eval set -- "$TEMP"
unset TEMP
LOADED_CONFIG=0
+CMD_TRACE=0
OPTION_EXCLUDE=()
while true; do
case "$1" in
@@ -1192,6 +1203,10 @@ while true; do
LOADED_CONFIG=1
shift 2
;;
+ '-t'|'--cmd-trace')
+ CMD_TRACE=1
+ shift
+ ;;
'-h'|'--help')
usage out
;;
--
2.54.0
^ permalink raw reply related
* [PATCH blktests 0/3] introduce command trace feature
From: Shin'ichiro Kawasaki @ 2026-05-13 11:23 UTC (permalink / raw)
To: linux-block; +Cc: Daniel Wagner, John Meneghini, Shin'ichiro Kawasaki
Some blktests test cases have deep nesting, making their behavior
difficult to understand. For example, the nvme test group has many
helper functions that set sysfs attribute values and call nvme-cli
commands. Understanding these behaviors is essential for debugging test
case failures.
This series adds a new 'command trace' feature to blktests. The first
patch introduces a new --cmd-trace (or -t) option to record commands
executed during test runs. The second and third patches add a new helper
function _echo(), which traces both the value and file name of sysfs
attribute writes.
With this series, blktests users can use the option to generate a
.cmdtrace file that records all commands executed during a test case
run. By grepping the .cmdtrace file, users can check writes to sysfs
attributes and nvme-cli command invocations. The example below shows how
nvme targets are set up for the nvme/008 test case with rdma transport.
# NVMET_TRTYPES=rdma NVMET_BLKDEV_TYPES=device ./check --cmd-trace nvme/008
nvme/008 (tr=rdma bd=device) (create an NVMeOF host) [passed]
runtime 1.903s ... 1.890s
# grep -e _echo -e "nvme " results/nodev_tr_rdma_bd_device/nvme/008.cmdtrace
+ _echo 0 /sys/kernel/config/nvmet/subsystems/blktests-subsystem-1/attr_allow_any_host
+ _echo /dev/loop0 /sys/kernel/config/nvmet/subsystems/blktests-subsystem-1/namespaces/1/device_path
+ _echo 91fdba0d-f87b-4c25-b80f-db7be1418b9e /sys/kernel/config/nvmet/subsystems/blktests-subsystem-1/namespaces/1/device_uuid
+ _echo 1 /sys/kernel/config/nvmet/subsystems/blktests-subsystem-1/namespaces/1/enable
++ _echo rdma /sys/kernel/config/nvmet/ports/0/addr_trtype
++ _echo 10.0.2.15 /sys/kernel/config/nvmet/ports/0/addr_traddr
++ _echo ipv4 /sys/kernel/config/nvmet/ports/0/addr_adrfam
++ _echo 4420 /sys/kernel/config/nvmet/ports/0/addr_trsvcid
++ nvme connect --traddr 10.0.2.15 --transport rdma --trsvcid 4420 --nqn blktests-subsystem-1 --hostnqn=nqn.2014-08.org.nvmexpress:uuid:0f01fb42-9f7f-4856-b0b3-51e60b8de349 --hostid=0f01fb42-9f7f-4856-b0b3-51e60b8de349 --output-format=json
+ nvme disconnect --nqn blktests-subsystem-1
+ _echo 0 /sys/kernel/config/nvmet/subsystems/blktests-subsystem-1/namespaces/1/enable
P.S. The idea of command trace came from the hallway discussion at LSFMMBPF
2026 with John Meneghini and Daniel Wagner. Thanks!
Shin'ichiro Kawasaki (3):
check: add --cmd-trace option
common/rc: add _echo() function to trace sysfs attribute writes
common/nvme, nvme/rc: use _echo() to trace sysfs attribute writes
check | 17 ++++++++++++++-
common/nvme | 34 ++++++++++++++---------------
common/rc | 6 ++++++
tests/nvme/rc | 60 +++++++++++++++++++++++++--------------------------
4 files changed, 68 insertions(+), 49 deletions(-)
--
2.54.0
^ permalink raw reply
* Re: [PATCH] block: fix handling of dead zone write plugs
From: Shin'ichiro Kawasaki @ 2026-05-13 11:22 UTC (permalink / raw)
To: Damien Le Moal; +Cc: Jens Axboe, linux-block, Christoph Hellwig
In-Reply-To: <20260513111129.108809-1-dlemoal@kernel.org>
On May 13, 2026 / 20:11, Damien Le Moal wrote:
> Shin'ichiro reported hard to reproduce unaligned write errors with zoned
> block devices. Under normal operation conditions (e.g. running XFS on an
> SMR disk), these errors are nearly impossible to trigger. But using a
> "slow" kernel with many debug options enables and some specific use cases
> (e.g. fio zbd test case 46), the errors can be reproduced fairly easily.
...
> Reported-by: Shin'ichiro Kawasaki <shinichiro.kawasaki@wdc.com>
> Fixes: b7d4ffb51037 ("block: fix zone write plug removal")
> Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
Thanks for the fix. I applied this patch on top of the v7.1-rc3 kernel and
confirmed that the fio zbd test case 46 failure goes away.
Tested-by: Shin'ichiro Kawasaki <shinichiro.kawasaki@wdc.com>
^ permalink raw reply
* [PATCH] block: fix handling of dead zone write plugs
From: Damien Le Moal @ 2026-05-13 11:11 UTC (permalink / raw)
To: Jens Axboe, linux-block; +Cc: Christoph Hellwig, Shin'ichiro Kawasaki
Shin'ichiro reported hard to reproduce unaligned write errors with zoned
block devices. Under normal operation conditions (e.g. running XFS on an
SMR disk), these errors are nearly impossible to trigger. But using a
"slow" kernel with many debug options enables and some specific use cases
(e.g. fio zbd test case 46), the errors can be reproduced fairly easily.
The unaligned write errors come from mishandling a valid reference
counting pattern of zone write plugs. Such pattern triggers for instance
if a process A writes a zone (not necessarilly to the full state), another
process B immediately resets the zone and immediately following the
completion of the zone reset, starts issuing writes to the zone. With such
pattern, in some cases, the zone write plugs worker thread of the device
may still be holding a reference to the zone write plug of the zone taken
when process A was writing to the zone. The following zone reset from
process B marks the zone as dead but does not remove the zone write plug
from the device hash table as a reference to the plug still exist. Once
process B starts issuing new writes, the zone write plug is seen as dead
and the writes from process B are immediately failed, despite this write
pattern being perfectly legal.
Fix this by allowing restoring a dead zone write plug to a live state if a
write is issued to the zone when the zone is: marked as dead, empty and
the write sector corresponds to the first sector of the zone (that is, the
write is aligned to the zone write pointer). This is done with the new
helper function disk_check_zone_wplug_dead(), which restores a dead zone
write plug to a live state by clearing the BLK_ZONE_WPLUG_DEAD flag and
restoring the initial reference to the zone write plug taken when the plug
was added to the device hash table.
Reported-by: Shin'ichiro Kawasaki <shinichiro.kawasaki@wdc.com>
Fixes: b7d4ffb51037 ("block: fix zone write plug removal")
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
block/blk-zoned.c | 32 +++++++++++++++++++++++++++-----
1 file changed, 27 insertions(+), 5 deletions(-)
diff --git a/block/blk-zoned.c b/block/blk-zoned.c
index 30cad2bb9291..42ef830054dc 100644
--- a/block/blk-zoned.c
+++ b/block/blk-zoned.c
@@ -623,6 +623,28 @@ static void disk_mark_zone_wplug_dead(struct blk_zone_wplug *zwplug)
}
}
+static inline bool disk_check_zone_wplug_dead(struct blk_zone_wplug *zwplug)
+{
+ if (!(zwplug->flags & BLK_ZONE_WPLUG_DEAD))
+ return false;
+
+ /*
+ * If a new write is received right after a zone reset completes and
+ * while the disk_zone_wplugs_worker() thread has not yet released the
+ * reference on the zone write plug after processing the last write to
+ * the zone, then the new write BIO will see the zone write plug marked
+ * as dead. This case is however a false positive and a perfectly valid
+ * pattern. In such case, restore the zone write plug to a live one.
+ */
+ if (!zwplug->wp_offset && bio_list_empty(&zwplug->bio_list)) {
+ zwplug->flags &= ~BLK_ZONE_WPLUG_DEAD;
+ refcount_inc(&zwplug->ref);
+ return false;
+ }
+
+ return true;
+}
+
static bool disk_zone_wplug_submit_bio(struct gendisk *disk,
struct blk_zone_wplug *zwplug);
@@ -1444,12 +1466,12 @@ static bool blk_zone_wplug_handle_write(struct bio *bio, unsigned int nr_segs)
spin_lock_irqsave(&zwplug->lock, flags);
/*
- * If we got a zone write plug marked as dead, then the user is issuing
- * writes to a full zone, or without synchronizing with zone reset or
- * zone finish operations. In such case, fail the BIO to signal this
- * invalid usage.
+ * Check if we got a zone write plug marked as dead. If yes, then the
+ * user is likely issuing writes to a full zone, or without
+ * synchronizing with zone reset or zone finish operations. In such
+ * case, fail the BIO to signal this invalid usage.
*/
- if (zwplug->flags & BLK_ZONE_WPLUG_DEAD) {
+ if (disk_check_zone_wplug_dead(zwplug)) {
spin_unlock_irqrestore(&zwplug->lock, flags);
disk_put_zone_wplug(zwplug);
bio_io_error(bio);
--
2.54.0
^ permalink raw reply related
* [PATCH] drbd: clean up UAPI headers
From: Christoph Böhmwalder @ 2026-05-13 11:03 UTC (permalink / raw)
To: Jens Axboe
Cc: drbd-dev, linux-kernel, Lars Ellenberg, Philipp Reisner,
linux-block, Christoph Böhmwalder, kernel test robot
Commit b1798910fc7f ("drbd: move UAPI headers to include/uapi/linux/")
broke compilation on targets without a hosted libc:
./usr/include/linux/drbd.h:18:10: fatal error: sys/types.h: No such
file or directory
The underlying issue is that there were some constructs left over in
those headers that don't belong in uapi.
Drop the __KERNEL__-gated split in drbd.h. The !__KERNEL__ branch pulls
in <sys/types.h>, <sys/wait.h> and <limits.h> for symbols that the
header does not actually reference; they were carried over from when
this lived in include/linux/.
Replace <asm/types.h> and the entire #ifdef block with the standard
UAPI combo <linux/types.h> + <asm/byteorder.h>, which provides
__u32/__u64/__s32 and __{LITTLE,BIG}_ENDIAN_BITFIELD in both kernel
and userspace contexts.
drbd_limits.h references some enum values and the DRBD_PROT_C define
from drbd.h, but does not include it. Add the missing include while
we're here.
Drop the unprefixed DEBUG_RANGE_CHECK from drbd_limits.h. It has no
in-kernel users and pollutes the userspace namespace.
Switch the drbd.h and drbd_limits.h include guards to the _UAPI_LINUX_*
convention already used by drbd_genl.h.
Reported-by: kernel test robot <lkp@intel.com>
Closes: https://lore.kernel.org/oe-kbuild-all/202605101346.V2wwJqv1-lkp@intel.com/
Fixes: b1798910fc7f ("drbd: move UAPI headers to include/uapi/linux/")
Signed-off-by: Christoph Böhmwalder <christoph.boehmwalder@linbit.com>
---
include/uapi/linux/drbd.h | 28 +++-------------------------
include/uapi/linux/drbd_limits.h | 8 ++++----
2 files changed, 7 insertions(+), 29 deletions(-)
diff --git a/include/uapi/linux/drbd.h b/include/uapi/linux/drbd.h
index 5d4d677cf1ad..cf1ec3eb872f 100644
--- a/include/uapi/linux/drbd.h
+++ b/include/uapi/linux/drbd.h
@@ -11,32 +11,10 @@
*/
-#ifndef DRBD_H
-#define DRBD_H
-#include <asm/types.h>
-
-#ifdef __KERNEL__
+#ifndef _UAPI_LINUX_DRBD_H
+#define _UAPI_LINUX_DRBD_H
#include <linux/types.h>
#include <asm/byteorder.h>
-#else
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <limits.h>
-
-/* Although the Linux source code makes a difference between
- generic endianness and the bitfields' endianness, there is no
- architecture as of Linux-2.6.24-rc4 where the bitfields' endianness
- does not match the generic endianness. */
-
-#if __BYTE_ORDER == __LITTLE_ENDIAN
-#define __LITTLE_ENDIAN_BITFIELD
-#elif __BYTE_ORDER == __BIG_ENDIAN
-#define __BIG_ENDIAN_BITFIELD
-#else
-# error "sorry, weird endianness on this box"
-#endif
-
-#endif
enum drbd_io_error_p {
EP_PASS_ON, /* FIXME should the better be named "Ignore"? */
@@ -432,4 +410,4 @@ enum drbd_state_info_bcast_reason {
SIB_SYNC_PROGRESS = 5,
};
-#endif
+#endif /* _UAPI_LINUX_DRBD_H */
diff --git a/include/uapi/linux/drbd_limits.h b/include/uapi/linux/drbd_limits.h
index a72a102d1ca7..acefe84bc602 100644
--- a/include/uapi/linux/drbd_limits.h
+++ b/include/uapi/linux/drbd_limits.h
@@ -11,10 +11,10 @@
* feedback about nonsense settings for certain configurable values.
*/
-#ifndef DRBD_LIMITS_H
-#define DRBD_LIMITS_H 1
+#ifndef _UAPI_LINUX_DRBD_LIMITS_H
+#define _UAPI_LINUX_DRBD_LIMITS_H
-#define DEBUG_RANGE_CHECK 0
+#include <linux/drbd.h>
#define DRBD_MINOR_COUNT_MIN 1U
#define DRBD_MINOR_COUNT_MAX 255U
@@ -248,4 +248,4 @@
#define DRBD_RS_DISCARD_GRANULARITY_DEF 0U /* disabled by default */
#define DRBD_RS_DISCARD_GRANULARITY_SCALE '1' /* bytes */
-#endif
+#endif /* _UAPI_LINUX_DRBD_LIMITS_H */
base-commit: 8098eeb693c4cc4e774c62fbd4875197cb5578ce
--
2.53.0
^ permalink raw reply related
* [PATCH V2] selftests: ublk: cap nthreads to kernel's actual nr_hw_queues
From: Ming Lei @ 2026-05-13 10:19 UTC (permalink / raw)
To: Jens Axboe, linux-block; +Cc: Caleb Sander Mateos, Uday Shankar, Ming Lei
dev->nthreads is derived from the user-requested queue count before the
ADD command, but the kernel may reduce nr_hw_queues (capped to
nr_cpu_ids). When the VM has fewer CPUs than requested queues, the
daemon creates more handler threads than there are kernel queues.
In non-batch mode, the extra threads access uninitialized queues
(q_depth=0), submit zero io_uring SQEs, and block forever in
io_cqring_wait. In batch mode, the extra threads cause similar hangs
during device removal.
In both cases, the stuck threads prevent the daemon from closing the
char device, holding the last ublk_device reference and causing
ublk_ctrl_del_dev() to hang in wait_event_interruptible().
Fix by capping dev->nthreads to the kernel-returned nr_hw_queues after
the ADD command completes. per_io_tasks mode is excluded because threads
interleave across all queues, so nthreads > nr_hw_queues is valid.
Fixes: abe54c160346 ("selftests: ublk: kublk: decouple ublk_queues from ublk server threads")
Signed-off-by: Ming Lei <tom.leiming@gmail.com>
---
V2:
- fix email address & signed-off-by
tools/testing/selftests/ublk/kublk.c | 11 +++++++++++
1 file changed, 11 insertions(+)
diff --git a/tools/testing/selftests/ublk/kublk.c b/tools/testing/selftests/ublk/kublk.c
index fbd9b1e7342a..0b23c09daea5 100644
--- a/tools/testing/selftests/ublk/kublk.c
+++ b/tools/testing/selftests/ublk/kublk.c
@@ -1735,6 +1735,17 @@ static int __cmd_dev_add(const struct dev_ctx *ctx)
goto fail;
}
+ /*
+ * The kernel may reduce nr_hw_queues (e.g. capped to nr_cpu_ids).
+ * Cap nthreads to the actual queue count to avoid creating extra
+ * handler threads that will hang during device removal.
+ *
+ * per_io_tasks mode is excluded: threads interleave across all
+ * queues so nthreads > nr_hw_queues is valid and intentional.
+ */
+ if (!ctx->per_io_tasks && dev->nthreads > info->nr_hw_queues)
+ dev->nthreads = info->nr_hw_queues;
+
ret = ublk_start_daemon(ctx, dev);
ublk_dbg(UBLK_DBG_DEV, "%s: daemon exit %d\n", __func__, ret);
if (ret < 0)
--
2.53.0
^ permalink raw reply related
* Re: [PATCH] selftests: ublk: cap nthreads to kernel's actual nr_hw_queues
From: Ming Lei @ 2026-05-13 10:17 UTC (permalink / raw)
To: Ming Lei; +Cc: Jens Axboe, linux-block, Caleb Sander Mateos, Uday Shankar
In-Reply-To: <20260513100142.1371363-1-tom.leiming@gmail.com>
On Wed, May 13, 2026 at 6:02 PM Ming Lei <tom.leiming@gmail.com> wrote:
>
> From: Ming Lei <ming.lei@redhat.com>
>
> dev->nthreads is derived from the user-requested queue count before the
> ADD command, but the kernel may reduce nr_hw_queues (capped to
> nr_cpu_ids). When the VM has fewer CPUs than requested queues, the
> daemon creates more handler threads than there are kernel queues.
>
> In non-batch mode, the extra threads access uninitialized queues
> (q_depth=0), submit zero io_uring SQEs, and block forever in
> io_cqring_wait. In batch mode, the extra threads cause similar hangs
> during device removal.
>
> In both cases, the stuck threads prevent the daemon from closing the
> char device, holding the last ublk_device reference and causing
> ublk_ctrl_del_dev() to hang in wait_event_interruptible().
>
> Fix by capping dev->nthreads to the kernel-returned nr_hw_queues after
> the ADD command completes. per_io_tasks mode is excluded because threads
> interleave across all queues, so nthreads > nr_hw_queues is valid.
>
> Fixes: abe54c160346 ("selftests: ublk: kublk: decouple ublk_queues from ublk server threads")
> Signed-off-by: Ming Lei <ming.lei@redhat.com>
Oops, please ignore this patch.
Thanks,
Ming
^ permalink raw reply
* Re: [PATCH v3 02/10] iov_iter: add iterator type for dmabuf maps
From: David Laight @ 2026-05-13 10:05 UTC (permalink / raw)
To: Pavel Begunkov
Cc: Jens Axboe, Keith Busch, Christoph Hellwig, Sagi Grimberg,
Alexander Viro, Christian Brauner, Andrew Morton, Sumit Semwal,
Christian König, linux-block, linux-kernel, linux-nvme,
linux-fsdevel, io-uring, linux-media, dri-devel, linaro-mm-sig,
Nitesh Shetty, Kanchan Joshi, Anuj Gupta, Tushar Gohad,
William Power, Phil Cayton, Jason Gunthorpe
In-Reply-To: <20a233d2f35274817aa643cc0fe113707eb47e72.1777475843.git.asml.silence@gmail.com>
On Wed, 29 Apr 2026 16:25:48 +0100
Pavel Begunkov <asml.silence@gmail.com> wrote:
> Introduce a new iterator type for dmabuf maps. The map in an opaque
> object with internals and format specific to the subsystem / driver, and
> only it can use that subsystem / driver for issuing IO. The task of the
> middle layers is to pass the map / iterator further down, maybe doing
> basic splitting and length checking. The iterator can only be used by
> operations of the file the associated map was created for.
>
> Suggested-by: Keith Busch <kbusch@kernel.org>
> Signed-off-by: Pavel Begunkov <asml.silence@gmail.com>
> ---
> include/linux/uio.h | 11 +++++++++++
> lib/iov_iter.c | 29 +++++++++++++++++++++++------
> 2 files changed, 34 insertions(+), 6 deletions(-)
>
> diff --git a/include/linux/uio.h b/include/linux/uio.h
> index a9bc5b3067e3..75051aed70de 100644
> --- a/include/linux/uio.h
> +++ b/include/linux/uio.h
> @@ -12,6 +12,7 @@
>
> struct page;
> struct folio_queue;
> +struct io_dmabuf_map;
>
> typedef unsigned int __bitwise iov_iter_extraction_t;
>
> @@ -29,6 +30,7 @@ enum iter_type {
> ITER_FOLIOQ,
> ITER_XARRAY,
> ITER_DISCARD,
> + ITER_DMABUF_MAP,
> };
>
> #define ITER_SOURCE 1 // == WRITE
> @@ -71,6 +73,7 @@ struct iov_iter {
> const struct folio_queue *folioq;
> struct xarray *xarray;
> void __user *ubuf;
> + struct io_dmabuf_map *dmabuf_map;
> };
> size_t count;
> };
> @@ -155,6 +158,11 @@ static inline bool iov_iter_is_xarray(const struct iov_iter *i)
> return iov_iter_type(i) == ITER_XARRAY;
> }
>
> +static inline bool iov_iter_is_dmabuf_map(const struct iov_iter *i)
> +{
> + return iov_iter_type(i) == ITER_DMABUF_MAP;
> +}
> +
> static inline unsigned char iov_iter_rw(const struct iov_iter *i)
> {
> return i->data_source ? WRITE : READ;
> @@ -300,6 +308,9 @@ void iov_iter_folio_queue(struct iov_iter *i, unsigned int direction,
> unsigned int first_slot, unsigned int offset, size_t count);
> void iov_iter_xarray(struct iov_iter *i, unsigned int direction, struct xarray *xarray,
> loff_t start, size_t count);
> +void iov_iter_dmabuf_map(struct iov_iter *i, unsigned int direction,
> + struct io_dmabuf_map *map,
> + loff_t off, size_t count);
> ssize_t iov_iter_get_pages2(struct iov_iter *i, struct page **pages,
> size_t maxsize, unsigned maxpages, size_t *start);
> ssize_t iov_iter_get_pages_alloc2(struct iov_iter *i, struct page ***pages,
> diff --git a/lib/iov_iter.c b/lib/iov_iter.c
> index 243662af1af7..e2253684b991 100644
> --- a/lib/iov_iter.c
> +++ b/lib/iov_iter.c
> @@ -575,7 +575,8 @@ void iov_iter_advance(struct iov_iter *i, size_t size)
> {
> if (unlikely(i->count < size))
> size = i->count;
> - if (likely(iter_is_ubuf(i)) || unlikely(iov_iter_is_xarray(i))) {
> + if (likely(iter_is_ubuf(i)) || unlikely(iov_iter_is_xarray(i)) ||
> + unlikely(iov_iter_is_dmabuf_map(i))) {
Doesn't the extra check add more code to all the non-ubuf cases?
This could be fixed by either making iter_type a bitmask (with one bit set)
or writing an iter_is_one_of(i, ITER_xxx, ITER_yyy) define that uses
'(1 << i->iter_type) & ((1 << ITER_xxx) | ...)'
(look at the the nolibc printf code for an example).
> i->iov_offset += size;
> i->count -= size;
> } else if (likely(iter_is_iovec(i) || iov_iter_is_kvec(i))) {
> @@ -631,7 +632,8 @@ void iov_iter_revert(struct iov_iter *i, size_t unroll)
> return;
> }
> unroll -= i->iov_offset;
> - if (iov_iter_is_xarray(i) || iter_is_ubuf(i)) {
> + if (iov_iter_is_xarray(i) || iter_is_ubuf(i) ||
iter_is_ubuf() should have been first here.
-- David
> + iov_iter_is_dmabuf_map(i)) {
> BUG(); /* We should never go beyond the start of the specified
> * range since we might then be straying into pages that
> * aren't pinned.
> @@ -775,6 +777,20 @@ void iov_iter_xarray(struct iov_iter *i, unsigned int direction,
> }
> EXPORT_SYMBOL(iov_iter_xarray);
>
> +void iov_iter_dmabuf_map(struct iov_iter *i, unsigned int direction,
> + struct io_dmabuf_map *map,
> + loff_t off, size_t count)
> +{
> + WARN_ON(direction & ~(READ | WRITE));
> + *i = (struct iov_iter){
> + .iter_type = ITER_DMABUF_MAP,
> + .data_source = direction,
> + .dmabuf_map = map,
> + .count = count,
> + .iov_offset = off,
> + };
> +}
> +
> /**
> * iov_iter_discard - Initialise an I/O iterator that discards data
> * @i: The iterator to initialise.
> @@ -841,7 +857,7 @@ static unsigned long iov_iter_alignment_bvec(const struct iov_iter *i)
>
> unsigned long iov_iter_alignment(const struct iov_iter *i)
> {
> - if (likely(iter_is_ubuf(i))) {
> + if (likely(iter_is_ubuf(i)) || iov_iter_is_dmabuf_map(i)) {
> size_t size = i->count;
> if (size)
> return ((unsigned long)i->ubuf + i->iov_offset) | size;
> @@ -872,7 +888,7 @@ unsigned long iov_iter_gap_alignment(const struct iov_iter *i)
> size_t size = i->count;
> unsigned k;
>
> - if (iter_is_ubuf(i))
> + if (iter_is_ubuf(i) || iov_iter_is_dmabuf_map(i))
> return 0;
>
> if (WARN_ON(!iter_is_iovec(i)))
> @@ -1469,11 +1485,12 @@ EXPORT_SYMBOL_GPL(import_ubuf);
> void iov_iter_restore(struct iov_iter *i, struct iov_iter_state *state)
> {
> if (WARN_ON_ONCE(!iov_iter_is_bvec(i) && !iter_is_iovec(i) &&
> - !iter_is_ubuf(i)) && !iov_iter_is_kvec(i))
> + !iter_is_ubuf(i) && !iov_iter_is_kvec(i) &&
> + !iov_iter_is_dmabuf_map(i)))
> return;
> i->iov_offset = state->iov_offset;
> i->count = state->count;
> - if (iter_is_ubuf(i))
> + if (iter_is_ubuf(i) || iov_iter_is_dmabuf_map(i))
> return;
> /*
> * For the *vec iters, nr_segs + iov is constant - if we increment
^ permalink raw reply
* [PATCH] selftests: ublk: cap nthreads to kernel's actual nr_hw_queues
From: Ming Lei @ 2026-05-13 10:01 UTC (permalink / raw)
To: Jens Axboe, linux-block; +Cc: Caleb Sander Mateos, Uday Shankar, Ming Lei
From: Ming Lei <ming.lei@redhat.com>
dev->nthreads is derived from the user-requested queue count before the
ADD command, but the kernel may reduce nr_hw_queues (capped to
nr_cpu_ids). When the VM has fewer CPUs than requested queues, the
daemon creates more handler threads than there are kernel queues.
In non-batch mode, the extra threads access uninitialized queues
(q_depth=0), submit zero io_uring SQEs, and block forever in
io_cqring_wait. In batch mode, the extra threads cause similar hangs
during device removal.
In both cases, the stuck threads prevent the daemon from closing the
char device, holding the last ublk_device reference and causing
ublk_ctrl_del_dev() to hang in wait_event_interruptible().
Fix by capping dev->nthreads to the kernel-returned nr_hw_queues after
the ADD command completes. per_io_tasks mode is excluded because threads
interleave across all queues, so nthreads > nr_hw_queues is valid.
Fixes: abe54c160346 ("selftests: ublk: kublk: decouple ublk_queues from ublk server threads")
Signed-off-by: Ming Lei <ming.lei@redhat.com>
---
tools/testing/selftests/ublk/kublk.c | 11 +++++++++++
1 file changed, 11 insertions(+)
diff --git a/tools/testing/selftests/ublk/kublk.c b/tools/testing/selftests/ublk/kublk.c
index fbd9b1e7342a..0b23c09daea5 100644
--- a/tools/testing/selftests/ublk/kublk.c
+++ b/tools/testing/selftests/ublk/kublk.c
@@ -1735,6 +1735,17 @@ static int __cmd_dev_add(const struct dev_ctx *ctx)
goto fail;
}
+ /*
+ * The kernel may reduce nr_hw_queues (e.g. capped to nr_cpu_ids).
+ * Cap nthreads to the actual queue count to avoid creating extra
+ * handler threads that will hang during device removal.
+ *
+ * per_io_tasks mode is excluded: threads interleave across all
+ * queues so nthreads > nr_hw_queues is valid and intentional.
+ */
+ if (!ctx->per_io_tasks && dev->nthreads > info->nr_hw_queues)
+ dev->nthreads = info->nr_hw_queues;
+
ret = ublk_start_daemon(ctx, dev);
ublk_dbg(UBLK_DBG_DEV, "%s: daemon exit %d\n", __func__, ret);
if (ret < 0)
--
2.53.0
^ permalink raw reply related
* Re: [PATCH v2] block/blk-iolatency: Add the processing flow of the chained bio in the QoS and define the related types to solve the problem of incorrect inflight processing in the QoS. The usage of the done_split_bio abstract function in the blk-iolatency project.
From: kernel test robot @ 2026-05-13 9:08 UTC (permalink / raw)
To: Li kunyu, axboe, tj, josef
Cc: oe-kbuild-all, linux-block, linux-kernel, Li kunyu
In-Reply-To: <20260506024244.2741-1-likunyu10@163.com>
Hi Li,
kernel test robot noticed the following build errors:
[auto build test ERROR on axboe/for-next]
[also build test ERROR on linus/master v7.1-rc3 next-20260508]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Li-kunyu/block-blk-iolatency-Add-the-processing-flow-of-the-chained-bio-in-the-QoS-and-define-the-related-types-to-solve-the-prob/20260513-135008
base: https://git.kernel.org/pub/scm/linux/kernel/git/axboe/linux.git for-next
patch link: https://lore.kernel.org/r/20260506024244.2741-1-likunyu10%40163.com
patch subject: [PATCH v2] block/blk-iolatency: Add the processing flow of the chained bio in the QoS and define the related types to solve the problem of incorrect inflight processing in the QoS. The usage of the done_split_bio abstract function in the blk-iolatency project.
config: nios2-allnoconfig (https://download.01.org/0day-ci/archive/20260513/202605131714.5UCGE4aF-lkp@intel.com/config)
compiler: nios2-linux-gcc (GCC) 11.5.0
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20260513/202605131714.5UCGE4aF-lkp@intel.com/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202605131714.5UCGE4aF-lkp@intel.com/
All errors (new ones prefixed by >>):
nios2-linux-ld: block/bio.o: in function `bio_endio':
bio.c:(.text+0x260c): undefined reference to `__rq_qos_done_split_bio'
>> bio.c:(.text+0x260c): relocation truncated to fit: R_NIOS2_CALL26 against `__rq_qos_done_split_bio'
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply
* [PATCH v7 43/43] btrfs: disable send if we have encryption enabled
From: Daniel Vacek @ 2026-05-13 8:53 UTC (permalink / raw)
To: Chris Mason, Josef Bacik, Eric Biggers, Theodore Y. Ts'o,
Jaegeuk Kim, Jens Axboe, David Sterba
Cc: linux-block, Daniel Vacek, linux-fscrypt, linux-btrfs,
linux-kernel, Boris Burkov
In-Reply-To: <20260513085340.3673127-1-neelx@suse.com>
From: Josef Bacik <josef@toxicpanda.com>
send needs to track the dir item values to see if files were renamed
when doing an incremental send. There is code to decrypt the names, but
this breaks the code that checks to see if something was overwritten.
Until this gap is closed we need to disable send on encrypted file
systems. Fixing this is straightforward, but a medium sized project.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Boris Burkov <boris@bur.io>
Signed-off-by: Daniel Vacek <neelx@suse.com>
---
v5: https://lore.kernel.org/linux-btrfs/62ce86b38e2575c542eed7fbe8d986e68496b1d7.1706116485.git.josef@toxicpanda.com/
* No changes since.
---
fs/btrfs/send.c | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c
index 1e80a3db1df2..11a3e928a4c2 100644
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -8095,6 +8095,12 @@ long btrfs_ioctl_send(struct btrfs_root *send_root, const struct btrfs_ioctl_sen
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
+ if (btrfs_fs_incompat(fs_info, ENCRYPT)) {
+ btrfs_err(fs_info,
+ "send with encryption enabled isn't currently suported");
+ return -EINVAL;
+ }
+
/*
* The subvolume must remain read-only during send, protect against
* making it RW. This also protects against deletion.
--
2.53.0
^ permalink raw reply related
* [PATCH v7 42/43] btrfs: disable encryption on RAID5/6
From: Daniel Vacek @ 2026-05-13 8:53 UTC (permalink / raw)
To: Chris Mason, Josef Bacik, Eric Biggers, Theodore Y. Ts'o,
Jaegeuk Kim, Jens Axboe, David Sterba
Cc: linux-block, Daniel Vacek, linux-fscrypt, linux-btrfs,
linux-kernel
In-Reply-To: <20260513085340.3673127-1-neelx@suse.com>
From: Josef Bacik <josef@toxicpanda.com>
The RAID5/6 code will re-arrange bios and submit them through a
different mechanism. This is problematic with inline encryption as we
have to get the bio and csum it after it's been encrypted, and the
raid5/6 bio's don't have the btrfs_bio embedded, so we have no way to
get the csums put on disk.
This isn't an unsolvable problem, but would require a bit of reworking.
Since we discourage users from using this code currently simply don't
allow encryption on RAID5/6 setups. If there's sufficient demand in the
future we can add the support for this.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Daniel Vacek <neelx@suse.com>
---
v7 changes:
* Prevent converting to RAID5/6 if encryption is already enabled as
suggested by Chris' AI review.
No changes in v6.
v5: https://lore.kernel.org/linux-btrfs/941f02bb923edadae1aea4ae3e5aa6ba05d1215a.1706116485.git.josef@toxicpanda.com/
---
fs/btrfs/ioctl.c | 4 ++++
fs/btrfs/super.c | 6 ++++++
fs/btrfs/volumes.c | 5 +++++
3 files changed, 15 insertions(+)
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 2e0b79f41197..873fe08cd19c 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -5165,6 +5165,10 @@ long btrfs_ioctl(struct file *file, unsigned int
return -EOPNOTSUPP;
if (sb_rdonly(fs_info->sb))
return -EROFS;
+ if (btrfs_fs_incompat(fs_info, RAID56)) {
+ btrfs_warn(fs_info, "can't enable encryption with RAID5/6");
+ return -EINVAL;
+ }
/*
* If we crash before we commit, nothing encrypted could have
* been written so it doesn't matter whether the encrypted
diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 7ec07d0bb473..5072ead57d49 100644
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -734,6 +734,12 @@ bool btrfs_check_options(const struct btrfs_fs_info *info,
if (btrfs_check_mountopts_zoned(info, mount_opt))
ret = false;
+ if (btrfs_fs_incompat(info, RAID56) &&
+ btrfs_raw_test_opt(*mount_opt, TEST_DUMMY_ENCRYPTION)) {
+ btrfs_err(info, "cannot use test_dummy_encryption with RAID5/6");
+ ret = false;
+ }
+
if (!test_bit(BTRFS_FS_STATE_REMOUNTING, &info->fs_state)) {
if (btrfs_raw_test_opt(*mount_opt, SPACE_CACHE)) {
btrfs_warn(info,
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index a88e68f90564..d70735d501c4 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -6053,6 +6053,11 @@ struct btrfs_block_group *btrfs_create_chunk(struct btrfs_trans_handle *trans,
lockdep_assert_held(&info->chunk_mutex);
+ if (type & BTRFS_BLOCK_GROUP_RAID56_MASK && btrfs_fs_incompat(info, ENCRYPT)) {
+ btrfs_warn(info, "RAID5/6 not yet supported on encrypted filesystem");
+ return ERR_PTR(-EINVAL);
+ }
+
if (!alloc_profile_is_valid(type, 0)) {
DEBUG_WARN("invalid alloc profile for type %llu", type);
return ERR_PTR(-EINVAL);
--
2.53.0
^ permalink raw reply related
* [PATCH v7 40/43] btrfs: support encryption with log replay
From: Daniel Vacek @ 2026-05-13 8:53 UTC (permalink / raw)
To: Chris Mason, Josef Bacik, Eric Biggers, Theodore Y. Ts'o,
Jaegeuk Kim, Jens Axboe, David Sterba
Cc: linux-block, Daniel Vacek, linux-fscrypt, linux-btrfs,
linux-kernel
In-Reply-To: <20260513085340.3673127-1-neelx@suse.com>
From: Josef Bacik <josef@toxicpanda.com>
Log replay needs a few tweaks in order to make sure everything works
with encryption.
1. Copy in the fscrypt context if we find one in the log.
2. Set NEEDS_FULL_SYNC when we update the inode context so all of the
items are copied into the log at fsync time.
This makes replay of encrypted files work properly.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Daniel Vacek <neelx@suse.com>
---
No changes in v7.
v6 changes:
* Adapted to the redesigned encryption context storing.
- No need to specially handle the extent item now.
It is not any different to before and the
new context items are simply copied.
v5: https://lore.kernel.org/linux-btrfs/d1ada7ac632c2ab554a840c7ba29b53a93b9855f.1706116485.git.josef@toxicpanda.com/
---
fs/btrfs/fscrypt.c | 1 +
fs/btrfs/tree-log.c | 4 +++-
2 files changed, 4 insertions(+), 1 deletion(-)
diff --git a/fs/btrfs/fscrypt.c b/fs/btrfs/fscrypt.c
index a972c8eadfef..b57d2b0ca9fa 100644
--- a/fs/btrfs/fscrypt.c
+++ b/fs/btrfs/fscrypt.c
@@ -145,6 +145,7 @@ static int btrfs_fscrypt_set_context(struct inode *inode, const void *ctx,
goto out_err;
}
+ set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);
leaf = path->nodes[0];
ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index f3b839950855..4336f90e3223 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -2929,7 +2929,9 @@ static int replay_one_buffer(struct extent_buffer *eb,
continue;
/* these keys are simply copied */
- if (wc->log_key.type == BTRFS_XATTR_ITEM_KEY) {
+ if (wc->log_key.type == BTRFS_XATTR_ITEM_KEY ||
+ wc->log_key.type == BTRFS_FSCRYPT_INODE_CTX_KEY ||
+ wc->log_key.type == BTRFS_FSCRYPT_CTX_KEY) {
ret = overwrite_item(wc);
if (ret)
break;
--
2.53.0
^ permalink raw reply related
* [PATCH v7 39/43] btrfs: set the appropriate free space settings in reconfigure
From: Daniel Vacek @ 2026-05-13 8:53 UTC (permalink / raw)
To: Chris Mason, Josef Bacik, Eric Biggers, Theodore Y. Ts'o,
Jaegeuk Kim, Jens Axboe, David Sterba
Cc: linux-block, Daniel Vacek, linux-fscrypt, linux-btrfs,
linux-kernel
In-Reply-To: <20260513085340.3673127-1-neelx@suse.com>
From: Josef Bacik <josef@toxicpanda.com>
btrfs/330 uncovered a problem where we were accidentally turning off the
free space tree when we do the transition from ro->rw. This happens
because we don't update
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Daniel Vacek <neelx@suse.com>
---
No changes in v7.
v6 changes:
* Re-wrapped comments.
* Fixed argument type. mount_opt is now ull.
v5: https://lore.kernel.org/linux-btrfs/325598eeb1d23f9ae04f675b4ee218f7e98e3ff0.1706116485.git.josef@toxicpanda.com/
---
fs/btrfs/disk-io.c | 2 +-
fs/btrfs/super.c | 28 +++++++++++++++-------------
fs/btrfs/super.h | 3 ++-
3 files changed, 18 insertions(+), 15 deletions(-)
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 1f0fe29dd549..4bfd851e1e9b 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -3412,7 +3412,7 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_device
* Handle the space caching options appropriately now that we have the
* super block loaded and validated.
*/
- btrfs_set_free_space_cache_settings(fs_info);
+ btrfs_set_free_space_cache_settings(fs_info, &fs_info->mount_opt);
if (!btrfs_check_options(fs_info, &fs_info->mount_opt, sb->s_flags)) {
ret = -EINVAL;
diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 2c033c68f052..7ec07d0bb473 100644
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -745,10 +745,10 @@ bool btrfs_check_options(const struct btrfs_fs_info *info,
}
/*
- * This is subtle, we only call this during open_ctree(). We need to pre-load
- * the mount options with the on-disk settings. Before the new mount API took
- * effect we would do this on mount and remount. With the new mount API we'll
- * only do this on the initial mount.
+ * Because we have an odd set of behavior with turning on and off the space cache
+ * and free space tree we have to call this before we start the mount operation
+ * after we load the super, or before we start remount. This is to make sure we
+ * have the proper free space settings in place if the user didn't specify any.
*
* This isn't a change in behavior, because we're using the current state of the
* file system to set the current mount options. If you mounted with special
@@ -756,21 +756,22 @@ bool btrfs_check_options(const struct btrfs_fs_info *info,
* settings, because mounting without these features cleared the on-disk
* settings, so this being called on re-mount is not needed.
*/
-void btrfs_set_free_space_cache_settings(struct btrfs_fs_info *fs_info)
+void btrfs_set_free_space_cache_settings(struct btrfs_fs_info *fs_info,
+ unsigned long long *mount_opt)
{
- if (fs_info->sectorsize != PAGE_SIZE && btrfs_test_opt(fs_info, SPACE_CACHE)) {
+ if (fs_info->sectorsize != PAGE_SIZE && btrfs_raw_test_opt(*mount_opt, SPACE_CACHE)) {
btrfs_info(fs_info,
"forcing free space tree for sector size %u with page size %lu",
fs_info->sectorsize, PAGE_SIZE);
- btrfs_clear_opt(fs_info->mount_opt, SPACE_CACHE);
- btrfs_set_opt(fs_info->mount_opt, FREE_SPACE_TREE);
+ btrfs_clear_opt(*mount_opt, SPACE_CACHE);
+ btrfs_set_opt(*mount_opt, FREE_SPACE_TREE);
}
/*
* At this point our mount options are populated, so we only mess with
* these settings if we don't have any settings already.
*/
- if (btrfs_test_opt(fs_info, FREE_SPACE_TREE))
+ if (btrfs_raw_test_opt(*mount_opt, FREE_SPACE_TREE))
return;
if (btrfs_is_zoned(fs_info) &&
@@ -780,10 +781,10 @@ void btrfs_set_free_space_cache_settings(struct btrfs_fs_info *fs_info)
return;
}
- if (btrfs_test_opt(fs_info, SPACE_CACHE))
+ if (btrfs_raw_test_opt(*mount_opt, SPACE_CACHE))
return;
- if (btrfs_test_opt(fs_info, NOSPACECACHE))
+ if (btrfs_raw_test_opt(*mount_opt, NOSPACECACHE))
return;
/*
@@ -791,9 +792,9 @@ void btrfs_set_free_space_cache_settings(struct btrfs_fs_info *fs_info)
* them ourselves based on the state of the file system.
*/
if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE))
- btrfs_set_opt(fs_info->mount_opt, FREE_SPACE_TREE);
+ btrfs_set_opt(*mount_opt, FREE_SPACE_TREE);
else if (btrfs_free_space_cache_v1_active(fs_info))
- btrfs_set_opt(fs_info->mount_opt, SPACE_CACHE);
+ btrfs_set_opt(*mount_opt, SPACE_CACHE);
}
static void set_device_specific_options(struct btrfs_fs_info *fs_info)
@@ -1573,6 +1574,7 @@ static int btrfs_reconfigure(struct fs_context *fc)
sync_filesystem(sb);
set_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);
+ btrfs_set_free_space_cache_settings(fs_info, &ctx->mount_opt);
if (!btrfs_check_options(fs_info, &ctx->mount_opt, fc->sb_flags))
return -EINVAL;
diff --git a/fs/btrfs/super.h b/fs/btrfs/super.h
index f85f8a8a7bfe..84a30b82a3ce 100644
--- a/fs/btrfs/super.h
+++ b/fs/btrfs/super.h
@@ -16,7 +16,8 @@ bool btrfs_check_options(const struct btrfs_fs_info *info,
int btrfs_sync_fs(struct super_block *sb, int wait);
char *btrfs_get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info,
u64 subvol_objectid);
-void btrfs_set_free_space_cache_settings(struct btrfs_fs_info *fs_info);
+void btrfs_set_free_space_cache_settings(struct btrfs_fs_info *fs_info,
+ unsigned long long *mount_opt);
static inline struct btrfs_fs_info *btrfs_sb(const struct super_block *sb)
{
--
2.53.0
^ permalink raw reply related
* [PATCH v7 38/43] btrfs: load the inode context before sending writes
From: Daniel Vacek @ 2026-05-13 8:53 UTC (permalink / raw)
To: Chris Mason, Josef Bacik, Eric Biggers, Theodore Y. Ts'o,
Jaegeuk Kim, Jens Axboe, David Sterba
Cc: linux-block, Daniel Vacek, linux-fscrypt, linux-btrfs,
linux-kernel
In-Reply-To: <20260513085340.3673127-1-neelx@suse.com>
From: Josef Bacik <josef@toxicpanda.com>
For send we will read the pages and copy them into our buffer. Use the
fscrypt_inode_open helper to make sure the key is loaded properly before
trying to read from the inode so the contents are properly decrypted.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Daniel Vacek <neelx@suse.com>
---
No changes in v7.
v6 changes:
* btrfs_iget() returns binode now.
v5: https://lore.kernel.org/linux-btrfs/a307def01bf28c3ed99398868a142180c6088527.1706116485.git.josef@toxicpanda.com/
---
fs/btrfs/send.c | 36 ++++++++++++++++++++++++++++++++++++
1 file changed, 36 insertions(+)
diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c
index 3d9764aa4a25..1e80a3db1df2 100644
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -5331,6 +5331,38 @@ static int put_file_data(struct send_ctx *sctx, u64 offset, u32 len)
return ret;
}
+static int load_fscrypt_context(struct send_ctx *sctx)
+{
+ struct btrfs_root *root = sctx->send_root;
+ struct name_cache_entry *nce;
+ struct btrfs_inode *dir;
+ int ret;
+
+ if (!btrfs_fs_incompat(root->fs_info, ENCRYPT))
+ return 0;
+
+ /*
+ * If we're encrypted we need to load the parent inode in order to make
+ * sure the encryption context is loaded. We have to do this even if
+ * we're not encrypted, as we need to make sure that we don't violate
+ * the rule about encrypted children with non-encrypted parents, which
+ * is enforced by __fscrypt_file_open.
+ */
+ nce = name_cache_search(sctx, sctx->cur_ino, sctx->cur_inode_gen);
+ if (!nce) {
+ ASSERT(nce);
+ return -EINVAL;
+ }
+
+ dir = btrfs_iget(nce->parent_ino, root);
+ if (IS_ERR(dir))
+ return PTR_ERR(dir);
+
+ ret = __fscrypt_file_open(&dir->vfs_inode, sctx->cur_inode);
+ iput(&dir->vfs_inode);
+ return ret;
+}
+
/*
* Read some bytes from the current inode/file and send a write command to
* user space.
@@ -5348,6 +5380,10 @@ static int send_write(struct send_ctx *sctx, u64 offset, u32 len)
if (ret < 0)
return ret;
+ ret = load_fscrypt_context(sctx);
+ if (ret < 0)
+ return ret;
+
TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
ret = put_file_data(sctx, offset, len);
--
2.53.0
^ permalink raw reply related
* [PATCH v7 37/43] btrfs: decrypt file names for send
From: Daniel Vacek @ 2026-05-13 8:53 UTC (permalink / raw)
To: Chris Mason, Josef Bacik, Eric Biggers, Theodore Y. Ts'o,
Jaegeuk Kim, Jens Axboe, David Sterba
Cc: linux-block, Daniel Vacek, linux-fscrypt, linux-btrfs,
linux-kernel
In-Reply-To: <20260513085340.3673127-1-neelx@suse.com>
From: Josef Bacik <josef@toxicpanda.com>
In send we're going to be looking up file names from back references and
putting them into the send stream. If we are encrypted use the helper
for decrypting names and copy the decrypted name into the buffer.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Daniel Vacek <neelx@suse.com>
---
No changes in v7.
v6 changes:
* Simplified the error return logic in fs_path_add_from_encrypted().
v5: https://lore.kernel.org/linux-btrfs/fd8b1d5f395a890dbdf8281a52fbaaa920c7b726.1706116485.git.josef@toxicpanda.com/
---
fs/btrfs/send.c | 47 +++++++++++++++++++++++++++++++++++++----------
1 file changed, 37 insertions(+), 10 deletions(-)
diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c
index d5256c22fe7a..3d9764aa4a25 100644
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -32,6 +32,7 @@
#include "ioctl.h"
#include "verity.h"
#include "lru_cache.h"
+#include "fscrypt.h"
/*
* Maximum number of references an extent can have in order for us to attempt to
@@ -579,13 +580,39 @@ static inline int fs_path_add_path(struct fs_path *p, const struct fs_path *p2)
return fs_path_add(p, p2->start, fs_path_len(p2));
}
-static int fs_path_add_from_extent_buffer(struct fs_path *p,
+static int fs_path_add_from_encrypted(struct btrfs_root *root,
+ struct fs_path *p,
+ struct extent_buffer *eb,
+ unsigned long off, int len,
+ u64 parent_ino)
+{
+ struct fscrypt_str fname = FSTR_INIT(NULL, 0);
+ int ret;
+
+ ret = fscrypt_fname_alloc_buffer(BTRFS_NAME_LEN, &fname);
+ if (ret)
+ return ret;
+
+ ret = btrfs_decrypt_name(root, eb, off, len, parent_ino, &fname);
+ if (!ret)
+ ret = fs_path_add(p, fname.name, fname.len);
+
+ fscrypt_fname_free_buffer(&fname);
+ return ret;
+}
+
+static int fs_path_add_from_extent_buffer(struct btrfs_root *root,
+ struct fs_path *p,
struct extent_buffer *eb,
- unsigned long off, int len)
+ unsigned long off, int len,
+ u64 parent_ino)
{
int ret;
char *prepared;
+ if (root && btrfs_fs_incompat(root->fs_info, ENCRYPT))
+ return fs_path_add_from_encrypted(root, p, eb, off, len, parent_ino);
+
ret = fs_path_prepare_for_add(p, len, &prepared);
if (ret < 0)
return ret;
@@ -1062,8 +1089,7 @@ static int iterate_inode_ref(struct btrfs_root *root, struct btrfs_path *path,
}
p->start = start;
} else {
- ret = fs_path_add_from_extent_buffer(p, eb, name_off,
- name_len);
+ ret = fs_path_add_from_extent_buffer(root, p, eb, name_off, name_len, dir);
if (ret < 0)
goto out;
}
@@ -1759,7 +1785,7 @@ static int read_symlink_unencrypted(struct btrfs_root *root, u64 ino, struct fs_
off = btrfs_file_extent_inline_start(ei);
len = btrfs_file_extent_ram_bytes(path->nodes[0], ei);
- return fs_path_add_from_extent_buffer(dest, path->nodes[0], off, len);
+ return fs_path_add_from_extent_buffer(NULL, dest, path->nodes[0], off, len, 0);
}
static int read_symlink_encrypted(struct btrfs_root *root, u64 ino, struct fs_path *dest)
@@ -2034,18 +2060,19 @@ static int get_first_ref(struct btrfs_root *root, u64 ino,
iref = btrfs_item_ptr(path->nodes[0], path->slots[0],
struct btrfs_inode_ref);
len = btrfs_inode_ref_name_len(path->nodes[0], iref);
- ret = fs_path_add_from_extent_buffer(name, path->nodes[0],
- (unsigned long)(iref + 1),
- len);
parent_dir = found_key.offset;
+ ret = fs_path_add_from_extent_buffer(root, name, path->nodes[0],
+ (unsigned long)(iref + 1),
+ len, parent_dir);
} else {
struct btrfs_inode_extref *extref;
extref = btrfs_item_ptr(path->nodes[0], path->slots[0],
struct btrfs_inode_extref);
len = btrfs_inode_extref_name_len(path->nodes[0], extref);
- ret = fs_path_add_from_extent_buffer(name, path->nodes[0],
- (unsigned long)&extref->name, len);
parent_dir = btrfs_inode_extref_parent(path->nodes[0], extref);
+ ret = fs_path_add_from_extent_buffer(root, name, path->nodes[0],
+ (unsigned long)&extref->name, len,
+ parent_dir);
}
if (ret < 0)
return ret;
--
2.53.0
^ permalink raw reply related
* [PATCH v7 36/43] btrfs: deal with encrypted symlinks in send
From: Daniel Vacek @ 2026-05-13 8:53 UTC (permalink / raw)
To: Chris Mason, Josef Bacik, Eric Biggers, Theodore Y. Ts'o,
Jaegeuk Kim, Jens Axboe, David Sterba
Cc: linux-block, Daniel Vacek, linux-fscrypt, linux-btrfs,
linux-kernel
In-Reply-To: <20260513085340.3673127-1-neelx@suse.com>
From: Josef Bacik <josef@toxicpanda.com>
Send needs to send the decrypted value of the symlinks, handle the case
where the inode is encrypted and decrypt the symlink name into a buffer
and copy this buffer into our fs_path struct.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Daniel Vacek <neelx@suse.com>
---
No changes in v7.
v6 changes:
* read_symlink_encrypted() reworked from using pages to using folios.
v5: https://lore.kernel.org/linux-btrfs/4d97f35d6f85ff041b09bed33b63446a92b7a20c.1706116485.git.josef@toxicpanda.com/
---
fs/btrfs/send.c | 45 ++++++++++++++++++++++++++++++++++++++++++---
1 file changed, 42 insertions(+), 3 deletions(-)
diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c
index 89d72d8cb85f..d5256c22fe7a 100644
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -1701,9 +1701,7 @@ static int find_extent_clone(struct send_ctx *sctx,
return ret;
}
-static int read_symlink(struct btrfs_root *root,
- u64 ino,
- struct fs_path *dest)
+static int read_symlink_unencrypted(struct btrfs_root *root, u64 ino, struct fs_path *dest)
{
int ret;
BTRFS_PATH_AUTO_FREE(path);
@@ -1764,6 +1762,47 @@ static int read_symlink(struct btrfs_root *root,
return fs_path_add_from_extent_buffer(dest, path->nodes[0], off, len);
}
+static int read_symlink_encrypted(struct btrfs_root *root, u64 ino, struct fs_path *dest)
+{
+ DEFINE_DELAYED_CALL(done);
+ const char *buf;
+ struct folio *folio;
+ struct btrfs_inode *inode;
+ int ret = 0;
+
+ inode = btrfs_iget(ino, root);
+ if (IS_ERR(inode))
+ return PTR_ERR(inode);
+
+ folio = read_mapping_folio(inode->vfs_inode.i_mapping, 0, NULL);
+ if (IS_ERR(folio)) {
+ iput(&inode->vfs_inode);
+ return PTR_ERR(folio);
+ }
+
+ buf = fscrypt_get_symlink(&inode->vfs_inode, folio_address(folio),
+ BTRFS_MAX_INLINE_DATA_SIZE(root->fs_info),
+ &done);
+ folio_put(folio);
+ iput(&inode->vfs_inode);
+
+ if (IS_ERR(buf))
+ return PTR_ERR(buf);
+
+ ret = fs_path_add(dest, buf, strlen(buf));
+ do_delayed_call(&done);
+ return ret;
+}
+
+
+static int read_symlink(struct btrfs_root *root, u64 ino,
+ struct fs_path *dest)
+{
+ if (btrfs_fs_incompat(root->fs_info, ENCRYPT))
+ return read_symlink_encrypted(root, ino, dest);
+ return read_symlink_unencrypted(root, ino, dest);
+}
+
/*
* Helper function to generate a file name that is unique in the root of
* send_root and parent_root. This is used to generate names for orphan inodes.
--
2.53.0
^ permalink raw reply related
* [PATCH v7 33/43] btrfs: implement read repair for encryption
From: Daniel Vacek @ 2026-05-13 8:53 UTC (permalink / raw)
To: Chris Mason, Josef Bacik, Eric Biggers, Theodore Y. Ts'o,
Jaegeuk Kim, Jens Axboe, David Sterba
Cc: linux-block, Daniel Vacek, linux-fscrypt, linux-btrfs,
linux-kernel
In-Reply-To: <20260513085340.3673127-1-neelx@suse.com>
From: Josef Bacik <josef@toxicpanda.com>
In order to do read repair we will allocate sectorsize bio's and read
them one at a time, repairing any sectors that don't match their csum.
In order to do this we re-submit the IO's after it's failed, and at this
point we still need the fscrypt_extent_info for these new bio's.
Add the fscrypt_extent_info to the read part of the union in the
btrfs_bio, and then pass this through all the places where we do reads.
Additionally add the orig_start, because we need to be able to put the
correct extent offset for the encryption context.
With these in place we can utilize the normal read repair path. The
only exception is that the actual repair of the bad copies has to be
triggered from the ->process_bio callback, because this is the encrypted
data. If we waited until the end_io we would have the decrypted data
and we don't want to write that to the disk. This is the only change to
the normal read repair path, we trigger the fixup of the broken sectors
in ->process_bio, and then we skip that part if we successfully repair
the sector in ->process_bio once we get to the endio.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Daniel Vacek <neelx@suse.com>
---
v7 changes:
* Follow upstream fscrypt cleanup and use byte offsets instead of
logical block numbers in the new api. As a result remove the
btrfs_set_bio_crypt_ctx_from_extent() and btrfs_mergeable_encrypted_bio()
helpers and directly use fscrypt_set_bio_crypt_ctx_from_extent()
and fscrypt_mergeable_extent_bio().
v6 changes:
* Fixed UAF bug with !ordered case doing bbio->end_io(bbio) >>>
fscrypt_put_extent_info(bbio->fscrypt_info).
- We can simply put the fscrypt_info first and then end the bio.
- Also no need to clear the bbio->fscrypt_info pointer as bbio is
just going to be freed. That cleans up the code a bit.
* Adapted to bs > ps changes.
* Updated and re-wrap the comments.
* Moved the dio-related changes from inode.c to direct-io.c
as upstream refactored in the meantime.
v5: https://lore.kernel.org/linux-btrfs/310c0ebdc78613b6f379595e160206013f75b6dc.1706116485.git.josef@toxicpanda.com/
---
fs/btrfs/bio.c | 76 +++++++++++++++++++++++++++++++++++++-----
fs/btrfs/bio.h | 10 +++++-
fs/btrfs/compression.c | 2 ++
fs/btrfs/direct-io.c | 2 ++
fs/btrfs/extent_io.c | 2 ++
5 files changed, 83 insertions(+), 9 deletions(-)
diff --git a/fs/btrfs/bio.c b/fs/btrfs/bio.c
index 729c5aff5c3d..3a8f32c5157f 100644
--- a/fs/btrfs/bio.c
+++ b/fs/btrfs/bio.c
@@ -98,6 +98,9 @@ static struct btrfs_bio *btrfs_split_bio(struct btrfs_fs_info *fs_info,
bbio->ordered = orig_bbio->ordered;
bbio->orig_logical = orig_bbio->orig_logical;
orig_bbio->orig_logical += map_length;
+ } else if (is_data_bbio(bbio)) {
+ bbio->fscrypt_info = fscrypt_get_extent_info(orig_bbio->fscrypt_info);
+ bbio->orig_start = orig_bbio->orig_start;
}
bbio->csum_search_commit_root = orig_bbio->csum_search_commit_root;
@@ -125,6 +128,8 @@ void btrfs_bio_end_io(struct btrfs_bio *bbio, blk_status_t status)
/* Free bio that was never submitted to the underlying device. */
if (bbio_has_ordered_extent(bbio))
btrfs_put_ordered_extent(bbio->ordered);
+ else if (is_data_bbio(bbio))
+ fscrypt_put_extent_info(bbio->fscrypt_info);
bio_put(&bbio->bio);
bbio = orig_bbio;
@@ -148,6 +153,8 @@ void btrfs_bio_end_io(struct btrfs_bio *bbio, blk_status_t status)
bbio->end_io(bbio);
btrfs_put_ordered_extent(ordered);
} else {
+ if (is_data_bbio(bbio))
+ fscrypt_put_extent_info(bbio->fscrypt_info);
bbio->end_io(bbio);
}
}
@@ -175,6 +182,23 @@ static void btrfs_repair_done(struct btrfs_failed_bio *fbio)
}
}
+static void handle_repair(struct btrfs_bio *repair_bbio, phys_addr_t *paddrs)
+{
+ struct btrfs_failed_bio *fbio = repair_bbio->private;
+ struct btrfs_inode *inode = repair_bbio->inode;
+ struct btrfs_fs_info *fs_info = inode->root->fs_info;
+ const u32 step = min(fs_info->sectorsize, PAGE_SIZE);
+ const u64 logical = repair_bbio->saved_iter.bi_sector << SECTOR_SHIFT;
+ int mirror = repair_bbio->mirror_num;
+
+ do {
+ mirror = prev_repair_mirror(fbio, mirror);
+ btrfs_repair_io_failure(fs_info, btrfs_ino(inode),
+ repair_bbio->file_offset, fs_info->sectorsize,
+ logical, paddrs, step, mirror);
+ } while (mirror != fbio->bbio->mirror_num);
+}
+
static void btrfs_end_repair_bio(struct btrfs_bio *repair_bbio,
struct btrfs_device *dev)
{
@@ -187,7 +211,6 @@ static void btrfs_end_repair_bio(struct btrfs_bio *repair_bbio,
*/
struct bvec_iter saved_iter = repair_bbio->saved_iter;
const u32 step = min(fs_info->sectorsize, PAGE_SIZE);
- const u64 logical = repair_bbio->saved_iter.bi_sector << SECTOR_SHIFT;
const u32 nr_steps = repair_bbio->saved_iter.bi_size / step;
int mirror = repair_bbio->mirror_num;
phys_addr_t paddrs[BTRFS_MAX_BLOCKSIZE / PAGE_SIZE];
@@ -197,6 +220,13 @@ static void btrfs_end_repair_bio(struct btrfs_bio *repair_bbio,
/* Repair bbio should be eaxctly one block sized. */
ASSERT(repair_bbio->saved_iter.bi_size == fs_info->sectorsize);
+ /*
+ * If we got here from the encrypted path with ->csum_ok set then
+ * we've already csumed and repaired this sector, we're all done.
+ */
+ if (repair_bbio->csum_ok)
+ goto done;
+
btrfs_bio_for_each_block(paddr, &repair_bbio->bio, &saved_iter, step) {
ASSERT(slot < nr_steps);
paddrs[slot] = paddr;
@@ -215,17 +245,17 @@ static void btrfs_end_repair_bio(struct btrfs_bio *repair_bbio,
goto done;
}
+ fscrypt_set_bio_crypt_ctx_from_extent(&repair_bbio->bio,
+ repair_bbio->fscrypt_info,
+ repair_bbio->file_offset -
+ repair_bbio->orig_start,
+ GFP_NOFS);
+
btrfs_submit_bbio(repair_bbio, mirror);
return;
}
- do {
- mirror = prev_repair_mirror(fbio, mirror);
- btrfs_repair_io_failure(fs_info, btrfs_ino(inode),
- repair_bbio->file_offset, fs_info->sectorsize,
- logical, paddrs, step, mirror);
- } while (mirror != fbio->bbio->mirror_num);
-
+ handle_repair(repair_bbio, paddrs);
done:
btrfs_repair_done(fbio);
bio_put(&repair_bbio->bio);
@@ -294,6 +324,14 @@ static struct btrfs_failed_bio *repair_one_sector(struct btrfs_bio *failed_bbio,
repair_bbio = btrfs_bio(repair_bio);
btrfs_bio_init(repair_bbio, failed_bbio->inode, failed_bbio->file_offset + bio_offset,
NULL, fbio);
+ repair_bbio->fscrypt_info = fscrypt_get_extent_info(failed_bbio->fscrypt_info);
+ repair_bbio->orig_start = failed_bbio->orig_start;
+
+ fscrypt_set_bio_crypt_ctx_from_extent(repair_bio,
+ failed_bbio->fscrypt_info,
+ repair_bbio->file_offset -
+ failed_bbio->orig_start,
+ GFP_NOFS);
mirror = next_repair_mirror(fbio, failed_bbio->mirror_num);
btrfs_debug(fs_info, "submitting repair read to mirror %d", mirror);
@@ -331,7 +369,29 @@ blk_status_t btrfs_check_encrypted_read_bio(struct btrfs_bio *bbio, struct bio *
}
}
+ /*
+ * Read repair is slightly different for encrypted bio's. This
+ * callback is before we decrypt the bio in the block crypto layer,
+ * we're not actually in the endio handler.
+ *
+ * We don't trigger the repair process here either, that is handled
+ * in the actual endio path because we don't want to create another
+ * pseudo endio path through this callback. This is because when we
+ * call btrfs_repair_done() we want to call the endio for the original
+ * bbio. Short circuiting that for the encrypted case would be ugly.
+ * We really want to the repair case to be handled generically.
+ *
+ * However for the actual repair part we need to use this page
+ * pre-decrypted, which is why we call the btrfs_repair_io_failure()
+ * code from this path. The repair path is synchronous so we are
+ * safe there. Then we simply mark the repair bbio as completed so
+ * the actual btrfs_end_repair_bio() code can skip the repair part.
+ */
+ if (bbio->bio.bi_pool == &btrfs_repair_bioset)
+ handle_repair(bbio, paddrs);
bbio->csum_ok = true;
+ fscrypt_put_extent_info(bbio->fscrypt_info);
+ bbio->fscrypt_info = NULL;
return BLK_STS_OK;
}
diff --git a/fs/btrfs/bio.h b/fs/btrfs/bio.h
index 456d32db9e9e..7a8ff4378cba 100644
--- a/fs/btrfs/bio.h
+++ b/fs/btrfs/bio.h
@@ -15,6 +15,7 @@
struct btrfs_bio;
struct btrfs_fs_info;
struct btrfs_inode;
+struct fscrypt_extent_info;
#define BTRFS_BIO_INLINE_CSUM_SIZE 64
@@ -38,13 +39,20 @@ struct btrfs_bio {
union {
/*
* For data reads: checksumming and original I/O information.
- * (for internal use in the btrfs_submit_bbio() machinery only)
+ * (for internal use in the btrfs_submit_bbio() machinery only).
+ *
+ * The fscrypt context is used for read repair, this is the
+ * only thing not internal to btrfs_submit_bbio() machinery.
*/
struct {
u8 *csum;
u8 csum_inline[BTRFS_BIO_INLINE_CSUM_SIZE];
bool csum_ok;
struct bvec_iter saved_iter;
+
+ /* Used for read repair. */
+ struct fscrypt_extent_info *fscrypt_info;
+ u64 orig_start;
};
/*
diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c
index e235a2ac5838..8269258d0dc4 100644
--- a/fs/btrfs/compression.c
+++ b/fs/btrfs/compression.c
@@ -592,6 +592,8 @@ void btrfs_submit_compressed_read(struct btrfs_bio *bbio)
cb->compress_type = btrfs_extent_map_compression(em);
cb->orig_bbio = bbio;
cb->bbio.csum_search_commit_root = bbio->csum_search_commit_root;
+ cb->bbio.fscrypt_info = fscrypt_get_extent_info(em->fscrypt_info);
+ cb->bbio.orig_start = 0;
fscrypt_set_bio_crypt_ctx_from_extent(&cb->bbio.bio, em->fscrypt_info, 0, GFP_NOFS);
btrfs_free_extent_map(em);
diff --git a/fs/btrfs/direct-io.c b/fs/btrfs/direct-io.c
index 4891bf233536..bef4e2f953e4 100644
--- a/fs/btrfs/direct-io.c
+++ b/fs/btrfs/direct-io.c
@@ -764,6 +764,8 @@ static void btrfs_dio_submit_io(const struct iomap_iter *iter, struct bio *bio,
} else {
fscrypt_info = dio_data->fscrypt_info;
offset = file_offset - dio_data->orig_start;
+ bbio->fscrypt_info = fscrypt_get_extent_info(fscrypt_info);
+ bbio->orig_start = dio_data->orig_start;
}
fscrypt_set_bio_crypt_ctx_from_extent(&bbio->bio, fscrypt_info, offset, GFP_NOFS);
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 5e9cdcdc996a..32e39837294b 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -795,6 +795,8 @@ static void alloc_new_bio(struct btrfs_inode *inode,
} else {
fscrypt_info = bio_ctrl->fscrypt_info;
offset = file_offset - bio_ctrl->orig_start;
+ bbio->fscrypt_info = fscrypt_get_extent_info(fscrypt_info);
+ bbio->orig_start = bio_ctrl->orig_start;
}
fscrypt_set_bio_crypt_ctx_from_extent(&bbio->bio, fscrypt_info, offset, GFP_NOFS);
--
2.53.0
^ permalink raw reply related
* [PATCH v7 32/43] btrfs: implement process_bio cb for fscrypt
From: Daniel Vacek @ 2026-05-13 8:53 UTC (permalink / raw)
To: Chris Mason, Josef Bacik, Eric Biggers, Theodore Y. Ts'o,
Jaegeuk Kim, Jens Axboe, David Sterba
Cc: linux-block, Daniel Vacek, linux-fscrypt, linux-btrfs,
linux-kernel
In-Reply-To: <20260513085340.3673127-1-neelx@suse.com>
From: Josef Bacik <josef@toxicpanda.com>
We are going to be checksumming the encrypted data, so we have to
implement the ->process_bio fscrypt callback. This will provide us with
the original bio and the encrypted bio to do work on. For WRITE's this
will happen after the encrypted bio has been encrypted. For READ's this
will happen after the read has completed and before the decryption step
is done.
For write's this is straightforward, we can just pass in the encrypted
bio to btrfs_csum_one_bio and then the csums will be added to the bbio
as normal.
For read's this is relatively straightforward, but requires some care.
We assume (because that's how it works currently) that the encrypted bio
match the original bio, this is important because we save the iter of
the bio before we submit. If this changes in the future we'll need a
hook to give us the bi_iter of the decryption bio before it's submitted.
We check the csums before decryption. If it doesn't match we simply
error out and we let the normal path handle the repair work.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Daniel Vacek <neelx@suse.com>
---
v7 changes:
* Fixed array overflow stack corruption for bios > max blocksize (>64KiB)
as reported by Chris' AI review.
v6 changes:
* Adapt to btrfs_data_csum_ok() changes for bs > ps. Mostly follow
what was done in 052fd7a5cace ("btrfs: make read verification
handle bs > ps cases without large folios").
* Rename bbio::csum_done to csum_ok due to name collision.
With upstream, member name csum_done was used for async csums.
v5: https://lore.kernel.org/linux-btrfs/ca32684b01ff8c252be515509137e0a4a0e5db7a.1706116485.git.josef@toxicpanda.com/
---
fs/btrfs/bio.c | 44 +++++++++++++++++++++++++++++++++++++++++++-
fs/btrfs/bio.h | 3 +++
fs/btrfs/file-item.c | 14 ++++++++++++--
fs/btrfs/fscrypt.c | 29 +++++++++++++++++++++++++++++
4 files changed, 87 insertions(+), 3 deletions(-)
diff --git a/fs/btrfs/bio.c b/fs/btrfs/bio.c
index 3e2ee19aab50..729c5aff5c3d 100644
--- a/fs/btrfs/bio.c
+++ b/fs/btrfs/bio.c
@@ -301,6 +301,40 @@ static struct btrfs_failed_bio *repair_one_sector(struct btrfs_bio *failed_bbio,
return fbio;
}
+blk_status_t btrfs_check_encrypted_read_bio(struct btrfs_bio *bbio, struct bio *enc_bio)
+{
+ struct btrfs_inode *inode = bbio->inode;
+ struct btrfs_fs_info *fs_info = inode->root->fs_info;
+ struct bvec_iter iter = bbio->saved_iter;
+ struct btrfs_device *dev = bbio->bio.bi_private;
+ const u32 blocksize = fs_info->sectorsize;
+ const u32 step = min(blocksize, PAGE_SIZE);
+ const u32 nr_steps = iter.bi_size / step;
+ phys_addr_t paddrs[BTRFS_MAX_BLOCKSIZE / PAGE_SIZE];
+ phys_addr_t paddr;
+ unsigned int slot = 0;
+ u32 offset = 0;
+
+ /*
+ * We have to use a copy of iter in case there's an error,
+ * btrfs_check_read_bio will handle submitting the repair bios.
+ */
+ btrfs_bio_for_each_block(paddr, enc_bio, &iter, step) {
+ ASSERT(slot < nr_steps);
+ paddrs[slot] = paddr;
+ slot++;
+ offset += step;
+ if (IS_ALIGNED(offset, blocksize)) {
+ if (!btrfs_data_csum_ok(bbio, dev, offset - blocksize, paddrs))
+ return BLK_STS_IOERR;
+ slot = 0;
+ }
+ }
+
+ bbio->csum_ok = true;
+ return BLK_STS_OK;
+}
+
static void btrfs_check_read_bio(struct btrfs_bio *bbio, struct btrfs_device *dev)
{
struct btrfs_inode *inode = bbio->inode;
@@ -330,6 +364,10 @@ static void btrfs_check_read_bio(struct btrfs_bio *bbio, struct btrfs_device *de
/* Clear the I/O error. A failed repair will reset it. */
bbio->bio.bi_status = BLK_STS_OK;
+ /* This was an encrypted bio and we've already done the csum check. */
+ if (status == BLK_STS_OK && bbio->csum_ok)
+ goto out;
+
btrfs_bio_for_each_block(paddr, &bbio->bio, iter, step) {
paddrs[(offset / step) % nr_steps] = paddr;
offset += step;
@@ -341,6 +379,7 @@ static void btrfs_check_read_bio(struct btrfs_bio *bbio, struct btrfs_device *de
paddrs, fbio);
}
}
+out:
if (bbio->csum != bbio->csum_inline)
kvfree(bbio->csum);
@@ -859,10 +898,13 @@ static bool btrfs_submit_chunk(struct btrfs_bio *bbio, int mirror_num)
/*
* Csum items for reloc roots have already been cloned at this
* point, so they are handled as part of the no-checksum case.
+ *
+ * Encrypted inodes are csum'ed via the ->process_bio callback.
*/
if (!(inode->flags & BTRFS_INODE_NODATASUM) &&
!test_bit(BTRFS_FS_STATE_NO_DATA_CSUMS, &fs_info->fs_state) &&
- !btrfs_is_data_reloc_root(inode->root) && !bbio->is_remap) {
+ !btrfs_is_data_reloc_root(inode->root) && !bbio->is_remap &&
+ !IS_ENCRYPTED(&inode->vfs_inode)) {
if (should_async_write(bbio) &&
btrfs_wq_submit_bio(bbio, bioc, &smap, mirror_num))
goto done;
diff --git a/fs/btrfs/bio.h b/fs/btrfs/bio.h
index 43f7544029ac..456d32db9e9e 100644
--- a/fs/btrfs/bio.h
+++ b/fs/btrfs/bio.h
@@ -43,6 +43,7 @@ struct btrfs_bio {
struct {
u8 *csum;
u8 csum_inline[BTRFS_BIO_INLINE_CSUM_SIZE];
+ bool csum_ok;
struct bvec_iter saved_iter;
};
@@ -130,5 +131,7 @@ void btrfs_submit_repair_write(struct btrfs_bio *bbio, int mirror_num, bool dev_
int btrfs_repair_io_failure(struct btrfs_fs_info *fs_info, u64 ino, u64 fileoff,
u32 length, u64 logical, const phys_addr_t paddrs[],
unsigned int step, int mirror_num);
+blk_status_t btrfs_check_encrypted_read_bio(struct btrfs_bio *bbio,
+ struct bio *enc_bio);
#endif
diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index 986914078708..72d9d3243460 100644
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -338,6 +338,14 @@ static int search_csum_tree(struct btrfs_fs_info *fs_info,
return ret;
}
+static inline bool inode_skip_csum(struct btrfs_inode *inode)
+{
+ struct btrfs_fs_info *fs_info = inode->root->fs_info;
+
+ return (inode->flags & BTRFS_INODE_NODATASUM) ||
+ test_bit(BTRFS_FS_STATE_NO_DATA_CSUMS, &fs_info->fs_state);
+}
+
/*
* Lookup the checksum for the read bio in csum tree.
*
@@ -357,8 +365,7 @@ int btrfs_lookup_bio_sums(struct btrfs_bio *bbio)
int ret = 0;
u32 bio_offset = 0;
- if ((inode->flags & BTRFS_INODE_NODATASUM) ||
- test_bit(BTRFS_FS_STATE_NO_DATA_CSUMS, &fs_info->fs_state))
+ if (inode_skip_csum(inode))
return 0;
/*
@@ -817,6 +824,9 @@ int btrfs_csum_one_bio(struct btrfs_bio *bbio, struct bio *bio, bool async)
struct btrfs_ordered_sum *sums;
unsigned nofs_flag;
+ if (inode_skip_csum(inode))
+ return 0;
+
nofs_flag = memalloc_nofs_save();
sums = kvzalloc(btrfs_ordered_sum_size(fs_info, bio->bi_iter.bi_size),
GFP_KERNEL);
diff --git a/fs/btrfs/fscrypt.c b/fs/btrfs/fscrypt.c
index 5d34a8b94da5..924ee3df7f32 100644
--- a/fs/btrfs/fscrypt.c
+++ b/fs/btrfs/fscrypt.c
@@ -16,6 +16,7 @@
#include "transaction.h"
#include "volumes.h"
#include "xattr.h"
+#include "file-item.h"
/*
* From a given location in a leaf, read a name into a qstr (usually a
@@ -212,6 +213,33 @@ static struct block_device **btrfs_fscrypt_get_devices(struct super_block *sb,
return devs;
}
+static blk_status_t btrfs_process_encrypted_bio(struct bio *orig_bio,
+ struct bio *enc_bio)
+{
+ struct btrfs_bio *bbio;
+
+ /*
+ * If our bio is from the normal fs_bio_set then we know this is a
+ * mirror split and we can skip it, we'll get the real bio on the last
+ * mirror and we can process that one.
+ */
+ if (orig_bio->bi_pool == &fs_bio_set)
+ return BLK_STS_OK;
+
+ bbio = btrfs_bio(orig_bio);
+
+ if (bio_op(orig_bio) == REQ_OP_READ) {
+ /*
+ * We have ->saved_iter based on the orig_bio, so if the block
+ * layer changes we need to notice this asap so we can update
+ * our code to handle the new world order.
+ */
+ ASSERT(orig_bio == enc_bio);
+ return btrfs_check_encrypted_read_bio(bbio, enc_bio);
+ }
+ return btrfs_csum_one_bio(bbio, enc_bio, false);
+}
+
int btrfs_fscrypt_load_extent_info(struct btrfs_inode *inode,
struct btrfs_path *path,
struct btrfs_key *key,
@@ -327,4 +355,5 @@ const struct fscrypt_operations btrfs_fscrypt_ops = {
.set_context = btrfs_fscrypt_set_context,
.empty_dir = btrfs_fscrypt_empty_dir,
.get_devices = btrfs_fscrypt_get_devices,
+ .process_bio = btrfs_process_encrypted_bio,
};
--
2.53.0
^ permalink raw reply related
* [PATCH v7 41/43] btrfs: disable auto defrag on encrypted files
From: Daniel Vacek @ 2026-05-13 8:53 UTC (permalink / raw)
To: Chris Mason, Josef Bacik, Eric Biggers, Theodore Y. Ts'o,
Jaegeuk Kim, Jens Axboe, David Sterba
Cc: linux-block, Daniel Vacek, linux-fscrypt, linux-btrfs,
linux-kernel
In-Reply-To: <20260513085340.3673127-1-neelx@suse.com>
From: Josef Bacik <josef@toxicpanda.com>
We will drop the inode and re-look it up to do defrag with auto defrag,
which means we could lose the encryption policy.
Auto defrag needs to be reworked to just hold onto the inode for
scheduling later so we don't lose the context. For now just disable it
if the file is encrypted.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Daniel Vacek <neelx@suse.com>
---
v5: https://lore.kernel.org/linux-btrfs/b717912bf88797b3044a3c2724b59b1ecc17ea78.1706116485.git.josef@toxicpanda.com/
* No changes since.
---
fs/btrfs/defrag.c | 8 ++++++++
1 file changed, 8 insertions(+)
diff --git a/fs/btrfs/defrag.c b/fs/btrfs/defrag.c
index a828ec45bb5f..652b8423f01e 100644
--- a/fs/btrfs/defrag.c
+++ b/fs/btrfs/defrag.c
@@ -126,6 +126,14 @@ void btrfs_add_inode_defrag(struct btrfs_inode *inode, u32 extent_thresh)
if (!need_auto_defrag(fs_info))
return;
+ /*
+ * Since we have to read the inode at defrag time disable auto defrag
+ * for encrypted inodes until we have code to read the parent and load
+ * the encryption context.
+ */
+ if (IS_ENCRYPTED(&inode->vfs_inode))
+ return;
+
if (test_bit(BTRFS_INODE_IN_DEFRAG, &inode->runtime_flags))
return;
--
2.53.0
^ permalink raw reply related
* [PATCH v7 31/43] btrfs: limit encrypted writes to 256 segments
From: Daniel Vacek @ 2026-05-13 8:53 UTC (permalink / raw)
To: Chris Mason, Josef Bacik, Eric Biggers, Theodore Y. Ts'o,
Jaegeuk Kim, Jens Axboe, David Sterba
Cc: linux-block, Daniel Vacek, linux-fscrypt, linux-btrfs,
linux-kernel
In-Reply-To: <20260513085340.3673127-1-neelx@suse.com>
From: Josef Bacik <josef@toxicpanda.com>
For the fallback encrypted writes it allocates a bounce buffer to
encrypt, and if the bio is larger than 256 segments it splits the bio we
send down. This wreaks havoc on us because we need our actual original
bio to be passed into the process_cb callback in order to get at our
ordered extent. With the split we'll get some cloned bio that has none
of our information. Handle this by returning the length we need to be
truncated to and then splitting ourselves, which will handle giving us
the correct btrfs_bio that we need.
Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Daniel Vacek <neelx@suse.com>
---
v5: https://lore.kernel.org/linux-btrfs/1fc07b885453495bccea5a37e13d7d26333bd2af.1706116485.git.josef@toxicpanda.com/
* No changes since.
---
fs/btrfs/bio.c | 29 ++++++++++++++++++++++++++++-
fs/btrfs/fscrypt.c | 24 ++++++++++++++++++++++++
fs/btrfs/fscrypt.h | 6 ++++++
3 files changed, 58 insertions(+), 1 deletion(-)
diff --git a/fs/btrfs/bio.c b/fs/btrfs/bio.c
index b79fc467445d..3e2ee19aab50 100644
--- a/fs/btrfs/bio.c
+++ b/fs/btrfs/bio.c
@@ -15,6 +15,7 @@
#include "zoned.h"
#include "file-item.h"
#include "raid-stripe-tree.h"
+#include "fscrypt.h"
static struct bio_set btrfs_bioset;
static struct bio_set btrfs_clone_bioset;
@@ -759,6 +760,7 @@ static bool btrfs_submit_chunk(struct btrfs_bio *bbio, int mirror_num)
u64 logical = bio->bi_iter.bi_sector << SECTOR_SHIFT;
u64 length = bio->bi_iter.bi_size;
u64 map_length = length;
+ u64 max_bio_len = length;
struct btrfs_io_context *bioc = NULL;
struct btrfs_io_stripe smap;
blk_status_t status;
@@ -770,6 +772,31 @@ static bool btrfs_submit_chunk(struct btrfs_bio *bbio, int mirror_num)
smap.rst_search_commit_root = false;
btrfs_bio_counter_inc_blocked(fs_info);
+
+ /*
+ * The blk-crypto-fallback limits bio sizes to 256 segments, because it
+ * has no way of controlling the pages it gets for the bounce bio it
+ * submits.
+ *
+ * If we don't pre-split our bio blk-crypto-fallback will do it for us,
+ * and then call into our checksum callback with a random cloned bio
+ * that isn't a btrfs_bio.
+ *
+ * To account for this we must truncate the bio ourselves, so we need to
+ * get our length at 256 segments and return that. We must do this
+ * before btrfs_map_block because the RAID5/6 code relies on having
+ * properly stripe aligned things, so we return the truncated length
+ * here so that btrfs_map_block() does the correct thing. Further down
+ * we actually truncate map_length to map_bio_len because map_length
+ * will be set to whatever the mapping length is for the underlying
+ * geometry. This will work properly with RAID5/6 as it will have
+ * already setup everything for the expected length, and everything else
+ * can handle with a truncated map_length.
+ */
+ if (bio_has_crypt_ctx(bio))
+ max_bio_len = btrfs_fscrypt_bio_length(bio, map_length);
+
+ map_length = max_bio_len;
ret = btrfs_map_block(fs_info, btrfs_op(bio), logical, &map_length,
&bioc, &smap, &mirror_num);
if (ret) {
@@ -788,7 +815,7 @@ static bool btrfs_submit_chunk(struct btrfs_bio *bbio, int mirror_num)
bbio->can_use_append = btrfs_use_zone_append(bbio);
- map_length = min(map_length, length);
+ map_length = min(map_length, max_bio_len);
if (bbio->can_use_append)
map_length = btrfs_append_map_length(bbio, map_length);
diff --git a/fs/btrfs/fscrypt.c b/fs/btrfs/fscrypt.c
index 5d4802fce7eb..5d34a8b94da5 100644
--- a/fs/btrfs/fscrypt.c
+++ b/fs/btrfs/fscrypt.c
@@ -295,6 +295,30 @@ ssize_t btrfs_fscrypt_context_for_new_extent(struct btrfs_inode *inode,
return ret;
}
+/*
+ * The block crypto stuff allocates bounce buffers for encryption, so splits at
+ * BIO_MAX_VECS worth of segments. If we are larger than that number of
+ * segments then we need to limit the size to the size that BIO_MAX_VECS covers.
+ */
+int btrfs_fscrypt_bio_length(struct bio *bio, u64 map_length)
+{
+ unsigned int i = 0;
+ struct bio_vec bv;
+ struct bvec_iter iter;
+ u64 segments_length = 0;
+
+ if (bio_op(bio) != REQ_OP_WRITE)
+ return map_length;
+
+ bio_for_each_segment(bv, bio, iter) {
+ segments_length += bv.bv_len;
+ if (++i == BIO_MAX_VECS)
+ return segments_length;
+ }
+
+ return map_length;
+}
+
const struct fscrypt_operations btrfs_fscrypt_ops = {
.inode_info_offs = (int)offsetof(struct btrfs_inode, i_crypt_info) -
(int)offsetof(struct btrfs_inode, vfs_inode),
diff --git a/fs/btrfs/fscrypt.h b/fs/btrfs/fscrypt.h
index 68eab4606935..f7ce2b2e6639 100644
--- a/fs/btrfs/fscrypt.h
+++ b/fs/btrfs/fscrypt.h
@@ -24,6 +24,7 @@ void btrfs_fscrypt_save_extent_info(struct btrfs_path *path, u8 *ctx, unsigned l
ssize_t btrfs_fscrypt_context_for_new_extent(struct btrfs_inode *inode,
struct fscrypt_extent_info *info,
u8 *ctx);
+int btrfs_fscrypt_bio_length(struct bio *bio, u64 map_length);
#else
static inline void btrfs_fscrypt_save_extent_info(struct btrfs_path *path,
@@ -63,6 +64,11 @@ static inline ssize_t btrfs_fscrypt_context_for_new_extent(struct btrfs_inode *i
return -EINVAL;
}
+static inline u64 btrfs_fscrypt_bio_length(struct bio *bio, u64 map_length)
+{
+ return map_length;
+}
+
#endif /* CONFIG_FS_ENCRYPTION */
extern const struct fscrypt_operations btrfs_fscrypt_ops;
--
2.53.0
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox