1/*-
2 * Copyright (c) 2004 David Schultz <das@FreeBSD.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27/*
28 * Test the correctness and C99-compliance of various fenv.h features.
29 */
30
31#include <sys/cdefs.h>
32__FBSDID("$FreeBSD$");
33
34#include <sys/types.h>
35#include <sys/wait.h>
36#include <assert.h>
37#include <err.h>
38#include <fenv.h>
39#include <float.h>
40#include <libutil.h>
41#include <math.h>
42#include <signal.h>
43#include <stdio.h>
44#include <string.h>
45#include <unistd.h>
46
47#include "test-utils.h"
48
49#define	NEXCEPTS	(sizeof(std_excepts) / sizeof(std_excepts[0]))
50
51static const int std_excepts[] = {
52	FE_INVALID,
53	FE_DIVBYZERO,
54	FE_OVERFLOW,
55	FE_UNDERFLOW,
56	FE_INEXACT,
57};
58
59/* init_exceptsets() initializes this to the power set of std_excepts[] */
60static int std_except_sets[1 << NEXCEPTS];
61
62#pragma STDC FENV_ACCESS ON
63
64/*
65 * Initialize std_except_sets[] to the power set of std_excepts[]
66 */
67static __attribute__((constructor)) void
68do_setup(void)
69{
70	unsigned i, j, sr;
71
72	/* Avoid double output after fork() */
73	setvbuf(stdout, NULL, _IONBF, 0);
74
75	for (i = 0; i < 1 << NEXCEPTS; i++) {
76		for (sr = i, j = 0; sr != 0; sr >>= 1, j++)
77			std_except_sets[i] |= std_excepts[j] & ((~sr & 1) - 1);
78	}
79}
80
81/*
82 * Raise a floating-point exception without relying on the standard
83 * library routines, which we are trying to test.
84 *
85 * XXX We can't raise an {over,under}flow without also raising an
86 * inexact exception.
87 */
88static void
89raiseexcept(int excepts)
90{
91	volatile double d;
92
93	/*
94	 * With a compiler that supports the FENV_ACCESS pragma
95	 * properly, simple expressions like '0.0 / 0.0' should
96	 * be sufficient to generate traps.  Unfortunately, we
97	 * need to bring a volatile variable into the equation
98	 * to prevent incorrect optimizations.
99	 */
100	if (excepts & FE_INVALID) {
101		d = 0.0;
102		d = 0.0 / d;
103	}
104	if (excepts & FE_DIVBYZERO) {
105		d = 0.0;
106		d = 1.0 / d;
107	}
108	if (excepts & FE_OVERFLOW) {
109		d = DBL_MAX;
110		d *= 2.0;
111	}
112	if (excepts & FE_UNDERFLOW) {
113		d = DBL_MIN;
114		d /= DBL_MAX;
115	}
116	if (excepts & FE_INEXACT) {
117		d = DBL_MIN;
118		d += 1.0;
119	}
120
121	/*
122	 * On the x86 (and some other architectures?) the FPU and
123	 * integer units are decoupled.  We need to execute an FWAIT
124	 * or a floating-point instruction to get synchronous exceptions.
125	 */
126	d = 1.0;
127	d += 1.0;
128}
129
130/*
131 * Determine the current rounding mode without relying on the fenv
132 * routines.  This function may raise an inexact exception.
133 */
134static int
135getround(void)
136{
137	volatile double d;
138
139	/*
140	 * This test works just as well with 0.0 - 0.0, except on ia64
141	 * where 0.0 - 0.0 gives the wrong sign when rounding downwards.
142	 */
143	d = 1.0;
144	d -= 1.0;
145	if (copysign(1.0, d) < 0.0)
146		return (FE_DOWNWARD);
147
148	d = 1.0;
149	if (d + (DBL_EPSILON * 3.0 / 4.0) == 1.0)
150		return (FE_TOWARDZERO);
151	if (d + (DBL_EPSILON * 1.0 / 4.0) > 1.0)
152		return (FE_UPWARD);
153
154	return (FE_TONEAREST);
155}
156
157static void
158trap_handler(int sig)
159{
160
161	ATF_CHECK_EQ(SIGFPE, sig);
162	_exit(0);
163}
164
165/*
166 * This tests checks the default FP environment, so it must be first.
167 * The memcmp() test below may be too much to ask for, since there
168 * could be multiple machine-specific default environments.
169 */
170ATF_TC_WITHOUT_HEAD(dfl_env);
171ATF_TC_BODY(dfl_env, tc)
172{
173#ifndef NO_STRICT_DFL_ENV
174	fenv_t env;
175
176	fegetenv(&env);
177	/* Print the default environment for debugging purposes. */
178	hexdump(&env, sizeof(env), "current fenv ", HD_OMIT_CHARS);
179	hexdump(FE_DFL_ENV, sizeof(env), "default fenv ", HD_OMIT_CHARS);
180	CHECK_FP_EXCEPTIONS(0, FE_ALL_EXCEPT);
181#ifdef __amd64__
182	/*
183	 * Compare the fields that the AMD [1] and Intel [2] specs say will be
184	 * set once fnstenv returns.
185	 *
186	 * Not all amd64 capable processors implement the fnstenv instruction
187	 * by zero'ing out the env.__x87.__other field (example: AMD Opteron
188	 * 6308). The AMD64/x64 specs aren't explicit on what the
189	 * env.__x87.__other field will contain after fnstenv is executed, so
190	 * the values in env.__x87.__other could be filled with arbitrary
191	 * data depending on how the CPU implements fnstenv.
192	 *
193	 * 1. http://support.amd.com/TechDocs/26569_APM_v5.pdf
194	 * 2. http://www.intel.com/Assets/en_US/PDF/manual/253666.pdf
195	 */
196	ATF_CHECK(memcmp(&env.__mxcsr, &FE_DFL_ENV->__mxcsr,
197	    sizeof(env.__mxcsr)) == 0);
198	ATF_CHECK(memcmp(&env.__x87.__control, &FE_DFL_ENV->__x87.__control,
199	    sizeof(env.__x87.__control)) == 0);
200	ATF_CHECK(memcmp(&env.__x87.__status, &FE_DFL_ENV->__x87.__status,
201	    sizeof(env.__x87.__status)) == 0);
202	ATF_CHECK(memcmp(&env.__x87.__tag, &FE_DFL_ENV->__x87.__tag,
203	    sizeof(env.__x87.__tag)) == 0);
204#else
205	ATF_CHECK_EQ(0, memcmp(&env, FE_DFL_ENV, sizeof(env)));
206#endif
207
208#endif
209	CHECK_FP_EXCEPTIONS(0, FE_ALL_EXCEPT);
210}
211
212/*
213 * Test fetestexcept() and feclearexcept().
214 */
215ATF_TC_WITHOUT_HEAD(fetestclearexcept);
216ATF_TC_BODY(fetestclearexcept, tc)
217{
218	int excepts, i;
219
220	for (i = 0; i < 1 << NEXCEPTS; i++)
221		ATF_CHECK_EQ(0, fetestexcept(std_except_sets[i]));
222	for (i = 0; i < 1 << NEXCEPTS; i++) {
223		excepts = std_except_sets[i];
224
225		/* FE_ALL_EXCEPT might be special-cased, as on i386. */
226		raiseexcept(excepts);
227		ATF_CHECK_EQ(excepts, fetestexcept(excepts));
228		ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT));
229		ATF_CHECK_EQ(0, fetestexcept(FE_ALL_EXCEPT));
230
231		raiseexcept(excepts);
232		ATF_CHECK_EQ(excepts, fetestexcept(excepts));
233		if ((excepts & (FE_UNDERFLOW | FE_OVERFLOW)) != 0) {
234			excepts |= FE_INEXACT;
235			ATF_CHECK_EQ(excepts, (fetestexcept(ALL_STD_EXCEPT) | FE_INEXACT));
236		} else {
237			ATF_CHECK_EQ(excepts, fetestexcept(ALL_STD_EXCEPT));
238		}
239		ATF_CHECK_EQ(0, feclearexcept(excepts));
240		ATF_CHECK_EQ(0, fetestexcept(ALL_STD_EXCEPT));
241	}
242}
243
244/*
245 * Test fegetexceptflag() and fesetexceptflag().
246 *
247 * Prerequisites: fetestexcept(), feclearexcept()
248 */
249ATF_TC_WITHOUT_HEAD(fegsetexceptflag);
250ATF_TC_BODY(fegsetexceptflag, tc)
251{
252	fexcept_t flag;
253	int excepts, i;
254
255	CHECK_FP_EXCEPTIONS(0, FE_ALL_EXCEPT);
256	for (i = 0; i < 1 << NEXCEPTS; i++) {
257		excepts = std_except_sets[i];
258
259		ATF_CHECK_EQ(0, fegetexceptflag(&flag, excepts));
260		raiseexcept(ALL_STD_EXCEPT);
261		ATF_CHECK_EQ(0, fesetexceptflag(&flag, excepts));
262		ATF_CHECK_EQ((ALL_STD_EXCEPT ^ excepts), fetestexcept(ALL_STD_EXCEPT));
263
264		ATF_CHECK_EQ(0, fegetexceptflag(&flag, FE_ALL_EXCEPT));
265		ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT));
266		ATF_CHECK_EQ(0, fesetexceptflag(&flag, excepts));
267		ATF_CHECK_EQ(0, fetestexcept(ALL_STD_EXCEPT));
268		ATF_CHECK_EQ(0, fesetexceptflag(&flag, ALL_STD_EXCEPT ^ excepts));
269		ATF_CHECK_EQ((ALL_STD_EXCEPT ^ excepts), fetestexcept(ALL_STD_EXCEPT));
270
271		ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT));
272	}
273}
274
275/*
276 * Test feraiseexcept().
277 *
278 * Prerequisites: fetestexcept(), feclearexcept()
279 */
280ATF_TC_WITHOUT_HEAD(feraiseexcept);
281ATF_TC_BODY(feraiseexcept, tc)
282{
283	int excepts, i;
284
285	for (i = 0; i < 1 << NEXCEPTS; i++) {
286		excepts = std_except_sets[i];
287
288		ATF_CHECK_EQ(0, fetestexcept(FE_ALL_EXCEPT));
289		ATF_CHECK_EQ(0, feraiseexcept(excepts));
290		if ((excepts & (FE_UNDERFLOW | FE_OVERFLOW)) != 0) {
291			excepts |= FE_INEXACT;
292			ATF_CHECK_EQ(excepts, (fetestexcept(ALL_STD_EXCEPT) | FE_INEXACT));
293		} else {
294			ATF_CHECK_EQ(excepts, fetestexcept(ALL_STD_EXCEPT));
295		}
296		ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT));
297	}
298	ATF_CHECK_EQ(0, feraiseexcept(FE_INVALID | FE_DIVBYZERO));
299	ATF_CHECK_EQ((FE_INVALID | FE_DIVBYZERO), fetestexcept(ALL_STD_EXCEPT));
300	ATF_CHECK_EQ(0, feraiseexcept(FE_OVERFLOW | FE_UNDERFLOW | FE_INEXACT));
301	ATF_CHECK_EQ(ALL_STD_EXCEPT, fetestexcept(ALL_STD_EXCEPT));
302	ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT));
303}
304
305/*
306 * Test fegetround() and fesetround().
307 */
308ATF_TC_WITHOUT_HEAD(fegsetround);
309ATF_TC_BODY(fegsetround, tc)
310{
311
312	ATF_CHECK_EQ(FE_TONEAREST, fegetround());
313	ATF_CHECK_EQ(FE_TONEAREST, getround());
314	ATF_CHECK_EQ(1, FLT_ROUNDS);
315
316	ATF_CHECK_EQ(0, fesetround(FE_DOWNWARD));
317	ATF_CHECK_EQ(FE_DOWNWARD, fegetround());
318	ATF_CHECK_EQ(FE_DOWNWARD, getround());
319	ATF_CHECK_EQ(3, FLT_ROUNDS);
320
321	ATF_CHECK_EQ(0, fesetround(FE_UPWARD));
322	ATF_CHECK_EQ(FE_UPWARD, getround());
323	ATF_CHECK_EQ(FE_UPWARD, fegetround());
324	ATF_CHECK_EQ(2, FLT_ROUNDS);
325
326	ATF_CHECK_EQ(0, fesetround(FE_TOWARDZERO));
327	ATF_CHECK_EQ(FE_TOWARDZERO, getround());
328	ATF_CHECK_EQ(FE_TOWARDZERO, fegetround());
329	ATF_CHECK_EQ(0, FLT_ROUNDS);
330
331	ATF_CHECK_EQ(0, fesetround(FE_TONEAREST));
332	ATF_CHECK_EQ(FE_TONEAREST, getround());
333	ATF_CHECK_EQ(1, FLT_ROUNDS);
334
335	ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT));
336}
337
338/*
339 * Test fegetenv() and fesetenv().
340 *
341 * Prerequisites: fetestexcept(), feclearexcept(), fegetround(), fesetround()
342 */
343ATF_TC_WITHOUT_HEAD(fegsetenv);
344ATF_TC_BODY(fegsetenv, tc)
345{
346	fenv_t env1, env2;
347	int excepts, i;
348
349	for (i = 0; i < 1 << NEXCEPTS; i++) {
350		excepts = std_except_sets[i];
351
352		ATF_CHECK_EQ(0, fetestexcept(FE_ALL_EXCEPT));
353		ATF_CHECK_EQ(FE_TONEAREST, fegetround());
354		ATF_CHECK_EQ(0, fegetenv(&env1));
355
356		/*
357		 * fe[gs]etenv() should be able to save and restore
358		 * exception flags without the spurious inexact
359		 * exceptions that afflict raiseexcept().
360		 */
361		raiseexcept(excepts);
362		if ((excepts & (FE_UNDERFLOW | FE_OVERFLOW)) != 0 &&
363		    (excepts & FE_INEXACT) == 0)
364			ATF_CHECK_EQ(0, feclearexcept(FE_INEXACT));
365
366		fesetround(FE_DOWNWARD);
367		ATF_CHECK_EQ(0, fegetenv(&env2));
368		ATF_CHECK_EQ(0, fesetenv(&env1));
369		ATF_CHECK_EQ(0, fetestexcept(FE_ALL_EXCEPT));
370		ATF_CHECK_EQ(FE_TONEAREST, fegetround());
371
372		ATF_CHECK_EQ(0, fesetenv(&env2));
373
374		/*
375		 * Some platforms like powerpc may set extra exception bits. Since
376		 * only standard exceptions are tested, mask against ALL_STD_EXCEPT
377		 */
378		ATF_CHECK_EQ(excepts, (fetestexcept(FE_ALL_EXCEPT) & ALL_STD_EXCEPT));
379
380		ATF_CHECK_EQ(FE_DOWNWARD, fegetround());
381		ATF_CHECK_EQ(0, fesetenv(&env1));
382		ATF_CHECK_EQ(0, fetestexcept(FE_ALL_EXCEPT));
383		ATF_CHECK_EQ(FE_TONEAREST, fegetround());
384	}
385}
386
387/*
388 * Test fegetexcept(), fedisableexcept(), and feenableexcept().
389 *
390 * Prerequisites: fetestexcept(), feraiseexcept()
391 */
392ATF_TC_WITHOUT_HEAD(masking);
393ATF_TC_BODY(masking, tc)
394{
395	struct sigaction act;
396	int except, pass, raise, status;
397	unsigned i;
398
399	ATF_REQUIRE_EQ(0, (fegetexcept() & ALL_STD_EXCEPT));
400
401	/*
402	 * Some CPUs, e.g. AArch64 QEMU does not support trapping on FP
403	 * exceptions. In that case the trap enable bits are all RAZ/WI, so
404	 * writing to those bits will be ignored and the the next read will
405	 * return all zeroes for those bits. Skip the test if no floating
406	 * point exceptions are supported and mark it XFAIL if some are missing.
407	 */
408	ATF_REQUIRE_EQ(0, (feenableexcept(FE_ALL_EXCEPT)));
409	except = fegetexcept();
410	if (except == 0) {
411		atf_tc_skip("CPU does not support trapping on floating point "
412		    "exceptions.");
413	} else if ((except & ALL_STD_EXCEPT) != ALL_STD_EXCEPT) {
414		atf_tc_expect_fail("Not all floating point exceptions can be "
415		    "set to trap: %#x vs %#x", except, ALL_STD_EXCEPT);
416	}
417	fedisableexcept(FE_ALL_EXCEPT);
418
419
420	ATF_CHECK_EQ(0, (feenableexcept(FE_INVALID|FE_OVERFLOW) & ALL_STD_EXCEPT));
421	ATF_CHECK_EQ((FE_INVALID | FE_OVERFLOW), (feenableexcept(FE_UNDERFLOW) & ALL_STD_EXCEPT));
422	ATF_CHECK_EQ((FE_INVALID | FE_OVERFLOW | FE_UNDERFLOW), (fedisableexcept(FE_OVERFLOW) & ALL_STD_EXCEPT));
423	ATF_CHECK_EQ((FE_INVALID | FE_UNDERFLOW), (fegetexcept() & ALL_STD_EXCEPT));
424	ATF_CHECK_EQ((FE_INVALID | FE_UNDERFLOW), (fedisableexcept(FE_ALL_EXCEPT) & ALL_STD_EXCEPT));
425	ATF_CHECK_EQ(0, (fegetexcept() & ALL_STD_EXCEPT));
426
427	sigemptyset(&act.sa_mask);
428	act.sa_flags = 0;
429	act.sa_handler = trap_handler;
430	for (pass = 0; pass < 2; pass++) {
431		for (i = 0; i < NEXCEPTS; i++) {
432			except = std_excepts[i];
433			/* over/underflow may also raise inexact */
434			if (except == FE_INEXACT)
435				raise = FE_DIVBYZERO | FE_INVALID;
436			else
437				raise = ALL_STD_EXCEPT ^ except;
438
439			/*
440			 * We need to fork a child process because
441			 * there isn't a portable way to recover from
442			 * a floating-point exception.
443			 */
444			switch(fork()) {
445			case 0:		/* child */
446				ATF_CHECK_EQ(0, (fegetexcept() & ALL_STD_EXCEPT));
447				ATF_REQUIRE_EQ(0, (feenableexcept(except) & ALL_STD_EXCEPT));
448				ATF_CHECK_EQ(except, fegetexcept());
449				raiseexcept(raise);
450				ATF_CHECK_EQ(0, feraiseexcept(raise));
451				ATF_CHECK_EQ(raise, fetestexcept(ALL_STD_EXCEPT));
452
453				ATF_CHECK_EQ(0, sigaction(SIGFPE, &act, NULL));
454				switch (pass) {
455				case 0:
456					raiseexcept(except);
457				case 1:
458					feraiseexcept(except);
459				default:
460					ATF_REQUIRE(0);
461				}
462				ATF_REQUIRE(0);
463			default:	/* parent */
464				ATF_REQUIRE(wait(&status) > 0);
465				/*
466				 * Avoid assert() here so that it's possible
467				 * to examine a failed child's core dump.
468				 */
469				if (!WIFEXITED(status))
470					errx(1, "child aborted\n");
471				ATF_CHECK_EQ(0, WEXITSTATUS(status));
472				break;
473			case -1:	/* error */
474				ATF_REQUIRE(0);
475			}
476		}
477	}
478	ATF_CHECK_EQ(0, fetestexcept(FE_ALL_EXCEPT));
479}
480
481/*
482 * Test feholdexcept() and feupdateenv().
483 *
484 * Prerequisites: fetestexcept(), fegetround(), fesetround(),
485 *	fedisableexcept(), feenableexcept()
486 */
487ATF_TC_WITHOUT_HEAD(feholdupdate);
488ATF_TC_BODY(feholdupdate, tc)
489{
490	fenv_t env;
491
492	struct sigaction act;
493	int except, pass, status, raise;
494	unsigned i;
495
496	sigemptyset(&act.sa_mask);
497	act.sa_flags = 0;
498	act.sa_handler = trap_handler;
499	for (pass = 0; pass < 2; pass++) {
500		for (i = 0; i < NEXCEPTS; i++) {
501			except = std_excepts[i];
502			/* over/underflow may also raise inexact */
503			if (except == FE_INEXACT)
504				raise = FE_DIVBYZERO | FE_INVALID;
505			else
506				raise = ALL_STD_EXCEPT ^ except;
507
508			/*
509			 * We need to fork a child process because
510			 * there isn't a portable way to recover from
511			 * a floating-point exception.
512			 */
513			switch(fork()) {
514			case 0:		/* child */
515				/*
516				 * We don't want to cause a fatal exception in
517				 * the child until the second pass, so we can
518				 * check other properties of feupdateenv().
519				 */
520				if (pass == 1)
521					ATF_REQUIRE_EQ(0, feenableexcept(except) & ALL_STD_EXCEPT);
522				raiseexcept(raise);
523				ATF_CHECK_EQ(0, fesetround(FE_DOWNWARD));
524				ATF_CHECK_EQ(0, feholdexcept(&env));
525				ATF_CHECK_EQ(0, fetestexcept(FE_ALL_EXCEPT));
526				raiseexcept(except);
527				ATF_CHECK_EQ(0, fesetround(FE_UPWARD));
528
529				if (pass == 1)
530					ATF_CHECK_EQ(0, sigaction(SIGFPE, &act, NULL));
531				ATF_CHECK_EQ(0, feupdateenv(&env));
532				ATF_CHECK_EQ(FE_DOWNWARD, fegetround());
533				ATF_CHECK_EQ((except | raise), fetestexcept(ALL_STD_EXCEPT));
534
535				ATF_CHECK_EQ(0, pass);
536				_exit(0);
537			default:	/* parent */
538				ATF_REQUIRE(wait(&status) > 0);
539				/*
540				 * Avoid assert() here so that it's possible
541				 * to examine a failed child's core dump.
542				 */
543				if (!WIFEXITED(status))
544					errx(1, "child aborted\n");
545				ATF_CHECK_EQ(0, WEXITSTATUS(status));
546				break;
547			case -1:	/* error */
548				ATF_REQUIRE(0);
549			}
550		}
551	}
552	ATF_CHECK_EQ(0, fetestexcept(FE_ALL_EXCEPT));
553}
554
555ATF_TP_ADD_TCS(tp)
556{
557	ATF_TP_ADD_TC(tp, dfl_env);
558	ATF_TP_ADD_TC(tp, fetestclearexcept);
559	ATF_TP_ADD_TC(tp, fegsetexceptflag);
560	ATF_TP_ADD_TC(tp, feraiseexcept);
561	ATF_TP_ADD_TC(tp, fegsetround);
562	ATF_TP_ADD_TC(tp, fegsetenv);
563	ATF_TP_ADD_TC(tp, masking);
564	ATF_TP_ADD_TC(tp, feholdupdate);
565
566	return (atf_no_error());
567}
568