|
111
|
1 /*
|
|
|
2 Copyright (c) 2014-2016 Intel Corporation. All Rights Reserved.
|
|
|
3
|
|
|
4 Redistribution and use in source and binary forms, with or without
|
|
|
5 modification, are permitted provided that the following conditions
|
|
|
6 are met:
|
|
|
7
|
|
|
8 * Redistributions of source code must retain the above copyright
|
|
|
9 notice, this list of conditions and the following disclaimer.
|
|
|
10 * Redistributions in binary form must reproduce the above copyright
|
|
|
11 notice, this list of conditions and the following disclaimer in the
|
|
|
12 documentation and/or other materials provided with the distribution.
|
|
|
13 * Neither the name of Intel Corporation nor the names of its
|
|
|
14 contributors may be used to endorse or promote products derived
|
|
|
15 from this software without specific prior written permission.
|
|
|
16
|
|
|
17 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
18 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
19 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
20 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
21 HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
22 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
23 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
24 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
25 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
26 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
27 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
28 */
|
|
|
29
|
|
|
30
|
|
|
31 #include "offload_env.h"
|
|
|
32 #include <string.h>
|
|
|
33 #include <ctype.h>
|
|
|
34 #include "offload_util.h"
|
|
|
35 #include "liboffload_error_codes.h"
|
|
|
36
|
|
|
37 // for environment variables valid on all cards
|
|
|
38 const int MicEnvVar::any_card = -1;
|
|
|
39
|
|
|
40 MicEnvVar::~MicEnvVar()
|
|
|
41 {
|
|
|
42 for (std::list<MicEnvVar::CardEnvVars*>::const_iterator
|
|
|
43 it = card_spec_list.begin();
|
|
|
44 it != card_spec_list.end(); it++) {
|
|
|
45 CardEnvVars *card_data = *it;
|
|
|
46 delete card_data;
|
|
|
47 }
|
|
|
48 }
|
|
|
49
|
|
|
50 MicEnvVar::VarValue::~VarValue()
|
|
|
51 {
|
|
|
52 free(env_var_value);
|
|
|
53 }
|
|
|
54
|
|
|
55 MicEnvVar::CardEnvVars::~CardEnvVars()
|
|
|
56 {
|
|
|
57 for (std::list<MicEnvVar::VarValue*>::const_iterator it = env_vars.begin();
|
|
|
58 it != env_vars.end(); it++) {
|
|
|
59 VarValue *var_value = *it;
|
|
|
60 delete var_value;
|
|
|
61 }
|
|
|
62 }
|
|
|
63
|
|
|
64 // Searching for card in "card_spec_list" list with the same "number"
|
|
|
65
|
|
|
66 MicEnvVar::CardEnvVars* MicEnvVar::get_card(int number)
|
|
|
67 {
|
|
|
68 if (number == any_card) {
|
|
|
69 return &common_vars;
|
|
|
70 }
|
|
|
71 for (std::list<MicEnvVar::CardEnvVars*>::const_iterator
|
|
|
72 it = card_spec_list.begin();
|
|
|
73 it != card_spec_list.end(); it++) {
|
|
|
74 CardEnvVars *card_data = *it;
|
|
|
75 if (card_data->card_number == number) {
|
|
|
76 return card_data;
|
|
|
77 }
|
|
|
78 }
|
|
|
79 return NULL;
|
|
|
80 }
|
|
|
81
|
|
|
82 // Searching for environment variable in "env_var" list with the same name
|
|
|
83
|
|
|
84 MicEnvVar::VarValue* MicEnvVar::CardEnvVars::find_var(
|
|
|
85 char* env_var_name,
|
|
|
86 int env_var_name_length
|
|
|
87 )
|
|
|
88 {
|
|
|
89 for (std::list<MicEnvVar::VarValue*>::const_iterator it = env_vars.begin();
|
|
|
90 it != env_vars.end(); it++) {
|
|
|
91 VarValue *var_value = *it;
|
|
|
92 if (var_value->length == env_var_name_length &&
|
|
|
93 !strncmp(var_value->env_var, env_var_name,
|
|
|
94 env_var_name_length)) {
|
|
|
95 return var_value;
|
|
|
96 }
|
|
|
97 }
|
|
|
98 return NULL;
|
|
|
99 }
|
|
|
100
|
|
|
101 void MicEnvVar::analyze_env_var(char *env_var_string)
|
|
|
102 {
|
|
|
103 char *env_var_name;
|
|
|
104 char *env_var_def;
|
|
|
105 int card_number;
|
|
|
106 int env_var_name_length;
|
|
|
107 MicEnvVarKind env_var_kind;
|
|
|
108
|
|
|
109 env_var_kind = get_env_var_kind(env_var_string,
|
|
|
110 &card_number,
|
|
|
111 &env_var_name,
|
|
|
112 &env_var_name_length,
|
|
|
113 &env_var_def);
|
|
|
114 switch (env_var_kind) {
|
|
|
115 case c_mic_var:
|
|
|
116 case c_mic_card_var:
|
|
|
117 add_env_var(card_number,
|
|
|
118 env_var_name,
|
|
|
119 env_var_name_length,
|
|
|
120 env_var_def);
|
|
|
121 break;
|
|
|
122 case c_mic_card_env:
|
|
|
123 mic_parse_env_var_list(card_number, env_var_def);
|
|
|
124 break;
|
|
|
125 case c_no_mic:
|
|
|
126 default:
|
|
|
127 break;
|
|
|
128 }
|
|
|
129 }
|
|
|
130
|
|
|
131 void MicEnvVar::add_env_var(
|
|
|
132 int card_number,
|
|
|
133 char *env_var_name,
|
|
|
134 int env_var_name_length,
|
|
|
135 char *env_var_def
|
|
|
136 )
|
|
|
137 {
|
|
|
138 VarValue *var;
|
|
|
139 CardEnvVars *card;
|
|
|
140
|
|
|
141 // The case corresponds to common env var definition of kind
|
|
|
142 // <mic-prefix>_<var>
|
|
|
143 if (card_number == any_card) {
|
|
|
144 card = &common_vars;
|
|
|
145 }
|
|
|
146 else {
|
|
|
147 card = get_card(card_number);
|
|
|
148 if (!card) {
|
|
|
149 // definition for new card occurred
|
|
|
150 card = new CardEnvVars(card_number);
|
|
|
151 card_spec_list.push_back(card);
|
|
|
152 }
|
|
|
153
|
|
|
154 }
|
|
|
155 var = card->find_var(env_var_name, env_var_name_length);
|
|
|
156 if (!var) {
|
|
|
157 // put new env var definition in "env_var" list
|
|
|
158 var = new VarValue(env_var_name, env_var_name_length, env_var_def);
|
|
|
159 card->env_vars.push_back(var);
|
|
|
160 }
|
|
|
161 }
|
|
|
162
|
|
|
163 // The routine analyses string pointed by "env_var_string" argument
|
|
|
164 // according to the following syntax:
|
|
|
165 //
|
|
|
166 // Specification of prefix for MIC environment variables
|
|
|
167 // MIC_ENV_PREFIX=<mic-prefix>
|
|
|
168 //
|
|
|
169 // Setting single MIC environment variable
|
|
|
170 // <mic-prefix>_<var>=<value>
|
|
|
171 // <mic-prefix>_<card-number>_<var>=<value>
|
|
|
172
|
|
|
173 // Setting multiple MIC environment variables
|
|
|
174 // <mic-prefix>_<card-number>_ENV=<env-vars>
|
|
|
175
|
|
|
176 MicEnvVarKind MicEnvVar::get_env_var_kind(
|
|
|
177 char *env_var_string,
|
|
|
178 int *card_number,
|
|
|
179 char **env_var_name,
|
|
|
180 int *env_var_name_length,
|
|
|
181 char **env_var_def
|
|
|
182 )
|
|
|
183 {
|
|
|
184 int len = strlen(prefix);
|
|
|
185 char *c = env_var_string;
|
|
|
186 int num = 0;
|
|
|
187 bool card_is_set = false;
|
|
|
188
|
|
|
189 if (strncmp(c, prefix, len) != 0 || c[len] != '_') {
|
|
|
190 return c_no_mic;
|
|
|
191 }
|
|
|
192 c += len + 1;
|
|
|
193
|
|
|
194 *card_number = any_card;
|
|
|
195 if (isdigit(*c)) {
|
|
|
196 while (isdigit (*c)) {
|
|
|
197 num = (*c++ - '0') + (num * 10);
|
|
|
198 }
|
|
|
199 if (*c != '_') {
|
|
|
200 return c_no_mic;
|
|
|
201 }
|
|
|
202 c++;
|
|
|
203 *card_number = num;
|
|
|
204 card_is_set = true;
|
|
|
205 }
|
|
|
206 if (!isalpha(*c)) {
|
|
|
207 return c_no_mic;
|
|
|
208 }
|
|
|
209 *env_var_name = *env_var_def = c;
|
|
|
210 if (strncmp(c, "ENV=", 4) == 0) {
|
|
|
211 if (!card_is_set) {
|
|
|
212 *env_var_name_length = 3;
|
|
|
213 *env_var_name = *env_var_def = c;
|
|
|
214 *env_var_def = strdup(*env_var_def);
|
|
|
215 if (*env_var_def == NULL)
|
|
|
216 LIBOFFLOAD_ERROR(c_malloc);
|
|
|
217 return c_mic_var;
|
|
|
218 }
|
|
|
219 *env_var_def = c + strlen("ENV=");
|
|
|
220 *env_var_def = strdup(*env_var_def);
|
|
|
221 if (*env_var_def == NULL)
|
|
|
222 LIBOFFLOAD_ERROR(c_malloc);
|
|
|
223 return c_mic_card_env;
|
|
|
224 }
|
|
|
225 if (isalpha(*c)) {
|
|
|
226 *env_var_name_length = 0;
|
|
|
227 while (isalnum(*c) || *c == '_') {
|
|
|
228 c++;
|
|
|
229 (*env_var_name_length)++;
|
|
|
230 }
|
|
|
231 }
|
|
|
232 if (*c != '=') {
|
|
|
233 return c_no_mic;
|
|
|
234 }
|
|
|
235 *env_var_def = strdup(*env_var_def);
|
|
|
236 if (*env_var_def == NULL)
|
|
|
237 LIBOFFLOAD_ERROR(c_malloc);
|
|
|
238 return card_is_set? c_mic_card_var : c_mic_var;
|
|
|
239 }
|
|
|
240
|
|
|
241 // analysing <env-vars> in form:
|
|
|
242 // <mic-prefix>_<card-number>_ENV=<env-vars>
|
|
|
243 // where:
|
|
|
244 //
|
|
|
245 // <env-vars>:
|
|
|
246 // <env-var>
|
|
|
247 // <env-vars> | <env-var>
|
|
|
248 //
|
|
|
249 // <env-var>:
|
|
|
250 // variable=value
|
|
|
251 // variable="value"
|
|
|
252 // variable=
|
|
|
253
|
|
|
254 void MicEnvVar::mic_parse_env_var_list(
|
|
|
255 int card_number, char *env_vars_def_list)
|
|
|
256 {
|
|
|
257 char *c = env_vars_def_list;
|
|
|
258 char *env_var_name;
|
|
|
259 int env_var_name_length;
|
|
|
260 char *env_var_def;
|
|
|
261 bool var_is_quoted;
|
|
|
262
|
|
|
263 if (*c == '"') {
|
|
|
264 c++;
|
|
|
265 }
|
|
|
266 while (*c != 0) {
|
|
|
267 var_is_quoted = false;
|
|
|
268 env_var_name = c;
|
|
|
269 env_var_name_length = 0;
|
|
|
270 if (isalpha(*c)) {
|
|
|
271 while (isalnum(*c) || *c == '_') {
|
|
|
272 c++;
|
|
|
273 env_var_name_length++;
|
|
|
274 }
|
|
|
275 }
|
|
|
276 else {
|
|
|
277 LIBOFFLOAD_ERROR(c_mic_parse_env_var_list1);
|
|
|
278 return;
|
|
|
279 }
|
|
|
280 if (*c != '=') {
|
|
|
281 LIBOFFLOAD_ERROR(c_mic_parse_env_var_list2);
|
|
|
282 return;
|
|
|
283 }
|
|
|
284 c++;
|
|
|
285
|
|
|
286 if (*c == '"') {
|
|
|
287 var_is_quoted = true;
|
|
|
288 c++;
|
|
|
289 }
|
|
|
290 // Environment variable values that contain | will need to be escaped.
|
|
|
291 while (*c != 0 && *c != '|' &&
|
|
|
292 (!var_is_quoted || *c != '"'))
|
|
|
293 {
|
|
|
294 // skip escaped symbol
|
|
|
295 if (*c == '\\') {
|
|
|
296 c++;
|
|
|
297 }
|
|
|
298 c++;
|
|
|
299 }
|
|
|
300 if (var_is_quoted) {
|
|
|
301 c++; // for "
|
|
|
302 while (*c != 0 && *c != '|') {
|
|
|
303 c++;
|
|
|
304 }
|
|
|
305 }
|
|
|
306
|
|
|
307 int sz = c - env_var_name;
|
|
|
308 env_var_def = (char*)malloc(sz);
|
|
|
309 if (env_var_def == NULL)
|
|
|
310 LIBOFFLOAD_ERROR(c_malloc);
|
|
|
311 memcpy(env_var_def, env_var_name, sz);
|
|
|
312 env_var_def[sz] = 0;
|
|
|
313
|
|
|
314 if (*c == '|') {
|
|
|
315 c++;
|
|
|
316 while (*c != 0 && *c == ' ') {
|
|
|
317 c++;
|
|
|
318 }
|
|
|
319 }
|
|
|
320 add_env_var(card_number,
|
|
|
321 env_var_name,
|
|
|
322 env_var_name_length,
|
|
|
323 env_var_def);
|
|
|
324 }
|
|
|
325 }
|
|
|
326
|
|
|
327 // Collect all definitions for the card with number "card_num".
|
|
|
328 // The returned result is vector of string pointers defining one
|
|
|
329 // environment variable. The vector is terminated by NULL pointer.
|
|
|
330 // In the beginning of the vector there are env vars defined as
|
|
|
331 // <mic-prefix>_<card-number>_<var>=<value>
|
|
|
332 // or
|
|
|
333 // <mic-prefix>_<card-number>_ENV=<env-vars>
|
|
|
334 // where <card-number> is equal to "card_num"
|
|
|
335 // They are followed by definitions valid for any card
|
|
|
336 // and absent in previous definitions.
|
|
|
337
|
|
|
338 char** MicEnvVar::create_environ_for_card(int card_num)
|
|
|
339 {
|
|
|
340 VarValue *var_value;
|
|
|
341 VarValue *var_value_find;
|
|
|
342 CardEnvVars *card_data = get_card(card_num);
|
|
|
343 CardEnvVars *card_data_common;
|
|
|
344 std::list<char*> new_env;
|
|
|
345 char **rez;
|
|
|
346
|
|
|
347 if (!prefix) {
|
|
|
348 return NULL;
|
|
|
349 }
|
|
|
350 // There is no personel env var definitions for the card with
|
|
|
351 // number "card_num"
|
|
|
352 if (!card_data) {
|
|
|
353 return create_environ_for_card(any_card);
|
|
|
354 }
|
|
|
355
|
|
|
356 for (std::list<MicEnvVar::VarValue*>::const_iterator
|
|
|
357 it = card_data->env_vars.begin();
|
|
|
358 it != card_data->env_vars.end(); it++) {
|
|
|
359 var_value = *it;
|
|
|
360 new_env.push_back(var_value->env_var_value);
|
|
|
361 }
|
|
|
362
|
|
|
363 if (card_num != any_card) {
|
|
|
364 card_data_common = get_card(any_card);
|
|
|
365 for (std::list<MicEnvVar::VarValue*>::const_iterator
|
|
|
366 it = card_data_common->env_vars.begin();
|
|
|
367 it != card_data_common->env_vars.end(); it++) {
|
|
|
368 var_value = *it;
|
|
|
369 var_value_find = card_data->find_var(var_value->env_var,
|
|
|
370 var_value->length);
|
|
|
371 if (!var_value_find) {
|
|
|
372 new_env.push_back(var_value->env_var_value);
|
|
|
373 }
|
|
|
374 }
|
|
|
375 }
|
|
|
376
|
|
|
377 int new_env_size = new_env.size();
|
|
|
378 rez = (char**) malloc((new_env_size + 1) * sizeof(char*));
|
|
|
379 if (rez == NULL)
|
|
|
380 LIBOFFLOAD_ERROR(c_malloc);
|
|
|
381 std::copy(new_env.begin(), new_env.end(), rez);
|
|
|
382 rez[new_env_size] = 0;
|
|
|
383 return rez;
|
|
|
384 }
|
