1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 *
26 * ident "%Z%%M% %I% %E% SMI"
27 */
28
29 import org.opensolaris.os.dtrace.*;
30
31 /**
32 * Regression test for the LocalConsumer state machine. Calls Consumer
33 * methods before and after open(), compile(), enable(), go(), stop(),
34 * and close() to verify that the calls succeed as expected or fail with
35 * the expected Java exception.
36 */
37 public class TestStateMachine {
38 static Program program;
39
40 static void
41 exit(int status)
42 {
43 exit(status, null);
44 }
45
46 static void
47 exit(int status, String msg)
48 {
49 if (msg != null) {
50 System.out.println(msg);
51 }
52 System.out.flush();
53 System.err.flush();
54 System.exit(status);
55 }
56
57 static void
58 printState(Consumer consumer)
59 {
60 System.out.println("open: " + consumer.isOpen());
61 System.out.println("enabled: " + consumer.isEnabled());
62 System.out.println("closed: " + consumer.isClosed());
63 }
64
65 static void
66 beforeOpen(Consumer consumer)
67 {
68 System.out.println("before open");
69 printState(consumer);
70
71 // compile
72 try {
73 consumer.compile("syscall:::entry");
74 exit(1, "compile before open");
75 } catch (IllegalStateException e) {
76 System.out.println(e);
77 } catch (Exception e) {
78 e.printStackTrace();
79 exit(1, "compile before open");
80 }
81
82 // enable
83 try {
84 consumer.enable();
85 exit(1, "enable before open");
86 } catch (IllegalStateException e) {
87 System.out.println(e);
88 } catch (Exception e) {
89 e.printStackTrace();
90 exit(1, "enable before open");
91 }
92
93 // getOption, setOption, unsetOption
94 try {
95 consumer.getOption(Option.bufsize);
96 exit(1, "getOption before open");
97 } catch (IllegalStateException e) {
98 System.out.println(e);
99 } catch (Exception e) {
100 e.printStackTrace();
101 exit(1, "getOption before open");
102 }
103 try {
104 consumer.setOption(Option.bufsize, Option.mb(1));
105 exit(1, "setOption before open");
106 } catch (IllegalStateException e) {
107 System.out.println(e);
108 } catch (Exception e) {
109 e.printStackTrace();
110 exit(1, "setOption before open");
111 }
112 try {
113 consumer.unsetOption(Option.quiet);
114 exit(1, "unsetOption before open");
115 } catch (IllegalStateException e) {
116 System.out.println(e);
117 } catch (Exception e) {
118 e.printStackTrace();
119 exit(1, "unsetOption before open");
120 }
121
122 // createProcess, grabProcess
123 try {
124 consumer.createProcess("date");
125 exit(1, "createProcess before open");
126 } catch (IllegalStateException e) {
127 System.out.println(e);
128 } catch (Exception e) {
129 e.printStackTrace();
130 exit(1, "createProcess before open");
131 }
132 try {
133 consumer.grabProcess(1);
134 exit(1, "grabProcess before open");
135 } catch (IllegalStateException e) {
136 System.out.println(e);
137 } catch (Exception e) {
138 e.printStackTrace();
139 exit(1, "grabProcess before open");
140 }
141
142 // listProbes
143 try {
144 consumer.listProbes(ProbeDescription.EMPTY);
145 exit(1, "listProbes before open");
146 } catch (IllegalStateException e) {
147 System.out.println(e);
148 } catch (Exception e) {
149 e.printStackTrace();
150 exit(1, "listProbes before open");
151 }
152
153 // getAggregate
154 try {
155 consumer.getAggregate();
156 exit(1, "getAggregate before open");
157 } catch (IllegalStateException e) {
158 System.out.println(e);
159 } catch (Exception e) {
160 e.printStackTrace();
161 exit(1, "getAggregate before open");
162 }
163
164 // getVersion
165 try {
166 consumer.getVersion(); // allowed
167 } catch (Exception e) {
168 e.printStackTrace();
169 exit(1, "getVersion before open");
170 }
171 }
172
173 static void
174 beforeCompile(Consumer consumer)
175 {
176 System.out.println("before compile");
177 printState(consumer);
178
179 // open
180 try {
181 consumer.open();
182 exit(1, "open after open");
183 } catch (IllegalStateException e) {
184 System.out.println(e);
185 } catch (Exception e) {
186 e.printStackTrace();
187 exit(1, "open after open");
188 }
189
190 // enable
191 try {
192 consumer.enable();
193 exit(1, "enable before compile");
194 } catch (IllegalStateException e) {
195 System.out.println(e);
196 } catch (Exception e) {
197 e.printStackTrace();
198 exit(1, "enable before compile");
199 }
200 }
201
202 static void
203 beforeEnable(Consumer consumer)
204 {
205 System.out.println("before enable");
206 printState(consumer);
207
208 // go
209 try {
210 consumer.go();
211 exit(1, "go before enable");
212 } catch (IllegalStateException e) {
213 System.out.println(e);
214 } catch (Exception e) {
215 e.printStackTrace();
216 exit(1, "go before enable");
217 }
218 }
219
220 static void
221 beforeGo(Consumer consumer)
222 {
223 System.out.println("before go");
224 printState(consumer);
225
226 // getAggregate
227 try {
228 consumer.getAggregate();
229 exit(1, "getAggregate before go");
230 } catch (IllegalStateException e) {
231 System.out.println(e);
232 } catch (Exception e) {
233 e.printStackTrace();
234 exit(1, "getAggregate before go");
235 }
236
237 // lookupKernelFunction, lookupUserFunction
238 try {
239 consumer.lookupKernelFunction(1);
240 exit(1, "lookupKernelFunction before go");
241 } catch (IllegalStateException e) {
242 System.out.println(e);
243 } catch (Exception e) {
244 e.printStackTrace();
245 exit(1, "lookupKernelFunction before go");
246 }
247 try {
248 consumer.lookupUserFunction(1, 1);
249 exit(1, "lookupUserFunction before go");
250 } catch (IllegalStateException e) {
251 System.out.println(e);
252 } catch (Exception e) {
253 e.printStackTrace();
254 exit(1, "lookupUserFunction before go");
255 }
256
257 // stop
258 try {
259 consumer.stop();
260 exit(1, "stop before go");
261 } catch (IllegalStateException e) {
262 System.out.println(e);
263 } catch (Exception e) {
264 e.printStackTrace();
265 exit(1, "stop before go");
266 }
267 }
268
269 static void
270 afterGo(Consumer consumer, Program program)
271 {
272 System.out.println("after go");
273 printState(consumer);
274
275 // go
276 try {
277 consumer.go();
278 exit(1, "go after go");
279 } catch (IllegalStateException e) {
280 System.out.println(e);
281 } catch (Exception e) {
282 e.printStackTrace();
283 exit(1, "go after go");
284 }
285
286 // createProcess, grabProcess
287 try {
288 consumer.createProcess("date");
289 exit(1, "createProcess after go");
290 } catch (IllegalStateException e) {
291 System.out.println(e);
292 } catch (Exception e) {
293 e.printStackTrace();
294 exit(1, "createProcess after go");
295 }
296 try {
297 consumer.grabProcess(1);
298 exit(1, "grabProcess after go");
299 } catch (IllegalStateException e) {
300 System.out.println(e);
301 } catch (Exception e) {
302 e.printStackTrace();
303 exit(1, "grabProcess after go");
304 }
305
306 // listProbes
307 try {
308 consumer.listProbes(ProbeDescription.EMPTY);
309 exit(1, "listProbes after go");
310 } catch (IllegalStateException e) {
311 System.out.println(e);
312 } catch (Exception e) {
313 e.printStackTrace();
314 exit(1, "listProbes after go");
315 }
316
317 // compile
318 try {
319 consumer.compile("syscall:::entry");
320 exit(1, "compile after go");
321 } catch (IllegalStateException e) {
322 System.out.println(e);
323 } catch (Exception e) {
324 e.printStackTrace();
325 exit(1, "compile after go");
326 }
327
328 // enable
329 try {
330 consumer.enable();
331 exit(1, "enable after go");
332 } catch (IllegalStateException e) {
333 System.out.println(e);
334 } catch (Exception e) {
335 e.printStackTrace();
336 exit(1, "enable after go");
337 }
338
339 // getAggregate
340 try {
341 consumer.getAggregate();
342 } catch (Exception e) {
343 e.printStackTrace();
344 exit(1, "getAggregate after go");
345 }
346
347 // getProgramInfo
348 try {
349 consumer.getProgramInfo(program);
350 } catch (Exception e) {
351 e.printStackTrace();
352 exit(1, "getProgramInfo after go");
353 }
354
355 // getOption, setOption, unsetOption
356 try {
357 consumer.getOption(Option.quiet);
358 consumer.setOption(Option.quiet);
359 consumer.unsetOption(Option.quiet);
360 } catch (Exception e) {
361 e.printStackTrace();
362 exit(1, "get, set, unset option after go");
363 }
364 }
365
366 static void
367 afterStop(Consumer consumer, Program program)
368 {
369 System.out.println("after stop");
370 printState(consumer);
371
372 // stop
373 try {
374 consumer.stop();
375 exit(1, "stop after stop");
376 } catch (IllegalStateException e) {
377 System.out.println(e);
378 } catch (Exception e) {
379 e.printStackTrace();
380 exit(1, "stop after stop");
381 }
382
383 // getAggregate
384 try {
385 consumer.getAggregate();
386 } catch (Exception e) {
387 e.printStackTrace();
388 exit(1, "getAggregate after stop");
389 }
390
391 // getProgramInfo
392 try {
393 consumer.getProgramInfo(program);
394 } catch (Exception e) {
395 e.printStackTrace();
396 exit(1, "getProgramInfo after stop");
397 }
398
399 // getOption, setOption, unsetOption
400 try {
401 consumer.getOption(Option.quiet);
402 consumer.setOption(Option.quiet);
403 consumer.unsetOption(Option.quiet);
404 } catch (Exception e) {
405 e.printStackTrace();
406 exit(1, "get, set, unset option after stop");
407 }
408 }
409
410 static void
411 afterClose(Consumer consumer, Program program)
412 {
413 System.out.println("after close");
414 printState(consumer);
415
416 // open
417 try {
418 consumer.open();
419 exit(1, "open after close");
420 } catch (IllegalStateException e) {
421 System.out.println(e);
422 } catch (Exception e) {
423 e.printStackTrace();
424 exit(1, "open after close");
425 }
426
427 // compile
428 try {
429 consumer.compile("syscall:::entry");
430 exit(1, "compile after close");
431 } catch (IllegalStateException e) {
432 System.out.println(e);
433 } catch (Exception e) {
434 e.printStackTrace();
435 exit(1, "compile after close");
436 }
437
438 // enable
439 try {
440 consumer.enable();
441 exit(1, "enable after close");
442 } catch (IllegalStateException e) {
443 System.out.println(e);
444 } catch (Exception e) {
445 e.printStackTrace();
446 exit(1, "enable after close");
447 }
448
449 // getOption, setOption, unsetOption
450 try {
451 consumer.getOption(Option.bufsize);
452 exit(1, "getOption after close");
453 } catch (IllegalStateException e) {
454 System.out.println(e);
455 } catch (Exception e) {
456 e.printStackTrace();
457 exit(1, "getOption after close");
458 }
459 try {
460 consumer.setOption(Option.bufsize, Option.mb(1));
461 exit(1, "setOption after close");
462 } catch (IllegalStateException e) {
463 System.out.println(e);
464 } catch (Exception e) {
465 e.printStackTrace();
466 exit(1, "setOption after close");
467 }
468 try {
469 consumer.unsetOption(Option.quiet);
470 exit(1, "unsetOption after close");
471 } catch (IllegalStateException e) {
472 System.out.println(e);
473 } catch (Exception e) {
474 e.printStackTrace();
475 exit(1, "unsetOption after close");
476 }
477
478 // createProcess, grabProcess
479 try {
480 consumer.createProcess("date");
481 exit(1, "createProcess after close");
482 } catch (IllegalStateException e) {
483 System.out.println(e);
484 } catch (Exception e) {
485 e.printStackTrace();
486 exit(1, "createProcess after close");
487 }
488 try {
489 consumer.grabProcess(1);
490 exit(1, "grabProcess after close");
491 } catch (IllegalStateException e) {
492 System.out.println(e);
493 } catch (Exception e) {
494 e.printStackTrace();
495 exit(1, "grabProcess after close");
496 }
497
498 // listProbes
499 try {
500 consumer.listProbes(ProbeDescription.EMPTY);
501 exit(1, "listProbes after close");
502 } catch (IllegalStateException e) {
503 System.out.println(e);
504 } catch (Exception e) {
505 e.printStackTrace();
506 exit(1, "listProbes after close");
507 }
508
509 // getAggregate
510 try {
511 consumer.getAggregate();
512 exit(1, "getAggregate after close");
513 } catch (IllegalStateException e) {
514 System.out.println(e);
515 } catch (Exception e) {
516 e.printStackTrace();
517 exit(1, "getAggregate after close");
518 }
519
520 // getVersion
521 try {
522 consumer.getVersion(); // allowed
523 } catch (Exception e) {
524 e.printStackTrace();
525 exit(1, "getVersion after close");
526 }
527
528 // go
529 try {
530 consumer.go();
531 exit(1, "go after close");
532 } catch (IllegalStateException e) {
533 System.out.println(e);
534 } catch (Exception e) {
535 e.printStackTrace();
536 exit(1, "go after close");
537 }
538
539 // lookupKernelFunction, lookupUserFunction
540 try {
541 consumer.lookupKernelFunction(1);
542 exit(1, "lookupKernelFunction after close");
543 } catch (IllegalStateException e) {
544 System.out.println(e);
545 } catch (Exception e) {
546 e.printStackTrace();
547 exit(1, "lookupKernelFunction after close");
548 }
549 try {
550 consumer.lookupUserFunction(1, 1);
551 exit(1, "lookupUserFunction after close");
552 } catch (IllegalStateException e) {
553 System.out.println(e);
554 } catch (Exception e) {
555 e.printStackTrace();
556 exit(1, "lookupUserFunction after close");
557 }
558
559 // stop
560 try {
561 consumer.stop();
562 exit(1, "stop after close");
563 } catch (IllegalStateException e) {
564 System.out.println(e);
565 } catch (Exception e) {
566 e.printStackTrace();
567 exit(1, "stop after close");
568 }
569
570 // getProgramInfo
571 try {
572 consumer.getProgramInfo(program);
573 exit(1, "getProgramInfo after close");
574 } catch (IllegalStateException e) {
575 System.out.println(e);
576 } catch (Exception e) {
577 e.printStackTrace();
578 exit(1, "getProgramInfo after close");
579 }
580 }
581
582 public static void
583 main(String[] args)
584 {
585 final Consumer consumer = new LocalConsumer();
586 consumer.addConsumerListener(new ConsumerAdapter() {
587 public void consumerStarted(ConsumerEvent e) {
588 System.out.println("consumerStarted, running: " +
589 consumer.isRunning());
590 afterGo(consumer, program);
591 }
592 public void consumerStopped(ConsumerEvent e) {
593 System.out.println("consumerStopped, running: " +
594 consumer.isRunning());
595 }
596 });
597
598 try {
599 beforeOpen(consumer);
600 consumer.open();
601 beforeCompile(consumer);
602 program = consumer.compile(
603 "syscall:::entry { @[execname] = count(); } " +
604 "tick-101ms { printa(@); }");
605 beforeEnable(consumer);
606 consumer.enable();
607 beforeGo(consumer);
608 System.out.println("before go, running: " + consumer.isRunning());
609 consumer.go();
610 // Avoid race, call afterGo() in ConsumerListener
611 try {
612 Thread.sleep(300);
613 } catch (InterruptedException e) {
614 e.printStackTrace();
615 exit(1);
616 }
617 consumer.stop();
618 System.out.println("after stop, running: " + consumer.isRunning());
619 afterStop(consumer, program);
620 consumer.close();
621 afterClose(consumer, program);
622 } catch (DTraceException e) {
623 e.printStackTrace();
624 exit(1);
625 }
626 }
627 }