Keep the kernel update procedure in .agents/skills so it travels with the
repository and is available to contributors without a personal install.
Document the canonical nightly list, derived CI matrices, official version
sources and the boundary between updates and new distribution support.
Include a read-only upstream helper that compares configured series with
both the kernel.org release feed and archives, including final EOL updates.
Use a repository-relative command and shared English UI metadata.
Refresh eight existing upstream series and add Linux 7.3, using the
kernel.org release feed and archives as of October 19, 2026. Keep older
series in the matrix, including the final Linux 7.1.13 release.
Update the existing Rocky 10.2, 9.8 and 8.10 kernels and the UEK entries
for Oracle Linux 10, 9 and 8. Also pick up the final AlmaLinux 9.3 and
8.8 source RPM updates. Preserve distribution releases and UEK generations.
Add the 7.3 regression selector. Both CI matrices resolve exact versions
from nightly.conf, so no workflow version lists need updating. Keep full
nightly checks on 7.3 and apply the usual -nc option to the previous head.
Add a directory map with Make entry points and explain the preserved
working-directory conventions. Identify the current checkpatch ignore and
scan policies and the separate kernel regression analyzer path.
Record the caller updates required when moving helpers and the scope of
make shellcheck. Describe the side effects of cleanup, release and runtime
tools.
Place interrupt and memory monitors beside the block-device benchmark and
persistent-reservation exerciser. Update the SRPT maintainer instructions
and copyright paths with the move.
The four helpers are byte-for-byte unchanged, including their existing
privilege requirements and device or host side effects.
Keep RPM artifact creation, archive generation, package release preparation
and version updates in one directory. Switch all component archive targets,
the top-level RPM target and the RPM workflow to the relocated helpers.
Point archive generation at the shared source inventory in source/ while
preserving its caller-directory semantics and the existing package inputs.
Move patch generation, specialization, regression, kernel selection and
module signing helpers together, with their shared shell libraries. Update
component Makefiles, CI, nightly jobs, packaging metadata, documentation
and KUnit tooling references alongside the move.
Adjust repository-root and source-inventory lookups for the deeper path.
Resolve rhel-rpm-functions relative to kernel-functions through
BASH_SOURCE, since it is also sourced by the QLogic extraction helpers.
Keep the regression runner behavior and the nightly kernel matrix intact,
including the existing checkpatch, sparse and smatch switches and policy.
Keep source inventory, cleanup and shell lint helpers together. Update the
Makefile, Debian packaging, scstadmin and the kernel, release and existing
checkpatch callers in the same commit so each consumer uses a valid path.
Keep run-shellcheck rooted at scripts/ after the move, preserving its
coverage of all tracked Bash helpers. Source selection and the existing
checkpatch exclusions are unchanged.
Run usr/fileio/fileio_tgt over scst_local with an LD_PRELOAD hook that
replaces the block length of one READ CAPACITY(10) or (16) reply with
809052976, as a user space backend did in production. The invalid reply
must be rejected with INTERNAL TARGET FAILURE sense, and afterwards READ
CAPACITY(10) and (16), reads and writes must return the right geometry
and data.
The local suite now builds usr and loads scst_user, and the CI image
builds usr for the Ginkgo guest.
Add scst-LIB-capacity, which passes READ CAPACITY(10) and (16) replies
through scst_block_generic_dev_done() in one and two SG entries. Valid
block lengths, including a change from 4096 to 512 bytes, must update
the geometry and leave the reply intact. Zero and invalid lengths must
leave the geometry unchanged and complete the command with INTERNAL
TARGET FAILURE sense. It also checks scst_calc_block_shift() directly.
Add scst-CDB-tape, which decodes tape READ(6) and WRITE(6) CDBs and
checks that scst_tape_generic_parse() sizes fixed-block transfers by
block sizes that are not powers of two, accepts the largest transfers
and rejects overflowing ones. It also checks the residual-write
alignment test in scst_tgt_pre_exec() for tape and disk devices.
scst_calc_block_shift() warns when the sector size is not a power of two
but still returns its floor log2. When a backend returns a malformed READ
CAPACITY response, scst_block_generic_dev_done() therefore changes the
device geometry to an unrelated block size. For example, a block length
of 809052976 produces
1 << 29 != 809052976
WARNING: ... at scst_calc_block_shift+0x9c/0xe0 [scst]
and the device is switched to 536870912-byte blocks. Subsequent READ and
WRITE commands then fail in PARSE until another READ CAPACITY restores the
original block size. A zero block length is only logged, and the
response is still returned to the initiator with GOOD status.
Treat sector sizes below 512 bytes or not a power of two as invalid in
scst_calc_block_shift() instead of warning. When a READ CAPACITY response
reports a zero or invalid block length, keep the current geometry and
complete the command with INTERNAL TARGET FAILURE sense, so that the
initiator does not use the malformed capacity data.
scst_block_generic_dev_done() reads the block length from a completed
READ CAPACITY response through scst_get_buf_full(cmd, &buffer, false).
When the response spans more than one scatterlist entry, that call
returns a vmalloc() buffer without copying the response data into it,
because the command transfers data from the device. The block length is
then taken from uninitialized memory, and scst_put_buf_full() copies the
same uninitialized memory back over the response before it is returned
to the initiator.
Request a copy of the response so that the block length is read from the
data returned by the backend and the response is left intact.
scst_tape_generic_parse() converts a fixed-block transfer length to bytes
by shifting it by dev->block_shift, which tape devices derive from the
block size with scst_calc_block_shift(). Tape block sizes need not be
powers of two, so a block size such as 1536 bytes is truncated to
shift 10 and the command buffer is sized for 1024-byte blocks.
Multiply by the block size instead and check the products for overflow,
rejecting a zero fixed block size. Tape devices no longer use
block_shift, so stop deriving it from the block size.
scst_tgt_pre_exec() also used block_shift to check that a short write
ends on a block boundary, and shifting by a negative block_shift is
undefined. For tape, check the received length against the block size
when the FIXED bit is set, and accept variable-length transfers, which
are counted in bytes. Other devices keep the existing check.
Fixes: 94a84adbf7 ("scst: Micro-optimize the overflow checks in scst_tape_generic_parse()")
The copy manager only executes block to block segments, and sizes them
with the block shift of the source and destination devices. A target
descriptor is matched to a device by its designator and block size only,
so a device added to the copy manager without a valid block shift can
be named in an EXTENDED COPY and shifted by a negative value.
scst_user already registers non-disk devices with block_shift -1, and
the following tape change does the same for scst_tape devices. Reject
such devices when they are added to the copy manager, as read-only
devices already are. Virtual CD-ROM devices keep their block shift and
remain supported.
The checkpatch workflows fetch checkpatch.pl, spelling.txt and
const_structs.checkpatch with a plain curl. When raw.githubusercontent.com
rate-limits the runner, curl saves the HTTP 429 error page as
checkpatch.pl and exits successfully. The next step then runs that page
as a script, so every commit fails with
./checkpatch.pl: line 1: 429:: command not found
which looks like a checkpatch failure of the pull request.
Pass -f so that an HTTP error fails the download step, and --retry 5 so
that transient errors, including HTTP 429, are retried first. Also use
-sSL to keep the log quiet and follow redirects.
Keep CI selection policy in shared ci-pr and ci-push label sets. Resolve
them to ordinary Ginkgo expressions for local discovery and execution,
and before booting CI guests so report validation still checks the exact
filter. Preserve ordinary expressions and the full manual selection.
Mark both ACG teardown scenarios as race and exclude that category from
master push runs. Keep their strict overlap, recovery and cleanup checks
unchanged. PR runs retain basic/smoke coverage through ci-pr.
Document the named selections and check their filtering behavior and
propagation through the VM supervisor.
Remove the issue #367 walkthrough from the KUnit guide and the smoke and
SCSI case lists from the Ginkgo guide. Keep scenario expectations with
the tests instead of duplicating them in runner documentation.
Retain label selection, environment requirements and artifact guidance.
Describe optional kernel-log collection without tying it to an issue.
Task-management initialization reads sess->acg before acquiring activity
protection. A concurrent reassignment can clear this pointer and later
drop the old ACG reference, so the read can dereference NULL or freed
storage even while ordinary command processing is suspended.
Keep a session-owned copy of the black-hole mode and read it with
READ_ONCE() in the TM path. Initialize it before admitting session work,
retain the old mode while replacing LUNs, and publish the new mode when
installing the new ACG. Update existing sessions on sysfs writes as well.
All writers hold scst_mutex and use WRITE_ONCE(); the TM command already
owns a session reference, so no additional locking or ACG reference is
needed for this scalar policy read.
Read the previous sysfs value under the same mutex so concurrent stores
cannot mistake a real change for a no-op and leave session copies stale.
Extend the private TM tests with sysfs mode transitions, rejected writes,
and old/new drop-policy checks inside and after real reassignment.
Remove the dedicated Ginkgo opt-in and Skip path now that the fix is
in place, so both teardown scenarios run whenever their labels are
selected, including full CI runs.
Link: https://github.com/SCST-project/scst/issues/367
Add opt-in issue-367 scenarios that move a fixture initiator between
disjoint LUN maps alongside logout or an exact TCP socket reset. Wait
for a fresh kernel reassignment message naming the initiator and groups
before requesting teardown, and require overlapping command intervals.
Verify group ownership, recovery and session cleanup after each move.
Capture new kernel records, reject diagnostics or incomplete evidence,
and preserve the target when teardown cannot be justified. Require an
explicit profile option even when all Ginkgo labels are selected.
Test socket selection, log observation and opt-in configuration.
The scenarios use nullio and do not implement a production fix or a
duplicate-IQN login generator. Kernel-observed reassignment and command
overlap do not prove that TM entered the NULL-ACG window; a successful
run means not reproduced.
Link: https://github.com/SCST-project/scst/issues/367
Issue #367 reports a TM thread dereferencing sess->acg while the session
reassignment path temporarily clears it. Add private fixtures covering
all black_hole modes for teardown TM functions, mode changes after real
reassignment, and the unchanged-group path.
Invoke the TM reader from the allocation stub during reassignment and
check command state, drop policy and event delivery for all five modes.
Keep the old and new modes equal in this case so that its expected policy
is unambiguous. The regression runs without SKIP and may crash the test
VM before a production fix; document this execution requirement.
Expose only private test entry points and task-scoped redirects; normal
build behavior is unchanged.
Link: https://github.com/SCST-project/scst/issues/367
Build RPM packages only on pushes to master and remove the manual package
workflow trigger. Keep DEB checks on pull requests and retain the rolling
master publication with its current-head checks and release serialization.
Cancel outdated runs of the same pull request within each CI workflow.
Give other events a separate group per run so master package builds and
publication are not interrupted by newer pushes. Keep the full regression
matrix and all build and test steps unchanged.
Build kernel-matched images on GitHub-hosted runners and execute tests
under an external QEMU supervisor. Run KUnit and Ginkgo in independent
jobs that each build and test SCST. Keep guest images local to each job
and upload build logs and test reports.
Capture serial logs outside the guests, require complete matching
reports, and bound guest execution independently of kernel health.
Exercise guest panic and timeout handling before KUnit. Give Ginkgo an
isolated iSCSI peer and disposable block storage.
Print native test output and summaries in the job log. On failure, include
supervisor errors, kernel diagnostics and bounded serial tails while
retaining complete artifacts and the original test command exit status.
Select basic management and smoke SCSI/I/O tests on both transports for
pull requests. Run every Ginkgo spec after pushes to master and on manual
runs. Pass the label filter into the guest and require both transport
reports to confirm the requested selection.
The UNMAP parser reads the descriptor length before checking that the
parameter header is present, and bounds descriptor reads by the CDB
length without checking the available SG data. A nonzero CDB length with
no buffer also succeeds silently. Reject short headers and transfers with
PARAMETER LIST LENGTH ERROR before reading any parameter data, while
preserving the zero-length command as a no-op.
SBC-3 section 5.26.2 requires an incomplete final UNMAP descriptor to be
ignored. The current multiple-of-16 check instead rejects the entire
command. Parse only complete descriptors within both the advertised
descriptor length and the CDB parameter length, as Linux target does.
Bound allocation and traversal by that same descriptor count.
Keep the existing KUnit expectations and enable the six short-transfer
cases previously skipped to avoid out-of-bounds reads. Add coverage for
zero-length CDBs with extra SG data, truncated headers across SG entries,
partial final descriptors and oversized descriptor-length fields. Fill
input descriptors independently of the expected output count.
Add shared Ginkgo cases over scst_local and TCP iSCSI using temporary
thin-provisioned fileio LUNs. Check target sense for short headers and
read back seeded ranges and guards to detect ignored valid descriptors,
unwanted discards and incomplete descriptors processed as complete ones.
Probe hole punching before export because fileio does not promise LBPRZ.
Keep SG_IO and CDB transfer lengths equal in these integration cases;
missing or split SG data remains covered by KUnit.
Fixes: 3b57904da6 ("Unify parsing of descriptors-based and internal commands")
GET_NEXT_EVENT removes a delivered event from queued_events_cnt when it
moves the event to processing_events_list. If the consumer does not
acknowledge that event before its timeout, scst_event_timeout_fn()
decrements the same counter again. This can make the count negative or
undercount other queued events, weakening the queue admission limit.
Clear the queued-counter pointer when delivery moves the event, under
scst_event_mutex, and decrement it on timeout only while it is present.
Keep the existing delivered-timeout expectations. Extend KUnit coverage
to expire an undelivered event after a copy fault, drain the remaining
queue, and acknowledge another processing event after a timeout.
Fixes: 297d268a7a ("SCST events infrastructure")
Dynamic attributes can contain CHAP secrets. Administrative update,
duplicate, removal and debug messages currently print their values,
exposing them in captured command output.
Report the operation and attribute name without the value in both
the CLI and Perl library. Keep metadata-driven discovery and explicit
privileged queries unchanged.
Add a Ginkgo case that checks add, duplicate, remove, missing-value
and debug output through the real scstadmin. Query the newly created
attribute explicitly to confirm that the synthetic secret was stored
before checking that the update output omits it.
Link: https://github.com/SCST-project/scst/issues/91
Saved configurations contain CHAP secrets. Opening a new output with
the caller's umask can make those secrets readable by other users.
Truncating an existing readable file also leaves its access mode
unchanged while the new contents are written.
Create outputs with mode 0600 and restrict existing files before
truncating them. Require an owned regular file, reject symbolic links
and report preparation, flush, sync and close failures. Keep the
original secret in the configuration because CHAP needs it.
Add Ginkgo coverage through the real scstadmin for new and existing
0644, 0640 and 0600 outputs and for symlink rejection. Run the writer
with umask 022 and probe access after dropping to UID/GID 65534, using
public and private control files to validate the probe itself.
Link: https://github.com/SCST-project/scst/issues/91
The unsupported-license diagnostic directs users to an obsolete
mailbox. Remove that invitation without inventing a replacement
contact or changing the licensing policy.
Keep the accepted license strings and the EPERM result unchanged.
This changes only the diagnostic text.
Link: https://github.com/SCST-project/scst/issues/240
A tape REWIND transfers no data, but its transport can supply Read or
Write flags with zero expected lengths. RFC 7143 section 11.3.1 permits
either or both flags in this case. The parser rejects the mismatch
before the command reaches the device handler.
Allow the mismatch only for tape REWIND with no decoded or expected
input or output data. Preserve the rejection of nonzero transfers and
the existing TEST UNIT READY exception.
Update the CDB KUnit cases to accept READ, WRITE and BIDI flags with
zero lengths. Cover nonzero input and output lengths as rejection
cases through the real command parser.
Link: https://github.com/SCST-project/scst/issues/278
The UNMAP parser allocates a counted descriptor array without a
terminating entry. Walking until a zero-block descriptor can read
beyond that array or miss valid ranges after a zero-block entry.
Bound the overlap walk by cmd_data_descriptors_cnt and skip each
zero-block entry individually. This keeps all valid ranges in the
atomic-command exclusion check without examining unpublished entries.
The existing UNMAP KUnit cases cover the count boundary, zero-block
entries and both command argument orders using allocated guard storage.
Link: https://github.com/SCST-project/scst/issues/328
The fio profile uses a final explicit synchronization, which can hide
an ignored FUA from issue #395. Send WRITE(10/16) FUA commands followed
by readback before any later cache command instead.
Share the protocol cases between local and iSCSI fixtures. Cover explicit
SYNCHRONIZE CACHE(10/16) ranges, zero-length-to-end and IMMED, using
nonzero offsets and one-block/cross-page transfers on sparse owned files.
Cover buffered synchronous/asynchronous I/O and asynchronous direct I/O
with 512/4096-byte sectors. Reject direct synchronous profiles before
creating a backing file: vdisk_fileio does not support that combination.
Add write-through and nonvolatile-cache FUA controls, keeping them out
of the separate unfixed commandless cache-bypass path.
Unit-test literal CDB bytes, range overflow, command order, data phases,
failed commands, corrupt readback and backend profile attributes without
storage access. These tests check the command contract and payload;
persistence after a crash remains a separate test-harness task.
Link: https://github.com/SCST-project/scst/issues/395
The issue #394 fix moves sync into sysfs work. A timed-out store may
return while that work still owns a device reference, so the handler can
disappear before backend lookup.
Exercise the real store and callback with a task-local executor, real
work allocation and device krefs. Cover allocation, suspend and backend
failures, successful and delayed completion, and handler removal
before delayed work runs. Check reference balance, suspend/resume
pairing and lockdep assertions at backend entry.
Use native task-scoped stubs at the core queue and suspension
boundaries; normal builds compile them out. Acquire scst_mutex directly
through the production callback. No synthetic device enters a real SCST
queue, and a delayed kobject release is joined before its independent
allocation and module reference are released; incomplete release is
retained. These deterministic ordering tests do not simulate concurrent
teardown or power loss.
Link: https://github.com/SCST-project/scst/issues/394
Issue #395 combined an advanced write offset, an incorrect flush end,
missing asynchronous FUA propagation and an explicit-flush bypass for
direct I/O. The existing backend tests supplied parsed parameters and
covered only successful queued completion.
Decode WRITE(10/12/16/32) through the core and handler parsers, including
large LBAs, FUA controls and both sector sizes. Check SYNCHRONIZE CACHE
range coverage, zero-length-to-end semantics, errors and IMMED ordering
with its temporary command reference. Also exercise commandless direct
flushes, queued FUA errors and residuals, and short-write-before-flush
ordering. Add the detached-handler guard case for issue #394.
Use a zero-length data buffer for cache commands. Their core parser leaves
data_len zero and vdisk flushes to the end of the device, so require the
flush to cover the CDB range without rejecting that wider flush.
The private fixture records filesystem calls and completion ordering;
it does not claim persistence across a crash. Keep the existing skips
for the separate commandless cache-bypass defect.
Link: https://github.com/SCST-project/scst/issues/394
Link: https://github.com/SCST-project/scst/issues/395
The sysfs sync regression in issue #394 originates in
commit 530af782ed ("scst_vdisk: Add 'sync' sysfs attribute").
It dereferenced a closed file. Require a management rejection for inactive
devices, the last detach and ALUA states that close the backend, then
verify recovery.
Remove only the fixture device's internal copy-manager mappings when
checking the last attachment: an external LUN count alone does not prove
that the backend is closed. Use an explicit local session for successful
sync and preserve unrelated devices. Put session LUNs in an explicit
initiator group because scstadmin does not report the default group map
in its session listing.
Drop the temporary known-crash label, opt-in setting and example filter.
The inactive-sync regression now belongs to the default basic selection.
Link: https://github.com/SCST-project/scst/issues/394
Setting o_direct causes vdisk_fsync() to skip FUA and SYNCHRONIZE CACHE.
Bypassing the page cache does not make data persistent in the backing
device's volatile cache. Direct I/O still needs explicit synchronization.
Moreover, fileio uses o_direct only in its asynchronous path: synchronous
writes, including the DIF fallback, remain buffered despite the flag.
The o_direct flush bypass was added by the 2007 cleanup of vdisk_fsync().
Remove it so that an explicit flush reaches the backend regardless of the
I/O mode. Preserve the write-through, non-volatile cache and nullio cases.
Fixes: 6e1cb95cce ("Minor cleanups")
Link: https://github.com/SCST-project/scst/issues/395
With async=1, fileio_exec_write() returns through fileio_exec_async()
before reaching its FUA flush. The asynchronous path only requests
IOCB_DSYNC for write-through devices and ignores the command's FUA bit.
A write-back device can consequently report a successful FUA write before
the data is persistent, for both buffered and direct I/O.
This has been the case since asynchronous fileio support was introduced
in 2018. Request IOCB_DSYNC for FUA writes as well as write-through writes
so that the filesystem performs the synchronization before completing
the I/O. Preserve the explicit nv_cache override and leave reads and
ordinary write-back writes unchanged.
Fixes: d84fc0783d ("vdisk_fileio: Add support for asynchronous I/O processing")
Link: https://github.com/SCST-project/scst/issues/395
Writing and waiting for dirty pages does not guarantee that the data can
be recovered after a crash. For example, a write into a sparse backing
file can also require an allocation or journal update, and the backing
device can still hold the data in a volatile write cache. A successful
FUA or SYNCHRONIZE CACHE must not acknowledge only page writeback.
The 2009 Linux 2.6.32 port replaced sync_page_range(), which also performed
metadata synchronization, with filemap_write_and_wait_range(). The
alternative generic_write_sync() was left disabled; it would also be
insufficient for an ordinary write-back file because it checks O_DSYNC.
Use vfs_fsync_range() with datasync enabled to let the filesystem persist
the data and the metadata needed to retrieve it, including any required
backend flush. Keep the existing range, DIF-tag handling and SCSI error
reporting. The API is available in all kernels in the nightly matrix.
Remove the unused writeback test boundary and its stub. The private file
operations now record filesystem synchronization directly, so a missing
fsync still fails the existing flush-count assertions.
Fixes: 2b5833d90e ("Update for 2.6.32 + fix context of vdisk_t10_dev_id_rwlock")
Link: https://github.com/SCST-project/scst/issues/395
__vdisk_fsync_fileio() receives an offset and a length but passes the
length as the last byte to filemap_write_and_wait_range(). At nonzero
LBAs this can truncate or invert the range and report success without
writing the requested pages. This affects FUA, SYNCHRONIZE CACHE and
file-backed DIF tags even when the starting offset is correct.
The Linux 2.6.32 update in 2009 replaced sync_page_range(), which took a
length, with filemap_write_and_wait_range(), which takes an inclusive end
offset, without converting the argument.
Calculate the last byte as loff + len - 1. Treat an empty range as a no-op
so that a zero-length flush cannot turn into an end offset of -1.
Fixes: 2b5833d90e ("Update for 2.6.32 + fix context of vdisk_t10_dev_id_rwlock")
Link: https://github.com/SCST-project/scst/issues/395
fileio_exec_write() passes its local loff to scst_writev(), which advances
it by the number of bytes written. Using that offset for the subsequent
FUA flush starts the range after the data instead of at its beginning.
The command can therefore complete without synchronizing its writes.
The 2011 opcode dispatch refactoring moved the flush into the write
function, where loff was already advanced between I/O batches. The 2012
zero-copy change then passed &loff instead of &fd->f_pos to vfs_writev(),
making the offset wrong even for a write completed in one call.
Use the unchanged command offset for the flush, including after short
writes and errors. Keep the working offset for advancing through the I/O.
Fixes: 63a6094cad ("Eliminate the blockio / fileio / nullio if-statements in vdisk_do_job() and the READ/WRITE functions called from that function. Convert the opcode switch in vdisk_*do_job() to an array with function pointers.")
Fixes: f742ae018e ("scst_vdisk: Add zero-copy file I/O readsupport")
Link: https://github.com/SCST-project/scst/issues/395
Writing to the sync attribute after the last target device has detached,
or while the virtual device is inactive, dereferences a NULL file pointer.
The blockio branch likewise passes a missing block device to the flush
helper. The sync attribute was introduced in 2015 without checking whether
the backend was open or serializing against its release.
Run the operation through the SCST sysfs work mechanism and keep a device
reference until it finishes. Suspend command and task management activity
to exclude backend reopen from MODE SELECT and resets. Hold scst_mutex and
the ALUA lock across the open check and flush to exclude detach, explicit
activation and ALUA transitions. This also closes the race that a NULL
check alone would leave behind.
Activity remains globally suspended until the flush completes, so a slow
backend can delay commands to other devices as well.
Return -ENOMEDIUM for a closed backend instead of opening an inactive
device. Preserve the nullio no-op and the existing fileio/blockio flush
selection. The sysfs work mechanism avoids taking scst_mutex directly in
a sysfs callback and provides the usual -EAGAIN completion protocol.
A device kobject reference does not keep the handler attached after the
sysfs store returns. Check dh_priv under scst_mutex as well and return
-ENODEV if handler teardown won the race with the queued work.
Keep backend dispatch in a private helper so KUnit can exercise it with
task-scoped stubs on an unregistered device. Enable the existing closed-
backend cases without queueing a synthetic device to the sysfs thread.
Fixes: 530af782ed ("scst_vdisk: Add 'sync' sysfs attribute")
Link: https://github.com/SCST-project/scst/issues/394
Allow named sets of base labels and exact suite names in one TOML file.
Keep KUNIT_LABEL as the selection interface and combine overlapping sets
without running a suite twice. Include an IO set for CDB, UNMAP and VDISK.
Share expansion between source listing and runtime module selection.
Validate requested sets against the supplied module manifests before any
module operation, then load their owners and dependencies as before.
Reject namespace conflicts, nested sets and incomplete selections.
List descriptions and expanded suites without a build or loaded modules.
Allow an alternate file through --label-config, record selected definitions
in reports, and cover source listing, configuration and module ordering.
Read and preserve the native KTAP document for each suite after its run
write completes, under the same operation timeout. Validate the document
identity, plan and completeness independently of the kernel log.
Keep kernel log capture for diagnostics, retained fixtures and unexpected
execution. Preserve the stop and module ownership rules, and cover result
read failures, parameter diagnostics and complete results with an Oops.
Ubuntu 24.04 kernel 6.8.0-147 includes default_gfp() and the typed
allocation helpers. The version checks only account for mainline and
selected stable releases, so backport.h redefines __default_gfp(),
default_gfp() and __alloc_flex(). The package build fails while compiling
scst_copy_mgr.o with -Werror.
Add an explicit Ubuntu 6.8 ABI boundary to the existing version checks.
The helpers are absent from 6.8.0-146 and present in 6.8.0-147. Apply the
same boundary to __alloc_objs() and document the Ubuntu backport commits.
Limit the exception to ABIs 147 through 998. Ubuntu recommends ABI 999
for custom builds, which may use older sources without these helpers.
Derivative kernels start at ABI 1000 and use independent ABI sequences;
for example, 6.8.0-1047-aws does not contain these helpers. Preserve the
existing fallback for these kernels rather than infer API availability
from their ABI numbers.
Keep the upstream and stable version checks and the existing object
wrappers. API availability remains a versioned compatibility decision.
Fixes: 77c1efbc1e ("scst/include/backport.h: Add kmalloc_obj() helper family")
Link: https://ubuntu.com/kernel/docs/how-to/develop-customise/build-kernel/#modify-abi-number
Link: https://discourse.ubuntu.com/t/73765
Link: https://github.com/SCST-project/scst/actions/runs/38561552270/job/115843592684
Keep local validation commands in CONTRIBUTING so developers and agents
follow the same checks. Link to them from AGENTS instead of maintaining
separate instructions, and distinguish static checks from builds and tests.
Add concise README navigation and contributor links to the KUnit and
Ginkgo guides without duplicating their commands and configuration
reference.
Integrate iSCSI test objects in out-of-tree module builds.
Move transmit state names to a private header and link a separate
suite with task-scoped socket and completion boundaries.
Exercise data, padding and digest progress, retries, short sends and
TX_END completion. Preserve socket arguments and completion order
without creating a socket or initiator session.
Link a USER suite with private cleanup access and a task-scoped
pool-flush boundary. Check existing cleanup-yield behavior, post-unjam
flush ordering and session reply ownership without changing logic or
destroying real SGV pools.
Link separate I/O and synchronization suites with shared fixtures. Use
private file operations and native task-scoped block-flush and writeback
stubs. Distinguish page writeback from filesystem synchronization and
accept either fsync or fdatasync. The writeback boundary retains the
original API and arguments.
Assert FUA offsets, inclusive ranges, filesystem synchronization,
asynchronous flags, errors and completion counts. Check failed writes
for status and progress without requiring full-range FUA synchronization.
Allow empty-range and empty-file requests to omit backend synchronization
or perform it.
Exercise the original sysfs store on a private device. Explicitly skip
unsafe closed-backend and commandless-bypass cases pending separate
production fixes.
Include all handler suites through the shared KUnit switch in external
module builds. Link the capacity suite as a separate object with private
access to the command dispatcher. Keep the access declarations available
to ordinary in-tree builds.
Check READ CAPACITY response bytes, queue geometry, short and split
buffers, and invalid CDBs using private fileio and nullio fixtures.
Bind the command CDB to its inline buffer and provide a private session
for allocation-failure status handling.
Make scst_vdisk and scst_user composite modules so KUnit can link
additional objects without including test sources. Rename the
implementation files while preserving the module names and update
source-path consumers.
Move existing private command and device layouts into local headers
without changing their fields, constants or logic. No installed
interface is expanded.
Add private access declarations and task-scoped boundaries for sysfs,
copy-manager admission, grace periods and blocking waits. Preserve
their original operations outside the current test task.
Share the existing ACG release-work layout through the private core
header so the worker and its separate test object use one definition.
Link separate lifecycle and blocker suites covering rollback, mapping
detach order, ACG worker locking and reference ownership. Cleanup
tolerates failed initialization and assertions.
Expose private functions to a separate test object and stub discovery,
registration and default-group lookup. Keep the actual update and
admission paths unchanged.
Check coalescing, failed inquiry, removal before retry and read-only
LUN rejection using private state.
Move the existing client layout into a private header and link
separate suites with shared fixtures. Add task-scoped usercopy and
allocation boundaries around the actual ioctl and timeout paths.
Use private clients without scheduling work or accessing userspace
memory. Preserve payload validation and counter behavior; the
delivered-timeout assertion exposes the existing double decrement.
Include the private event headers needed by ordinary in-tree builds
in generated kernel patches.
Gleb Chesnokov
wenlxieandGleb Chesnokov