Fix memory leaks of buffer allocated in __kmp_str_format()

[vhscampos]

Summary

Following comment in kmp_str.c line 480, strings allocated by kmp_str_format() have to be freed using kmp_str_free(). In many instances, these buffers were freed by calling free() directly.

In almost all calls to kmp_msg(), KMP_ERR and KMP_SYSERRCODE are used to allocate messages. This allocation uses kmp_str_format() as well, but the buffer is not freed afterwards. I made changes aiming to eliminate these leaks.

[AndreyChurbanov]

1. __kmp_msg(kmp_ms_fatal,...) never returns, and it cleans up its arguments inside. Thus trying to clean its argument once more time is an error.
2. __kmp_msg(kmp_ms_warning,...) cleans its arguments in case it tries to print anything, and doesn't clean in case it returns immediately. Thus the added cleanup action should be conditional, e.g.

if(__kmp_generate_warnings == kmp_warnings_off)
    __kmp_str_free(&err_code.str);

I tried to mark all changes those need to be under condition, and those are OK. All the changes for fatal messages should be reverted.

runtime/src/kmp_affinity.h

61 ↗

(On Diff #78303)

This change is bad, as well as all other changes for __kmp_msg(kmp_ms_fatal,...).

runtime/src/kmp_environment.c

569

This change is OK, as the __kmp_str_free frees and nullifies parameter.

runtime/src/kmp_i18n.c

159

Needs condition.

433

Needs condition.

827

OK to remove the comment.

842

I think keeping all declarations together looks better that moving one here. Why this change?

944

These two changes are OK.

970

These two are OK as well.

runtime/src/kmp_itt.c

107

Needs condition.

107

Needs condition.

143

Needs condition.

152

Needs condition.

runtime/src/kmp_settings.c

363

This is OK.

421

These two are OK.

2238

This is OK.

runtime/src/kmp_str.c

423

This is OK.

481

OK

runtime/src/z_Linux_util.c

171

Needs condition.

207

Needs condition.

259

Needs condition.

294

Needs condition.

737

Needs condition.

984

Needs condition.

1090

Needs condition.

1149

Needs condition.

runtime/src/z_Windows_NT_util.c

566

Needs condition.

[vhscampos]

Ok, I'm fixing the patch. Thanks.

[vhscampos]

Applied your comments.

[AndreyChurbanov]

runtime/src/kmp_i18n.c

151

Something is wrong with indents here. Please check that replacement of tabs with spaces done correctly in this code block.

428

It should be err_msg.str variable, not err_code.str. Or, alternatively, name it err_code in lines 419, 423 and here.

[vhscampos]

Fixed indentation and variable name issues.

[AndreyChurbanov]

LGTM

[AndreyChurbanov]

Victor,
shell I commit the change on your behalf?

[vhscampos]

Yes, thanks.

runtime/src/kmp_environment.c

 
 
 void
 __kmp_env_blk_free(
     kmp_env_blk_t * block  // M: Block of environment variables to free.
 ) {
 
     KMP_INTERNAL_FREE( (void *) block->vars );
-    KMP_INTERNAL_FREE( (void *) block->bulk );
+    __kmp_str_free(&(block->bulk));
 
     block->count = 0;
     block->vars  = NULL;
-    block->bulk  = NULL;
 
 } // __kmp_env_blk_free
 
 
 
 char const *               // R: Value of variable or NULL if variable does not exist.
 __kmp_env_blk_var(
     kmp_env_blk_t * block, // I: Block of environment variables.

runtime/src/kmp_i18n.c

return;
     if ( status == KMP_I18N_ABSENT ) {
       if (__kmp_generate_warnings > kmp_warnings_low) { // AC: only issue warning in case explicitly asked to
         int    error   = errno; // Save errno immediately.
   char * nlspath = __kmp_env_get( "NLSPATH" );
         char * lang    = __kmp_env_get( "LANG" );
 
   // Infinite recursion will not occur -- status is KMP_I18N_ABSENT now, so
   // __kmp_i18n_catgets() will not try to open catalog, but will return default message.
-  __kmp_msg(
-      kmp_ms_warning,
-      KMP_MSG( CantOpenMessageCatalog, name ),
-      KMP_ERR( error ),
-      KMP_HNT( CheckEnvVar, "NLSPATH", nlspath ),
+  kmp_msg_t err_code = KMP_ERR( error );
+  __kmp_msg(
+      kmp_ms_warning,
+      KMP_MSG( CantOpenMessageCatalog, name ),
+      err_code,
+      KMP_HNT( CheckEnvVar, "NLSPATH", nlspath ),
             KMP_HNT( CheckEnvVar, "LANG", lang ),
-      __kmp_msg_null
-  );
+      __kmp_msg_null
+  );
+  if (__kmp_generate_warnings == kmp_warnings_off) {
+    __kmp_str_free(&err_code.str);
+  }
+
   KMP_INFORM( WillUseDefaultMessages );
         KMP_INTERNAL_FREE( nlspath );
         KMP_INTERNAL_FREE( lang );
       }
     } else { // status == KMP_I18N_OPENED
 
         int section = get_section( kmp_i18n_prp_Version );
         int number  = get_number( kmp_i18n_prp_Version );
for ( s = 0; s < table->size; ++ s ) {
         table->sect[ s ].size = 0;
         // Free section itself.
         KMP_INTERNAL_FREE ( (void *) table->sect[ s ].str );
         table->sect[ s ].str = NULL;
     }; // for s
     table->size = 0;
     KMP_INTERNAL_FREE( (void *) table->sect );
     table->sect = NULL;
-} // kmp_i8n_table_free
+} // kmp_i18n_table_free
 
 
 void
 __kmp_i18n_do_catopen(
 ) {
 
     LCID          locale_id = GetThreadLocale();
     WORD    lang_id = LANGIDFROMLCID( locale_id );
goto end;
     }
 
     // For security reasons, use LoadLibraryEx() and load message catalog as a data file.
     cat = LoadLibraryEx( path.str, NULL, LOAD_LIBRARY_AS_DATAFILE );
     status = ( cat == KMP_I18N_NULLCAT ? KMP_I18N_ABSENT : KMP_I18N_OPENED );
 
     if ( status == KMP_I18N_ABSENT ) {
       if (__kmp_generate_warnings > kmp_warnings_low) { // AC: only issue warning in case explicitly asked to
-  DWORD error = GetLastError();
-  // Infinite recursion will not occur -- status is KMP_I18N_ABSENT now, so
-  // __kmp_i18n_catgets() will not try to open catalog but will return default message.
+        DWORD error = GetLastError();
+        // Infinite recursion will not occur -- status is KMP_I18N_ABSENT now, so
+        // __kmp_i18n_catgets() will not try to open catalog but will return default message.
         /*
            If message catalog for another architecture found (e.g. OpenMP RTL
-   for IA-32 architecture opens libompui.dll for Intel(R) 64)
-   Windows* OS returns error 193 (ERROR_BAD_EXE_FORMAT). However,
+           for IA-32 architecture opens libompui.dll for Intel(R) 64)
+           Windows* OS returns error 193 (ERROR_BAD_EXE_FORMAT). However,
            FormatMessage fails to return a message for this error, so user
-   will see:
+           will see:
 
           OMP: Warning #2: Cannot open message catalog "1041\libompui.dll":
           OMP: System error #193: (No system error message available)
           OMP: Info #3: Default messages will be used.
 
           Issue a hint in this case to let cause of trouble more understandable.
         */
-  __kmp_msg(
-      kmp_ms_warning,
-      KMP_MSG( CantOpenMessageCatalog, path.str ),
-      KMP_SYSERRCODE( error ),
+        __kmp_msg_t err_msg = KMP_SYSERRCODE(error);
+        __kmp_msg(
+            kmp_ms_warning,
+            KMP_MSG( CantOpenMessageCatalog, path.str ),
+            err_msg,
             ( error == ERROR_BAD_EXE_FORMAT ? KMP_HNT( BadExeFormat, path.str, KMP_ARCH_STR ) : __kmp_msg_null ),
-      __kmp_msg_null
-  );
-  KMP_INFORM( WillUseDefaultMessages );
+            __kmp_msg_null
+            );
+        if (__kmp_generate_warnings == kmp_warnings_off) {
+          __kmp_str_free(&err_code.str);
+        }
+
+        KMP_INFORM( WillUseDefaultMessages );
       }
     } else { // status == KMP_I18N_OPENED
 
         int section = get_section( kmp_i18n_prp_Version );
         int number  = get_number( kmp_i18n_prp_Version );
         char const * expected = __kmp_i18n_default_table.sect[ section ].str[ number ];
         kmp_str_buf_t version;   // Actual version of the catalog.
         __kmp_str_buf_init( & version );
         __kmp_str_buf_print( & version, "%s", ___catgets( kmp_i18n_prp_Version ) );
             // String returned by catgets is invalid after closing the catalog, so copy it.
#else // Non-Windows* OS: Linux* OS or OS X*
                 // not issue warning if strerror_r() returns `int' instead of expected `char *'.
             message = __kmp_str_format( "%s", err_msg );
 
         #else // OS X*, FreeBSD* etc.
 
             // XSI version of strerror_r.
 
             int    size   = 2048;
-            // TODO: Add checking result of malloc().
             char * buffer = (char *) KMP_INTERNAL_MALLOC( size );
             int    rc;
             if (buffer == NULL) {
                 KMP_FATAL(MemoryAllocFailed);
             }
             rc = strerror_r( err, buffer, size );
             if ( rc == -1 ) {
                 rc = errno;            // XSI version sets errno.
             }; // if
             while ( rc == ERANGE ) {   // ERANGE means the buffer is too small.
                 KMP_INTERNAL_FREE( buffer );
                 size *= 2;
                 buffer = (char *) KMP_INTERNAL_MALLOC( size );
                 if (buffer == NULL) {
switch ( severity ) {
         case kmp_ms_fatal : {
             format = kmp_i18n_fmt_Fatal;
         } break;
         default : {
             KMP_DEBUG_ASSERT( 0 );
         };
     }; // switch
     fmsg = __kmp_msg_format( format, message.num, message.str );
-    KMP_INTERNAL_FREE( (void *) message.str );
+    __kmp_str_free(&message.str);
     __kmp_str_buf_cat( & buffer, fmsg.str, fmsg.len );
-    KMP_INTERNAL_FREE( (void *) fmsg.str );
+    __kmp_str_free(&fmsg.str);
 
     // Format other messages.
     va_start( args, message );
     for ( ; ; ) {
         message = va_arg( args, kmp_msg_t );
         if ( message.type == kmp_mt_dummy && message.str == NULL ) {
             break;
         }; // if
         if ( message.type == kmp_mt_dummy && message.str == __kmp_msg_empty.str ) {
             continue;
         }; // if
         switch ( message.type ) {
             case kmp_mt_hint : {
                 format = kmp_i18n_fmt_Hint;
             } break;
             case kmp_mt_syserr : {
                 format = kmp_i18n_fmt_SysErr;
             } break;
             default : {
                 KMP_DEBUG_ASSERT( 0 );
             };
         }; // switch
         fmsg = __kmp_msg_format( format, message.num, message.str );
-        KMP_INTERNAL_FREE( (void *) message.str );
+        __kmp_str_free(&message.str);
         __kmp_str_buf_cat( & buffer, fmsg.str, fmsg.len );
-        KMP_INTERNAL_FREE( (void *) fmsg.str );
+        __kmp_str_free(&fmsg.str);
     }; // forever
     va_end( args );
 
     // Print formatted messages.
     // This lock prevents multiple fatal errors on the same problem.
     // __kmp_acquire_bootstrap_lock( & lock );    // GEH - This lock causing tests to hang on OS X*.
     __kmp_printf( "%s", buffer.str );
     __kmp_str_buf_free( & buffer );

runtime/src/kmp_itt.c

 __itt_error_handler(
     __itt_error_code err,
     va_list args
 ) {
 
     switch ( err ) {
         case __itt_error_no_module : {
             char const * library = va_arg( args, char const * );
-            #if KMP_OS_WINDOWS
-                int sys_err = va_arg( args, int );
-                __kmp_msg( kmp_ms_warning, KMP_MSG( IttLoadLibFailed, library ), KMP_SYSERRCODE( sys_err ), __kmp_msg_null );
-            #else
-                char const * sys_err = va_arg( args, char const * );
-                __kmp_msg( kmp_ms_warning, KMP_MSG( IttLoadLibFailed, library ), KMP_SYSERRMESG( sys_err ), __kmp_msg_null );
-            #endif
+            kmp_msg_t err_code = KMP_SYSERRCODE( sys_err );
+            __kmp_msg( kmp_ms_warning, KMP_MSG( IttLoadLibFailed, library ), err_code, __kmp_msg_null );
+            if (__kmp_generate_warnings == kmp_warnings_off) {
+              __kmp_str_free(&err_code.str);
+            }
+            kmp_msg_t err_code = KMP_SYSERRMESG( sys_err );
+            __kmp_msg( kmp_ms_warning, KMP_MSG( IttLoadLibFailed, library ), err_code, __kmp_msg_null );
+            if (__kmp_generate_warnings == kmp_warnings_off) {
+              __kmp_str_free(&err_code.str);
+            }
         } break;
         case __itt_error_no_symbol : {
             char const * library = va_arg( args, char const * );
             char const * symbol  = va_arg( args, char const * );
             KMP_WARNING( IttLookupFailed, symbol, library );
         } break;
         case __itt_error_unknown_group : {
             char const * var   = va_arg( args, char const * );
             char const * group = va_arg( args, char const * );
             KMP_WARNING( IttUnknownGroup, var, group );
         } break;
         case __itt_error_env_too_long : {
             char const * var     = va_arg( args, char const * );
             size_t       act_len = va_arg( args, size_t );
             size_t       max_len = va_arg( args, size_t );
             KMP_WARNING( IttEnvVarTooLong, var, (unsigned long) act_len, (unsigned long) max_len );
         } break;
         case __itt_error_cant_read_env : {
             char const * var     = va_arg( args, char const * );
             int          sys_err = va_arg( args, int );
-            __kmp_msg( kmp_ms_warning, KMP_MSG( CantGetEnvVar, var ), KMP_ERR( sys_err ), __kmp_msg_null );
+            kmp_msg_t err_code = KMP_ERR( sys_err );
+            __kmp_msg( kmp_ms_warning, KMP_MSG( CantGetEnvVar, var ), err_code, __kmp_msg_null );
+            if (__kmp_generate_warnings == kmp_warnings_off) {
+              __kmp_str_free(&err_code.str);
+            }
         } break;
         case __itt_error_system : {
             char const * func    = va_arg( args, char const * );
             int          sys_err = va_arg( args, int );
-            __kmp_msg( kmp_ms_warning, KMP_MSG( IttFunctionError, func ), KMP_SYSERRCODE( sys_err ), __kmp_msg_null );
+            kmp_msg_t err_code = KMP_SYSERRCODE( sys_err );
+            __kmp_msg( kmp_ms_warning, KMP_MSG( IttFunctionError, func ), err_code, __kmp_msg_null );
+            if (__kmp_generate_warnings == kmp_warnings_off) {
+              __kmp_str_free(&err_code.str);
+            }
         } break;
         default : {
             KMP_WARNING( IttUnknownError, err );
         };
     }; // switch
 
 } // __itt_error_handler
 
 #endif /* USE_ITT_BUILD */

runtime/src/kmp_settings.c

 
 #if KMP_AFFINITY_SUPPORTED
 static void
 __kmp_stg_parse_str(
     char const *      name,
     char const *      value,
     char const * *    out
 ) {
-    KMP_INTERNAL_FREE( (void *) * out );
+    __kmp_str_free(out);
     * out = __kmp_str_format( "%s", value );
 } // __kmp_stg_parse_str
 #endif
 
 static void
 __kmp_stg_parse_int(
     char const * name,   // I: Name of environment variable (used in warning messages).
     char const * value,  // I: Value of environment variable to parse.
__kmp_stg_parse_file(
     char const * name,
     char const * value,
     char *       suffix,
     char * *     out
 ) {
     char buffer[256];
     char *t;
     int hasSuffix;
-    KMP_INTERNAL_FREE( (void *) * out );
+    __kmp_str_free(out);
     t = (char *) strrchr(value, '.');
     hasSuffix = t && __kmp_str_eqf( t, suffix );
     t = __kmp_str_format( "%s%s", value, hasSuffix ? "" : suffix );
     __kmp_expand_file_name( buffer, sizeof(buffer), t);
-    KMP_INTERNAL_FREE(t);
+    __kmp_str_free(&t);
     * out = __kmp_str_format( "%s", buffer );
 } // __kmp_stg_parse_file
 #endif
 
 #ifdef KMP_DEBUG
 static char * par_range_to_print = NULL;
 
 static void
# endif /* KMP_GROUP AFFINITY */
     #undef EMIT_WARN
     #undef _set_param
     #undef set_type
     #undef set_verbose
     #undef set_warnings
     #undef set_respect
     #undef set_granularity
 
-    KMP_INTERNAL_FREE( buffer );
+    __kmp_str_free((const char **) &buffer);
 
     if ( proclist ) {
         if ( ! type ) {
             KMP_WARNING( AffProcListNoType, name );
             __kmp_affinity_type = affinity_explicit;
         }
         else if ( __kmp_affinity_type != affinity_explicit ) {
             KMP_WARNING( AffProcListNotExplicit, name );

runtime/src/kmp_str.c

 } // kmp_str_loc_init
 
 
 void
 __kmp_str_loc_free(
     kmp_str_loc_t * loc
 ) {
     __kmp_str_fname_free( & loc->fname );
-    KMP_INTERNAL_FREE( loc->_bulk );
-    loc->_bulk = NULL;
+    __kmp_str_free((const char **) &(loc->_bulk));
     loc->file  = NULL;
     loc->func  = NULL;
 } // kmp_str_loc_free
 
 
 
 /*
     This function is intended to compare file names. On Windows* OS file names are case-insensitive,
Why does this function use malloc()?
            reasons in using __kmp_allocate() for strings due to extra overhead while cache-aligned
            memory is not necessary.
         2. __kmp_thread_malloc() cannot be used because it requires pointer to thread structure.
            We need to perform string operations during library startup (for example, in
            __kmp_register_library_startup()) when no thread structures are allocated yet.
     So standard malloc() is the only available option.
 */
 
-// TODO: Find and replace all regular free() with __kmp_str_free().
-
 char *
 __kmp_str_format(           // Allocated string.
     char const * format,    // Format string.
     ...                     // Other parameters.
 ) {
 
     va_list args;
     int     size   = 512;

runtime/src/z_Linux_util.c

if (gCode < 0) {
         //
         // System call not supported
         //
         if (__kmp_affinity_verbose || (__kmp_affinity_warnings
           && (__kmp_affinity_type != affinity_none)
           && (__kmp_affinity_type != affinity_default)
           && (__kmp_affinity_type != affinity_disabled))) {
             int error = errno;
+            kmp_msg_t err_code = KMP_ERR( error );
             __kmp_msg(
                     kmp_ms_warning,
                     KMP_MSG( GetAffSysCallNotSupported, env_var ),
-                KMP_ERR( error ),
+                    err_code,
                     __kmp_msg_null
                     );
+            if (__kmp_generate_warnings == kmp_warnings_off) {
+                __kmp_str_free(&err_code.str);
+            }
         }
         KMP_AFFINITY_DISABLE();
         KMP_INTERNAL_FREE(buf);
         return;
     }
     if (gCode > 0) { // Linux* OS only
         // The optimal situation: the OS returns the size of the buffer
         // it expects.
         //
         // A verification of correct behavior is that Isetaffinity on a NULL
         // buffer with the same size fails with errno set to EFAULT.
         sCode = syscall( __NR_sched_setaffinity, 0, gCode, NULL );
         KA_TRACE(30, ( "__kmp_affinity_determine_capable: "
            "setaffinity for mask size %d returned %d errno = %d\n",
            gCode, sCode, errno));
         if (sCode < 0) {
             if (errno == ENOSYS) {
                 if (__kmp_affinity_verbose || (__kmp_affinity_warnings
                   && (__kmp_affinity_type != affinity_none)
                   && (__kmp_affinity_type != affinity_default)
                   && (__kmp_affinity_type != affinity_disabled))) {
                     int error = errno;
+                    kmp_msg_t err_code = KMP_ERR( error );
                     __kmp_msg(
                             kmp_ms_warning,
                             KMP_MSG( SetAffSysCallNotSupported, env_var ),
-                        KMP_ERR( error ),
+                            err_code,
                             __kmp_msg_null
                             );
+                    if (__kmp_generate_warnings == kmp_warnings_off) {
+                        __kmp_str_free(&err_code.str);
+                    }
                 }
                 KMP_AFFINITY_DISABLE();
                 KMP_INTERNAL_FREE(buf);
             }
             if (errno == EFAULT) {
                 KMP_AFFINITY_ENABLE(gCode);
                 KA_TRACE(10, ( "__kmp_affinity_determine_capable: "
                   "affinity supported (mask size %d)\n",
for (size = 1; size <= KMP_CPU_SET_SIZE_LIMIT; size *= 2) {
                 KA_TRACE(30, ( "__kmp_affinity_determine_capable: "
                   "inconsistent OS call behavior: errno == ENOSYS for mask size %d\n",
                    size));
                 if (__kmp_affinity_verbose || (__kmp_affinity_warnings
                   && (__kmp_affinity_type != affinity_none)
                   && (__kmp_affinity_type != affinity_default)
                   && (__kmp_affinity_type != affinity_disabled))) {
                     int error = errno;
+                    kmp_msg_t err_code = KMP_ERR( error );
                     __kmp_msg(
                             kmp_ms_warning,
                             KMP_MSG( GetAffSysCallNotSupported, env_var ),
-                        KMP_ERR( error ),
+                            err_code,
                             __kmp_msg_null
                             );
+                    if (__kmp_generate_warnings == kmp_warnings_off) {
+                        __kmp_str_free(&err_code.str);
+                    }
                 }
                 KMP_AFFINITY_DISABLE();
                 KMP_INTERNAL_FREE(buf);
                 return;
             }
             continue;
         }
 
for (size = 1; size <= KMP_CPU_SET_SIZE_LIMIT; size *= 2) {
                 KA_TRACE(30, ( "__kmp_affinity_determine_capable: "
                   "inconsistent OS call behavior: errno == ENOSYS for mask size %d\n",
                    size));
                 if (__kmp_affinity_verbose || (__kmp_affinity_warnings
                   && (__kmp_affinity_type != affinity_none)
                   && (__kmp_affinity_type != affinity_default)
                   && (__kmp_affinity_type != affinity_disabled))) {
                     int error = errno;
+                    kmp_msg_t err_code = KMP_ERR( error );
                     __kmp_msg(
                             kmp_ms_warning,
                             KMP_MSG( SetAffSysCallNotSupported, env_var ),
-                        KMP_ERR( error ),
+                            err_code,
                             __kmp_msg_null
                             );
+                    if (__kmp_generate_warnings == kmp_warnings_off) {
+                        __kmp_str_free(&err_code.str);
+                    }
                 }
                 KMP_AFFINITY_DISABLE();
                 KMP_INTERNAL_FREE(buf);
                 return;
             }
             if (errno == EFAULT) {
                 KMP_AFFINITY_ENABLE(gCode);
                 KA_TRACE(10, ( "__kmp_affinity_determine_capable: "
// However, decision about the fix is not made yet, so it is disabled by default.
             int    rc;
             KMP_WARNING( RealTimeSchedNotSupported );
             sched_getparam( 0, & param );
             if ( param.sched_priority < max_priority ) {
                 param.sched_priority += 1;
                 rc = sched_setscheduler( 0, sched, & param );
                 if ( rc != 0 ) {
                     int error = errno;
+                    kmp_msg_t err_code = KMP_ERR( error );
                     __kmp_msg(
                             kmp_ms_warning,
                             KMP_MSG( CantChangeMonitorPriority ),
-                      KMP_ERR( error ),
+                            err_code,
                             KMP_MSG( MonitorWillStarve ),
                             __kmp_msg_null
                             );
+                    if (__kmp_generate_warnings == kmp_warnings_off) {
+                        __kmp_str_free(&err_code.str);
+                    }
                 }; // if
             } else {
                 // We cannot abort here, because number of CPUs may be enough for all the threads,
                 // including the monitor thread, so application could potentially work...
                 __kmp_msg(
                     kmp_ms_warning,
                     KMP_MSG( RunningAtMaxPriority ),
                     KMP_MSG( MonitorWillStarve ),
#endif /* _POSIX_THREAD_ATTR_STACKSIZE */
         KMP_SYSFAIL( "pthread_create", status );
     }; // if
 
     th->th.th_info.ds.ds_thread = handle;
 
 #ifdef KMP_THREAD_ATTR
     status = pthread_attr_destroy( & thread_attr );
     if ( status ) {
-        __kmp_msg(kmp_ms_warning, KMP_MSG( CantDestroyThreadAttrs ), KMP_ERR( status ), __kmp_msg_null);
+        kmp_msg_t err_code = KMP_ERR( status );
+        __kmp_msg(kmp_ms_warning, KMP_MSG( CantDestroyThreadAttrs ), err_code, __kmp_msg_null);
+        if (__kmp_generate_warnings == kmp_warnings_off) {
+            __kmp_str_free(&err_code.str);
+        }
     }; // if
 #endif /* KMP_THREAD_ATTR */
 
     KMP_MB();       /* Flush all pending memory write invalidates.  */
 
     KA_TRACE( 10, ("__kmp_create_worker: done creating thread (%d)\n", gtid ) );
 
 } // __kmp_create_worker
#ifdef _POSIX_THREAD_ATTR_STACKSIZE
         KA_TRACE( 10, ( "__kmp_create_monitor: setting stacksize = %lu bytes,",
                         __kmp_monitor_stksize ) );
         status = pthread_attr_setstacksize( & thread_attr, __kmp_monitor_stksize );
         if ( status != 0 ) {
             if ( auto_adj_size ) {
                 __kmp_monitor_stksize *= 2;
                 goto retry;
             }
+            kmp_msg_t err_code = KMP_ERR( status );
             __kmp_msg(
                     kmp_ms_warning,  // should this be fatal?  BB
                     KMP_MSG( CantSetMonitorStackSize, (long int) __kmp_monitor_stksize ),
-                KMP_ERR( status ),
+                    err_code,
                     KMP_HNT( ChangeMonitorStackSize ),
                     __kmp_msg_null
                     );
+            if (__kmp_generate_warnings == kmp_warnings_off) {
+                __kmp_str_free(&err_code.str);
+            }
         }; // if
     #endif /* _POSIX_THREAD_ATTR_STACKSIZE */
 
     status = pthread_create( &handle, & thread_attr, __kmp_launch_monitor, (void *) th );
 
     if ( status != 0 ) {
         #ifdef _POSIX_THREAD_ATTR_STACKSIZE
             if ( status == EINVAL ) {
#if KMP_REAL_TIME_FIX
         __kmp_wait_yield_4(
             (kmp_uint32 volatile *) & __kmp_global.g.g_time.dt.t_value, -1, & __kmp_neq_4, NULL
         );
     #endif // KMP_REAL_TIME_FIX
 
     #ifdef KMP_THREAD_ATTR
         status = pthread_attr_destroy( & thread_attr );
         if ( status != 0 ) {
-            __kmp_msg(    //
+            kmp_msg_t err_code = KMP_ERR( status );
+            __kmp_msg( 
                     kmp_ms_warning,
                     KMP_MSG( CantDestroyThreadAttrs ),
-                KMP_ERR( status ),
+                    err_code,
                     __kmp_msg_null
                     );
+            if (__kmp_generate_warnings == kmp_warnings_off) {
+                __kmp_str_free(&err_code.str);
+            }
         }; // if
     #endif
 
     KMP_MB();       /* Flush all pending memory write invalidates.  */
 
     KA_TRACE( 10, ( "__kmp_create_monitor: monitor created %#.8lx\n", th->th.th_info.ds.ds_thread ) );
 
 } // __kmp_create_monitor

runtime/src/z_Windows_NT_util.c

if (__kmp_num_proc_groups > 1) {
         ga.Group = proc / (CHAR_BIT * sizeof(DWORD_PTR));
         ga.Mask = (unsigned long long)1 << (proc % (CHAR_BIT * sizeof(DWORD_PTR)));
         ga.Reserved[0] = ga.Reserved[1] = ga.Reserved[2] = 0;
 
         KMP_DEBUG_ASSERT(__kmp_SetThreadGroupAffinity != NULL);
         if (__kmp_SetThreadGroupAffinity(GetCurrentThread(), &ga, NULL) == 0) {
             DWORD error = GetLastError();
             if (__kmp_affinity_verbose) { // AC: continue silently if not verbose
+                kmp_msg_t err_code = KMP_ERR( error );
                 __kmp_msg(
                         kmp_ms_warning,
                         KMP_MSG( CantSetThreadAffMask ),
-                    KMP_ERR( error ),
+                        err_code,
                         __kmp_msg_null
                         );
+                if (__kmp_generate_warnings == kmp_warnings_off) {
+                    __kmp_str_free(&err_code.str);
+                }
             }
         }
     } else {
         kmp_affin_mask_t *mask;
         KMP_CPU_ALLOC_ON_STACK(mask);
         KMP_CPU_ZERO(mask);
         KMP_CPU_SET(proc, mask);
         __kmp_set_system_affinity(mask, TRUE);