LLVM OpenMP* Runtime Library
kmp_environment.c
1 /*
2  * kmp_environment.c -- Handle environment variables OS-independently.
3  */
4 
5 
6 //===----------------------------------------------------------------------===//
7 //
8 // The LLVM Compiler Infrastructure
9 //
10 // This file is dual licensed under the MIT and the University of Illinois Open
11 // Source Licenses. See LICENSE.txt for details.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 
16 /*
17  ------------------------------------------------------------------------------------------------
18  We use GetEnvironmentVariable for Windows* OS instead of getenv because the act of
19  loading a DLL on Windows* OS makes any user-set environment variables (i.e. with putenv())
20  unavailable. getenv() apparently gets a clean copy of the env variables as they existed
21  at the start of the run.
22  JH 12/23/2002
23  ------------------------------------------------------------------------------------------------
24  On Windows* OS, there are two environments (at least, see below):
25 
26  1. Environment maintained by Windows* OS on IA-32 architecture.
27  Accessible through GetEnvironmentVariable(),
28  SetEnvironmentVariable(), and GetEnvironmentStrings().
29 
30  2. Environment maintained by C RTL. Accessible through getenv(), putenv().
31 
32  putenv() function updates both C and Windows* OS on IA-32 architecture. getenv() function
33  search for variables in C RTL environment only. Windows* OS on IA-32 architecture functions work *only*
34  with Windows* OS on IA-32 architecture.
35 
36  Windows* OS on IA-32 architecture maintained by OS, so there is always only one Windows* OS on
37  IA-32 architecture per process. Changes in Windows* OS on IA-32 architecture are process-visible.
38 
39  C environment maintained by C RTL. Multiple copies of C RTL may be present in the process, and
40  each C RTL maintains its own environment. :-(
41 
42  Thus, proper way to work with environment on Windows* OS is:
43 
44  1. Set variables with putenv() function -- both C and Windows* OS on
45  IA-32 architecture are being updated. Windows* OS on
46  IA-32 architecture may be considered as primary target,
47  while updating C RTL environment is a free bonus.
48 
49  2. Get variables with GetEnvironmentVariable() -- getenv() does not
50  search Windows* OS on IA-32 architecture, and can not see variables
51  set with SetEnvironmentVariable().
52 
53  2007-04-05 -- lev
54  ------------------------------------------------------------------------------------------------
55 */
56 
57 #include "kmp_environment.h"
58 
59 #include "kmp_os.h" // KMP_OS_*.
60 #include "kmp.h" //
61 #include "kmp_str.h" // __kmp_str_*().
62 #include "kmp_i18n.h"
63 
64 #if KMP_OS_UNIX
65  #include <stdlib.h> // getenv, setenv, unsetenv.
66  #include <string.h> // strlen, strcpy.
67  #if KMP_OS_LINUX || KMP_OS_FREEBSD
68  extern char * * environ;
69  #elif KMP_OS_DARWIN
70  #include <crt_externs.h>
71  #define environ (*_NSGetEnviron())
72  #else
73  #error Unknown or unsupported OS.
74  #endif
75 #elif KMP_OS_WINDOWS
76  #include <windows.h> // GetEnvironmentVariable, SetEnvironmentVariable, GetLastError.
77 #else
78  #error Unknown or unsupported OS.
79 #endif
80 
81 
82 // TODO: Eliminate direct memory allocations, use string operations instead.
83 
84 static inline
85 void *
86 allocate(
87  size_t size
88 ) {
89  void * ptr = KMP_INTERNAL_MALLOC( size );
90  if ( ptr == NULL ) {
91  KMP_FATAL( MemoryAllocFailed );
92  }; // if
93  return ptr;
94 } // allocate
95 
96 
97 char *
98 __kmp_env_get( char const * name ) {
99 
100  char * result = NULL;
101 
102  #if KMP_OS_UNIX
103  char const * value = getenv( name );
104  if ( value != NULL ) {
105  size_t len = KMP_STRLEN( value ) + 1;
106  result = (char *) KMP_INTERNAL_MALLOC( len );
107  if ( result == NULL ) {
108  KMP_FATAL( MemoryAllocFailed );
109  }; // if
110  KMP_STRNCPY_S( result, len, value, len );
111  }; // if
112  #elif KMP_OS_WINDOWS
113  /*
114  We use GetEnvironmentVariable for Windows* OS instead of getenv because the act of
115  loading a DLL on Windows* OS makes any user-set environment variables (i.e. with putenv())
116  unavailable. getenv() apparently gets a clean copy of the env variables as they existed
117  at the start of the run.
118  JH 12/23/2002
119  */
120  DWORD rc;
121  rc = GetEnvironmentVariable( name, NULL, 0 );
122  if ( ! rc ) {
123  DWORD error = GetLastError();
124  if ( error != ERROR_ENVVAR_NOT_FOUND ) {
125  __kmp_msg(
126  kmp_ms_fatal,
127  KMP_MSG( CantGetEnvVar, name ),
128  KMP_ERR( error ),
129  __kmp_msg_null
130  );
131  }; // if
132  // Variable is not found, it's ok, just continue.
133  } else {
134  DWORD len = rc;
135  result = (char *) KMP_INTERNAL_MALLOC( len );
136  if ( result == NULL ) {
137  KMP_FATAL( MemoryAllocFailed );
138  }; // if
139  rc = GetEnvironmentVariable( name, result, len );
140  if ( ! rc ) {
141  // GetEnvironmentVariable() may return 0 if variable is empty.
142  // In such a case GetLastError() returns ERROR_SUCCESS.
143  DWORD error = GetLastError();
144  if ( error != ERROR_SUCCESS ) {
145  // Unexpected error. The variable should be in the environment,
146  // and buffer should be large enough.
147  __kmp_msg(
148  kmp_ms_fatal,
149  KMP_MSG( CantGetEnvVar, name ),
150  KMP_ERR( error ),
151  __kmp_msg_null
152  );
153  KMP_INTERNAL_FREE( (void *) result );
154  result = NULL;
155  }; // if
156  }; // if
157  }; // if
158  #else
159  #error Unknown or unsupported OS.
160  #endif
161 
162  return result;
163 
164 } // func __kmp_env_get
165 
166 
167 // TODO: Find and replace all regular free() with __kmp_env_free().
168 
169 void
170 __kmp_env_free( char const * * value ) {
171 
172  KMP_DEBUG_ASSERT( value != NULL );
173  KMP_INTERNAL_FREE( (void *) * value );
174  * value = NULL;
175 
176 } // func __kmp_env_free
177 
178 
179 
180 int
181 __kmp_env_exists( char const * name ) {
182 
183  #if KMP_OS_UNIX
184  char const * value = getenv( name );
185  return ( ( value == NULL ) ? ( 0 ) : ( 1 ) );
186  #elif KMP_OS_WINDOWS
187  DWORD rc;
188  rc = GetEnvironmentVariable( name, NULL, 0 );
189  if ( rc == 0 ) {
190  DWORD error = GetLastError();
191  if ( error != ERROR_ENVVAR_NOT_FOUND ) {
192  __kmp_msg(
193  kmp_ms_fatal,
194  KMP_MSG( CantGetEnvVar, name ),
195  KMP_ERR( error ),
196  __kmp_msg_null
197  );
198  }; // if
199  return 0;
200  }; // if
201  return 1;
202  #else
203  #error Unknown or unsupported OS.
204  #endif
205 
206 } // func __kmp_env_exists
207 
208 
209 
210 void
211 __kmp_env_set( char const * name, char const * value, int overwrite ) {
212 
213  #if KMP_OS_UNIX
214  int rc = setenv( name, value, overwrite );
215  if ( rc != 0 ) {
216  // Dead code. I tried to put too many variables into Linux* OS
217  // environment on IA-32 architecture. When application consumes
218  // more than ~2.5 GB of memory, entire system feels bad. Sometimes
219  // application is killed (by OS?), sometimes system stops
220  // responding... But this error message never appears. --ln
221  __kmp_msg(
222  kmp_ms_fatal,
223  KMP_MSG( CantSetEnvVar, name ),
224  KMP_HNT( NotEnoughMemory ),
225  __kmp_msg_null
226  );
227  }; // if
228  #elif KMP_OS_WINDOWS
229  BOOL rc;
230  if ( ! overwrite ) {
231  rc = GetEnvironmentVariable( name, NULL, 0 );
232  if ( rc ) {
233  // Variable exists, do not overwrite.
234  return;
235  }; // if
236  DWORD error = GetLastError();
237  if ( error != ERROR_ENVVAR_NOT_FOUND ) {
238  __kmp_msg(
239  kmp_ms_fatal,
240  KMP_MSG( CantGetEnvVar, name ),
241  KMP_ERR( error ),
242  __kmp_msg_null
243  );
244  }; // if
245  }; // if
246  rc = SetEnvironmentVariable( name, value );
247  if ( ! rc ) {
248  DWORD error = GetLastError();
249  __kmp_msg(
250  kmp_ms_fatal,
251  KMP_MSG( CantSetEnvVar, name ),
252  KMP_ERR( error ),
253  __kmp_msg_null
254  );
255  }; // if
256  #else
257  #error Unknown or unsupported OS.
258  #endif
259 
260 } // func __kmp_env_set
261 
262 
263 
264 void
265 __kmp_env_unset( char const * name ) {
266 
267  #if KMP_OS_UNIX
268  unsetenv( name );
269  #elif KMP_OS_WINDOWS
270  BOOL rc = SetEnvironmentVariable( name, NULL );
271  if ( ! rc ) {
272  DWORD error = GetLastError();
273  __kmp_msg(
274  kmp_ms_fatal,
275  KMP_MSG( CantSetEnvVar, name ),
276  KMP_ERR( error ),
277  __kmp_msg_null
278  );
279  }; // if
280  #else
281  #error Unknown or unsupported OS.
282  #endif
283 
284 } // func __kmp_env_unset
285 
286 // -------------------------------------------------------------------------------------------------
287 
288 /*
289  Intel OpenMP RTL string representation of environment: just a string of characters, variables
290  are separated with vertical bars, e. g.:
291 
292  "KMP_WARNINGS=0|KMP_AFFINITY=compact|"
293 
294  Empty variables are allowed and ignored:
295 
296  "||KMP_WARNINGS=1||"
297 
298 */
299 
300 static
301 void
302 ___kmp_env_blk_parse_string(
303  kmp_env_blk_t * block, // M: Env block to fill.
304  char const * env // I: String to parse.
305 ) {
306 
307  char const chr_delimiter = '|';
308  char const str_delimiter[] = { chr_delimiter, 0 };
309 
310  char * bulk = NULL;
311  kmp_env_var_t * vars = NULL;
312  int count = 0; // Number of used elements in vars array.
313  int delimiters = 0; // Number of delimiters in input string.
314 
315  // Copy original string, we will modify the copy.
316  bulk = __kmp_str_format( "%s", env );
317 
318  // Loop thru all the vars in environment block. Count delimiters (maximum number of variables
319  // is number of delimiters plus one).
320  {
321  char const * ptr = bulk;
322  for ( ; ; ) {
323  ptr = strchr( ptr, chr_delimiter );
324  if ( ptr == NULL ) {
325  break;
326  }; // if
327  ++ delimiters;
328  ptr += 1;
329  }; // forever
330  }
331 
332  // Allocate vars array.
333  vars = (kmp_env_var_t *) allocate( ( delimiters + 1 ) * sizeof( kmp_env_var_t ) );
334 
335  // Loop thru all the variables.
336  {
337  char * var; // Pointer to variable (both name and value).
338  char * name; // Pointer to name of variable.
339  char * value; // Pointer to value.
340  char * buf; // Buffer for __kmp_str_token() function.
341  var = __kmp_str_token( bulk, str_delimiter, & buf ); // Get the first var.
342  while ( var != NULL ) {
343  // Save found variable in vars array.
344  __kmp_str_split( var, '=', & name, & value );
345  KMP_DEBUG_ASSERT( count < delimiters + 1 );
346  vars[ count ].name = name;
347  vars[ count ].value = value;
348  ++ count;
349  // Get the next var.
350  var = __kmp_str_token( NULL, str_delimiter, & buf );
351  }; // while
352  }
353 
354  // Fill out result.
355  block->bulk = bulk;
356  block->vars = vars;
357  block->count = count;
358 
359 }; // ___kmp_env_blk_parse_string
360 
361 
362 
363 /*
364  Windows* OS (actually, DOS) environment block is a piece of memory with environment variables. Each
365  variable is terminated with zero byte, entire block is terminated with one extra zero byte, so
366  we have two zero bytes at the end of environment block, e. g.:
367 
368  "HOME=C:\\users\\lev\x00OS=Windows_NT\x00\x00"
369 
370  It is not clear how empty environment is represented. "\x00\x00"?
371 */
372 
373 #if KMP_OS_WINDOWS
374 static
375 void
376 ___kmp_env_blk_parse_windows(
377  kmp_env_blk_t * block, // M: Env block to fill.
378  char const * env // I: Pointer to Windows* OS (DOS) environment block.
379 ) {
380 
381  char * bulk = NULL;
382  kmp_env_var_t * vars = NULL;
383  int count = 0; // Number of used elements in vars array.
384  int size = 0; // Size of bulk.
385 
386  char * name; // Pointer to name of variable.
387  char * value; // Pointer to value.
388 
389  if ( env != NULL ) {
390 
391  // Loop thru all the vars in environment block. Count variables, find size of block.
392  {
393  char const * var; // Pointer to beginning of var.
394  int len; // Length of variable.
395  count = 0;
396  var = env; // The first variable starts and beginning of environment block.
397  len = KMP_STRLEN( var );
398  while ( len != 0 ) {
399  ++ count;
400  size = size + len + 1;
401  var = var + len + 1; // Move pointer to the beginning of the next variable.
402  len = KMP_STRLEN( var );
403  }; // while
404  size = size + 1; // Total size of env block, including terminating zero byte.
405  }
406 
407  // Copy original block to bulk, we will modify bulk, not original block.
408  bulk = (char *) allocate( size );
409  KMP_MEMCPY_S( bulk, size, env, size );
410  // Allocate vars array.
411  vars = (kmp_env_var_t *) allocate( count * sizeof( kmp_env_var_t ) );
412 
413  // Loop thru all the vars, now in bulk.
414  {
415  char * var; // Pointer to beginning of var.
416  int len; // Length of variable.
417  count = 0;
418  var = bulk;
419  len = KMP_STRLEN( var );
420  while ( len != 0 ) {
421  // Save variable in vars array.
422  __kmp_str_split( var, '=', & name, & value );
423  vars[ count ].name = name;
424  vars[ count ].value = value;
425  ++ count;
426  // Get the next var.
427  var = var + len + 1;
428  len = KMP_STRLEN( var );
429  }; // while
430  }
431 
432  }; // if
433 
434  // Fill out result.
435  block->bulk = bulk;
436  block->vars = vars;
437  block->count = count;
438 
439 }; // ___kmp_env_blk_parse_windows
440 #endif
441 
442 
443 /*
444  Unix environment block is a array of pointers to variables, last pointer in array is NULL:
445 
446  { "HOME=/home/lev", "TERM=xterm", NULL }
447 */
448 
449 static
450 void
451 ___kmp_env_blk_parse_unix(
452  kmp_env_blk_t * block, // M: Env block to fill.
453  char * * env // I: Unix environment to parse.
454 ) {
455 
456  char * bulk = NULL;
457  kmp_env_var_t * vars = NULL;
458  int count = 0;
459  int size = 0; // Size of bulk.
460 
461  // Count number of variables and length of required bulk.
462  {
463  count = 0;
464  size = 0;
465  while ( env[ count ] != NULL ) {
466  size += KMP_STRLEN( env[ count ] ) + 1;
467  ++ count;
468  }; // while
469  }
470 
471  // Allocate memory.
472  bulk = (char *) allocate( size );
473  vars = (kmp_env_var_t *) allocate( count * sizeof( kmp_env_var_t ) );
474 
475  // Loop thru all the vars.
476  {
477  char * var; // Pointer to beginning of var.
478  char * name; // Pointer to name of variable.
479  char * value; // Pointer to value.
480  int len; // Length of variable.
481  int i;
482  var = bulk;
483  for ( i = 0; i < count; ++ i ) {
484  // Copy variable to bulk.
485  len = KMP_STRLEN( env[ i ] );
486  KMP_MEMCPY_S( var, size, env[ i ], len + 1 );
487  // Save found variable in vars array.
488  __kmp_str_split( var, '=', & name, & value );
489  vars[ i ].name = name;
490  vars[ i ].value = value;
491  // Move pointer.
492  var += len + 1;
493  }; // for
494  }
495 
496  // Fill out result.
497  block->bulk = bulk;
498  block->vars = vars;
499  block->count = count;
500 
501 }; // ___kmp_env_blk_parse_unix
502 
503 
504 
505 void
506 __kmp_env_blk_init(
507  kmp_env_blk_t * block, // M: Block to initialize.
508  char const * bulk // I: Initialization string, or NULL.
509 ) {
510 
511  if ( bulk != NULL ) {
512  ___kmp_env_blk_parse_string( block, bulk );
513  } else {
514  #if KMP_OS_UNIX
515  ___kmp_env_blk_parse_unix( block, environ );
516  #elif KMP_OS_WINDOWS
517  {
518  char * mem = GetEnvironmentStrings();
519  if ( mem == NULL ) {
520  DWORD error = GetLastError();
521  __kmp_msg(
522  kmp_ms_fatal,
523  KMP_MSG( CantGetEnvironment ),
524  KMP_ERR( error ),
525  __kmp_msg_null
526  );
527  }; // if
528  ___kmp_env_blk_parse_windows( block, mem );
529  FreeEnvironmentStrings( mem );
530  }
531  #else
532  #error Unknown or unsupported OS.
533  #endif
534  }; // if
535 
536 } // __kmp_env_blk_init
537 
538 
539 
540 static
541 int
542 ___kmp_env_var_cmp( // Comparison function for qsort().
543  kmp_env_var_t const * lhs,
544  kmp_env_var_t const * rhs
545 ) {
546  return strcmp( lhs->name, rhs->name );
547 }
548 
549 void
550 __kmp_env_blk_sort(
551  kmp_env_blk_t * block // M: Block of environment variables to sort.
552 ) {
553 
554  qsort(
555  (void *) block->vars,
556  block->count,
557  sizeof( kmp_env_var_t ),
558  ( int ( * )( void const *, void const * ) ) & ___kmp_env_var_cmp
559  );
560 
561 } // __kmp_env_block_sort
562 
563 
564 
565 void
566 __kmp_env_blk_free(
567  kmp_env_blk_t * block // M: Block of environment variables to free.
568 ) {
569 
570  KMP_INTERNAL_FREE( (void *) block->vars );
571  KMP_INTERNAL_FREE( (void *) block->bulk );
572 
573  block->count = 0;
574  block->vars = NULL;
575  block->bulk = NULL;
576 
577 } // __kmp_env_blk_free
578 
579 
580 
581 char const * // R: Value of variable or NULL if variable does not exist.
582 __kmp_env_blk_var(
583  kmp_env_blk_t * block, // I: Block of environment variables.
584  char const * name // I: Name of variable to find.
585 ) {
586 
587  int i;
588  for ( i = 0; i < block->count; ++ i ) {
589  if ( strcmp( block->vars[ i ].name, name ) == 0 ) {
590  return block->vars[ i ].value;
591  }; // if
592  }; // for
593  return NULL;
594 
595 } // __kmp_env_block_var
596 
597 
598 // end of file //