[LTP] [PATCH 4/4] lib: add tst_res_r.c

Alexey Kodanev
2014-02-11T09:48:24Z

It contains thread-safe versions of functions defined in tst_res.c.
NOPASS mode not implemented yet.

Signed-off-by: Alexey Kodanev <alexey.kodanev@oracle.com>
---
lib/tst_res_r.c | 499 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 499 insertions(+), 0 deletions(-)
create mode 100644 lib/tst_res_r.c

diff --git a/lib/tst_res_r.c b/lib/tst_res_r.c
new file mode 100644
index 0000000..1cf79ad
--- /dev/null
+++ b/lib/tst_res_r.c
@@ -0,0 +1,499 @@
+/*
+ * Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
+ * Copyright (c) 2009-2013 Cyril Hrubis <chrubis@suse.cz>
+ * Copyright (c) 2014 Oracle and/or its affiliates. All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <pthread.h>
+#include "tst_res.h"
+
+/*
+ * Synchronize access to global vars T_exitval, T_out, tst_count with
+ * mutexes.
+ */
+pthread_mutex_t exitval_mutex = PTHREAD_MUTEX_INITIALIZER,
+ tstcount_mutex = PTHREAD_MUTEX_INITIALIZER,
+ tout_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static int exitval_or(int ttype_result)
+{
+ int res;
+ pthread_mutex_lock(&exitval_mutex);
+ res = T_exitval |= ttype_result;
+ pthread_mutex_unlock(&exitval_mutex);
+ return res;
+}
+
+static int exitval_and(int ttype_result)
+{
+ int res;
+ pthread_mutex_lock(&exitval_mutex);
+ res = T_exitval &= ttype_result;
+ pthread_mutex_unlock(&exitval_mutex);
+ return res;
+}
+
+static int get_tst_count()
+{
+ int res;
+ pthread_mutex_lock(&tstcount_mutex);
+ res = tst_count;
+ pthread_mutex_unlock(&tstcount_mutex);
+ return res;
+}
+
+static void cat_file_r(char *filename);
+
+/*
+ * tst_print_r() - thread-safe version of tst_print()
+ * Additionally takes filename, because it isn't using global File
+ */
+static void tst_print_r(char *tcid, char *fname, int tnum, int ttype, char *tmesg)
+{
+ /*
+ * avoid unintended side effects from failures with fprintf when
+ * calling write(2), et all.
+ */
+ int err = errno;
+ const char *type;
+ int ttype_result = TTYPE_RESULT(ttype);
+ char message[USERMESG];
+ size_t size;
+
+#if DEBUG
+ printf("IN tst_print_r: tnum = %d, ttype = %d, tmesg = %s\n",
+ tnum, ttype, tmesg);
+ fflush(stdout);
+#endif
+
+ /*
+ * Save the test result type by ORing ttype into the current exit value
+ * (used by tst_exit()). This is already done in tst_res(), but is
+ * also done here to catch internal warnings. For internal warnings,
+ * tst_print() is called directly with a case of TWARN.
+ */
+ exitval_or(ttype_result);
+
+ /*
+ * If output mode is DISCARD, or if the output mode is NOPASS and this
+ * result is not one of FAIL, BROK, or WARN, just return. This check
+ * is necessary even though we check for DISCARD mode inside of
+ * tst_res(), since occasionally we get to this point without going
+ * through tst_res() (e.g. internal TWARN messages).
+ */
+ if (T_mode == DISCARD || (T_mode == NOPASS && ttype_result != TFAIL &&
+ ttype_result != TBROK
+ && ttype_result != TWARN))
+ return;
+
+ /*
+ * Build the result line and print it.
+ */
+ type = strttype(ttype);
+ if (T_mode == VERBOSE) {
+ size = snprintf(message, sizeof(message),
+ "%-8s %4d %s : %s", tcid, tnum, type, tmesg);
+ } else {
+ size = snprintf(message, sizeof(message),
+ "%-8s %4d %s : %s",
+ tcid, tnum, type, tmesg);
+ }
+
+ if (size >= sizeof(message)) {
+ printf("%s: %i: line too long\n", __func__, __LINE__);
+ abort();
+ }
+
+ if (ttype & TERRNO) {
+ size += snprintf(message + size, sizeof(message) - size,
+ ": errno=%s(%i): %s", strerrnodef(err),
+ err, strerror(err));
+ }
+
+ if (size >= sizeof(message)) {
+ printf("%s: %i: line too long\n", __func__, __LINE__);
+ abort();
+ }
+
+ if (ttype & TTERRNO) {
+ size += snprintf(message + size, sizeof(message) - size,
+ ": TEST_ERRNO=%s(%i): %s",
+ strerrnodef(TEST_ERRNO), (int)TEST_ERRNO,
+ strerror(TEST_ERRNO));
+ }
+
+ if (size + 1 >= sizeof(message)) {
+ printf("%s: %i: line too long\n", __func__, __LINE__);
+ abort();
+ }
+
+ message[size] = '\n';
+ message[size + 1] = '\0';
+
+ pthread_mutex_lock(&tout_mutex);
+ fputs(message, T_out);
+ pthread_mutex_unlock(&tout_mutex);
+
+ /*
+ * If tst_res() was called with a file, append file contents to the
+ * end of last printed result.
+ */
+ if (fname != NULL)
+ cat_file_r(fname);
+}
+
+/*
+ * check_env_once() - thread-safe version of check_env()
+ */
+static void check_env_once(void)
+{
+ char *value;
+
+#if DEBUG
+ printf("IN check_env_r\n");
+ fflush(stdout);
+#endif
+
+ /* BTOUTPUT not defined, use default */
+ if ((value = getenv(TOUTPUT)) == NULL) {
+ T_mode = VERBOSE;
+ return;
+ }
+
+ if (strcmp(value, TOUT_NOPASS_S) == 0) {
+ T_mode = NOPASS;
+ return;
+ }
+
+ if (strcmp(value, TOUT_DISCARD_S) == 0) {
+ T_mode = DISCARD;
+ return;
+ }
+
+ /* default */
+ T_mode = VERBOSE;
+ return;
+}
+DECLARE_ONCE_FN(check_env_r, check_env_once)
+
+/*
+ * tst_res_r() - thread-safe version of tst_res()
+ * Note: NOPASS mode not implemented
+ */
+void tst_res_r(int ttype, char *fname, char *arg_fmt, ...)
+{
+ char tmesg[USERMESG];
+ int ttype_result = TTYPE_RESULT(ttype);
+
+#if DEBUG
+ printf("IN tst_res_r; tst_count = %d\n", get_tst_count());
+ fflush(stdout);
+#endif
+
+ EXPAND_VAR_ARGS(tmesg, arg_fmt, USERMESG);
+
+ /*
+ * Save the test result type by ORing ttype into the current exit
+ * value (used by tst_exit()).
+ */
+ exitval_or(ttype_result);
+ /*
+ * Unless T_out has already been set by tst_environ(), make tst_res()
+ * output go to standard output.
+ */
+ pthread_mutex_lock(&tout_mutex);
+ if (T_out == NULL)
+ T_out = stdout;
+ pthread_mutex_unlock(&tout_mutex);
+
+ /*
+ * Check TOUTPUT environment variable (if first time) and set T_mode
+ * flag.
+ */
+ check_env_r();
+
+ if (fname != 0 && access(fname, F_OK) != 0)
+ fname = NULL;
+
+ /*
+ * Set the test case number and print the results, depending on the
+ * display type.
+ */
+ if (ttype_result == TWARN || ttype_result == TINFO) {
+ tst_print_r(TCID, fname, 0, ttype, tmesg);
+ } else {
+ if (get_tst_count() < 0)
+ tst_print_r(TCID, NULL, 0, TWARN,
+ "tst_res(): tst_count < 0 is not valid");
+
+ /*
+ * Process each display type.
+ */
+ switch (T_mode) {
+ case DISCARD:
+ break;
+ /* thread-safe NOPASS mode not implemented */
+ default: /* VERBOSE */
+ tst_print_r(TCID, fname, get_tst_count() + 1,
+ ttype, tmesg);
+ break;
+ }
+
+ pthread_mutex_lock(&tstcount_mutex);
+ ++tst_count;
+ pthread_mutex_unlock(&tstcount_mutex);
+ }
+}
+
+/*
+ * tst_flush_r() - thread-safe version of tst_flush()
+ * Note: NOPASS mode not implemented
+ */
+void tst_flush_r(void)
+{
+#if DEBUG
+ printf("IN tst_flush_r\n");
+ fflush(stdout);
+#endif
+
+ pthread_mutex_lock(&tout_mutex);
+ fflush(T_out);
+ pthread_mutex_unlock(&tout_mutex);
+}
+
+/*
+ * cat_file_r() - thread-safe version of cat_file()
+ */
+static void cat_file_r(char *filename)
+{
+ FILE *fp;
+ int b_read = 0, b_written = 0;
+ char buffer[BUFSIZ];
+ char warn_msg[MAXMESG];
+
+#if DEBUG
+ printf("IN cat_file_r\n");
+ fflush(stdout);
+#endif
+
+ if ((fp = fopen(filename, "r")) == NULL) {
+ sprintf(warn_msg,
+ "tst_res(): fopen(%s, \"r\") failed; errno = %d: %s",
+ filename, errno, strerror(errno));
+ tst_print_r(TCID, NULL, 0, TWARN, warn_msg);
+ return;
+ }
+
+ errno = 0;
+
+ pthread_mutex_lock(&tout_mutex);
+ while ((b_read = fread(buffer, 1, BUFSIZ, fp)) != 0) {
+ b_written = fwrite(buffer, 1, b_read, T_out);
+ if (b_written != b_read)
+ break;
+ }
+ pthread_mutex_unlock(&tout_mutex);
+
+ if (b_read && b_written != b_read) {
+ sprintf(warn_msg, "tst_res(): While trying to cat \"%s\", "
+ "fwrite() wrote only %d of %d bytes",
+ filename, b_written, b_read);
+ tst_print_r(TCID, NULL, 0, TWARN, warn_msg);
+ }
+
+ if (!feof(fp)) {
+ sprintf(warn_msg,
+ "tst_res(): While trying to cat \"%s\", fread() "
+ "failed, errno = %d: %s",
+ filename, errno, strerror(errno));
+ tst_print_r(TCID, NULL, 0, TWARN, warn_msg);
+ }
+
+ if (fclose(fp) != 0) {
+ sprintf(warn_msg,
+ "tst_res(): While trying to cat \"%s\", fclose() "
+ "failed, errno = %d: %s",
+ filename, errno, strerror(errno));
+ tst_print_r(TCID, NULL, 0, TWARN, warn_msg);
+ }
+}
+
+
+/*
+ * tst_exit_once() - thread-safe version of tst_exit()
+ */
+static void tst_exit_once(void)
+{
+#if DEBUG
+ printf("IN tst_exit_r\n");
+ fflush(stdout);
+ fflush(stdout);
+#endif
+
+ /* Call tst_flush() flush any output in the buffer. */
+ tst_flush_r();
+
+ /* Mask out TRETR, TINFO, and TCONF results from the exit status. */
+ exit(exitval_and(~(TRETR | TINFO | TCONF)));
+}
+DECLARE_ONCE_FN(tst_exit_r, tst_exit_once)
+
+/*
+ * tst_environ_r() - thread-safe version of tst_environ()
+ */
+int tst_environ_r(void)
+{
+ int res;
+ pthread_mutex_lock(&tout_mutex);
+ T_out = fdopen(dup(fileno(stdout)), "w");
+ res = T_out ? 0 : -1;
+ pthread_mutex_unlock(&tout_mutex);
+ return res;
+}
+
+/*
+ * tst_brk_r() - thread-safe version of tst_brk()
+ */
+void tst_brk_r(int ttype, char *fname, void (*func) (void), char *arg_fmt, ...)
+{
+ char tmesg[USERMESG];
+ int ttype_result = TTYPE_RESULT(ttype);
+ char warn_msg[MAXMESG];
+
+#if DEBUG
+ printf("IN tst_brk_r\n");
+ fflush(stdout);
+ fflush(stdout);
+#endif
+
+ EXPAND_VAR_ARGS(tmesg, arg_fmt, USERMESG);
+
+ /*
+ * Only FAIL, BROK, CONF, and RETR are supported by tst_brk().
+ */
+ if (ttype_result != TFAIL && ttype_result != TBROK &&
+ ttype_result != TCONF && ttype_result != TRETR) {
+ sprintf(warn_msg, "%s: Invalid Type: %d. Using TBROK",
+ __func__, ttype_result);
+ tst_print_r(TCID, fname, 0, TWARN, warn_msg);
+ /* Keep TERRNO, TTERRNO, etc. */
+ ttype = (ttype & ~ttype_result) | TBROK;
+ }
+
+ tst_res_r(ttype, fname, "%s", tmesg);
+
+ if (ttype_result == TCONF)
+ tst_res_r(ttype, NULL,
+ "Remaining cases not appropriate for "
+ "configuration");
+ else if (ttype_result == TRETR)
+ tst_res_r(ttype, NULL, "Remaining cases retired");
+ else if (ttype_result == TBROK)
+ tst_res_r(TBROK, NULL, "Remaining cases broken");
+
+ if (func != NULL)
+ (*func) ();
+ tst_exit_r();
+}
+
+/*
+ * tst_resm_r() - thread-safe version of tst_resm()
+ */
+void tst_resm_r(int ttype, char *arg_fmt, ...)
+{
+ char tmesg[USERMESG];
+
+#if DEBUG
+ printf("IN tst_resm_r\n");
+ fflush(stdout);
+ fflush(stdout);
+#endif
+
+ EXPAND_VAR_ARGS(tmesg, arg_fmt, USERMESG);
+
+ tst_res_r(ttype, NULL, "%s", tmesg);
+}
+
+/*
+ * tst_resm_hexd_r() - thread-safe version of tst_resm_hexd()
+ */
+void tst_resm_hexd_r(int ttype, const void *buf, size_t size, char *arg_fmt, ...)
+{
+ char tmesg[USERMESG];
+
+#if DEBUG
+ printf("IN tst_resm_hexd_r\n");
+ fflush(stdout);
+#endif
+
+ EXPAND_VAR_ARGS(tmesg, arg_fmt, USERMESG);
+
+ static const size_t symb_num = 2; /* xx */
+ static const size_t size_max = 16;
+ size_t offset = strlen(tmesg);
+ char *pmesg = tmesg;
+
+ if (size > size_max || size == 0 ||
+ (offset + size * (symb_num + 1)) >= USERMESG)
+ tst_res_r(ttype, NULL, "%s", tmesg);
+ else
+ pmesg += offset;
+
+ size_t i;
+ for (i = 0; i < size; ++i) {
+ /* add space before byte except first one */
+ if (pmesg != tmesg)
+ *(pmesg++) = ' ';
+
+ sprintf(pmesg, "%02x", ((unsigned char *)buf)[i]);
+ pmesg += symb_num;
+ if ((i + 1) % size_max == 0 || i + 1 == size) {
+ tst_res_r(ttype, NULL, "%s", tmesg);
+ pmesg = tmesg;
+ }
+ }
+}
+
+/*
+ * tst_brkm_r() - thread-safe version of tst_brkm()
+ */
+void tst_brkm_r(int ttype, void (*func) (void), char *arg_fmt, ...)
+{
+ char tmesg[USERMESG];
+
+#if DEBUG
+ printf("IN tst_brkm_r\n");
+ fflush(stdout);
+ fflush(stdout);
+#endif
+
+ EXPAND_VAR_ARGS(tmesg, arg_fmt, USERMESG);
+
+ tst_brk_r(ttype, NULL, func, "%s", tmesg);
+ /* Shouldn't be reach, but fixes build time warnings about noreturn. */
+ abort();
+}
+
+/*
+ * tst_require_root_r() - thread-safe version of tst_require_root()
+ */
+void tst_require_root_r(void (*func) (void))
+{
+ if (geteuid() != 0)
+ tst_brkm_r(TCONF, func, "Test needs to be run as root");
+}
--
1.7.1