25 files changed, 641 insertions, 62 deletions
diff --git a/lib/libc/gen/fdopendir.c b/lib/libc/gen/fdopendir.c
index df6709fbcb85..9393cbe28f85 100644
--- a/lib/libc/gen/fdopendir.c
+++ b/lib/libc/gen/fdopendir.c
@@ -48,8 +48,16 @@
 DIR *
 fdopendir(int fd)
 {
+	int flags, rc;
 
-	if (_fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
+	flags = _fcntl(fd, F_GETFD, 0);
+	if (flags == -1)
 		return (NULL);
+
+	if ((flags & FD_CLOEXEC) == 0) {
+		rc = _fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
+		if (rc == -1)
+			return (NULL);
+	}
 	return (__opendir_common(fd, DTF_HIDEW | DTF_NODUP, true));
 }
diff --git a/lib/libc/gen/readdir.c b/lib/libc/gen/readdir.c
index 32603c0b4677..b70102954df1 100644
--- a/lib/libc/gen/readdir.c
+++ b/lib/libc/gen/readdir.c
@@ -50,6 +50,7 @@ _readdir_unlocked(DIR *dirp, int flags)
 	struct dirent *dp;
 	off_t initial_seek;
 	size_t initial_loc = 0;
+	ssize_t ret;
 
 	for (;;) {
 		if (dirp->dd_loc >= dirp->dd_size) {
@@ -61,11 +62,13 @@ _readdir_unlocked(DIR *dirp, int flags)
 		}
 		if (dirp->dd_loc == 0 &&
 		    !(dirp->dd_flags & (__DTF_READALL | __DTF_SKIPREAD))) {
+			dirp->dd_size = 0;
 			initial_seek = dirp->dd_seek;
-			dirp->dd_size = _getdirentries(dirp->dd_fd,
+			ret = _getdirentries(dirp->dd_fd,
 			    dirp->dd_buf, dirp->dd_len, &dirp->dd_seek);
-			if (dirp->dd_size <= 0)
+			if (ret <= 0)
 				return (NULL);
+			dirp->dd_size = (size_t)ret;
 			_fixtelldir(dirp, initial_seek, initial_loc);
 		}
 		dirp->dd_flags &= ~__DTF_SKIPREAD;
diff --git a/lib/libc/powerpc64/gen/_ctx_start.S b/lib/libc/powerpc64/gen/_ctx_start.S
index c2f8abfd6486..98225f9c1138 100644
--- a/lib/libc/powerpc64/gen/_ctx_start.S
+++ b/lib/libc/powerpc64/gen/_ctx_start.S
@@ -34,6 +34,16 @@
 	ld	%r2,8(%r14)
 	ld	%r14,0(%r14)
 #else
+	/*
+	 * The stack frame was already set up in makecontext(),
+	 * so we can safely use the guaranteed fields here.
+	 *
+	 * Note we do step on the allocated stack frame's TOC,
+	 * but since we never return from this function (i.e.
+	 * never restore the stack frame) this should be safe.
+	 */
+	std	%r2,24(%r1)	/* save TOC */
+
 	/* Load global entry point */
 	mr	%r12,%r14
 #endif
@@ -41,6 +51,10 @@
 	blrl			/* branch to start function */
 	mr	%r3,%r15	/* pass pointer to ucontext as argument */
 	nop
+#if defined(_CALL_ELF) && _CALL_ELF != 1
+	/* Restore TOC */
+	ld	%r2,24(%r1)
+#endif
 	bl	CNAME(_ctx_done) /* branch to ctxt completion func */
 	/*
 	 * we should never return from the
diff --git a/lib/libc/powerpc64/gen/makecontext.c b/lib/libc/powerpc64/gen/makecontext.c
index 75c2d40bdd60..9e3a976fa1bd 100644
--- a/lib/libc/powerpc64/gen/makecontext.c
+++ b/lib/libc/powerpc64/gen/makecontext.c
@@ -78,7 +78,7 @@ __makecontext(ucontext_t *ucp, void (*start)(void), int argc, ...)
 	 */
 	stackargs = (argc > 8) ? argc - 8 : 0;
 	sp = (char *) ucp->uc_stack.ss_sp + ucp->uc_stack.ss_size
-		- sizeof(uintptr_t)*(stackargs + 2);
+		- sizeof(uintptr_t)*(stackargs + 6);
 	sp = (char *)((uintptr_t)sp & ~0x1f);
 
 	mc = &ucp->uc_mcontext;
@@ -119,6 +119,7 @@ __makecontext(ucontext_t *ucp, void (*start)(void), int argc, ...)
 	mc->mc_srr0 = *(uintptr_t *)_ctx_start;
 #else
 	mc->mc_srr0 = (uintptr_t) _ctx_start;
+	mc->mc_gpr[12] = (uintptr_t) _ctx_start;/* required for prologue */
 #endif
 	mc->mc_gpr[1] = (uintptr_t) sp;		/* new stack pointer */
 	mc->mc_gpr[14] = (uintptr_t) start;	/* r14 <- start */
diff --git a/lib/libc/stdio/fdopen.c b/lib/libc/stdio/fdopen.c
index a0d7b71df782..49ec97eda39d 100644
--- a/lib/libc/stdio/fdopen.c
+++ b/lib/libc/stdio/fdopen.c
@@ -46,7 +46,7 @@ FILE *
 fdopen(int fd, const char *mode)
 {
 	FILE *fp;
-	int flags, oflags, fdflags, tmp;
+	int flags, oflags, fdflags, rc, tmp;
 
 	/*
 	 * File descriptors are a full int, but _file is only a short.
@@ -76,9 +76,19 @@ fdopen(int fd, const char *mode)
 	if ((fp = __sfp()) == NULL)
 		return (NULL);
 
-	if ((oflags & O_CLOEXEC) && _fcntl(fd, F_SETFD, FD_CLOEXEC) == -1) {
-		fp->_flags = 0;
-		return (NULL);
+	if ((oflags & O_CLOEXEC) != 0) {
+		tmp = _fcntl(fd, F_GETFD, 0);
+		if (tmp == -1) {
+			fp->_flags = 0;
+			return (NULL);
+		}
+		if ((tmp & FD_CLOEXEC) == 0) {
+			rc = _fcntl(fd, F_SETFD, tmp | FD_CLOEXEC);
+			if (rc == -1) {
+				fp->_flags = 0;
+				return (NULL);
+			}
+		}
 	}
 
 	fp->_flags = flags;
diff --git a/lib/libc/stdio/freopen.c b/lib/libc/stdio/freopen.c
index f0732b6d6741..048fd30b3193 100644
--- a/lib/libc/stdio/freopen.c
+++ b/lib/libc/stdio/freopen.c
@@ -55,7 +55,7 @@ freopen(const char * __restrict file, const char * __restrict mode,
     FILE * __restrict fp)
 {
 	int f;
-	int dflags, flags, isopen, oflags, sverrno, wantfd;
+	int dflags, fdflags, flags, isopen, oflags, sverrno, wantfd;
 
 	if ((flags = __sflags(mode, &oflags)) == 0) {
 		sverrno = errno;
@@ -113,8 +113,12 @@ freopen(const char * __restrict file, const char * __restrict mode,
 			(void) ftruncate(fp->_file, (off_t)0);
 		if (!(oflags & O_APPEND))
 			(void) _sseek(fp, (fpos_t)0, SEEK_SET);
-		if (oflags & O_CLOEXEC)
-			(void) _fcntl(fp->_file, F_SETFD, FD_CLOEXEC);
+		if ((oflags & O_CLOEXEC) != 0) {
+			fdflags = _fcntl(fp->_file, F_GETFD, 0);
+			if (fdflags != -1 && (fdflags & FD_CLOEXEC) == 0)
+				(void) _fcntl(fp->_file, F_SETFD,
+				    fdflags | FD_CLOEXEC);
+		}
 		f = fp->_file;
 		isopen = 0;
 		wantfd = -1;
diff --git a/lib/libc/stdtime/Makefile.inc b/lib/libc/stdtime/Makefile.inc
index 5d0ce7765b63..647cbe6f40ba 100644
--- a/lib/libc/stdtime/Makefile.inc
+++ b/lib/libc/stdtime/Makefile.inc
@@ -18,6 +18,7 @@ CFLAGS.${src}+=	-I${LIBC_SRCTOP}/stdtime
 CFLAGS.localtime.c+= -DALL_STATE -DTHREAD_SAFE
 .if ${MK_DETECT_TZ_CHANGES} != "no"
 CFLAGS.localtime.c+= -DDETECT_TZ_CHANGES
+CFLAGS.Version.map+= -DDETECT_TZ_CHANGES
 .endif
 
 MAN+=	ctime.3 strftime.3 strptime.3 time2posix.3 tzset.3
diff --git a/lib/libc/stdtime/Symbol.map b/lib/libc/stdtime/Symbol.map
index 669d4d47907b..6a34cd3ea590 100644
--- a/lib/libc/stdtime/Symbol.map
+++ b/lib/libc/stdtime/Symbol.map
@@ -35,3 +35,9 @@ FBSD_1.8 {
 	daylight;
 	timezone;
 };
+
+FBSDprivate_1.0 {
+#ifdef DETECT_TZ_CHANGES
+	__tz_change_interval;
+#endif
+};
diff --git a/lib/libc/tests/gen/opendir_test.c b/lib/libc/tests/gen/opendir_test.c
index 89be2becc607..b7481255654f 100644
--- a/lib/libc/tests/gen/opendir_test.c
+++ b/lib/libc/tests/gen/opendir_test.c
@@ -46,6 +46,7 @@ opendir_check(const struct atf_tc *tc, DIR *dirp)
 	ATF_CHECK_STREQ("subdir", ent->d_name);
 	ATF_CHECK_EQ(DT_DIR, ent->d_type);
 	ATF_CHECK(readdir(dirp) == NULL);
+	ATF_CHECK(readdir(dirp) == NULL);
 }
 
 ATF_TC(opendir_ok);
diff --git a/lib/libc/tests/gen/scandir_test.c b/lib/libc/tests/gen/scandir_test.c
index f7b52b5e3616..afd25bf7c0b2 100644
--- a/lib/libc/tests/gen/scandir_test.c
+++ b/lib/libc/tests/gen/scandir_test.c
@@ -157,7 +157,7 @@ ATF_TC_BODY(scandir_error, tc)
 {
 	char path[16];
 	struct dirent **namelist = NULL;
-	int fd, i, ret;
+	int fd, i;
 
 	ATF_REQUIRE_EQ(0, mkdir("dir", 0755));
 	for (i = 0; i < 1024; i++) {
@@ -170,9 +170,8 @@ ATF_TC_BODY(scandir_error, tc)
 	scandir_error_count = 0;
 	scandir_error_fd = fd;
 	scandir_error_select_return = 0;
-	ret = fdscandir(fd, &namelist, scandir_error_select, NULL);
-	ATF_CHECK_EQ(-1, ret);
-	ATF_CHECK_ERRNO(EBADF, ret < 0);
+	ATF_CHECK_ERRNO(EBADF,
+	    fdscandir(fd, &namelist, scandir_error_select, NULL) < 0);
 	ATF_CHECK_EQ(NULL, namelist);
 
 	/* second pass, select everything */
@@ -180,9 +179,8 @@ ATF_TC_BODY(scandir_error, tc)
 	scandir_error_count = 0;
 	scandir_error_fd = fd;
 	scandir_error_select_return = 1;
-	ret = fdscandir(fd, &namelist, scandir_error_select, NULL);
-	ATF_CHECK_EQ(-1, ret);
-	ATF_CHECK_ERRNO(EBADF, ret < 0);
+	ATF_CHECK_ERRNO(EBADF,
+	    fdscandir(fd, &namelist, scandir_error_select, NULL) < 0);
 	ATF_CHECK_EQ(NULL, namelist);
 }
 
diff --git a/lib/libc/tests/stdtime/Makefile b/lib/libc/tests/stdtime/Makefile
index c7a7f5b9436f..adb883cc5b9a 100644
--- a/lib/libc/tests/stdtime/Makefile
+++ b/lib/libc/tests/stdtime/Makefile
@@ -1,6 +1,9 @@
-.include <bsd.own.mk>
+.include <src.opts.mk>
 
 ATF_TESTS_C+=		strptime_test
+.if ${MK_DETECT_TZ_CHANGES} != "no"
+ATF_TESTS_C+=		detect_tz_changes_test
+.endif
 
 TESTSDIR:=	${TESTSBASE}/${RELDIR:C/libc\/tests/libc/}
 
diff --git a/lib/libc/tests/stdtime/detect_tz_changes_test.c b/lib/libc/tests/stdtime/detect_tz_changes_test.c
new file mode 100644
index 000000000000..9722546747fd
--- /dev/null
+++ b/lib/libc/tests/stdtime/detect_tz_changes_test.c
@@ -0,0 +1,281 @@
+/*-
+ * Copyright (c) 2025 Klara, Inc.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <sys/stat.h>
+#include <sys/wait.h>
+
+#include <dlfcn.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <poll.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <atf-c.h>
+
+static const time_t then = 1751328000; /* 2025-07-01 00:00:00 UTC */
+static const char *tz_change_interval_sym = "__tz_change_interval";
+static int *tz_change_interval_p;
+static const int tz_change_interval = 3;
+static int tz_change_timeout = 90;
+
+static bool debugging;
+
+static void
+debug(const char *fmt, ...)
+{
+	va_list ap;
+
+	if (debugging) {
+		va_start(ap, fmt);
+		vfprintf(stderr, fmt, ap);
+		va_end(ap);
+		fputc('\n', stderr);
+	}
+}
+
+static void
+change_tz(const char *tzn)
+{
+	static const char *zfn = "/usr/share/zoneinfo";
+	static const char *tfn = "root/etc/.localtime";
+	static const char *dfn = "root/etc/localtime";
+	ssize_t clen;
+	int zfd, sfd, dfd;
+
+	ATF_REQUIRE((zfd = open(zfn, O_DIRECTORY | O_SEARCH)) >= 0);
+	ATF_REQUIRE((sfd = openat(zfd, tzn, O_RDONLY)) >= 0);
+	ATF_REQUIRE((dfd = open(tfn, O_CREAT | O_TRUNC | O_WRONLY)) >= 0);
+	do {
+		clen = copy_file_range(sfd, NULL, dfd, NULL, SSIZE_MAX, 0);
+		ATF_REQUIRE_MSG(clen != -1, "failed to copy %s/%s: %m",
+		    zfn, tzn);
+	} while (clen > 0);
+	ATF_CHECK_EQ(0, close(dfd));
+	ATF_CHECK_EQ(0, close(sfd));
+	ATF_CHECK_EQ(0, close(zfd));
+	ATF_REQUIRE_EQ(0, rename(tfn, dfn));
+	debug("time zone %s installed", tzn);
+}
+
+/*
+ * Test time zone change detection.
+ *
+ * The parent creates a chroot containing only /etc/localtime, initially
+ * set to UTC.  It then forks a child which enters the chroot, repeatedly
+ * checks the current time zone, and prints it to stdout if it changes
+ * (including once on startup).  Meanwhile, the parent waits for output
+ * from the child.  Every time it receives a line of text from the child,
+ * it checks that it is as expected, then changes /etc/localtime within
+ * the chroot to the next case in the list.  Once it reaches the end of
+ * the list, it closes a pipe to notify the child, which terminates.
+ *
+ * Note that ATF and / or Kyua may have set the timezone before the test
+ * case starts (even unintentionally).  Therefore, we start the test only
+ * after we've received and discarded the first report from the child,
+ * which should come almost immediately on startup.
+ */
+ATF_TC(detect_tz_changes);
+ATF_TC_HEAD(detect_tz_changes, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Test timezone change detection");
+	atf_tc_set_md_var(tc, "require.user", "root");
+	atf_tc_set_md_var(tc, "timeout", "600");
+}
+ATF_TC_BODY(detect_tz_changes, tc)
+{
+	static const struct tzcase {
+		const char *tzfn;
+		const char *expect;
+	} tzcases[] = {
+		/*
+		 * A handful of time zones and the expected result of
+		 * strftime("%z (%Z)", tm) when that time zone is active
+		 * and tm represents a date in the summer of 2025.
+		 */
+		{ "America/Vancouver",	"-0700 (PDT)"	},
+		{ "America/New_York",	"-0400 (EDT)"	},
+		{ "Europe/London",	"+0100 (BST)"	},
+		{ "Europe/Paris",	"+0200 (CEST)"	},
+		{ "Asia/Kolkata",	"+0530 (IST)"	},
+		{ "Asia/Tokyo",		"+0900 (JST)"	},
+		{ "Australia/Canberra",	"+1000 (AEST)"	},
+		{ "UTC",		"+0000 (UTC)"	},
+		{ 0 },
+	};
+	char obuf[1024] = "";
+	char ebuf[1024] = "";
+	struct pollfd fds[3];
+	int opd[2], epd[2], spd[2];
+	time_t changed, now;
+	const struct tzcase *tzcase = NULL;
+	struct tm *tm;
+	size_t olen = 0, elen = 0;
+	ssize_t rlen;
+	long curoff = LONG_MIN;
+	pid_t pid;
+	int nfds, status;
+
+	/* speed up the test if possible */
+	tz_change_interval_p = dlsym(RTLD_SELF, tz_change_interval_sym);
+	if (tz_change_interval_p != NULL &&
+	    *tz_change_interval_p > tz_change_interval) {
+		debug("reducing detection interval from %d to %d",
+		    *tz_change_interval_p, tz_change_interval);
+		*tz_change_interval_p = tz_change_interval;
+		tz_change_timeout = tz_change_interval * 3;
+	}
+	/* prepare chroot */
+	ATF_REQUIRE_EQ(0, mkdir("root", 0755));
+	ATF_REQUIRE_EQ(0, mkdir("root/etc", 0755));
+	change_tz("UTC");
+	time(&changed);
+	/* output, error, sync pipes */
+	if (pipe(opd) != 0 || pipe(epd) != 0 || pipe(spd) != 0)
+		atf_tc_fail("failed to pipe");
+	/* fork child */
+	if ((pid = fork()) < 0)
+		atf_tc_fail("failed to fork");
+	if (pid == 0) {
+		/* child */
+		dup2(opd[1], STDOUT_FILENO);
+		close(opd[0]);
+		close(opd[1]);
+		dup2(epd[1], STDERR_FILENO);
+		close(epd[0]);
+		close(epd[1]);
+		close(spd[0]);
+		unsetenv("TZ");
+		ATF_REQUIRE_EQ(0, chroot("root"));
+		ATF_REQUIRE_EQ(0, chdir("/"));
+		fds[0].fd = spd[1];
+		fds[0].events = POLLIN;
+		for (;;) {
+			ATF_REQUIRE(poll(fds, 1, 100) >= 0);
+			if (fds[0].revents & POLLHUP) {
+				/* parent closed sync pipe */
+				_exit(0);
+			}
+			ATF_REQUIRE((tm = localtime(&then)) != NULL);
+			if (tm->tm_gmtoff == curoff)
+				continue;
+			olen = strftime(obuf, sizeof(obuf), "%z (%Z)", tm);
+			ATF_REQUIRE(olen > 0);
+			fprintf(stdout, "%s\n", obuf);
+			fflush(stdout);
+			curoff = tm->tm_gmtoff;
+		}
+		_exit(2);
+	}
+	/* parent */
+	close(opd[1]);
+	close(epd[1]);
+	close(spd[1]);
+	/* receive output until child terminates */
+	fds[0].fd = opd[0];
+	fds[0].events = POLLIN;
+	fds[1].fd = epd[0];
+	fds[1].events = POLLIN;
+	fds[2].fd = spd[0];
+	fds[2].events = POLLIN;
+	nfds = 3;
+	for (;;) {
+		ATF_REQUIRE(poll(fds, 3, 1000) >= 0);
+		time(&now);
+		if (fds[0].revents & POLLIN && olen < sizeof(obuf)) {
+			rlen = read(opd[0], obuf + olen, sizeof(obuf) - olen);
+			ATF_REQUIRE(rlen >= 0);
+			olen += rlen;
+		}
+		if (olen > 0) {
+			ATF_REQUIRE_EQ('\n', obuf[olen - 1]);
+			obuf[--olen] = '\0';
+			/* tzcase will be NULL at first */
+			if (tzcase != NULL) {
+				debug("%s", obuf);
+				ATF_REQUIRE_STREQ(tzcase->expect, obuf);
+				debug("change to %s detected after %d s",
+				    tzcase->tzfn, (int)(now - changed));
+				if (tz_change_interval_p != NULL) {
+					ATF_CHECK((int)(now - changed) >=
+					    *tz_change_interval_p - 1);
+					ATF_CHECK((int)(now - changed) <=
+					    *tz_change_interval_p + 1);
+				}
+			}
+			olen = 0;
+			/* first / next test case */
+			if (tzcase == NULL)
+				tzcase = tzcases;
+			else
+				tzcase++;
+			if (tzcase->tzfn == NULL) {
+				/* test is over */
+				break;
+			}
+			change_tz(tzcase->tzfn);
+			changed = now;
+		}
+		if (fds[1].revents & POLLIN && elen < sizeof(ebuf)) {
+			rlen = read(epd[0], ebuf + elen, sizeof(ebuf) - elen);
+			ATF_REQUIRE(rlen >= 0);
+			elen += rlen;
+		}
+		if (elen > 0) {
+			ATF_REQUIRE_EQ(elen, fwrite(ebuf, 1, elen, stderr));
+			elen = 0;
+		}
+		if (nfds > 2 && fds[2].revents & POLLHUP) {
+			/* child closed sync pipe */
+			break;
+		}
+		/*
+		 * The timeout for this test case is set to 10 minutes,
+		 * because it can take that long to run with the default
+		 * 61-second interval.  However, each individual tzcase
+		 * entry should not take much longer than the detection
+		 * interval to test, so we can detect a problem long
+		 * before Kyua terminates us.
+		 */
+		if ((now - changed) > tz_change_timeout) {
+			close(spd[0]);
+			if (tz_change_interval_p == NULL &&
+			    tzcase == tzcases) {
+				/*
+				 * The most likely explanation in this
+				 * case is that libc was built without
+				 * time zone change detection.
+				 */
+				atf_tc_skip("time zone change detection "
+				    "does not appear to be enabled");
+			}
+			atf_tc_fail("timed out waiting for change to %s "
+			    "to be detected", tzcase->tzfn);
+		}
+	}
+	close(opd[0]);
+	close(epd[0]);
+	close(spd[0]); /* this will wake up and terminate the child */
+	if (olen > 0)
+		ATF_REQUIRE_EQ(olen, fwrite(obuf, 1, olen, stdout));
+	if (elen > 0)
+		ATF_REQUIRE_EQ(elen, fwrite(ebuf, 1, elen, stderr));
+	ATF_REQUIRE_EQ(pid, waitpid(pid, &status, 0));
+	ATF_REQUIRE(WIFEXITED(status));
+	ATF_REQUIRE_EQ(0, WEXITSTATUS(status));
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+	debugging = !getenv("__RUNNING_INSIDE_ATF_RUN") &&
+	    isatty(STDERR_FILENO);
+	ATF_TP_ADD_TC(tp, detect_tz_changes);
+	return (atf_no_error());
+}
diff --git a/lib/libc/tests/sys/Makefile b/lib/libc/tests/sys/Makefile
index 89d341ff400a..88f8191a16eb 100644
--- a/lib/libc/tests/sys/Makefile
+++ b/lib/libc/tests/sys/Makefile
@@ -7,11 +7,11 @@ ATF_TESTS_C+=			brk_test
 .endif
 ATF_TESTS_C+=			cpuset_test
 ATF_TESTS_C+=			errno_test
+ATF_TESTS_C+=			swapcontext_test
 ATF_TESTS_C+=			queue_test
 ATF_TESTS_C+=			sendfile_test
 
-# TODO: clone, lwp_create, lwp_ctl, posix_fadvise, recvmmsg,
-# swapcontext
+# TODO: clone, lwp_create, lwp_ctl, posix_fadvise, recvmmsg
 NETBSD_ATF_TESTS_C+=		access_test
 NETBSD_ATF_TESTS_C+=		bind_test
 NETBSD_ATF_TESTS_C+=		chroot_test
diff --git a/lib/libc/tests/sys/swapcontext_test.c b/lib/libc/tests/sys/swapcontext_test.c
new file mode 100644
index 000000000000..f341a746e515
--- /dev/null
+++ b/lib/libc/tests/sys/swapcontext_test.c
@@ -0,0 +1,63 @@
+/*-
+ * Copyright (c) 2025 Raptor Computing Systems, LLC
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ucontext.h>
+#include <errno.h>
+
+#include <atf-c.h>
+
+#define STACK_SIZE	(64ull << 10)
+
+static volatile int callback_reached = 0;
+
+static ucontext_t uctx_save, uctx_switch;
+
+static void swapcontext_callback()
+{
+	// Increment callback reached variable
+	// If this is called multiple times, we will fail the test
+	// If this is not called at all, we will fail the test
+	callback_reached++;
+}
+
+ATF_TC(swapcontext_basic);
+ATF_TC_HEAD(swapcontext_basic, tc)
+{
+	atf_tc_set_md_var(tc, "descr",
+		"Verify basic functionality of swapcontext");
+}
+
+ATF_TC_BODY(swapcontext_basic, tc)
+{
+	char *stack;
+        int res;
+
+	stack = malloc(STACK_SIZE);
+	ATF_REQUIRE_MSG(stack != NULL, "malloc failed: %s", strerror(errno));
+	res = getcontext(&uctx_switch);
+	ATF_REQUIRE_MSG(res == 0, "getcontext failed: %s", strerror(errno));
+
+	uctx_switch.uc_stack.ss_sp = stack;
+	uctx_switch.uc_stack.ss_size = STACK_SIZE;
+	uctx_switch.uc_link = &uctx_save;
+	makecontext(&uctx_switch, swapcontext_callback, 0);
+
+	res = swapcontext(&uctx_save, &uctx_switch);
+
+        ATF_REQUIRE_MSG(res == 0, "swapcontext failed: %s", strerror(errno));
+        ATF_REQUIRE_MSG(callback_reached == 1,
+		"callback failed, reached %d times", callback_reached);
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+	ATF_TP_ADD_TC(tp, swapcontext_basic);
+
+	return (atf_no_error());
+}
+
diff --git a/lib/libfetch/common.c b/lib/libfetch/common.c
index 0d85ed468284..786d5647d993 100644
--- a/lib/libfetch/common.c
+++ b/lib/libfetch/common.c
@@ -277,13 +277,16 @@ conn_t *
 fetch_reopen(int sd)
 {
 	conn_t *conn;
+	int flags;
 	int opt = 1;
 
 	/* allocate and fill connection structure */
 	if ((conn = calloc(1, sizeof(*conn))) == NULL)
 		return (NULL);
-	fcntl(sd, F_SETFD, FD_CLOEXEC);
-	setsockopt(sd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof opt);
+	flags = fcntl(sd, F_GETFD);
+	if (flags != -1 && (flags & FD_CLOEXEC) == 0)
+		(void)fcntl(sd, F_SETFD, flags | FD_CLOEXEC);
+	(void)setsockopt(sd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt));
 	conn->sd = sd;
 	++conn->ref;
 	return (conn);
diff --git a/lib/libsecureboot/h/libsecureboot.h b/lib/libsecureboot/h/libsecureboot.h
index 017558536825..d32df9594332 100644
--- a/lib/libsecureboot/h/libsecureboot.h
+++ b/lib/libsecureboot/h/libsecureboot.h
@@ -29,6 +29,7 @@
 
 #include <sys/param.h>
 #ifdef _STANDALONE
+#define _DEBUG_LEVEL_VAR DebugVe
 #include <stand.h>
 #else
 #include <sys/types.h>
diff --git a/lib/libsys/fhopen.2 b/lib/libsys/fhopen.2
index aba53f1dd907..b281ac3d8949 100644
--- a/lib/libsys/fhopen.2
+++ b/lib/libsys/fhopen.2
@@ -31,7 +31,7 @@
 .\" ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 .\" POSSIBILITY OF SUCH DAMAGE.
 .\"
-.Dd April 6, 2025
+.Dd July 20, 2025
 .Dt FHOPEN 2
 .Os
 .Sh NAME
@@ -140,7 +140,7 @@ is no longer valid.
 .Xr fstatfs 2 ,
 .Xr getfh 2 ,
 .Xr open 2 ,
-.Xr named_attribute 9
+.Xr named_attribute 7
 .Sh HISTORY
 The
 .Fn fhopen ,
diff --git a/lib/libsys/statfs.2 b/lib/libsys/statfs.2
index 49e8b5120558..ab65def11ebb 100644
--- a/lib/libsys/statfs.2
+++ b/lib/libsys/statfs.2
@@ -25,7 +25,7 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.Dd April 7, 2025
+.Dd July 20, 2025
 .Dt STATFS 2
 .Os
 .Sh NAME
@@ -127,7 +127,7 @@ Mandatory Access Control (MAC) support for individual objects
 .Xr mac 4 ) .
 .It Dv MNT_NAMEDATTR
 The file system supports named attributes as described in
-.Xr named_attribute 9 .
+.Xr named_attribute 7 .
 .It Dv MNT_NFS4ACLS
 ACLs in NFSv4 variant are supported.
 .It Dv MNT_NOATIME
@@ -264,7 +264,7 @@ each file or directory name or disk label
 .Sh SEE ALSO
 .Xr fhstatfs 2 ,
 .Xr getfsstat 2 ,
-.Xr named_attribute 9
+.Xr named_attribute 7
 .Sh HISTORY
 The
 .Fn statfs
diff --git a/lib/libusb/libusb.3 b/lib/libusb/libusb.3
index a9a99f307a86..9dc752f0fd7b 100644
--- a/lib/libusb/libusb.3
+++ b/lib/libusb/libusb.3
@@ -22,7 +22,7 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.Dd June 12, 2025
+.Dd July 9, 2025
 .Dt LIBUSB 3
 .Os
 .Sh NAME
@@ -106,6 +106,19 @@ Get the ASCII representation of the error given by the
 argument.
 This function does not return NULL.
 .Pp
+.Ft int
+.Fn libusb_setlocale "const char *locale"
+Set locale for the error message when using
+.Fn libusb_strerror
+to
+.Ft locale .
+Note other
+.Nm
+implementations only support the first two bytes, that means
+.Ql en-US
+is equivalent to
+.Ql en-CA .
+.Pp
 .Ft const char *
 .Fn libusb_error_name "int code"
 Get the ASCII representation of the error enum given by the
@@ -353,6 +366,23 @@ argument is non-zero the feature is enabled.
 Else disabled.
 Returns 0 on success and a LIBUSB_ERROR code on
 failure.
+.Pp
+.Ft unsigned char *
+.Fn libusb_dev_mem_alloc "libusb_device_handle *devh"
+This function attempts to allocate a DMA memory block from the given
+.Fa devh
+so that we can enjoy the zero-copy transfer from kernel.
+This function is provided for compatibility and is currently unimplemented and always returns NULL.
+.Pp
+.Ft int
+.Fn libusb_dev_mem_free "libusb_device_handle *devh" "unsigned char *buffer" "size_t size"
+This function frees the DMA memory in
+.Fa devh
+from the given
+.Fa buffer
+with
+.Fa size .
+This function is unimplemented and always returns LIBUSB_ERROR_NOT_SUPPORTED.
 .Sh USB DESCRIPTORS
 .Ft int
 .Fn libusb_get_device_descriptor "libusb_device *dev" "libusb_device_descriptor *desc"
@@ -762,6 +792,17 @@ argument can be either of LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED or LIBUSB_HOTPLUG_
 .Ft void
 .Fn libusb_hotplug_deregister_callback "libusb_context *ctx" "libusb_hotplug_callback_handle handle"
 This function unregisters a hotplug filter.
+.Pp
+.Ft void
+.Fn libusb_free_pollfds "const struct libusb_pollfd **pollfds"
+This function releases the memory storage in
+.Fa pollfds ,
+and is safe to call when the argument is NULL.
+.Pp void *
+.Fn libusb_hotplug_get_user_data "struct libusb_context *ctx" "libusb_hotplug_callback_handle callback_handle"
+This function returns the user data from the opaque
+.Fa callback_handle ,
+or returns NULL if no matching handle is found.
 .Sh LIBUSB VERSION 0.1 COMPATIBILITY
 The library is also compliant with LibUSB version 0.1.12.
 .Pp
diff --git a/lib/libusb/libusb.h b/lib/libusb/libusb.h
index 17d341d1b91c..1803ff637738 100644
--- a/lib/libusb/libusb.h
+++ b/lib/libusb/libusb.h
@@ -122,6 +122,7 @@ enum libusb_transfer_type {
 	LIBUSB_TRANSFER_TYPE_ISOCHRONOUS = 1,
 	LIBUSB_TRANSFER_TYPE_BULK = 2,
 	LIBUSB_TRANSFER_TYPE_INTERRUPT = 3,
+	LIBUSB_TRANSFER_TYPE_BULK_STREAM = 4,
 };
 
 enum libusb_standard_request {
@@ -210,6 +211,8 @@ enum libusb_error {
 	LIBUSB_ERROR_OTHER = -99,
 };
 
+#define	LIBUSB_ERROR_COUNT 14
+
 enum libusb_speed {
 	LIBUSB_SPEED_UNKNOWN = 0,
 	LIBUSB_SPEED_LOW = 1,
@@ -475,6 +478,7 @@ int	libusb_init(libusb_context ** context);
 int	libusb_init_context(libusb_context **, const struct libusb_init_option [], int num_options);
 void	libusb_exit(struct libusb_context *ctx);
 int	libusb_has_capability(uint32_t capability);
+int	libusb_setlocale(const char *locale);
 
 /* Device handling and enumeration */
 
@@ -510,6 +514,9 @@ int 	libusb_detach_kernel_driver(libusb_device_handle * devh, int interface);
 int 	libusb_attach_kernel_driver(libusb_device_handle * devh, int interface);
 int	libusb_set_auto_detach_kernel_driver(libusb_device_handle *dev, int enable);
 int	libusb_set_interface_alt_setting(libusb_device_handle * devh, int interface_number, int alternate_setting);
+unsigned char *libusb_dev_mem_alloc(libusb_device_handle *devh);
+int	libusb_dev_mem_free(libusb_device_handle *devh, unsigned char *buffer,
+    size_t size);
 
 /* USB Descriptors */
 
@@ -570,7 +577,8 @@ int	libusb_handle_events(libusb_context * ctx);
 int	libusb_handle_events_locked(libusb_context * ctx, struct timeval *tv);
 int	libusb_get_next_timeout(libusb_context * ctx, struct timeval *tv);
 void	libusb_set_pollfd_notifiers(libusb_context * ctx, libusb_pollfd_added_cb added_cb, libusb_pollfd_removed_cb removed_cb, void *user_data);
-const struct libusb_pollfd **libusb_get_pollfds(libusb_context * ctx);
+const struct libusb_pollfd **libusb_get_pollfds(libusb_context *ctx);
+void    libusb_free_pollfds(const struct libusb_pollfd **pollfds);
 
 /* Synchronous device I/O */
 
@@ -590,6 +598,8 @@ typedef int (*libusb_hotplug_callback_fn)(libusb_context *ctx,
 
 int	libusb_hotplug_register_callback(libusb_context *ctx, libusb_hotplug_event events, libusb_hotplug_flag flags, int vendor_id, int product_id, int dev_class, libusb_hotplug_callback_fn cb_fn, void *user_data, libusb_hotplug_callback_handle *handle);
 void	libusb_hotplug_deregister_callback(libusb_context *ctx, libusb_hotplug_callback_handle handle);
+void   *libusb_hotplug_get_user_data(struct libusb_context *ctx,
+    libusb_hotplug_callback_handle callback_handle);
 
 /* Streams support */
 
diff --git a/lib/libusb/libusb10.c b/lib/libusb/libusb10.c
index 173f51aa88b3..5c116b39ea17 100644
--- a/lib/libusb/libusb10.c
+++ b/lib/libusb/libusb10.c
@@ -4,6 +4,7 @@
  * Copyright (c) 2009 Sylvestre Gallon. All rights reserved.
  * Copyright (c) 2009-2023 Hans Petter Selasky
  * Copyright (c) 2024 Aymeric Wibo
+ * Copyright (c) 2025 ShengYi Hung
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -31,6 +32,7 @@
 #include LIBUSB_GLOBAL_INCLUDE_FILE
 #else
 #include <assert.h>
+#include <ctype.h>
 #include <errno.h>
 #include <poll.h>
 #include <pthread.h>
@@ -84,6 +86,52 @@ static const struct libusb_version libusb_version = {
 	.describe = "https://www.freebsd.org"
 };
 
+static const struct libusb_language_context libusb_language_ctx[] = {
+	{
+	    .lang_name = "en",
+	    .err_strs = {
+			[-LIBUSB_SUCCESS] = "Success",
+			[-LIBUSB_ERROR_IO] = "I/O error",
+			[-LIBUSB_ERROR_INVALID_PARAM] = "Invalid parameter",
+			[-LIBUSB_ERROR_ACCESS] = "Permissions error",
+			[-LIBUSB_ERROR_NO_DEVICE] = "No device",
+			[-LIBUSB_ERROR_NOT_FOUND] = "Not found",
+			[-LIBUSB_ERROR_BUSY] = "Device busy",
+			[-LIBUSB_ERROR_TIMEOUT] = "Timeout",
+			[-LIBUSB_ERROR_OVERFLOW] = "Overflow",
+			[-LIBUSB_ERROR_PIPE] = "Pipe error",
+			[-LIBUSB_ERROR_INTERRUPTED] = "Interrupted",
+			[-LIBUSB_ERROR_NO_MEM] = "Out of memory",
+			[-LIBUSB_ERROR_NOT_SUPPORTED]  ="Not supported",
+			[LIBUSB_ERROR_COUNT - 1] = "Other error",
+			[LIBUSB_ERROR_COUNT] = "Unknown error",
+		}
+	},
+	{
+		.lang_name = "zh",
+		.err_strs = {
+			[-LIBUSB_SUCCESS] = "成功",
+			[-LIBUSB_ERROR_IO] = "I/O 錯誤",
+			[-LIBUSB_ERROR_INVALID_PARAM] = "不合法的參數",
+			[-LIBUSB_ERROR_ACCESS] = "權限錯誤",
+			[-LIBUSB_ERROR_NO_DEVICE] = "裝置不存在",
+			[-LIBUSB_ERROR_NOT_FOUND] = "不存在",
+			[-LIBUSB_ERROR_BUSY] = "裝置忙碌中",
+			[-LIBUSB_ERROR_TIMEOUT] = "逾時",
+			[-LIBUSB_ERROR_OVERFLOW] = "溢位",
+			[-LIBUSB_ERROR_PIPE] = "管道錯誤",
+			[-LIBUSB_ERROR_INTERRUPTED] = "被中斷",
+			[-LIBUSB_ERROR_NO_MEM] = "記憶體不足",
+			[-LIBUSB_ERROR_NOT_SUPPORTED]  ="不支援",
+			[LIBUSB_ERROR_COUNT - 1] = "其他錯誤",
+			[LIBUSB_ERROR_COUNT] = "未知錯誤",
+		}
+	},
+};
+
+static const struct libusb_language_context *default_language_context =
+    &libusb_language_ctx[0];
+
 const struct libusb_version *
 libusb_get_version(void)
 {
@@ -1482,6 +1530,7 @@ found:
 		libusb20_tr_set_callback(pxfer0, libusb10_isoc_proxy);
 		break;
 	case LIBUSB_TRANSFER_TYPE_BULK:
+	case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
 	case LIBUSB_TRANSFER_TYPE_INTERRUPT:
 		libusb20_tr_set_callback(pxfer0, libusb10_bulk_intr_proxy);
 		break;
@@ -1728,38 +1777,26 @@ libusb_le16_to_cpu(uint16_t x)
 const char *
 libusb_strerror(int code)
 {
-	switch (code) {
-	case LIBUSB_SUCCESS:
-		return ("Success");
-	case LIBUSB_ERROR_IO:
-		return ("I/O error");
-	case LIBUSB_ERROR_INVALID_PARAM:
-		return ("Invalid parameter");
-	case LIBUSB_ERROR_ACCESS:
-		return ("Permissions error");
-	case LIBUSB_ERROR_NO_DEVICE:
-		return ("No device");
-	case LIBUSB_ERROR_NOT_FOUND:
-		return ("Not found");
-	case LIBUSB_ERROR_BUSY:
-		return ("Device busy");
-	case LIBUSB_ERROR_TIMEOUT:
-		return ("Timeout");
-	case LIBUSB_ERROR_OVERFLOW:
-		return ("Overflow");
-	case LIBUSB_ERROR_PIPE:
-		return ("Pipe error");
-	case LIBUSB_ERROR_INTERRUPTED:
-		return ("Interrupted");
-	case LIBUSB_ERROR_NO_MEM:
-		return ("Out of memory");
-	case LIBUSB_ERROR_NOT_SUPPORTED:
-		return ("Not supported");
-	case LIBUSB_ERROR_OTHER:
-		return ("Other error");
-	default:
-		return ("Unknown error");
-	}
+	int entry = -code;
+
+	if (code == LIBUSB_ERROR_OTHER)
+		entry = LIBUSB_ERROR_COUNT - 1;
+	/*
+	 * The libusb upstream considers all code out of range a
+	 * LIBUSB_ERROR_OTHER. In FreeBSD, it is a special unknown error. We
+	 * preserve the FreeBSD implementation as I think it make sense.
+	 */
+	if (entry < 0 || entry >= LIBUSB_ERROR_COUNT)
+		entry = LIBUSB_ERROR_COUNT;
+
+	/*
+	 * Fall back to English one as the translation may be unimplemented
+	 * when adding new error code.
+	 */
+	if (default_language_context->err_strs[entry] == NULL)
+		return (libusb_language_ctx[0].err_strs[entry]);
+
+	return (default_language_context->err_strs[entry]);
 }
 
 const char *
@@ -1842,3 +1879,42 @@ libusb_log_va_args(struct libusb_context *ctx, enum libusb_log_level level,
 
 	va_end(args);
 }
+
+/*
+ * Upstream code actually recognizes the first two characters to identify a
+ * language. We do so to provide API compatibility with setlocale.
+ */
+int
+libusb_setlocale(const char *locale)
+{
+	size_t idx;
+	const char *lang;
+
+	if (locale == NULL || strlen(locale) < 2 ||
+	    (locale[2] != '\0' && strchr("-_.", locale[2]) == NULL))
+		return (LIBUSB_ERROR_INVALID_PARAM);
+
+	for (idx = 0; idx < nitems(libusb_language_ctx); ++idx) {
+		lang = libusb_language_ctx[idx].lang_name;
+		if (tolower(locale[0]) == lang[0] &&
+		    tolower(locale[1]) == lang[1]) {
+			default_language_context = &libusb_language_ctx[idx];
+			return (LIBUSB_SUCCESS);
+		}
+	}
+
+	return (LIBUSB_ERROR_INVALID_PARAM);
+}
+
+unsigned char *
+libusb_dev_mem_alloc(libusb_device_handle *devh)
+{
+	return (NULL);
+}
+
+int
+libusb_dev_mem_free(libusb_device_handle *devh, unsigned char *buffer,
+    size_t size)
+{
+	return (LIBUSB_ERROR_NOT_SUPPORTED);
+}
diff --git a/lib/libusb/libusb10.h b/lib/libusb/libusb10.h
index 9ad08edf075b..eced364ef857 100644
--- a/lib/libusb/libusb10.h
+++ b/lib/libusb/libusb10.h
@@ -139,6 +139,12 @@ struct libusb_device {
 	struct libusb20_device *os_priv;
 };
 
+struct libusb_language_context {
+	const char *lang_name;
+	/* All error Plus 1 UNKNOWN */
+	const char *err_strs[LIBUSB_ERROR_COUNT + 1];
+};
+
 extern struct libusb_context *usbi_default_context;
 
 void	libusb10_add_pollfd(libusb_context *ctx, struct libusb_super_pollfd *pollfd, struct libusb20_device *pdev, int fd, short events);
diff --git a/lib/libusb/libusb10_hotplug.c b/lib/libusb/libusb10_hotplug.c
index 369539d4512e..9c46d4926bfa 100644
--- a/lib/libusb/libusb10_hotplug.c
+++ b/lib/libusb/libusb10_hotplug.c
@@ -414,3 +414,21 @@ void libusb_hotplug_deregister_callback(libusb_context *ctx,
 
 	free(handle);
 }
+
+void *
+libusb_hotplug_get_user_data(struct libusb_context *ctx,
+    libusb_hotplug_callback_handle callback_handle)
+{
+	libusb_hotplug_callback_handle handle;
+
+	ctx = GET_CONTEXT(ctx);
+
+	HOTPLUG_LOCK(ctx);
+	TAILQ_FOREACH(handle, &ctx->hotplug_cbh, entry) {
+		if (handle == callback_handle)
+			break;
+	}
+	HOTPLUG_UNLOCK(ctx);
+
+	return (handle);
+}
diff --git a/lib/libusb/libusb10_io.c b/lib/libusb/libusb10_io.c
index dd541b09caa6..c99586ff650d 100644
--- a/lib/libusb/libusb10_io.c
+++ b/lib/libusb/libusb10_io.c
@@ -781,6 +781,19 @@ libusb_fill_interrupt_transfer(struct libusb_transfer *transfer,
 }
 
 void
+libusb_fill_bulk_stream_transfer(struct libusb_transfer *transfer,
+    libusb_device_handle *dev_handle, unsigned char endpoint,
+    uint32_t stream_id, unsigned char *buffer, int length,
+    libusb_transfer_cb_fn callback, void *user_data, unsigned int timeout)
+{
+	libusb_fill_bulk_transfer(transfer, dev_handle, endpoint, buffer,
+	    length, callback, user_data, timeout);
+	transfer->type = LIBUSB_TRANSFER_TYPE_BULK_STREAM;
+
+	libusb_transfer_set_stream_id(transfer, stream_id);
+}
+
+void
 libusb_fill_iso_transfer(struct libusb_transfer *transfer, 
     libusb_device_handle *devh, uint8_t endpoint, uint8_t *buf,
     int length, int npacket, libusb_transfer_cb_fn callback,
@@ -842,3 +855,12 @@ libusb_transfer_get_stream_id(struct libusb_transfer *transfer)
 	/* get stream ID */
 	return (sxfer->stream_id);
 }
+
+void
+libusb_free_pollfds(const struct libusb_pollfd **pollfds)
+{
+	if (pollfds == NULL)
+		return;
+
+	free(pollfds);
+}
diff --git a/lib/ncurses/tinfo/Makefile b/lib/ncurses/tinfo/Makefile
index 920bd6e5559c..476df54bb72a 100644
--- a/lib/ncurses/tinfo/Makefile
+++ b/lib/ncurses/tinfo/Makefile
@@ -259,10 +259,18 @@ term.h: MKterm.h.awk edit_cfg.sh Caps Caps-ncurses
 	sh ${NCURSES_DIR}/include/edit_cfg.sh ${NCURSES_CFG_H} $@.new
 	mv -f $@.new $@
 
+# Avoid hard-coding absolute source paths if requested.
+.if ${MK_REPRODUCIBLE_BUILD} != "no"
+NCURSES_SRCTOP=/usr/src
+.else
+NCURSES_SRCTOP=${SRCTOP}
+.endif
+
 curses.h: curses.head MKkey_defs.sh Caps Caps-ncurses
 	cat curses.head > $@.new
 	AWK=${AWK} _POSIX2_VERSION=199209 sh ${NCURSES_DIR}/include/MKkey_defs.sh \
 	    ${NCURSES_DIR}/include/Caps ${NCURSES_DIR}/include/Caps-ncurses >> $@.new
+	sed -i '' 's|${SRCTOP}|${NCURSES_SRCTOP}|g' $@.new
 	cat ${NCURSES_DIR}/include/curses.wide >> $@.new
 	cat ${NCURSES_DIR}/include/curses.tail >> $@.new
 	mv -f $@.new $@
@@ -387,6 +395,7 @@ unctrl.h: unctrl.h.in
 terminfo.5: MKterminfo.sh terminfo.head Caps
 	sh ${NCURSES_DIR}/man/MKterminfo.sh ${NCURSES_DIR}/man/terminfo.head \
 	    ${NCURSES_DIR}/include/Caps ${NCURSES_DIR}/man/terminfo.tail >$@
+	sed -i '' 's|${SRCTOP}|${NCURSES_SRCTOP}|g' $@
 
 CLEANFILES+=	terminfo.5