nfs_nfsdsocket.c: Fix "nfsstats -d" for ERELOOKUP
When ERELOOKLUP is returned by a file operation
(always vop_lookup?) the operation is retried without
doing nfsrv_statsend().
This patch fixes this problem,
The only effect of the bug was bogus "nfsstat -d"
output.
PR: 298534
(cherry picked from commit 9a237074d380233e93a17ddee6b155cc2f90ee96)
[mlir][scf] Fix front peeling skipped due to float rounding in trip count (#231100)
fixes #231062 which affects loops with constant bounds where the `step`
and `upper bound - lower bound` are very close and by "close" the `upper
bound - lower bound` exceeds step by less than about half a float32 ulp
at that magnitude.
eg:
`ub - lb`: 20000001, `step`: 20000000
`ub - lb`: 1099511693312, `step`: 1099511627776
removing the float conversation and hence the ceil operation and
comparing `*ubInt - *lbInt <= *stepInt` with repro as a test.
x11/bhotkeys: Update to 1.4
Several improvements and bug fixes.
Update XDM examples and XDM section in bhotkeys-greeter(1) to provide the
typical location of Xsetup/GiveConsole files
Add a Listener checkbox to the panel footer to allow toggling overall
functionality (both to facilitate quick comparison of default window manager
functionality versus bhothkeys as well as quick-disable to prevent distraction
during certain games)
Fix incorrect default sort order. Should be category-then- alphabetic instead
of alphabetic
Add support for remembering scroll position and sort order in greeter mode
Fix an issue that prevented root window click from dismissing the session panel
[10 lines not shown]
[mlir][scf] Fix front-peel unsigned loops with at most one iteration (#231542)
For unsigned loops with constant bounds, read the bounds as `APInt` and
skip peeling when `ub <= lb` or `ub - lb <= step` (compared unsigned),
bail out if failed.
from #231100 and fixes #231541
uhidev: the report size when doing USB_GET_REPORT could exceed the size
of ucr_data. Check that report size doesn't exceed ucr_data, preventing
heap overflow. Also for USB_SET_REPORT.
From Acts1631
"looks correct" deraadt@
[mlir][bufferization] Fix bug when moving dealloc operation (#229296)
This commit fixes bugs that were identified in #227975.
The core reason is that the existing code does not perform checks on
wether it is safe to move `dealloc`, and would blindly do a
`deallocOp->moveAfter(lastUser)`.
We have to check that where we move it to is:
- After all the operand definitions that the `dealloc` uses
- Before any of ops that consume the results produced by the `dealloc`
This is what the `findValidInsertionPoint` method does.
AI disclosure: assistance from copilot to navigate code base, and plan
out the code. Was still written by me.
[CIR] Support statements after co_return (#231046)
Emit code for statements after a co_return in a new block, which may be
reachable through a label. Unlike classic codegen, this patch still
keeps unreachable code alive through flattening to stay closer to the
source code, though this could still be changed.
---------
Co-authored-by: Claude Opus 5.5 <noreply at anthropic.com>
[libc++] Create a reusable workflow for submitting to LNT (#232127)
This allows reusing the same logic in other workflows, and most
importantly it will allow separating concerns (such as API keys) by
making them accessible only to the workflow that needs to submit to LNT,
not the workflows that produce the benchmark data.
[CIR] Handle lifetime-extended temporaries in loop conditions (#231469)
The lifetime of temporaries used to initialize a loop condition variable
needs to be extended to the end of each iteration. Example:
```c++
ConvertibleToBool get_ctb();
while(ConvertibleToBool const& cond = get_ctb()) {
...
} // destroy temporary here, then reevaluate
```
Capture the destructor cleanups so temporary lifetimes get extended.
Assisted-By: Claude Opus 5.5 <noreply at anthropic.com>
zio: free the gang header ABD when its read fails
zio_gang_tree_assemble() wraps the gang header buffer in an ABD with
abd_get_from_buf(). zio_gang_tree_assemble_done() frees it, but only
when the read succeeded: on an error it returns first and the abd_t is
never freed. Each failed gang header read, whether from a checksum
or an I/O error, leaks one.
A pool whose MOS has large gang headers that can not be read while
the pool is loading (#19189) shows it. On a debug kernel, the failed
imports of such a pool left six abd_t objects behind and "rmmod zfs"
then panicked on
VERIFY3U(percpu_counter_sum(&skc->skc_linux_alloc), ==, 0). valgrind
on a failed "zdb -e" of the same kind of pool reports the abd_t
allocated by abd_get_from_buf() in zio_gang_tree_assemble() as
definitely lost.
Free the ABD on the error path as well. Nothing else owns it: the
gang tree only frees the header buffer, and the other gang callbacks
[5 lines not shown]
[orc-rt] Add C addressing regression tests for BSS. (#232137)
Add static/global x load/store tests for zero-initialized data, plus
load and store tests of the last element of a 1MB BSS array, which catch
zero-fill memory that is undersized (e.g. a single page) or only partly
writable.
[DAGCombiner] Use willNotOverflowAdd in addition to the nsw flag in DAGCombiner::visitAVG. (#231347)
I encountered a case in our downstream compiler where we generated
an avgfloors but a later reassociation brought an add with 1 closer
to the avgfloors, exposing an opportunity to use avgceils.
Unfortunately, we didn't have the nsw flag because DAGCombiner
doesn't infer it.
We could do this for avgflooru/avgceilu too, but I don't have a test
case yet. Converting the signed test I have to unsigned by using zext
still ends up picking avgfloors instead of avgflooru.
[llvm-objcopy] Stream ELF output to regular files
Write ELF output directly to seekable regular files instead of first allocating a buffer for the entire output. Keep buffered output for stdout and other non-seekable streams.
Use separate buffered and file-backed output implementations. Serialize regenerated metadata sequentially, seeking once per output range, and report sticky file errors after writing finishes. Truncate and extend seekable output up front so unwritten layout gaps read as zero without being materialized; explicitly overwrite only removed section contents within copied segments.
On a synthetic stamping-style ELF containing a 1 GiB payload, three warm-cache no-op copies had median peak RSS of 2,102,916 KiB before and 1,053,844 KiB after (49.9% lower). Median wall time improved from 1.06 s to 0.77 s, and the outputs were byte-identical.
Co-authored-by: Jeremy Braun <jtbraun at meta.com>
Co-authored-by: Fangrui Song <i at maskray.me>
Assisted-by: OpenAI Codex
[Support] Support seekable temporary output streams
Use raw_fd_stream for temporary outputs so callbacks can perform positioned writes and resize the destination. Add raw_fd_ostream::takeError and raw_fd_stream::resize, and return stream failures through Error while preserving an existing destination.
Co-authored-by: Jeremy Braun <jtbraun at meta.com>
Assisted-by: OpenAI Codex
[llvm-objcopy] Route section copies through writeSectionContents
Centralize section byte copies behind a virtual helper so ELF output can later target either a memory buffer or a seekable stream. Materialize SHT_SYMTAB_SHNDX entries using the target ELF word type to preserve output endianness.
Co-authored-by: Jeremy Braun <jtbraun at meta.com>
Assisted-by: OpenAI Codex
[lldb-dap] Return raw stop info from exceptionInfo (#231760)
lldb-dap folds the thread's extended stop info and the process's
extended crash information into the exceptionInfo description as
formatted text. Clients that want interpret these themselves currently
have to parse them back out.
Return both as raw JSON in two new lldb-dap extension fields,
`$__lldb_stopReasonExtendedInfo` and `$__lldb_extendedCrashInformation`.
rdar://188761988
[LoopPredication] Check profitability per widenable guard
The profitability check refuses to predicate a loop if any exit is more
than twice as likely as the latch exit. For a guard expressed as a
widenable branch, the guard's own deopt edge is one of these exits, but
predicating the guard cannot make that edge taken spuriously; it can only
move an actual failure to the loop entry.
A frontend that gives every guard a fixed, very small failure probability
(e.g. weights {983040, 1}) therefore never gets its guards predicated in
loops running more than ~1.97M iterations per entry, because the latch
exit becomes less likely than the guard's own deopt edge. This keeps the
range check inside the loop and blocks its vectorization.
Check the profitability separately for each widenable guard, ignoring
only that guard's deopt edge. Deopt edges of other guards and all other
exits still compete with the latch exit. Guard intrinsics and loop exit
predication still use the check for the whole loop.
Co-Authored-By: Claude Opus 5.5 <noreply at anthropic.com>
