util: Fix write handling in multiple functions

Fix both a real (but unlikely) error and warning with the return code
of write().  Recent versions of Glibc tag the write() function to raise
a warning if the return value is ignored.  The issue is real, so do
a slightly better job of handling the issue and silence the warning.

Signed-off-by: Brian Barrett <bbarrett@amazon.com>

Author: bwbarrett

ompi/mca/sharedfp/sm/sharedfp_sm_file_open.c

@@ -35,6 +35,7 @@
 #include "sharedfp_sm.h"
 
 #include "mpi.h"
+#include "opal/util/output.h"
 #include "ompi/constants.h"
 #include "ompi/group/group.h"
 #include "ompi/proc/proc.h"
@@ -139,7 +140,10 @@ int mca_sharedfp_sm_file_open (struct ompi_communicator_t *comm,
     /* TODO: is it necessary to write to the file first? */
     if( 0 == fh->f_rank ){
         memset ( &sm_offset, 0, sizeof (struct mca_sharedfp_sm_offset ));
-        write ( sm_fd, &sm_offset, sizeof(struct mca_sharedfp_sm_offset));
+        err = opal_best_effort_write ( sm_fd, &sm_offset, sizeof(struct mca_sharedfp_sm_offset));
+        if (OPAL_SUCCESS != err) {
+            return err;
+        }
     }
     err = comm->c_coll->coll_barrier (comm, comm->c_coll->coll_barrier_module );
     if ( OMPI_SUCCESS != err ) {

opal/mca/backtrace/execinfo/backtrace_execinfo.c

@@ -30,6 +30,7 @@
 #endif
 
 #include "opal/constants.h"
+#include "opal/util/output.h"
 #include "opal/mca/backtrace/backtrace.h"
 
 int opal_backtrace_print(FILE *file, char *prefix, int strip)
@@ -52,10 +53,10 @@ int opal_backtrace_print(FILE *file, char *prefix, int strip)
 
     for (i = strip; i < trace_size; i++) {
         if (NULL != prefix) {
-            write(fd, prefix, strlen(prefix));
+            opal_best_effort_write(fd, prefix, strlen(prefix));
         }
         len = snprintf(buf, sizeof(buf), "[%2d] ", i - strip);
-        write(fd, buf, len);
+        opal_best_effort_write(fd, buf, len);
         backtrace_symbols_fd(&trace[i], 1, fd);
     }
 

opal/mca/rcache/base/rcache_base_mem_cb.c

@@ -30,6 +30,7 @@
 #endif
 
 #include "opal/runtime/opal_params.h"
+#include "opal/util/output.h"
 #include "opal/util/proc.h"
 #include "opal/util/show_help.h"
 
@@ -72,7 +73,7 @@ void mca_rcache_base_mem_cb(void *base, size_t size, void *cbdata, bool from_all
                         "will now abort.\n",
                         opal_process_info.nodename, getpid(), base, (unsigned long) size);
                     msg[sizeof(msg) - 1] = '\0';
-                    write(2, msg, len);
+                    opal_best_effort_write(2, msg, len);
                 } else {
                     opal_show_help("help-rcache-base.txt", "cannot deregister in-use memory", true,
                                    current->rcache_component->rcache_version.mca_component_name,

opal/util/error.c

@@ -35,6 +35,7 @@
 #include "opal/constants.h"
 #include "opal/runtime/opal_params.h"
 #include "opal/util/error.h"
+#include "opal/util/output.h"
 #include "opal/util/printf.h"
 #include "opal/util/proc.h"
 #include "opal/util/string_copy.h"
@@ -217,14 +218,18 @@ void opal_delay_abort(void)
                      "[%s:%05d] Looping forever "
                      "(MCA parameter opal_abort_delay is < 0)\n",
                      opal_process_info.nodename, (int) pid);
-            write(STDERR_FILENO, msg, strlen(msg));
+        } else {
+            snprintf(msg, sizeof(msg), "[%s:%05d] Delaying for %d seconds before aborting\n",
+                     opal_process_info.nodename, (int) pid, delay);
+        }
+
+        opal_best_effort_write(STDERR_FILENO, msg, strlen(msg));
+
+        if (delay < 0) {
             while (1) {
                 sleep(5);
             }
         } else {
-            snprintf(msg, sizeof(msg), "[%s:%05d] Delaying for %d seconds before aborting\n",
-                     opal_process_info.nodename, (int) pid, delay);
-            write(STDERR_FILENO, msg, strlen(msg));
             do {
                 sleep(1);
             } while (--delay > 0);

opal/util/output.c

@@ -948,14 +948,20 @@ static int output(int output_id, const char *format, va_list arglist)
 
         /* stdout output */
         if (ldi->ldi_stdout) {
-            write(fileno(stdout), out, (int) strlen(out));
+            int tmp = opal_best_effort_write(fileno(stdout), out, strlen(out));
+            if (OPAL_SUCCESS != tmp) {
+                rc = tmp;
+            }
             fflush(stdout);
         }
 
         /* stderr output */
         if (ldi->ldi_stderr) {
-            write((-1 == default_stderr_fd) ? fileno(stderr) : default_stderr_fd, out,
-                  (int) strlen(out));
+            int tmp = opal_best_effort_write((-1 == default_stderr_fd) ? fileno(stderr) : default_stderr_fd,
+                                             out, strlen(out));
+            if (OPAL_SUCCESS != tmp) {
+                rc = tmp;
+            }
             fflush(stderr);
         }
 
@@ -970,17 +976,24 @@ static int output(int output_id, const char *format, va_list arglist)
                     ++ldi->ldi_file_num_lines_lost;
                 } else if (ldi->ldi_file_num_lines_lost > 0) {
                     char buffer[BUFSIZ];
+                    int tmp;
                     memset(buffer, 0, BUFSIZ);
                     snprintf(buffer, BUFSIZ - 1,
                              "[WARNING: %d lines lost because the Open MPI process session "
                              "directory did\n not exist when opal_output() was invoked]\n",
                              ldi->ldi_file_num_lines_lost);
-                    write(ldi->ldi_fd, buffer, (int) strlen(buffer));
+                    tmp = opal_best_effort_write(ldi->ldi_fd, buffer, strlen(buffer));
+                    if (OPAL_SUCCESS != tmp) {
+                        rc = tmp;
+                    }
                     ldi->ldi_file_num_lines_lost = 0;
                 }
             }
             if (ldi->ldi_fd != -1) {
-                write(ldi->ldi_fd, out, (int) strlen(out));
+                int tmp = opal_best_effort_write(ldi->ldi_fd, out, strlen(out));
+                if (OPAL_SUCCESS != tmp) {
+                    rc = tmp;
+                }
             }
         }
         OPAL_THREAD_UNLOCK(&mutex);

opal/util/output.h

@@ -71,7 +71,10 @@
 #include "opal_config.h"
 
 #include <stdarg.h>
+#include <unistd.h>
+#include <errno.h>
 
+#include "opal/constants.h"
 #include "opal/class/opal_object.h"
 
 BEGIN_C_DECLS
@@ -552,6 +555,30 @@ OPAL_DECLSPEC void opal_output_set_output_file_info(const char *dir, const char
  */
 OPAL_DECLSPEC OBJ_CLASS_DECLARATION(opal_output_stream_t);
 
+/**
+ * Best effort write for blocking file descriptors
+ *
+ * A wrapper around write() that will spin trying to write the entire
+ * buffer until either an error occurs or a write is not able to write
+ * any data.  Useful for situations where opal_output cannot be used
+ * for signal reasons.  Do not use with non-blocking file descriptors.
+ */
+static inline int opal_best_effort_write(int fd, const void *buf, size_t count)
+{
+    size_t written = 0;
+
+    while (written != count) {
+        ssize_t tmp = write(fd, (char *)buf + written, count - written);
+        /* we explicitly do not recover from errors in this wrapper */
+        if ((tmp < 0 && errno != EINTR) || (tmp == 0)) {
+            return OPAL_ERROR;
+        }
+        written += tmp;
+    }
+
+    return OPAL_SUCCESS;
+}
+
 END_C_DECLS
 
 #endif /* OPAL_OUTPUT_H_ */

opal/util/stacktrace.c

@@ -146,7 +146,7 @@ static void show_stackframe(int signo, siginfo_t *info, void *p)
     memset(print_buffer, 0, sizeof(print_buffer));
     ret = snprintf(print_buffer, sizeof(print_buffer),
                    HOSTFORMAT "*** Process received signal ***\n", stacktrace_hostname, getpid());
-    write(opal_stacktrace_output_fileno, print_buffer, ret);
+    opal_best_effort_write(opal_stacktrace_output_fileno, print_buffer, ret);
 
     memset(print_buffer, 0, sizeof(print_buffer));
 
@@ -467,23 +467,25 @@ static void show_stackframe(int signo, siginfo_t *info, void *p)
     }
 
     /* write out the signal information generated above */
-    write(opal_stacktrace_output_fileno, print_buffer, sizeof(print_buffer) - size);
+    opal_best_effort_write(opal_stacktrace_output_fileno, print_buffer, sizeof(print_buffer) - size);
 
     /* print out the stack trace */
     snprintf(print_buffer, sizeof(print_buffer), HOSTFORMAT, stacktrace_hostname, getpid());
     ret = opal_backtrace_print(NULL, print_buffer, 2);
     if (OPAL_SUCCESS != ret) {
-        write(opal_stacktrace_output_fileno, unable_to_print_msg, strlen(unable_to_print_msg));
+        opal_best_effort_write(opal_stacktrace_output_fileno, unable_to_print_msg,
+                               strlen(unable_to_print_msg));
     }
 
     /* write out the footer information */
     memset(print_buffer, 0, sizeof(print_buffer));
     ret = snprintf(print_buffer, sizeof(print_buffer), HOSTFORMAT "*** End of error message ***\n",
                    stacktrace_hostname, getpid());
     if (ret > 0) {
-        write(opal_stacktrace_output_fileno, print_buffer, ret);
+        opal_best_effort_write(opal_stacktrace_output_fileno, print_buffer, ret);
     } else {
-        write(opal_stacktrace_output_fileno, unable_to_print_msg, strlen(unable_to_print_msg));
+        opal_best_effort_write(opal_stacktrace_output_fileno, unable_to_print_msg,
+                               strlen(unable_to_print_msg));
     }
 
     if (fileno(stdout) != opal_stacktrace_output_fileno