www/remark42: build frontend with pnpm
- Switch to USES=npm:pnpm so the frontend is built from upstream's
pnpm-lock.yaml (frozen, offline, no lifecycle scripts) instead of
an npm-resolved dependency set.
- Follow the default Node.js version instead of hardcoding node24.
- Relax the Go requirement to 1.27+.
- Fetch the prefetch distfiles from MASTER_SITES before the framework
regenerates them, and recompress the node modules archive with xz.
- Drop the TypeScript patch, no longer needed with upstream's
locked dependency versions.
- Remove unused variables and reorder per portclippy.
[AMDGPU] Use 8-bit barrier member count on GFX13
GFX13 widens the barrier member count in M0 to 8 bits for cluster
named barriers. s_barrier_init and s_barrier_signal_var lowering
masked it to 6 bits, truncating counts above 63.
Change-Id: I33571d2ed499ebe168571c6b4cd5d0e3340f8a0f
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply at anthropic.com>
[flang][cuda] share runtime type info between host and device under managed memory (#229213)
With -gpu=mem:managed, descriptors can live in managed memory, so a
descriptor built on the device may be read on the host. The type
descriptor address in its addendum then pointed at the device copy of
the type info, and host code dereferencing it crashed.
Make the host copy of the type info the single shared copy:
- Add the cuf-shared-type-info pass. It makes host type-info globals
writable, places them in the __nv_type_info section, and drops
acc.declare from type info on both host and device so that OpenACC
declare constructors no longer copy it to the device. For each type
descriptor used in the GPU module, it creates a managed pointer
global <dt>Xhostaddr<tag>. The tag is a per-unit hash, which keeps
the name unique when each unit has its own device module. The GPU
module gets a cuf.shared_type_descs dictionary mapping each type
descriptor to its pointer.
- CUFAddConstructor: add the cuda-managed-type-info option. It
[12 lines not shown]
[orc-rt] Default LockedAccess's LockT arg to std::scoped_lock (#230881)
In the common case where LockT = std::scoped_lock<std::mutex> is the
desired lock (and mutex) type, this allows us to write:
LockedAccess<T> getValue() { return { Value, Mutex }; }
without having to spell out the type for LockT.
nfs_nfsdstate.c: Add an extra safety belt check for the backchannel
I do not think that xp_p2 can be NULL at this point,
but add an extra safety belt, just in case.
(cherry picked from commit a52c50b4b7c2652954ef1bd34710a4b1fc8ef391)
clnt_vc.c: Fix handling of broken TCP connections
After more than, I don't know, maybe 10k operations: mount, copy,
remove, verify and unmount cycles, one cp command hung in
close() / ncl_flush and never recovered. The machine and the mount
continued to work normally through a new connection, but the writes
using the old connection stayed frozen.
I did not understand exactly what happened. I traced what appears to
be the issue in the code. My current understanding is that
clnt_vc_soupcall() saw the EOF and woke the caller waiting for RPC
replies, but one caller remained blocked in sosend().
That thread continued holding a reference to the old client, preventing
it from being completely cleaned up.
The attached patch calls socantsendmore() when EOF is received, which
should wake the blocked sender and let the normal reconnect code replace
the connection.
(cherry picked from commit 49bec8c3dc58cf8e944f9bbbbea07e7e856ad897)
[NVPTX] Preserve the load chain when custom-lowering i1 loads (#230497)
lowerLOADi1() rewrites an i1 load into a zext load to i16 plus a
truncate, and returns the (value, chain) pair as a MERGE_VALUES node.
LegalizeLoadOps installs that pair with
RChain = Res.getValue(1);
DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 1), RChain);
so the second value of the MERGE_VALUES becomes the replacement for the
original load's chain result. Returning LD->getChain() therefore rewires
every memory operation that followed the original load to that load's
predecessor, and leaves the new zext load's chain result with no users.
The ordering edge between the new load and those memory operations is
dropped, so nothing in the DAG keeps them in order beyond whatever data
dependency happens to exist between them.
Return newLD.getValue(1) instead, so the edge is preserved.
clnt_vc.c: Fix handling of backchannel xprt
When clnt_vc_destroy() is called, it might not be the
current connection. Without this patch, if it is not
the current connection, xp_p2 is set NULL and xprt is released
when it should not be released.
This patch adds a check for "current connection" to fix
the problem. Found during testing to the client RDMA code,
but could happen for TCP as well.
(cherry picked from commit 81a6514689cefdaa5c92b5539ae885ec8c6b3336)
Fix an off-by-one in bsd_decompress()
An incorrect bounds check for the LZW KwKwK case allows the creation of a
self-refential dictionary entry, resulting in an infinite expansion loop
that writes backward from the output mbuf, corrupting kernel memory.
This is an ancient buffer overflow that is also present in the version of
the code in RFC 1977.
From Acts1631
ok deraadt
nfs_nfsdstate.c: Add an extra safety belt check for the backchannel
I do not think that xp_p2 can be NULL at this point,
but add an extra safety belt, just in case.
(cherry picked from commit a52c50b4b7c2652954ef1bd34710a4b1fc8ef391)
clnt_vc.c: Fix handling of broken TCP connections
After more than, I don't know, maybe 10k operations: mount, copy,
remove, verify and unmount cycles, one cp command hung in
close() / ncl_flush and never recovered. The machine and the mount
continued to work normally through a new connection, but the writes
using the old connection stayed frozen.
I did not understand exactly what happened. I traced what appears to
be the issue in the code. My current understanding is that
clnt_vc_soupcall() saw the EOF and woke the caller waiting for RPC
replies, but one caller remained blocked in sosend().
That thread continued holding a reference to the old client, preventing
it from being completely cleaned up.
The attached patch calls socantsendmore() when EOF is received, which
should wake the blocked sender and let the normal reconnect code replace
the connection.
(cherry picked from commit 49bec8c3dc58cf8e944f9bbbbea07e7e856ad897)
