Print this page
OS-224 add more zonecfg net properties
OS-216 store all net config info on zone
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/zonecfg/zonecfg_lex.l
+++ new/usr/src/cmd/zonecfg/zonecfg_lex.l
1 1 %{
2 2 /*
3 3 * CDDL HEADER START
4 4 *
5 5 * The contents of this file are subject to the terms of the
6 6 * Common Development and Distribution License (the "License").
7 7 * You may not use this file except in compliance with the License.
8 8 *
9 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 10 * or http://www.opensolaris.org/os/licensing.
11 11 * See the License for the specific language governing permissions
12 12 * and limitations under the License.
13 13 *
14 14 * When distributing Covered Code, include this CDDL HEADER in each
15 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 16 * If applicable, add the following below this CDDL HEADER, with the
17 17 * fields enclosed by brackets "[]" replaced with your own identifying
18 18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 19 *
20 20 * CDDL HEADER END
21 21 */
22 22
23 23 /*
24 24 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
25 25 */
26 26
27 27 #include <assert.h>
28 28 #include <string.h>
29 29 #include <libintl.h>
30 30 #include "zonecfg.h"
31 31 #include "zonecfg_grammar.tab.h"
32 32
33 33 /*
34 34 * This constant defines the number of entries added to unclaimed_tokens[]
35 35 * when it runs out of space.
36 36 */
37 37 #define UNCLAIMED_TOKENS_BUFFER_GROWTH 4
38 38
39 39 /*
40 40 * Invariants:
41 41 *
42 42 * unclaimed_tokens == NULL IFF unclaimed_tokens_size == 0
43 43 * unclaimed_tokens_size == 0 IFF num_unclaimed_tokens == 0
44 44 */
45 45 static char **unclaimed_tokens; /* TOKENs produced by Lex (see below) */
46 46 /* but not claimed by YACC reduction */
47 47 /* rules */
48 48 static unsigned int unclaimed_tokens_size; /* size of unclaimed_tokens */
49 49 static unsigned int num_unclaimed_tokens; /* number of unclaimed TOKENs */
|
↓ open down ↓ |
49 lines elided |
↑ open up ↑ |
50 50
51 51 int lex_lineno = 1; /* line number for error reporting */
52 52 static int state = INITIAL;
53 53 extern boolean_t cmd_file_mode;
54 54 extern boolean_t saw_error;
55 55 extern void yyerror(char *s);
56 56
57 57 static char *create_token(char *s);
58 58 %}
59 59
60 -%a 7000
60 +%a 8000
61 61 %p 5000
62 62 %e 2000
63 63 %n 1000
64 +%o 13000
64 65
65 66 %{
66 67 /*
67 68 * The three states below are for tokens, lists and complex property values.
68 69 * Note that simple property values are a subset of tokens.
69 70 */
70 71 %}
71 72 %s TSTATE
72 73 %s LSTATE
73 74 %s CSTATE
74 75 %%
75 76
76 77 <INITIAL>"#"[^\n]* { }
77 78
78 79 <INITIAL>add {
79 80 BEGIN TSTATE;
80 81 state = TSTATE;
81 82 return ADD;
82 83 }
83 84
84 85 <INITIAL>cancel {
85 86 BEGIN TSTATE;
86 87 state = TSTATE;
87 88 return CANCEL;
88 89 }
89 90
90 91 <INITIAL>commit {
91 92 BEGIN TSTATE;
92 93 state = TSTATE;
93 94 return COMMIT;
94 95 }
95 96
96 97 <INITIAL>create {
97 98 BEGIN TSTATE;
98 99 state = TSTATE;
99 100 return CREATE;
100 101 }
101 102
102 103 <INITIAL>delete {
103 104 BEGIN TSTATE;
104 105 state = TSTATE;
105 106 return DELETE;
106 107 }
107 108
108 109 <INITIAL>end {
109 110 BEGIN TSTATE;
110 111 state = TSTATE;
111 112 return END;
112 113 }
113 114
114 115 <INITIAL>exit {
115 116 BEGIN TSTATE;
116 117 state = TSTATE;
117 118 return EXIT;
118 119 }
119 120
120 121 <INITIAL>export {
121 122 BEGIN TSTATE;
122 123 state = TSTATE;
123 124 return EXPORT;
124 125 }
125 126
126 127 <INITIAL>"?"|help {
127 128 BEGIN TSTATE;
128 129 state = TSTATE;
129 130 return HELP;
130 131 }
131 132
132 133 <INITIAL>info {
133 134 BEGIN TSTATE;
134 135 state = TSTATE;
135 136 return INFO;
136 137 }
137 138
138 139 <INITIAL>remove {
139 140 BEGIN TSTATE;
140 141 state = TSTATE;
141 142 return REMOVE;
142 143 }
143 144
144 145 <INITIAL>revert {
145 146 BEGIN TSTATE;
146 147 state = TSTATE;
147 148 return REVERT;
148 149 }
149 150
150 151 <INITIAL>select {
151 152 BEGIN TSTATE;
152 153 state = TSTATE;
153 154 return SELECT;
154 155 }
155 156
156 157 <INITIAL>set {
157 158 BEGIN TSTATE;
158 159 state = TSTATE;
159 160 return SET;
160 161 }
161 162
162 163 <INITIAL>clear {
163 164 BEGIN TSTATE;
164 165 state = TSTATE;
165 166 return CLEAR;
166 167 }
167 168
168 169 <INITIAL>verify {
169 170 BEGIN TSTATE;
170 171 state = TSTATE;
171 172 return VERIFY;
172 173 }
173 174
174 175 <TSTATE>net { return NET; }
175 176
176 177 <TSTATE>fs { return FS; }
177 178
178 179 <TSTATE>device { return DEVICE; }
179 180
180 181 <TSTATE>rctl { return RCTL; }
181 182
182 183 <TSTATE>attr { return ATTR; }
183 184
184 185 <TSTATE>admin { return ADMIN; }
185 186
186 187 <TSTATE>zonename { return ZONENAME; }
187 188 <CSTATE>zonename { return ZONENAME; }
188 189
189 190 <TSTATE>dataset { return DATASET; }
190 191
191 192 <TSTATE>dedicated-cpu { return PSET; }
192 193
193 194 <TSTATE>capped-cpu { return PCAP; }
194 195
195 196 <TSTATE>capped-memory { return MCAP; }
196 197
197 198 <TSTATE>zonepath { return ZONEPATH; }
198 199 <CSTATE>zonepath { return ZONEPATH; }
199 200
200 201 <TSTATE>brand { return BRAND; }
201 202 <CSTATE>brand { return BRAND; }
202 203
203 204 <TSTATE>autoboot { return AUTOBOOT; }
204 205 <CSTATE>autoboot { return AUTOBOOT; }
205 206
206 207 <TSTATE>ip-type { return IPTYPE; }
207 208 <CSTATE>ip-type { return IPTYPE; }
208 209
209 210 <TSTATE>pool { return POOL; }
210 211 <CSTATE>pool { return POOL; }
211 212
212 213 <TSTATE>limitpriv { return LIMITPRIV; }
213 214 <CSTATE>limitpriv { return LIMITPRIV; }
214 215
215 216 <TSTATE>bootargs { return BOOTARGS; }
216 217 <CSTATE>bootargs { return BOOTARGS; }
217 218
218 219 <TSTATE>type { return TYPE; }
219 220 <CSTATE>type { return TYPE; }
220 221
221 222 <TSTATE>value { return VALUE; }
222 223 <CSTATE>value { return VALUE; }
223 224
224 225 <TSTATE>options { return OPTIONS; }
225 226 <CSTATE>options { return OPTIONS; }
226 227
227 228 <TSTATE>allowed-address { return ALLOWED_ADDRESS; }
228 229 <CSTATE>allowed-address { return ALLOWED_ADDRESS; }
|
↓ open down ↓ |
155 lines elided |
↑ open up ↑ |
229 230
230 231 <TSTATE>address { return ADDRESS; }
231 232 <CSTATE>address { return ADDRESS; }
232 233
233 234 <TSTATE>physical { return PHYSICAL; }
234 235 <CSTATE>physical { return PHYSICAL; }
235 236
236 237 <TSTATE>defrouter { return DEFROUTER; }
237 238 <CSTATE>defrouter { return DEFROUTER; }
238 239
240 +<TSTATE>mac-addr { return MAC; }
241 +<CSTATE>mac-addr { return MAC; }
242 +
243 +<TSTATE>vlan-id { return VLANID; }
244 +<CSTATE>vlan-id { return VLANID; }
245 +
246 +<TSTATE>global-nic { return GNIC; }
247 +<CSTATE>global-nic { return GNIC; }
248 +
249 +<TSTATE>property { return NPROP; }
250 +<CSTATE>property { return NPROP; }
251 +
239 252 <TSTATE>dir { return DIR; }
240 253 <CSTATE>dir { return DIR; }
241 254
242 255 <TSTATE>special { return SPECIAL; }
243 256 <CSTATE>special { return SPECIAL; }
244 257
245 258 <TSTATE>raw { return RAW; }
246 259 <CSTATE>raw { return RAW; }
247 260
248 261 <TSTATE>name { return NAME; }
249 262 <CSTATE>name { return NAME; }
250 263
251 264 <TSTATE>match { return MATCH; }
252 265 <CSTATE>match { return MATCH; }
253 266
254 267 <TSTATE>priv { return PRIV; }
255 268 <CSTATE>priv { return PRIV; }
256 269
257 270 <TSTATE>limit { return LIMIT; }
258 271 <CSTATE>limit { return LIMIT; }
259 272
260 273 <TSTATE>action { return ACTION; }
261 274 <CSTATE>action { return ACTION; }
262 275
263 276 <TSTATE>ncpus { return NCPUS; }
264 277 <CSTATE>ncpus { return NCPUS; }
265 278
266 279 <TSTATE>locked { return LOCKED; }
267 280 <CSTATE>locked { return LOCKED; }
268 281
269 282 <TSTATE>swap { return SWAP; }
270 283 <CSTATE>swap { return SWAP; }
271 284
272 285 <TSTATE>importance { return IMPORTANCE; }
273 286 <CSTATE>importance { return IMPORTANCE; }
274 287
275 288 <TSTATE>cpu-shares { return SHARES; }
276 289 <CSTATE>cpu-shares { return SHARES; }
277 290
278 291 <TSTATE>max-lwps { return MAXLWPS; }
279 292 <CSTATE>max-lwps { return MAXLWPS; }
280 293
281 294 <TSTATE>max-processes { return MAXPROCS; }
282 295 <CSTATE>max-processes { return MAXPROCS; }
283 296
284 297 <TSTATE>max-shm-memory { return MAXSHMMEM; }
285 298 <CSTATE>max-shm-memory { return MAXSHMMEM; }
286 299
287 300 <TSTATE>max-shm-ids { return MAXSHMIDS; }
288 301 <CSTATE>max-shm-ids { return MAXSHMIDS; }
289 302
290 303 <TSTATE>max-msg-ids { return MAXMSGIDS; }
291 304 <CSTATE>max-msg-ids { return MAXMSGIDS; }
292 305
293 306 <TSTATE>max-sem-ids { return MAXSEMIDS; }
294 307 <CSTATE>max-sem-ids { return MAXSEMIDS; }
295 308
296 309 <TSTATE>scheduling-class { return SCHED; }
297 310 <CSTATE>scheduling-class { return SCHED; }
298 311
299 312 <TSTATE>hostid { return HOSTID; }
300 313 <CSTATE>hostid { return HOSTID; }
301 314
302 315 <TSTATE>user { return USER; }
303 316 <CSTATE>user { return USER; }
304 317
305 318 <TSTATE>auths { return AUTHS; }
306 319 <CSTATE>auths { return AUTHS; }
307 320
308 321 <TSTATE>fs-allowed { return FS_ALLOWED; }
309 322 <CSTATE>fs-allowed { return FS_ALLOWED; }
310 323
311 324 <TSTATE>= { return EQUAL; }
312 325 <LSTATE>= { return EQUAL; }
313 326 <CSTATE>= { return EQUAL; }
314 327
315 328 <TSTATE>"[" {
316 329 BEGIN LSTATE;
317 330 state = LSTATE;
318 331 return OPEN_SQ_BRACKET;
319 332 }
320 333
321 334 <LSTATE>"]" {
322 335 BEGIN TSTATE;
323 336 state = TSTATE;
324 337 return CLOSE_SQ_BRACKET;
325 338 }
326 339
327 340 <TSTATE>"(" {
328 341 BEGIN CSTATE;
329 342 return OPEN_PAREN;
330 343 }
331 344
332 345 <LSTATE>"(" {
333 346 BEGIN CSTATE;
334 347 return OPEN_PAREN;
335 348 }
336 349
337 350 <CSTATE>")" {
338 351 BEGIN state;
339 352 return CLOSE_PAREN;
340 353 }
341 354
342 355 <LSTATE>"," { return COMMA; }
343 356 <CSTATE>"," { return COMMA; }
344 357
345 358 <TSTATE>[^ \t\n\";=\[\]\(\)]+ {
346 359 yylval.strval = create_token(yytext);
347 360 return TOKEN;
348 361 }
|
↓ open down ↓ |
100 lines elided |
↑ open up ↑ |
349 362
350 363 <LSTATE>[^ \t\n\",;=\[\]\(\)]+ {
351 364 yylval.strval = create_token(yytext);
352 365 return TOKEN;
353 366 }
354 367
355 368 <CSTATE>[^ \t\n\",;=\(\)]+ {
356 369 yylval.strval = create_token(yytext);
357 370 return TOKEN;
358 371 }
372 +
373 +<CSTATE>\"[^\"\n]*[\"\n] {
374 + yylval.strval = create_token(yytext + 1);
375 + if (yylval.strval[yyleng - 2] == '"')
376 + yylval.strval[yyleng - 2] = 0;
377 + return TOKEN;
378 + }
359 379
360 380 <TSTATE>\"[^\"\n]*[\"\n] {
361 381 yylval.strval = create_token(yytext + 1);
362 382 if (yylval.strval[yyleng - 2] == '"')
363 383 yylval.strval[yyleng - 2] = 0;
364 384 return TOKEN;
365 385 }
366 386
367 387 <LSTATE>\"[^\"\n]*[\"\n] {
368 388 yylval.strval = create_token(yytext + 1);
369 389 if (yylval.strval[yyleng - 2] == '"')
370 390 yylval.strval[yyleng - 2] = 0;
371 391 return TOKEN;
372 392 }
373 393
374 394 ";" {
375 395 BEGIN INITIAL;
376 396 return (yytext[0]);
377 397 }
378 398
379 399 \n {
380 400 lex_lineno++;
381 401 BEGIN INITIAL;
382 402 return (yytext[0]);
383 403 }
384 404
385 405 [ \t] ; /* Ignore whitespace */
386 406
387 407 . {
388 408 return (yytext[0]);
389 409 }
390 410
391 411 %%
392 412
393 413 /*
394 414 * Assert that there are no unclaimed tokens. This function enforces the
395 415 * invariants mentioned at the top of this file.
396 416 */
397 417 void
398 418 assert_no_unclaimed_tokens(void)
399 419 {
400 420 assert(num_unclaimed_tokens == 0);
401 421 assert(unclaimed_tokens == NULL);
402 422 assert(unclaimed_tokens_size == 0);
403 423 }
404 424
405 425 /*
406 426 * Claim the specified unclaimed TOKEN. YACC reduction rules that
407 427 * use TOKENs should invoke this function immediately before freeing the TOKENs
408 428 * or adding them to data structures that will be cleaned up when the YACC
409 429 * parser finishes or encounters errors. Reduction rules should only claim the
410 430 * TOKENs that they use.
411 431 *
412 432 * This function returns its argument but does not free its memory.
413 433 */
414 434 char *
415 435 claim_token(char *token)
416 436 {
417 437 unsigned int index;
418 438
419 439 /*
420 440 * Find the token in the list of unclaimed tokens.
421 441 */
422 442 assert(num_unclaimed_tokens > 0);
423 443 for (index = 0; index < num_unclaimed_tokens; index++) {
424 444 if (unclaimed_tokens[index] == token)
425 445 break;
426 446 }
427 447
428 448 /*
429 449 * Abort if we didn't find the token.
430 450 */
431 451 assert(index != num_unclaimed_tokens);
432 452
433 453 /*
434 454 * Replace the token with the last unclaimed token.
435 455 */
436 456 num_unclaimed_tokens--;
437 457 unclaimed_tokens[index] = unclaimed_tokens[num_unclaimed_tokens];
438 458
439 459 /*
440 460 * Delete the list of unclaimed tokens if it's empty.
441 461 */
442 462 if (num_unclaimed_tokens == 0) {
443 463 free(unclaimed_tokens);
444 464 unclaimed_tokens = NULL;
445 465 unclaimed_tokens_size = 0;
446 466 }
447 467
448 468 return (token);
449 469 }
450 470
451 471 /*
452 472 * Free all unclaimed TOKENs. This should only be invoked when the YACC
453 473 * parser encounters errors.
454 474 */
455 475 static void
456 476 free_tokens(void)
457 477 {
458 478 if (unclaimed_tokens != NULL) {
459 479 while (num_unclaimed_tokens > 0)
460 480 free(unclaimed_tokens[--num_unclaimed_tokens]);
461 481 free(unclaimed_tokens);
462 482 unclaimed_tokens = NULL;
463 483 unclaimed_tokens_size = 0;
464 484 }
465 485 assert_no_unclaimed_tokens();
466 486 }
467 487
468 488 /*
469 489 * Create a TOKEN from the specified string. The TOKEN is merely a duplicate
470 490 * of the specified string. TOKENs must be claimed by the YACC reduction rules
471 491 * that use them; see claim_token() above.
472 492 */
473 493 char *
474 494 create_token(char *s)
475 495 {
476 496 char *result;
477 497
478 498 if ((result = strdup(s)) == NULL) {
479 499 yyerror("Out of memory");
480 500 exit(Z_ERR);
481 501 }
482 502
483 503 /*
484 504 * Add the new TOKEN to the list of unclaimed TOKENs. The list might
485 505 * have to be resized.
486 506 *
487 507 * Reduction rules should claim TOKENs via claim_token() (see above).
488 508 */
489 509 if (num_unclaimed_tokens == unclaimed_tokens_size) {
490 510 char **new_unclaimed_tokens;
491 511
492 512 unclaimed_tokens_size += UNCLAIMED_TOKENS_BUFFER_GROWTH;
493 513 new_unclaimed_tokens = (char **)realloc(unclaimed_tokens,
494 514 unclaimed_tokens_size * sizeof (char *));
495 515 if (new_unclaimed_tokens == NULL) {
496 516 yyerror("Out of memory");
497 517 free(result);
498 518 exit(Z_ERR);
499 519 }
500 520 unclaimed_tokens = new_unclaimed_tokens;
501 521 }
502 522 unclaimed_tokens[num_unclaimed_tokens] = result;
503 523 num_unclaimed_tokens++;
504 524 return (result);
505 525 }
506 526
507 527 void
508 528 yyerror(char *s)
509 529 {
510 530 /*
511 531 * Ensure that we won't leak unclaimed tokens.
512 532 */
513 533 free_tokens();
514 534
515 535 /* feof(yyin) is not an error; anything else is, so we set saw_error */
516 536 if (yytext[0] == '\0') {
517 537 if (!feof(yyin)) {
518 538 saw_error = B_TRUE;
519 539 (void) fprintf(stderr, gettext("%s, token expected\n"),
520 540 s);
521 541 }
522 542 return;
523 543 }
524 544
525 545 saw_error = B_TRUE;
526 546 if (cmd_file_mode)
527 547 (void) fprintf(stderr, gettext("%s on line %d at '%s'\n"), s,
528 548 lex_lineno, (yytext[0] == '\n') ? "\\n" : yytext);
529 549 else
530 550 (void) fprintf(stderr, gettext("%s at '%s'\n"), s,
531 551 (yytext[0] == '\n') ? "\\n" : yytext);
532 552 usage(B_FALSE, HELP_SUBCMDS);
533 553 }
|
↓ open down ↓ |
165 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX