Hi,

As discussed earlier with bluhm, regress tests shouldn't set or modify
MALLOC_OPTIONS (except under very specific situations, like malloc tests).
It would be better to set the options globally through sysctl when
running the suite, as bluhm does.

So remove most cases of MALLOC_OPTIONS from regress and amend the
manpage guidelines accordingly.

OK?

diff 9ca4957b0bf957d4e3a97547c791aeac34911aaf /usr/src
blob - a40fad57e604ca5bf7ccfee8c91bcb68bbb46456
file + regress/bin/csh/Makefile
--- regress/bin/csh/Makefile
+++ regress/bin/csh/Makefile
@@ -20,7 +20,6 @@ REGRESS_TARGETS+=     env
 .SUFFIXES: .in
 
 .in:
-       env -i MALLOC_OPTIONS=S ${CSH} <${.CURDIR}/${@}.in 2>&1 | \
-               diff -u ${.CURDIR}/${@}.ok -
+       ${CSH} <${.CURDIR}/${@}.in 2>&1 | diff -u ${.CURDIR}/${@}.ok -
 
 .include <bsd.regress.mk>
blob - 3341dabb1403688df8f8e16fa2e31dcd3739d108
file + regress/bin/csh/filec.sh
--- regress/bin/csh/filec.sh
+++ regress/bin/csh/filec.sh
@@ -50,8 +50,7 @@ cd ~
 !
 
 HOME=$tmp
-MALLOC_OPTIONS=S
-export HOME MALLOC_OPTIONS
+export HOME
 
 # NL: Execute command.
 testseq "echo a\n" "? echo a\r\na\r\n? "
blob - aee8864d3f8965a05eb4ca63f0ee80979d4d1591
file + regress/bin/ksh/edit/emacs.sh
--- regress/bin/ksh/edit/emacs.sh
+++ regress/bin/ksh/edit/emacs.sh
@@ -25,10 +25,9 @@ EDITOR=
 ENV=
 HISTFILE=
 MAIL=
-MALLOC_OPTIONS=S
 PS1=' # '
 VISUAL=emacs
-export EDITOR ENV HISTFILE MAIL MALLOC_OPTIONS PS1 VISUAL
+export EDITOR ENV HISTFILE MAIL PS1 VISUAL
 
 # The function testseq() sets up a pseudo terminal and feeds its first
 # argument to a shell on standard input.  It then checks that output
blob - be15c4d1ee8d04be8f36c6f0d647241edbeb70f1
file + regress/bin/ksh/edit/vi.sh
--- regress/bin/ksh/edit/vi.sh
+++ regress/bin/ksh/edit/vi.sh
@@ -25,10 +25,9 @@ EDITOR=
 ENV=
 HISTFILE=
 MAIL=
-MALLOC_OPTIONS=S
 PS1=' # '
 VISUAL=vi
-export EDITOR ENV HISTFILE MAIL MALLOC_OPTIONS PS1 VISUAL
+export EDITOR ENV HISTFILE MAIL PS1 VISUAL
 
 # The function testseq() sets up a pseudo terminal and feeds its first
 # argument to a shell on standard input.  It then checks that output
blob - 4a35e2664dba5fab3029d832bf181cd63bfa8c0a
file + regress/bin/ksh/th
--- regress/bin/ksh/th
+++ regress/bin/ksh/th
@@ -56,8 +56,7 @@
 #                                      missing, NAME is removed from the
 #                                      environment.  Programs are run with
 #                                      the following minimal environment:
-#                                          USER, LOGNAME, HOME, PATH, SHELL,
-#                                          MALLOC_OPTIONS=S
+#                                          USER, LOGNAME, HOME, PATH, SHELL
 #                                      (values from the current environment
 #                                      takes higher precedence).
 #      file-setup                  mps Used to create files, directories
@@ -233,10 +232,8 @@ grep($do_test{$_} = 1, @ARGV);
 $all_tests = @ARGV == 0;
 
 # Set up a very minimal environment
-%new_env = (
-    MALLOC_OPTIONS => 'S',
-);
-foreach $env (('USER', 'LOGNAME', 'HOME', 'PATH', 'SHELL', 'MALLOC_OPTIONS')) {
+%new_env = ();
+foreach $env (('USER', 'LOGNAME', 'HOME', 'PATH', 'SHELL')) {
     $new_env{$env} = $ENV{$env} if defined $ENV{$env};
 }
 if (defined $opt_e) {
blob - f70d94bd6299646db94cbd0ef873bda47536d474
file + regress/usr.bin/doas/Makefile
--- regress/usr.bin/doas/Makefile
+++ regress/usr.bin/doas/Makefile
@@ -114,8 +114,7 @@ ${t}:
            /bin/echo $$tdir/bin/echo; \
        ${SUDO} install -o ${BINOWN} -g ${BINGRP} -m 4555 \
            /usr/bin/doas $$tdir/usr/bin/doas; \
-       ${SUDO} env MALLOC_OPTIONS=S chroot -u nobody $$tdir \
-           /usr/bin/doas echo okay
+       ${SUDO} chroot -u nobody $$tdir /usr/bin/doas echo okay
 . endif
 .endfor
 
blob - 7b9898b8ed49bbb82e891f12a98415ac996f9033
file + regress/usr.bin/mail/send.sh
--- regress/usr.bin/mail/send.sh
+++ regress/usr.bin/mail/send.sh
@@ -43,8 +43,7 @@ set ask
 !
 
 HOME=$tmp
-MALLOC_OPTIONS=S
-export HOME MALLOC_OPTIONS
+export HOME
 
 # VERASE: Delete character.
 testseq "\0177" "Subject: "
blob - 64237f6cc9abe1803f2082d0c8d0b91d214b58da
file + regress/usr.bin/make/Makefile
--- regress/usr.bin/make/Makefile
+++ regress/usr.bin/make/Makefile
@@ -8,191 +8,190 @@ REGRESS_TARGETS=     t1  t2  t3  t4  t5  t6  t7  t8  t
 
 REGRESS_EXPECTED_FAILURES = t14 t17 t18
 
-MALLOC_OPTIONS?=J
 t1: t1.out
-       env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -e -r -f 
${.CURDIR}/mk1 | diff - t1.out
+       env -i PATH=${PATH} ${MAKE} -e -r -f ${.CURDIR}/mk1 | diff - t1.out
 
 # This is a POSIX test. pmake does not pass variables to submakes until
 # after OpenBSD 2.7.
 t2:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk2| diff - t2.out
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk2| diff - t2.out
 
 t3:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk3 -f mk3a|diff - t3.out
-       cd ${.CURDIR} && cat mk3a |env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f mk3 -f -|diff - t3.out
-       cd ${.CURDIR} && cat mk3 |env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f - -f mk3a|diff - t3.out
-       cd ${.CURDIR} && cat mk3 mk3a|env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f - |diff - t3.out
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk3 -f mk3a|diff - 
t3.out
+       cd ${.CURDIR} && cat mk3a |env -i PATH=${PATH} ${MAKE} -r -f mk3 -f 
-|diff - t3.out
+       cd ${.CURDIR} && cat mk3 |env -i PATH=${PATH} ${MAKE} -r -f - -f 
mk3a|diff - t3.out
+       cd ${.CURDIR} && cat mk3 mk3a|env -i PATH=${PATH} ${MAKE} -r -f - |diff 
- t3.out
 
 t4:
-       cd ${.CURDIR} && cat mk4 mk4a|env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f - |diff - t4.out
+       cd ${.CURDIR} && cat mk4 mk4a|env -i PATH=${PATH} ${MAKE} -r -f - |diff 
- t4.out
        # Splitting files along conditionals should not work
-       if cd ${.CURDIR} && env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f mk4 -f mk4a 2>/dev/null || test 
$$? -ge 128 ; then false; fi
+       if cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk4 -f mk4a 
2>/dev/null || test $$? -ge 128 ; then false; fi
 
 # Another POSIX test, checking that MAKEFLAGS does work
 t5:
        # first check that make does fail as expected
-       if cd ${.CURDIR} && env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f mkfail 2>/dev/null || test $$? 
-ge 128; then false; fi
+       if cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mkfail 
2>/dev/null || test $$? -ge 128; then false; fi
        # first form of MAKEFLAGS
-       cd ${.CURDIR} && env -i PATH=${PATH} MAKEFLAGS=-n 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f mkfail
+       cd ${.CURDIR} && env -i PATH=${PATH} MAKEFLAGS=-n ${MAKE} -r -f mkfail
        # second form of MAKEFLAGS
-       cd ${.CURDIR} && env -i PATH=${PATH} MAKEFLAGS=n 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f mkfail
+       cd ${.CURDIR} && env -i PATH=${PATH} MAKEFLAGS=n ${MAKE} -r -f mkfail
 
 t6:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} A=good -r -f mk6 | diff - t6.out
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} A=good -r -f mk6 | diff - 
t6.out
 
 # This test passes since the cond parser has been rewritten.
 t7:
-       if cd ${.CURDIR} && env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f mk7 2>/dev/null || test $$? -ge 
128; then false; fi
+       if cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk7 2>/dev/null 
|| test $$? -ge 128; then false; fi
 
 # check for existent/non existent files
 t8:
        touch goodfile phony
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk8 | diff - t8.out
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk8 | diff - t8.out
 
 t9:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk9 2>&1 | diff - t9.out
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk9 2>&1 | diff - 
t9.out
 
 # verify that systemV extended variables work as expected
 t10:   z.a
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk10 |diff - t10.out
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk10 |diff - t10.out
 
 # check for substitution parser in some confusing situations
 t11:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk11 |diff - t11.out
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk11 A=t|diff - t11.out2
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk11 |diff - t11.out
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk11 A=t|diff - 
t11.out2
 
 # Check for filename expansions.
 t12:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk12 |diff - t12.out
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk12 |diff - t12.out
 
 # Verify whitespace handling.
 t13:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk13 |diff - t13.out
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk13 |diff - t13.out
 
-# make currently incorrectly uses annotations for suffixes rules 
+# make currently incorrectly uses annotations for suffixes rules
 # for non-suffixes rules.
 # this is hard to fix without breaking something else
 t14:
-       if cd ${.CURDIR} && env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f mk14 2>/dev/null || test $$? -ge 
128; then false; fi
+       if cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk14 2>/dev/null 
|| test $$? -ge 128; then false; fi
 
 t15:
        touch t15file
-       cd ${.CURDIR} && ulimit -t 2 && env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f mk15 2>/dev/null
+       cd ${.CURDIR} && ulimit -t 2 && env -i PATH=${PATH} ${MAKE} -r -f mk15 
2>/dev/null
 
 t16:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk16
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk16
 
 # Bug in cond-parser, ends up having too many open conds.
 t17:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk17
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk17
 
 # bug in cond-parser again: this one holds too many open conditionals,
 # and exactly enough closes...
 t18:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk18
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk18
 
 t19:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
SHELL=/bin/zsh ${MAKE} -r -f mk19 | diff - t19.out
+       cd ${.CURDIR} && env -i PATH=${PATH} SHELL=/bin/zsh ${MAKE} -r -f mk19 
| diff - t19.out
 
 t20:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
SHELL=/bin/sh ${MAKE} -r -f mk20 | diff - t20.out
+       cd ${.CURDIR} && env -i PATH=${PATH} SHELL=/bin/sh ${MAKE} -r -f mk20 | 
diff - t20.out
 
 t21:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk21 | diff - t21.out
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk21 | diff - t21.out
 
 t22:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk22 b | diff - t22.out
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk22 b | diff - 
t22.out
 
 t23:
-       cd ${.CURDIR} && ulimit -t 60 && env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f mk22 a 2>&1| diff - t23.out
+       cd ${.CURDIR} && ulimit -t 60 && env -i PATH=${PATH} ${MAKE} -r -f mk22 
a 2>&1| diff - t23.out
 
 t24:
-       if cd ${.CURDIR} && env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f mk23 a 2>/dev/null || test $$? 
-ge 128; then false; fi
+       if cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk23 a 
2>/dev/null || test $$? -ge 128; then false; fi
 
 t25:
        touch ${.OBJDIR}/t25.1st
        rm -f ${.OBJDIR}/t25.2nd
-       if cd ${.CURDIR} && env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f mk24 t25.2nd 2>/dev/null || test 
$$? -ge 128; then false; fi
+       if cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk24 t25.2nd 
2>/dev/null || test $$? -ge 128; then false; fi
 
 t26:
        touch ${.OBJDIR}/f26.2nd
        rm -f ${.OBJDIR}/f26
-       if cd ${.CURDIR} && env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f mk24 f26 2>/dev/null || test $$? 
-ge 128; then false; fi
+       if cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk24 f26 
2>/dev/null || test $$? -ge 128; then false; fi
 
 t27:
        touch ${.OBJDIR}/t27.2nd
        rm -f ${.OBJDIR}/t27.3rd
-       if cd ${.CURDIR} && env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f mk24 t27.3rd 2>/dev/null || test 
$$? -ge 128; then false; fi
+       if cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk24 t27.3rd 
2>/dev/null || test $$? -ge 128; then false; fi
 
 t28:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk25 all >/dev/null
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk25 all >/dev/null
 
 t29:
        rm -f t29dep t29.targ t29.targ2 libt29.a
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk26 all | diff - t29.out
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk26 all | diff - t29.out2
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk26 all | diff - 
t29.out
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk26 all | diff - 
t29.out2
 
 t30:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk27 all | diff - t30.out
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk27 all | diff - 
t30.out
 
 t31:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk28 all
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk28 all
 
 t32:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
B="A" ${MAKE} -r -f mk32 all | diff - t32.out
+       cd ${.CURDIR} && env -i PATH=${PATH} B="A" ${MAKE} -r -f mk32 all | 
diff - t32.out
 
 t33:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
B=0 ${MAKE} -r -f mk32 all | diff - t33.out
+       cd ${.CURDIR} && env -i PATH=${PATH} B=0 ${MAKE} -r -f mk32 all | diff 
- t33.out
 
 t34:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
B=1 ${MAKE} -r -f mk32 all | diff - t34.out
+       cd ${.CURDIR} && env -i PATH=${PATH} B=1 ${MAKE} -r -f mk32 all | diff 
- t34.out
 
 t35:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
B=2 ${MAKE} -r -f mk32 all | diff - t35.out
+       cd ${.CURDIR} && env -i PATH=${PATH} B=2 ${MAKE} -r -f mk32 all | diff 
- t35.out
 
 t36:
-       if echo '$$$$(A:&)' | env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f - 2>/dev/null|| test $$? -ge 
128; then false; fi
+       if echo '$$$$(A:&)' | env -i PATH=${PATH} ${MAKE} -r -f - 2>/dev/null|| 
test $$? -ge 128; then false; fi
 
 z.a:
        touch $@
 
 t37:
-       if cd ${.CURDIR} && env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} B=2 ${MAKE} -r -f mk33 all; then false; else 
true; fi
+       if cd ${.CURDIR} && env -i PATH=${PATH} B=2 ${MAKE} -r -f mk33 all; 
then false; else true; fi
 
 t38:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk34 | diff - t38.out
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk34 | diff - t38.out
 
 t38j:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk34 -j2 | diff - t38.out
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk34 -j2 | diff - 
t38.out
 
 t39:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk35 2>&1 | diff - t39.out
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk35 2>&1 | diff - 
t39.out
 
 t40:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -f mk36 2>/dev/null
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk36 2>/dev/null
 
 t41:
-       if cd ${.CURDIR} && env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f mk37 2>/dev/null || test $$? -ge 
128; then false; fi
+       if cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk37 2>/dev/null 
|| test $$? -ge 128; then false; fi
 
 t42:
-       if cd ${.CURDIR} && env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f mk38 2>/dev/null || test $$? -ge 
128; then false; fi
+       if cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk38 2>/dev/null 
|| test $$? -ge 128; then false; fi
 
 t42bis:
-       if cd ${.CURDIR} && env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f mk38bis 2>/dev/null || test $$? 
-ge 128; then false; fi
+       if cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk38bis 
2>/dev/null || test $$? -ge 128; then false; fi
 
 t43:
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -j2 -f mk39 b 2>&1 | diff - t43.out
-       cd ${.CURDIR} && env -i PATH=${PATH} MALLOC_OPTIONS=${MALLOC_OPTIONS} 
${MAKE} -r -j2 -f mk39 a 2>&1 | diff - t43.out
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -j2 -f mk39 b 2>&1 | 
diff - t43.out
+       cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -j2 -f mk39 a 2>&1 | 
diff - t43.out
 
 t44:
-       if cd ${.CURDIR} && env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f mk40 2>/dev/null || test $$? -ge 
128; then false; fi
+       if cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk40 2>/dev/null 
|| test $$? -ge 128; then false; fi
 
 t45:
-       if cd ${.CURDIR} && env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f mk41 2>/dev/null || test $$? -ge 
128; then false; fi
+       if cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk41 2>/dev/null 
|| test $$? -ge 128; then false; fi
 
 # this file should fail, but NOT segfault
 t46:
-       if cd ${.CURDIR} && env -i PATH=${PATH} 
MALLOC_OPTIONS=${MALLOC_OPTIONS} ${MAKE} -r -f mk42 a 2>/dev/null; then \
+       if cd ${.CURDIR} && env -i PATH=${PATH} ${MAKE} -r -f mk42 a 
2>/dev/null; then \
            false; \
            else \
                if test $$? -ge 1 -a $$? -lt 128; then \
blob - 81597a26e7b1a7ddf560837599458ba5b0fd3f7c
file + share/man/man5/bsd.regress.mk.5
--- share/man/man5/bsd.regress.mk.5
+++ share/man/man5/bsd.regress.mk.5
@@ -206,6 +206,14 @@ The
 tree can be found with a relative path or with the
 .Ev BSDSRCDIR
 variable.
+.Pp
+Tests should generally not set or modify
+.Ev MALLOC_OPTIONS
+unless it is testing specific behaviour that depends on a particular
+flag or combination of flags.
+When running tests the approciate sysctl
+.Pq vm.malloc_conf
+could be used instead.
 .Sh SEE ALSO
 .Xr bsd.port.mk 5
 .Sh HISTORY

Reply via email to