• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2000 Silicon Graphics, Inc.  All Rights Reserved.
3  *    AUTHOR            : Kent Rogers (from Dave Fenner's original)
4  *    CO-PILOT          : Rich Logan
5  *    DATE STARTED      : 05/01/90 (rewritten 1/96)
6  * Copyright (c) 2009-2016 Cyril Hrubis <chrubis@suse.cz>
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of version 2 of the GNU General Public License as
10  * published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it would be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
15  *
16  * Further, this software is distributed without any warranty that it is
17  * free of the rightful claim of any third person regarding infringement
18  * or the like.  Any license provided herein, whether implied or
19  * otherwise, applies only to this software file.  Patent licenses, if
20  * any, provided herein do not apply to combinations of this program with
21  * other software, or any other product whatsoever.
22  *
23  * You should have received a copy of the GNU General Public License along
24  * with this program; if not, write the Free Software Foundation, Inc.,
25  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
26  *
27  * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
28  * Mountain View, CA  94043, or:
29  *
30  * http://www.sgi.com
31  *
32  * For further information regarding this notice, see:
33  *
34  * http://oss.sgi.com/projects/GenInfo/NoticeExplan/
35  */
36 
37 #define _GNU_SOURCE
38 
39 #include <pthread.h>
40 #include <assert.h>
41 #include <errno.h>
42 #include <stdio.h>
43 #include <stdlib.h>
44 #include <stdarg.h>
45 #include <string.h>
46 #include <unistd.h>
47 #include <sys/types.h>
48 #include <sys/wait.h>
49 
50 #include "test.h"
51 #include "safe_macros.h"
52 #include "usctest.h"
53 #include "ltp_priv.h"
54 #include "tst_ansi_color.h"
55 
56 long TEST_RETURN;
57 int TEST_ERRNO;
58 void *TST_RET_PTR;
59 
60 #define VERBOSE      1
61 #define NOPASS       3
62 #define DISCARD      4
63 
64 #define MAXMESG      80		/* max length of internal messages */
65 #define USERMESG     2048	/* max length of user message */
66 #define TRUE         1
67 #define FALSE        0
68 
69 /*
70  * EXPAND_VAR_ARGS - Expand the variable portion (arg_fmt) of a result
71  *                   message into the specified string.
72  *
73  * NOTE (garrcoop):  arg_fmt _must_ be the last element in each function
74  *		     argument list that employs this.
75  */
76 #define EXPAND_VAR_ARGS(buf, arg_fmt, buf_len) do {\
77 	va_list ap;				\
78 	assert(arg_fmt != NULL);		\
79 	va_start(ap, arg_fmt);			\
80 	vsnprintf(buf, buf_len, arg_fmt, ap);	\
81 	va_end(ap);				\
82 	assert(strlen(buf) > 0);		\
83 } while (0)
84 
85 #ifndef PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
86 # ifdef __ANDROID__
87 #  define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP \
88 	PTHREAD_RECURSIVE_MUTEX_INITIALIZER
89 # else
90 /* MUSL: http://www.openwall.com/lists/musl/2017/02/20/5 */
91 #  define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP  { {PTHREAD_MUTEX_RECURSIVE} }
92 # endif
93 #endif
94 
95 static pthread_mutex_t tmutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
96 
97 static void check_env(void);
98 static void tst_condense(int tnum, int ttype, const char *tmesg);
99 static void tst_print(const char *tcid, int tnum, int ttype, const char *tmesg);
100 
101 static int T_exitval = 0;	/* exit value used by tst_exit() */
102 static int passed_cnt;
103 static int T_mode = VERBOSE;	/* flag indicating print mode: VERBOSE, */
104 				/* NOPASS, DISCARD */
105 
106 static char Warn_mesg[MAXMESG];	/* holds warning messages */
107 
108 /*
109  * These are used for condensing output when NOT in verbose mode.
110  */
111 static int Buffered = FALSE;	/* TRUE if condensed output is currently */
112 				/* buffered (i.e. not yet printed) */
113 static char *Last_tcid;		/* previous test case id */
114 static int Last_num;		/* previous test case number */
115 static int Last_type;		/* previous test result type */
116 static char *Last_mesg;		/* previous test result message */
117 
118 int tst_count = 0;
119 
120 /*
121  * These globals must be defined in the test.
122  */
123 extern char *TCID;		/* Test case identifier from the test source */
124 extern int TST_TOTAL;		/* Total number of test cases from the test */
125 
126 
127 struct pair {
128 	const char *name;
129 	int val;
130 };
131 
132 #define PAIR(def) [def] = {.name = #def, .val = def},
133 #define STRPAIR(key, value) [key] = {.name = value, .val = key},
134 
135 #define PAIR_LOOKUP(pair_arr, idx) do {                       \
136 	if (idx < 0 || (size_t)idx >= ARRAY_SIZE(pair_arr) || \
137 	    pair_arr[idx].name == NULL)                       \
138 		return "???";                                 \
139 	return pair_arr[idx].name;                            \
140 } while (0)
141 
strttype(int ttype)142 const char *strttype(int ttype)
143 {
144 	static const struct pair ttype_pairs[] = {
145 		PAIR(TPASS)
146 		PAIR(TFAIL)
147 		PAIR(TBROK)
148 		PAIR(TCONF)
149 		PAIR(TWARN)
150 		PAIR(TINFO)
151 	};
152 
153 	PAIR_LOOKUP(ttype_pairs, TTYPE_RESULT(ttype));
154 }
155 
156 #include "errnos.h"
157 #include "signame.h"
158 
tst_res__(const char * file,const int lineno,int ttype,const char * arg_fmt,...)159 static void tst_res__(const char *file, const int lineno, int ttype,
160                       const char *arg_fmt, ...)
161 {
162 	pthread_mutex_lock(&tmutex);
163 
164 	char tmesg[USERMESG];
165 	int len = 0;
166 	int ttype_result = TTYPE_RESULT(ttype);
167 
168 	if (file && (ttype_result != TPASS && ttype_result != TINFO))
169 		len = sprintf(tmesg, "%s:%d: ", file, lineno);
170 	EXPAND_VAR_ARGS(tmesg + len, arg_fmt, USERMESG - len);
171 
172 	/*
173 	 * Save the test result type by ORing ttype into the current exit
174 	 * value (used by tst_exit()).
175 	 */
176 	T_exitval |= ttype_result;
177 
178 	if (ttype_result == TPASS)
179 		passed_cnt++;
180 
181 	check_env();
182 
183 	/*
184 	 * Set the test case number and print the results, depending on the
185 	 * display type.
186 	 */
187 	if (ttype_result == TWARN || ttype_result == TINFO) {
188 		tst_print(TCID, 0, ttype, tmesg);
189 	} else {
190 		if (tst_count < 0)
191 			tst_print(TCID, 0, TWARN,
192 				  "tst_res(): tst_count < 0 is not valid");
193 
194 		/*
195 		 * Process each display type.
196 		 */
197 		switch (T_mode) {
198 		case DISCARD:
199 			break;
200 		case NOPASS:	/* filtered by tst_print() */
201 			tst_condense(tst_count + 1, ttype, tmesg);
202 			break;
203 		default:	/* VERBOSE */
204 			tst_print(TCID, tst_count + 1, ttype, tmesg);
205 			break;
206 		}
207 
208 		tst_count++;
209 	}
210 
211 	pthread_mutex_unlock(&tmutex);
212 }
213 
tst_condense(int tnum,int ttype,const char * tmesg)214 static void tst_condense(int tnum, int ttype, const char *tmesg)
215 {
216 	int ttype_result = TTYPE_RESULT(ttype);
217 
218 	/*
219 	 * If this result is the same as the previous result, return.
220 	 */
221 	if (Buffered == TRUE) {
222 		if (strcmp(Last_tcid, TCID) == 0 && Last_type == ttype_result &&
223 		    strcmp(Last_mesg, tmesg) == 0)
224 			return;
225 
226 		/*
227 		 * This result is different from the previous result.  First,
228 		 * print the previous result.
229 		 */
230 		tst_print(Last_tcid, Last_num, Last_type, Last_mesg);
231 		free(Last_tcid);
232 		free(Last_mesg);
233 	}
234 
235 	/*
236 	 * If a file was specified, print the current result since we have no
237 	 * way of retaining the file contents for comparing with future
238 	 * results.  Otherwise, buffer the current result info for next time.
239 	 */
240 	Last_tcid = malloc(strlen(TCID) + 1);
241 	strcpy(Last_tcid, TCID);
242 	Last_num = tnum;
243 	Last_type = ttype_result;
244 	Last_mesg = malloc(strlen(tmesg) + 1);
245 	strcpy(Last_mesg, tmesg);
246 	Buffered = TRUE;
247 }
248 
tst_old_flush(void)249 void tst_old_flush(void)
250 {
251 	NO_NEWLIB_ASSERT("Unknown", 0);
252 
253 	pthread_mutex_lock(&tmutex);
254 
255 	/*
256 	 * Print out last line if in NOPASS mode.
257 	 */
258 	if (Buffered == TRUE && T_mode == NOPASS) {
259 		tst_print(Last_tcid, Last_num, Last_type, Last_mesg);
260 		Buffered = FALSE;
261 	}
262 
263 	fflush(stdout);
264 
265 	pthread_mutex_unlock(&tmutex);
266 }
267 
tst_print(const char * tcid,int tnum,int ttype,const char * tmesg)268 static void tst_print(const char *tcid, int tnum, int ttype, const char *tmesg)
269 {
270 	int err = errno;
271 	const char *type;
272 	int ttype_result = TTYPE_RESULT(ttype);
273 	char message[USERMESG];
274 	size_t size = 0;
275 
276 	/*
277 	 * Save the test result type by ORing ttype into the current exit value
278 	 * (used by tst_exit()).  This is already done in tst_res(), but is
279 	 * also done here to catch internal warnings.  For internal warnings,
280 	 * tst_print() is called directly with a case of TWARN.
281 	 */
282 	T_exitval |= ttype_result;
283 
284 	/*
285 	 * If output mode is DISCARD, or if the output mode is NOPASS and this
286 	 * result is not one of FAIL, BROK, or WARN, just return.  This check
287 	 * is necessary even though we check for DISCARD mode inside of
288 	 * tst_res(), since occasionally we get to this point without going
289 	 * through tst_res() (e.g. internal TWARN messages).
290 	 */
291 	if (T_mode == DISCARD || (T_mode == NOPASS && ttype_result != TFAIL &&
292 				  ttype_result != TBROK
293 				  && ttype_result != TWARN))
294 		return;
295 
296 	/*
297 	 * Build the result line and print it.
298 	 */
299 	type = strttype(ttype);
300 
301 	if (T_mode == VERBOSE) {
302 		size += snprintf(message + size, sizeof(message) - size,
303 				"%-8s %4d  ", tcid, tnum);
304 	} else {
305 		size += snprintf(message + size, sizeof(message) - size,
306 				"%-8s %4d       ", tcid, tnum);
307 	}
308 
309 	if (size >= sizeof(message)) {
310 		printf("%s: %i: line too long\n", __func__, __LINE__);
311 		abort();
312 	}
313 
314 	if (tst_color_enabled(STDOUT_FILENO))
315 		size += snprintf(message + size, sizeof(message) - size,
316 		"%s%s%s  :  %s", tst_ttype2color(ttype), type, ANSI_COLOR_RESET, tmesg);
317 	else
318 		size += snprintf(message + size, sizeof(message) - size,
319 		"%s  :  %s", type, tmesg);
320 
321 	if (size >= sizeof(message)) {
322 		printf("%s: %i: line too long\n", __func__, __LINE__);
323 		abort();
324 	}
325 
326 	if (ttype & TERRNO) {
327 		size += snprintf(message + size, sizeof(message) - size,
328 				 ": errno=%s(%i): %s", tst_strerrno(err),
329 				 err, strerror(err));
330 	}
331 
332 	if (size >= sizeof(message)) {
333 		printf("%s: %i: line too long\n", __func__, __LINE__);
334 		abort();
335 	}
336 
337 	if (ttype & TTERRNO) {
338 		size += snprintf(message + size, sizeof(message) - size,
339 				 ": TEST_ERRNO=%s(%i): %s",
340 				 tst_strerrno(TEST_ERRNO), (int)TEST_ERRNO,
341 				 strerror(TEST_ERRNO));
342 	}
343 
344 	if (size >= sizeof(message)) {
345 		printf("%s: %i: line too long\n", __func__, __LINE__);
346 		abort();
347 	}
348 
349 	if (ttype & TRERRNO) {
350 		err = TEST_RETURN < 0 ? -(int)TEST_RETURN : (int)TEST_RETURN;
351 		size += snprintf(message + size, sizeof(message) - size,
352 				 ": TEST_RETURN=%s(%i): %s",
353 				 tst_strerrno(err), err, strerror(err));
354 	}
355 
356 	if (size + 1 >= sizeof(message)) {
357 		printf("%s: %i: line too long\n", __func__, __LINE__);
358 		abort();
359 	}
360 
361 	message[size] = '\n';
362 	message[size + 1] = '\0';
363 
364 	fputs(message, stdout);
365 }
366 
check_env(void)367 static void check_env(void)
368 {
369 	static int first_time = 1;
370 	char *value;
371 
372 	if (!first_time)
373 		return;
374 
375 	first_time = 0;
376 
377 	/* BTOUTPUT not defined, use default */
378 	if ((value = getenv(TOUTPUT)) == NULL) {
379 		T_mode = VERBOSE;
380 		return;
381 	}
382 
383 	if (strcmp(value, TOUT_NOPASS_S) == 0) {
384 		T_mode = NOPASS;
385 		return;
386 	}
387 
388 	if (strcmp(value, TOUT_DISCARD_S) == 0) {
389 		T_mode = DISCARD;
390 		return;
391 	}
392 
393 	T_mode = VERBOSE;
394 	return;
395 }
396 
tst_exit(void)397 void tst_exit(void)
398 {
399 	NO_NEWLIB_ASSERT("Unknown", 0);
400 
401 	pthread_mutex_lock(&tmutex);
402 
403 	tst_old_flush();
404 
405 	T_exitval &= ~TINFO;
406 
407 	if (T_exitval == TCONF && passed_cnt)
408 		T_exitval &= ~TCONF;
409 
410 	exit(T_exitval);
411 }
412 
tst_fork(void)413 pid_t tst_fork(void)
414 {
415 	pid_t child;
416 
417 	NO_NEWLIB_ASSERT("Unknown", 0);
418 
419 	tst_old_flush();
420 
421 	child = fork();
422 	if (child == 0)
423 		T_exitval = 0;
424 
425 	return child;
426 }
427 
tst_record_childstatus(void (* cleanup)(void),pid_t child)428 void tst_record_childstatus(void (*cleanup)(void), pid_t child)
429 {
430 	int status, ttype_result;
431 
432 	NO_NEWLIB_ASSERT("Unknown", 0);
433 
434 	SAFE_WAITPID(cleanup, child, &status, 0);
435 
436 	if (WIFEXITED(status)) {
437 		ttype_result = WEXITSTATUS(status);
438 		ttype_result = TTYPE_RESULT(ttype_result);
439 		T_exitval |= ttype_result;
440 
441 		if (ttype_result == TPASS)
442 			tst_resm(TINFO, "Child process returned TPASS");
443 
444 		if (ttype_result & TFAIL)
445 			tst_resm(TINFO, "Child process returned TFAIL");
446 
447 		if (ttype_result & TBROK)
448 			tst_resm(TINFO, "Child process returned TBROK");
449 
450 		if (ttype_result & TCONF)
451 			tst_resm(TINFO, "Child process returned TCONF");
452 
453 	} else {
454 		tst_brkm(TBROK, cleanup, "child process(%d) killed by "
455 			 "unexpected signal %s(%d)", child,
456 			 tst_strsig(WTERMSIG(status)), WTERMSIG(status));
457 	}
458 }
459 
tst_vfork(void)460 pid_t tst_vfork(void)
461 {
462 	NO_NEWLIB_ASSERT("Unknown", 0);
463 
464 	tst_old_flush();
465 	return vfork();
466 }
467 
468 /*
469  * Make tst_brk reentrant so that one can call the SAFE_* macros from within
470  * user-defined cleanup functions.
471  */
472 static int tst_brk_entered = 0;
473 
tst_brk__(const char * file,const int lineno,int ttype,void (* func)(void),const char * arg_fmt,...)474 static void tst_brk__(const char *file, const int lineno, int ttype,
475                       void (*func)(void), const char *arg_fmt, ...)
476 {
477 	pthread_mutex_lock(&tmutex);
478 
479 	char tmesg[USERMESG];
480 	int ttype_result = TTYPE_RESULT(ttype);
481 
482 	EXPAND_VAR_ARGS(tmesg, arg_fmt, USERMESG);
483 
484 	/*
485 	 * Only FAIL, BROK, CONF, and RETR are supported by tst_brk().
486 	 */
487 	if (ttype_result != TFAIL && ttype_result != TBROK &&
488 	    ttype_result != TCONF) {
489 		sprintf(Warn_mesg, "%s: Invalid Type: %d. Using TBROK",
490 			__func__, ttype_result);
491 		tst_print(TCID, 0, TWARN, Warn_mesg);
492 		/* Keep TERRNO, TTERRNO, etc. */
493 		ttype = (ttype & ~ttype_result) | TBROK;
494 	}
495 
496 	tst_res__(file, lineno, ttype, "%s", tmesg);
497 	if (tst_brk_entered == 0) {
498 		if (ttype_result == TCONF) {
499 			tst_res__(file, lineno, ttype,
500 				"Remaining cases not appropriate for "
501 				"configuration");
502 		} else if (ttype_result == TBROK) {
503 			tst_res__(file, lineno, TBROK,
504 				 "Remaining cases broken");
505 		}
506 	}
507 
508 	/*
509 	 * If no cleanup function was specified, just return to the caller.
510 	 * Otherwise call the specified function.
511 	 */
512 	if (func != NULL) {
513 		tst_brk_entered++;
514 		(*func) ();
515 		tst_brk_entered--;
516 	}
517 	if (tst_brk_entered == 0)
518 		tst_exit();
519 
520 	pthread_mutex_unlock(&tmutex);
521 }
522 
tst_resm_(const char * file,const int lineno,int ttype,const char * arg_fmt,...)523 void tst_resm_(const char *file, const int lineno, int ttype,
524 	const char *arg_fmt, ...)
525 {
526 	char tmesg[USERMESG];
527 
528 	EXPAND_VAR_ARGS(tmesg, arg_fmt, USERMESG);
529 
530 	if (tst_test)
531 		tst_res_(file, lineno, ttype, "%s", tmesg);
532 	else
533 		tst_res__(file, lineno, ttype, "%s", tmesg);
534 }
535 
536 typedef void (*tst_res_func_t)(const char *file, const int lineno,
537 		int ttype, const char *fmt, ...);
538 
tst_resm_hexd_(const char * file,const int lineno,int ttype,const void * buf,size_t size,const char * arg_fmt,...)539 void tst_resm_hexd_(const char *file, const int lineno, int ttype,
540 	const void *buf, size_t size, const char *arg_fmt, ...)
541 {
542 	char tmesg[USERMESG];
543 	static const size_t symb_num	= 2; /* xx */
544 	static const size_t size_max	= 16;
545 	size_t offset;
546 	size_t i;
547 	char *pmesg = tmesg;
548 	tst_res_func_t res_func;
549 
550 	if (tst_test)
551 		res_func = tst_res_;
552 	else
553 		res_func = tst_res__;
554 
555 	EXPAND_VAR_ARGS(tmesg, arg_fmt, USERMESG);
556 	offset = strlen(tmesg);
557 
558 	if (size > size_max || size == 0 ||
559 		(offset + size * (symb_num + 1)) >= USERMESG)
560 		res_func(file, lineno, ttype, "%s", tmesg);
561 	else
562 		pmesg += offset;
563 
564 	for (i = 0; i < size; ++i) {
565 		/* add space before byte except first one */
566 		if (pmesg != tmesg)
567 			*(pmesg++) = ' ';
568 
569 		sprintf(pmesg, "%02x", ((unsigned char *)buf)[i]);
570 		pmesg += symb_num;
571 		if ((i + 1) % size_max == 0 || i + 1 == size) {
572 			res_func(file, lineno, ttype, "%s", tmesg);
573 			pmesg = tmesg;
574 		}
575 	}
576 }
577 
tst_brkm_(const char * file,const int lineno,int ttype,void (* func)(void),const char * arg_fmt,...)578 void tst_brkm_(const char *file, const int lineno, int ttype,
579 	void (*func)(void), const char *arg_fmt, ...)
580 {
581 	char tmesg[USERMESG];
582 
583 	EXPAND_VAR_ARGS(tmesg, arg_fmt, USERMESG);
584 
585 	if (tst_test) {
586 		if (func) {
587 			tst_brk_(file, lineno, TBROK,
588 			         "Non-NULL cleanup in newlib!");
589 		}
590 
591 		tst_brk_(file, lineno, ttype, "%s", tmesg);
592 	} else {
593 		tst_brk__(file, lineno, ttype, func, "%s", tmesg);
594 	}
595 
596 	/* Shouldn't be reached, but fixes build time warnings about noreturn. */
597 	abort();
598 }
599 
tst_require_root(void)600 void tst_require_root(void)
601 {
602 	NO_NEWLIB_ASSERT("Unknown", 0);
603 
604 	if (geteuid() != 0)
605 		tst_brkm(TCONF, NULL, "Test needs to be run as root");
606 }
607