?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel - ACPI - Fix missing unlocks in error path in acpi_ec
[dragonfly.git] / sbin / natacontrol / natacontrol.c
blob594b4b088a9523369cae8cd3ba60eeb5660d0999
1 /*-
2 * Copyright (c) 2000 - 2006 Søren Schmidt <sos@FreeBSD.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer,
10 * without modification, immediately at the beginning of the file.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 *
26 * $FreeBSD: src/sbin/atacontrol/atacontrol.c,v 1.42 2006/03/15 19:32:43 sos Exp $
27 * $DragonFly: src/sbin/natacontrol/natacontrol.c,v 1.3 2008/09/04 21:00:28 swildner Exp $
28 */
29
30 #include <sys/nata.h>
31
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <fcntl.h>
36 #include <errno.h>
37 #include <err.h>
38
39 #include <sysexits.h>
40 #include <unistd.h>
41
42 static const char *mode2str(int mode);
43 static int str2mode(char *str);
44 static void usage(void);
45 static int version(int ver);
46 static void param_print(struct ata_params *parm);
47 static void cap_print(struct ata_params *parm);
48 static int ata_cap_print(int fd);
49 static int info_print(int fd, int channel, int prchan);
50
51 const char *
52 mode2str(int mode)
53 {
54 switch (mode) {
55 case ATA_PIO: return "BIOSPIO";
56 case ATA_PIO0: return "PIO0";
57 case ATA_PIO1: return "PIO1";
58 case ATA_PIO2: return "PIO2";
59 case ATA_PIO3: return "PIO3";
60 case ATA_PIO4: return "PIO4";
61 case ATA_WDMA2: return "WDMA2";
62 case ATA_UDMA2: return "UDMA33";
63 case ATA_UDMA4: return "UDMA66";
64 case ATA_UDMA5: return "UDMA100";
65 case ATA_UDMA6: return "UDMA133";
66 case ATA_SA150: return "SATA150";
67 case ATA_SA300: return "SATA300";
68 case ATA_USB: return "USB";
69 case ATA_USB1: return "USB1";
70 case ATA_USB2: return "USB2";
71 case ATA_DMA: return "BIOSDMA";
72 default: return "???";
73 }
74 }
75
76 int
77 str2mode(char *str)
78 {
79 if (!strcasecmp(str, "BIOSPIO")) return ATA_PIO;
80 if (!strcasecmp(str, "PIO0")) return ATA_PIO0;
81 if (!strcasecmp(str, "PIO1")) return ATA_PIO1;
82 if (!strcasecmp(str, "PIO2")) return ATA_PIO2;
83 if (!strcasecmp(str, "PIO3")) return ATA_PIO3;
84 if (!strcasecmp(str, "PIO4")) return ATA_PIO4;
85 if (!strcasecmp(str, "WDMA2")) return ATA_WDMA2;
86 if (!strcasecmp(str, "UDMA2")) return ATA_UDMA2;
87 if (!strcasecmp(str, "UDMA33")) return ATA_UDMA2;
88 if (!strcasecmp(str, "UDMA4")) return ATA_UDMA4;
89 if (!strcasecmp(str, "UDMA66")) return ATA_UDMA4;
90 if (!strcasecmp(str, "UDMA5")) return ATA_UDMA5;
91 if (!strcasecmp(str, "UDMA100")) return ATA_UDMA5;
92 if (!strcasecmp(str, "UDMA6")) return ATA_UDMA6;
93 if (!strcasecmp(str, "UDMA133")) return ATA_UDMA6;
94 if (!strcasecmp(str, "BIOSDMA")) return ATA_DMA;
95 return -1;
96 }
97
98 void
99 usage(void)
100 {
101 fprintf(stderr,
102 "usage: natacontrol <command> args:\n"
103 " natacontrol list\n"
104 " natacontrol info channel\n"
105 " natacontrol attach channel\n"
106 " natacontrol detach channel\n"
107 " natacontrol reinit channel\n"
108 " natacontrol create type [interleave] disk0 ... diskN\n"
109 " natacontrol delete array\n"
110 " natacontrol addspare array disk\n"
111 " natacontrol rebuild array\n"
112 " natacontrol status array\n"
113 " natacontrol mode device [mode]\n"
114 " natacontrol cap device\n"
115 );
116 exit(EX_USAGE);
117 }
118
119 int
120 version(int ver)
121 {
122 int bit;
123
124 if (ver == 0xffff)
125 return 0;
126 for (bit = 15; bit >= 0; bit--)
127 if (ver & (1<<bit))
128 return bit;
129 return 0;
130 }
131
132 void
133 param_print(struct ata_params *parm)
134 {
135 printf("<%.40s/%.8s> ", parm->model, parm->revision);
136 if (parm->satacapabilities && parm->satacapabilities != 0xffff) {
137 if (parm->satacapabilities & ATA_SATA_GEN2)
138 printf("Serial ATA II\n");
139 else if (parm->satacapabilities & ATA_SATA_GEN1)
140 printf("Serial ATA v1.0\n");
141 else
142 printf("Unknown serial ATA version\n");
143 }
144 else
145 printf("ATA/ATAPI revision %d\n", version(parm->version_major));
146 }
147
148 void
149 cap_print(struct ata_params *parm)
150 {
151 u_int32_t lbasize = (u_int32_t)parm->lba_size_1 |
152 ((u_int32_t)parm->lba_size_2 << 16);
153
154 u_int64_t lbasize48 = ((u_int64_t)parm->lba_size48_1) |
155 ((u_int64_t)parm->lba_size48_2 << 16) |
156 ((u_int64_t)parm->lba_size48_3 << 32) |
157 ((u_int64_t)parm->lba_size48_4 << 48);
158
159 printf("\n");
160 printf("Protocol ");
161 if (parm->satacapabilities && parm->satacapabilities != 0xffff) {
162 if (parm->satacapabilities & ATA_SATA_GEN2)
163 printf("Serial ATA II\n");
164 else if (parm->satacapabilities & ATA_SATA_GEN1)
165 printf("Serial ATA v1.0\n");
166 else
167 printf("Unknown serial ATA version\n");
168 }
169 else
170 printf("ATA/ATAPI revision %d\n", version(parm->version_major));
171 printf("device model %.40s\n", parm->model);
172 printf("serial number %.20s\n", parm->serial);
173 printf("firmware revision %.8s\n", parm->revision);
174
175 printf("cylinders %d\n", parm->cylinders);
176 printf("heads %d\n", parm->heads);
177 printf("sectors/track %d\n", parm->sectors);
178
179 printf("lba%ssupported ",
180 parm->capabilities1 & ATA_SUPPORT_LBA ? " " : " not ");
181 if (lbasize)
182 printf("%d sectors\n", lbasize);
183 else
184 printf("\n");
185
186 printf("lba48%ssupported ",
187 parm->support.command2 & ATA_SUPPORT_ADDRESS48 ? " " : " not ");
188 if (lbasize48)
189 printf("%llu sectors\n", (unsigned long long)lbasize48);
190 else
191 printf("\n");
192
193 printf("dma%ssupported\n",
194 parm->capabilities1 & ATA_SUPPORT_DMA ? " " : " not ");
195
196 printf("overlap%ssupported\n",
197 parm->capabilities1 & ATA_SUPPORT_OVERLAP ? " " : " not ");
198
199 printf("\nFeature "
200 "Support Enable Value Vendor\n");
201
202 printf("write cache %s %s\n",
203 parm->support.command1 & ATA_SUPPORT_WRITECACHE ? "yes" : "no",
204 parm->enabled.command1 & ATA_SUPPORT_WRITECACHE ? "yes" : "no");
205
206 printf("read ahead %s %s\n",
207 parm->support.command1 & ATA_SUPPORT_LOOKAHEAD ? "yes" : "no",
208 parm->enabled.command1 & ATA_SUPPORT_LOOKAHEAD ? "yes" : "no");
209
210 if (parm->satacapabilities && parm->satacapabilities != 0xffff) {
211 printf("Native Command Queuing (NCQ) %s %s"
212 " %d/0x%02X\n",
213 parm->satacapabilities & ATA_SUPPORT_NCQ ?
214 "yes" : "no", " -",
215 (parm->satacapabilities & ATA_SUPPORT_NCQ) ?
216 ATA_QUEUE_LEN(parm->queue) : 0,
217 (parm->satacapabilities & ATA_SUPPORT_NCQ) ?
218 ATA_QUEUE_LEN(parm->queue) : 0);
219 }
220 printf("Tagged Command Queuing (TCQ) %s %s %d/0x%02X\n",
221 parm->support.command2 & ATA_SUPPORT_QUEUED ? "yes" : "no",
222 parm->enabled.command2 & ATA_SUPPORT_QUEUED ? "yes" : "no",
223 ATA_QUEUE_LEN(parm->queue), ATA_QUEUE_LEN(parm->queue));
224
225 printf("SMART %s %s\n",
226 parm->support.command1 & ATA_SUPPORT_SMART ? "yes" : "no",
227 parm->enabled.command1 & ATA_SUPPORT_SMART ? "yes" : "no");
228
229 printf("microcode download %s %s\n",
230 parm->support.command2 & ATA_SUPPORT_MICROCODE ? "yes" : "no",
231 parm->enabled.command2 & ATA_SUPPORT_MICROCODE ? "yes" : "no");
232
233 printf("security %s %s\n",
234 parm->support.command1 & ATA_SUPPORT_SECURITY ? "yes" : "no",
235 parm->enabled.command1 & ATA_SUPPORT_SECURITY ? "yes" : "no");
236
237 printf("power management %s %s\n",
238 parm->support.command1 & ATA_SUPPORT_POWERMGT ? "yes" : "no",
239 parm->enabled.command1 & ATA_SUPPORT_POWERMGT ? "yes" : "no");
240
241 printf("advanced power management %s %s %d/0x%02X\n",
242 parm->support.command2 & ATA_SUPPORT_APM ? "yes" : "no",
243 parm->enabled.command2 & ATA_SUPPORT_APM ? "yes" : "no",
244 parm->apm_value, parm->apm_value);
245
246 printf("automatic acoustic management %s %s "
247 "%d/0x%02X %d/0x%02X\n",
248 parm->support.command2 & ATA_SUPPORT_AUTOACOUSTIC ? "yes" :"no",
249 parm->enabled.command2 & ATA_SUPPORT_AUTOACOUSTIC ? "yes" :"no",
250 ATA_ACOUSTIC_CURRENT(parm->acoustic),
251 ATA_ACOUSTIC_CURRENT(parm->acoustic),
252 ATA_ACOUSTIC_VENDOR(parm->acoustic),
253 ATA_ACOUSTIC_VENDOR(parm->acoustic));
254 }
255
256 int
257 ata_cap_print(int fd)
258 {
259 struct ata_params params;
260
261 if (ioctl(fd, IOCATAGPARM, &params) < 0)
262 return errno;
263 cap_print(&params);
264 return 0;
265 }
266
267 int
268 info_print(int fd, int channel, int prchan)
269 {
270 struct ata_ioc_devices devices;
271
272 devices.channel = channel;
273
274 if (ioctl(fd, IOCATADEVICES, &devices) < 0)
275 return errno;
276
277 if (prchan)
278 printf("ATA channel %d:\n", channel);
279 printf("%sMaster: ", prchan ? " " : "");
280 if (*devices.name[0]) {
281 printf("%4.4s ", devices.name[0]);
282 param_print(&devices.params[0]);
283 }
284 else
285 printf(" no device present\n");
286 printf("%sSlave: ", prchan ? " " : "");
287 if (*devices.name[1]) {
288 printf("%4.4s ", devices.name[1]);
289 param_print(&devices.params[1]);
290 }
291 else
292 printf(" no device present\n");
293 return 0;
294 }
295
296 int
297 main(int argc, char **argv)
298 {
299 int fd;
300
301 if (argc < 2)
302 usage();
303
304 if (!strcmp(argv[1], "mode") && (argc == 3 || argc == 4)) {
305 int disk, mode;
306 char device[64];
307
308 if (!(sscanf(argv[2], "ad%d", &disk) == 1 ||
309 sscanf(argv[2], "acd%d", &disk) == 1 ||
310 sscanf(argv[2], "afd%d", &disk) == 1 ||
311 sscanf(argv[2], "ast%d", &disk) == 1)) {
312 fprintf(stderr, "natacontrol: Invalid device %s\n",
313 argv[2]);
314 exit(EX_USAGE);
315 }
316 sprintf(device, "/dev/%s", argv[2]);
317 if ((fd = open(device, O_RDONLY)) < 0)
318 err(1, "device not found");
319 if (argc == 4) {
320 mode = str2mode(argv[3]);
321 if (ioctl(fd, IOCATASMODE, &mode) < 0)
322 warn("ioctl(IOCATASMODE)");
323 }
324 if (argc == 3 || argc == 4) {
325 if (ioctl(fd, IOCATAGMODE, &mode) < 0)
326 err(1, "ioctl(IOCATAGMODE)");
327 printf("current mode = %s\n", mode2str(mode));
328 }
329 exit(EX_OK);
330 }
331 if (!strcmp(argv[1], "cap") && argc == 3) {
332 int disk;
333 char device[64];
334
335 if (!(sscanf(argv[2], "ad%d", &disk) == 1 ||
336 sscanf(argv[2], "acd%d", &disk) == 1 ||
337 sscanf(argv[2], "afd%d", &disk) == 1 ||
338 sscanf(argv[2], "ast%d", &disk) == 1)) {
339 fprintf(stderr, "natacontrol: Invalid device %s\n",
340 argv[2]);
341 exit(EX_USAGE);
342 }
343 sprintf(device, "/dev/%s", argv[2]);
344 if ((fd = open(device, O_RDONLY)) < 0)
345 err(1, "device not found");
346 ata_cap_print(fd);
347 exit(EX_OK);
348 }
349
350 if ((fd = open("/dev/ata", O_RDWR)) < 0)
351 err(1, "control device not found");
352
353 if (!strcmp(argv[1], "list") && argc == 2) {
354 int maxchannel, channel;
355
356 if (ioctl(fd, IOCATAGMAXCHANNEL, &maxchannel) < 0)
357 err(1, "ioctl(IOCATAGMAXCHANNEL)");
358 for (channel = 0; channel < maxchannel; channel++)
359 info_print(fd, channel, 1);
360 exit(EX_OK);
361 }
362 if (!strcmp(argv[1], "info") && argc == 3) {
363 int channel;
364
365 if (!(sscanf(argv[2], "ata%d", &channel) == 1)) {
366 fprintf(stderr,
367 "natacontrol: Invalid channel %s\n", argv[2]);
368 exit(EX_USAGE);
369 }
370 info_print(fd, channel, 0);
371 exit(EX_OK);
372 }
373 if (!strcmp(argv[1], "detach") && argc == 3) {
374 int channel;
375
376 if (!(sscanf(argv[2], "ata%d", &channel) == 1)) {
377 fprintf(stderr,
378 "natacontrol: Invalid channel %s\n", argv[2]);
379 exit(EX_USAGE);
380 }
381 if (ioctl(fd, IOCATADETACH, &channel) < 0)
382 err(1, "ioctl(IOCATADETACH)");
383 exit(EX_OK);
384 }
385 if (!strcmp(argv[1], "attach") && argc == 3) {
386 int channel;
387
388 if (!(sscanf(argv[2], "ata%d", &channel) == 1)) {
389 fprintf(stderr,
390 "natacontrol: Invalid channel %s\n", argv[2]);
391 exit(EX_USAGE);
392 }
393 if (ioctl(fd, IOCATAATTACH, &channel) < 0)
394 err(1, "ioctl(IOCATAATTACH)");
395 info_print(fd, channel, 0);
396 exit(EX_OK);
397 }
398 if (!strcmp(argv[1], "reinit") && argc == 3) {
399 int channel;
400
401 if (!(sscanf(argv[2], "ata%d", &channel) == 1)) {
402 fprintf(stderr,
403 "natacontrol: Invalid channel %s\n", argv[2]);
404 exit(EX_USAGE);
405 }
406 if (ioctl(fd, IOCATAREINIT, &channel) < 0)
407 warn("ioctl(IOCATAREINIT)");
408 info_print(fd, channel, 0);
409 exit(EX_OK);
410 }
411 if (!strcmp(argv[1], "create")) {
412 int disk, dev, offset;
413 struct ata_ioc_raid_config config;
414
415 bzero(&config, sizeof(config));
416 if (argc > 2) {
417 if (!strcasecmp(argv[2], "RAID0") ||
418 !strcasecmp(argv[2], "stripe"))
419 config.type = AR_RAID0;
420 if (!strcasecmp(argv[2], "RAID1") ||
421 !strcasecmp(argv[2],"mirror"))
422 config.type = AR_RAID1;
423 if (!strcasecmp(argv[2], "RAID0+1") ||
424 !strcasecmp(argv[2],"RAID10"))
425 config.type = AR_RAID01;
426 if (!strcasecmp(argv[2], "RAID5"))
427 config.type = AR_RAID5;
428 if (!strcasecmp(argv[2], "SPAN"))
429 config.type = AR_SPAN;
430 if (!strcasecmp(argv[2], "JBOD"))
431 config.type = AR_JBOD;
432 }
433 if (!config.type) {
434 fprintf(stderr, "natacontrol: Invalid RAID type %s\n",
435 argv[2]);
436 fprintf(stderr, "natacontrol: Valid RAID types: \n");
437 fprintf(stderr, " stripe | mirror | "
438 "RAID0 | RAID1 | RAID0+1 | RAID5 | "
439 "SPAN | JBOD\n");
440 exit(EX_USAGE);
441 }
442
443 if (config.type == AR_RAID0 ||
444 config.type == AR_RAID01 ||
445 config.type == AR_RAID5) {
446 if (argc < 4 ||
447 !sscanf(argv[3], "%d", &config.interleave) == 1) {
448 fprintf(stderr,
449 "natacontrol: Invalid interleave %s\n",
450 argv[3]);
451 exit(EX_USAGE);
452 }
453 offset = 4;
454 }
455 else
456 offset = 3;
457
458 for (disk = 0; disk < 16 && (offset + disk) < argc; disk++) {
459 if (!(sscanf(argv[offset + disk], "ad%d", &dev) == 1)) {
460 fprintf(stderr,
461 "natacontrol: Invalid disk %s\n",
462 argv[offset + disk]);
463 exit(EX_USAGE);
464 }
465 config.disks[disk] = dev;
466 }
467
468 if ((config.type == AR_RAID1 || config.type == AR_RAID01) &&
469 disk < 2) {
470 fprintf(stderr, "natacontrol: At least 2 disks must be "
471 "specified\n");
472 exit(EX_USAGE);
473 }
474
475 config.total_disks = disk;
476 if (ioctl(fd, IOCATARAIDCREATE, &config) < 0)
477 err(1, "ioctl(IOCATARAIDCREATE)");
478 else
479 printf("ar%d created\n", config.lun);
480 exit(EX_OK);
481 }
482 if (!strcmp(argv[1], "delete") && argc == 3) {
483 int array;
484
485 if (!(sscanf(argv[2], "ar%d", &array) == 1)) {
486 fprintf(stderr,
487 "natacontrol: Invalid array %s\n", argv[2]);
488 exit(EX_USAGE);
489 }
490 if (ioctl(fd, IOCATARAIDDELETE, &array) < 0)
491 warn("ioctl(IOCATARAIDDELETE)");
492 exit(EX_OK);
493 }
494 if (!strcmp(argv[1], "addspare") && argc == 4) {
495 struct ata_ioc_raid_config config;
496
497 if (!(sscanf(argv[2], "ar%d", &config.lun) == 1)) {
498 fprintf(stderr,
499 "natacontrol: Invalid array %s\n", argv[2]);
500 usage();
501 }
502 if (!(sscanf(argv[3], "ad%d", &config.disks[0]) == 1)) {
503 fprintf(stderr,
504 "natacontrol: Invalid disk %s\n", argv[3]);
505 usage();
506 }
507 if (ioctl(fd, IOCATARAIDADDSPARE, &config) < 0)
508 warn("ioctl(IOCATARAIDADDSPARE)");
509 exit(EX_OK);
510 }
511 if (!strcmp(argv[1], "rebuild") && argc == 3) {
512 int array;
513
514 if (!(sscanf(argv[2], "ar%d", &array) == 1)) {
515 fprintf(stderr,
516 "natacontrol: Invalid array %s\n", argv[2]);
517 usage();
518 }
519 if (ioctl(fd, IOCATARAIDREBUILD, &array) < 0)
520 warn("ioctl(IOCATARAIDREBUILD)");
521 else {
522 char device[64];
523 char *buffer;
524 ssize_t len;
525 int arfd;
526
527 if (daemon(0, 1) == -1)
528 err(1, "daemon");
529 nice(20);
530 snprintf(device, sizeof(device), "/dev/ar%d",
531 array);
532 if ((arfd = open(device, O_RDONLY)) == -1)
533 err(1, "open %s", device);
534 if ((buffer = malloc(1024 * 1024)) == NULL)
535 err(1, "malloc");
536 while ((len = read(arfd, buffer, 1024 * 1024)) > 0)
537 ;
538 if (len == -1)
539 err(1, "read");
540 else
541 fprintf(stderr,
542 "atacontrol: ar%d rebuild completed\n",
543 array);
544 free(buffer);
545 close(arfd);
546 }
547 exit(EX_OK);
548 }
549 if (!strcmp(argv[1], "status") && argc == 3) {
550 struct ata_ioc_raid_config config;
551 int i;
552
553 if (!(sscanf(argv[2], "ar%d", &config.lun) == 1)) {
554 fprintf(stderr,
555 "natacontrol: Invalid array %s\n", argv[2]);
556 usage();
557 }
558 if (ioctl(fd, IOCATARAIDSTATUS, &config) < 0)
559 err(1, "ioctl(IOCATARAIDSTATUS)");
560
561 printf("ar%d: ATA ", config.lun);
562 switch (config.type) {
563 case AR_RAID0:
564 printf("RAID0 stripesize=%d", config.interleave);
565 break;
566 case AR_RAID1:
567 printf("RAID1");
568 break;
569 case AR_RAID01:
570 printf("RAID0+1 stripesize=%d", config.interleave);
571 break;
572 case AR_RAID5:
573 printf("RAID5 stripesize=%d", config.interleave);
574 break;
575 case AR_JBOD:
576 printf("JBOD");
577 case AR_SPAN:
578 printf("SPAN");
579 break;
580 }
581 printf(" subdisks: ");
582 for (i = 0; i < config.total_disks; i++) {
583 if (config.disks[i] >= 0)
584 printf("ad%d ", config.disks[i]);
585 else
586 printf("DOWN ");
587 }
588 printf("status: ");
589 switch (config.status) {
590 case AR_READY:
591 printf("READY\n");
592 break;
593 case AR_READY | AR_DEGRADED:
594 printf("DEGRADED\n");
595 break;
596 case AR_READY | AR_DEGRADED | AR_REBUILDING:
597 printf("REBUILDING %d%% completed\n",
598 config.progress);
599 break;
600 default:
601 printf("BROKEN\n");
602 }
603 exit(EX_OK);
604 }
605 usage();
606 exit(EX_OK);
607 }
DragonFly BSD