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 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #pragma ident "%Z%%M% %I% %E% SMI"
27
28 /*
29 * Just in case we're not in a build environment, make sure that
30 * TEXT_DOMAIN gets set to something.
31 */
32 #if !defined(TEXT_DOMAIN)
33 #define TEXT_DOMAIN "SYS_TEST"
34 #endif
35
36 /*
37 * print metedevice errors
38 */
39
40 #include <meta.h>
41 #include <sys/lvm/md_mddb.h>
42
43 #include <syslog.h>
44
45 /*
46 * clear error
47 */
48 void
mdclrerror(md_error_t * ep)49 mdclrerror(
50 md_error_t *ep
51 )
52 {
53 if (ep->name != NULL)
54 Free(ep->name);
55 if (ep->host != NULL)
56 Free(ep->host);
57 if (ep->extra != NULL)
58 Free(ep->extra);
59 (void) memset(ep, '\0', sizeof (*ep));
60 }
61
62 /*
63 * cook names
64 */
65 static char *
md_name(minor_t mnum)66 md_name(
67 minor_t mnum
68 )
69 {
70 char *name;
71
72 /* get name, or fake it */
73 if ((name = get_mdname(NULL, mnum)) == NULL) {
74 char buf[40];
75
76 (void) sprintf(buf, "%lu/%lu", MD_MIN2SET(mnum),
77 MD_MIN2UNIT(mnum));
78 return (Strdup(buf));
79 }
80 return (Strdup(name));
81 }
82
83 static char *
dev_name(set_t setno,md_dev64_t dev)84 dev_name(
85 set_t setno,
86 md_dev64_t dev
87 )
88 {
89 char *name;
90
91 /* get name or fake it */
92 if (dev == NODEV64)
93 return (Strdup(dgettext(TEXT_DOMAIN, "unknown device")));
94 if ((name = get_devname(setno, dev)) == NULL) {
95 char buf[40];
96
97 (void) sprintf(buf, "%lu.%lu", meta_getmajor(dev),
98 meta_getminor(dev));
99 return (Strdup(buf));
100 }
101 return (Strdup(name));
102 }
103
104 static char *
hsp_name(hsp_t hsp)105 hsp_name(
106 hsp_t hsp
107 )
108 {
109 char *name;
110
111 if ((name = get_hspname(NULL, hsp)) == NULL) {
112 char buf[40];
113
114 (void) sprintf(buf, "%u/%u", HSP_SET(hsp), HSP_ID(hsp));
115 return (Strdup(buf));
116 }
117 return (Strdup(name));
118 }
119
120 static char *
set_name(set_t setno)121 set_name(
122 set_t setno
123 )
124 {
125 mdsetname_t *sp;
126 md_error_t xep = mdnullerror;
127
128 if (setno == MD_SET_BAD)
129 return (NULL);
130
131 if ((sp = metasetnosetname(setno, &xep)) == NULL) {
132 char buf[40];
133
134 mdclrerror(&xep);
135 (void) sprintf(buf, "setno %u", setno);
136 return (Strdup(buf));
137 }
138 return (Strdup(sp->setname));
139 }
140
141 /*
142 * fill in all the appropriate md_error_t fields
143 */
144 static void
metacookerror(md_error_t * ep,char * name)145 metacookerror(
146 md_error_t *ep, /* generic error */
147 char *name /* optional name or host */
148 )
149 {
150 /* get host name */
151 if (ep->host != NULL) {
152 Free(ep->host);
153 ep->host = NULL;
154 }
155 if ((ep->info.errclass == MDEC_RPC) &&
156 (name != NULL) && (*name != '\0')) {
157 ep->host = Strdup(name);
158 name = NULL;
159 } else
160 ep->host = Strdup(mynode());
161
162 /* get appropriate name */
163 if (ep->name != NULL) {
164 Free(ep->name);
165 ep->name = NULL;
166 }
167 if ((name != NULL) && (*name != '\0')) {
168 ep->name = Strdup(name);
169 } else {
170 switch (ep->info.errclass) {
171
172 /* can't do anything about these */
173 case MDEC_VOID:
174 case MDEC_SYS:
175 case MDEC_RPC:
176 default:
177 break;
178
179 /* device name */
180 case MDEC_DEV:
181 {
182 md_dev_error_t *ip =
183 &ep->info.md_error_info_t_u.dev_error;
184
185 ep->name = dev_name(MD_SET_BAD, ip->dev);
186 break;
187 }
188
189 /* device name */
190 case MDEC_USE:
191 {
192 md_use_error_t *ip =
193 &ep->info.md_error_info_t_u.use_error;
194
195 ep->name = dev_name(MD_SET_BAD, ip->dev);
196 if (ip->where == NULL) {
197 ip->where = Strdup(dgettext(TEXT_DOMAIN,
198 "unknown"));
199 }
200 break;
201 }
202
203 /* metadevice name */
204 case MDEC_MD:
205 {
206 md_md_error_t *ip =
207 &ep->info.md_error_info_t_u.md_error;
208
209 ep->name = md_name(ip->mnum);
210 break;
211 }
212
213 /* component name */
214 case MDEC_COMP:
215 {
216 md_comp_error_t *ip =
217 &ep->info.md_error_info_t_u.comp_error;
218 char *mdname, *devname;
219 size_t len;
220
221 mdname = md_name(ip->comp.mnum);
222 devname = dev_name(MD_MIN2SET(ip->comp.mnum),
223 ip->comp.dev);
224 len = strlen(mdname) + strlen(": ")
225 + strlen(devname) + 1;
226 ep->name = Malloc(len);
227 (void) snprintf(ep->name, len, "%s: %s",
228 mdname, devname);
229 Free(mdname);
230 Free(devname);
231 break;
232 }
233
234 /* hotspare pool name */
235 case MDEC_HSP:
236 {
237 md_hsp_error_t *ip =
238 &ep->info.md_error_info_t_u.hsp_error;
239
240 ep->name = hsp_name(ip->hsp);
241 break;
242 }
243
244 /* hotspare name */
245 case MDEC_HS:
246 {
247 md_hs_error_t *ip =
248 &ep->info.md_error_info_t_u.hs_error;
249 char *hspname, *devname;
250 size_t len;
251
252 hspname = hsp_name(ip->hs.hsp);
253 devname = dev_name(HSP_SET(ip->hs.hsp), ip->hs.dev);
254 len = strlen(hspname) + strlen(": ")
255 + strlen(devname) + 1;
256 ep->name = Malloc(len);
257 (void) snprintf(ep->name, len, "%s: %s",
258 hspname, devname);
259 Free(hspname);
260 Free(devname);
261 break;
262 }
263
264 /* mddb name */
265 case MDEC_MDDB:
266 {
267 md_mddb_error_t *ip =
268 &ep->info.md_error_info_t_u.mddb_error;
269 if (ip->mnum != NODEV32)
270 ep->name = md_name(ip->mnum);
271 ep->name = set_name(ip->setno);
272 break;
273 }
274
275 /* set name */
276 case MDEC_DS:
277 {
278 md_ds_error_t *ip =
279 &ep->info.md_error_info_t_u.ds_error;
280
281 ep->name = set_name(ip->setno);
282 break;
283 }
284 }
285 }
286 }
287
288 /*
289 * simple error
290 */
291 int
mderror(md_error_t * ep,md_void_errno_t errnum,char * name)292 mderror(
293 md_error_t *ep,
294 md_void_errno_t errnum,
295 char *name
296 )
297 {
298 md_void_error_t *ip = &ep->info.md_error_info_t_u.void_error;
299
300 mdclrerror(ep);
301 ep->info.errclass = MDEC_VOID;
302 ip->errnum = errnum;
303
304 metacookerror(ep, name);
305 return (-1);
306 }
307
308 /*
309 * system error
310 */
311 int
mdsyserror(md_error_t * ep,int errnum,char * name)312 mdsyserror(
313 md_error_t *ep,
314 int errnum,
315 char *name
316 )
317 {
318 md_sys_error_t *ip = &ep->info.md_error_info_t_u.sys_error;
319
320 mdclrerror(ep);
321 if (errnum != 0) {
322 ep->info.errclass = MDEC_SYS;
323 ip->errnum = errnum;
324 }
325
326 metacookerror(ep, name);
327 return (-1);
328 }
329
330 /*
331 * RPC error
332 */
333 int
mdrpcerror(md_error_t * ep,CLIENT * clntp,char * host,char * extra)334 mdrpcerror(
335 md_error_t *ep,
336 CLIENT *clntp,
337 char *host,
338 char *extra
339 )
340 {
341 md_rpc_error_t *ip = &ep->info.md_error_info_t_u.rpc_error;
342 struct rpc_err rpcerr;
343
344 mdclrerror(ep);
345 clnt_geterr(clntp, &rpcerr);
346 ep->info.errclass = MDEC_RPC;
347 ip->errnum = rpcerr.re_status;
348
349 metacookerror(ep, host);
350 mderrorextra(ep, extra);
351 return (-1);
352 }
353
354 /*
355 * RPC create error
356 */
357 int
mdrpccreateerror(md_error_t * ep,char * host,char * extra)358 mdrpccreateerror(
359 md_error_t *ep,
360 char *host,
361 char *extra
362 )
363 {
364 md_rpc_error_t *ip = &ep->info.md_error_info_t_u.rpc_error;
365
366 mdclrerror(ep);
367 ep->info.errclass = MDEC_RPC;
368 ip->errnum = rpc_createerr.cf_stat;
369
370 metacookerror(ep, host);
371 mderrorextra(ep, extra);
372 return (-1);
373 }
374
375 /*
376 * device error
377 */
378 int
mddeverror(md_error_t * ep,md_dev_errno_t errnum,md_dev64_t dev,char * name)379 mddeverror(
380 md_error_t *ep,
381 md_dev_errno_t errnum,
382 md_dev64_t dev,
383 char *name
384 )
385 {
386 md_dev_error_t *ip = &ep->info.md_error_info_t_u.dev_error;
387
388 mdclrerror(ep);
389 ep->info.errclass = MDEC_DEV;
390 ip->errnum = errnum;
391 ip->dev = dev;
392
393 metacookerror(ep, name);
394 return (-1);
395 }
396
397 /*
398 * use error
399 */
400 int
mduseerror(md_error_t * ep,md_use_errno_t errnum,md_dev64_t dev,char * where,char * name)401 mduseerror(
402 md_error_t *ep,
403 md_use_errno_t errnum,
404 md_dev64_t dev,
405 char *where,
406 char *name
407 )
408 {
409 md_use_error_t *ip = &ep->info.md_error_info_t_u.use_error;
410
411 assert(where != NULL);
412 mdclrerror(ep);
413 ep->info.errclass = MDEC_USE;
414 ip->errnum = errnum;
415 ip->dev = dev;
416 ip->where = Strdup(where);
417
418 metacookerror(ep, name);
419 return (-1);
420 }
421
422 /*
423 * overlap error
424 */
425 int
mdoverlaperror(md_error_t * ep,md_overlap_errno_t errnum,char * name,char * where,char * overlap)426 mdoverlaperror(
427 md_error_t *ep,
428 md_overlap_errno_t errnum,
429 char *name,
430 char *where,
431 char *overlap
432 )
433 {
434 md_overlap_error_t *ip =
435 &ep->info.md_error_info_t_u.overlap_error;
436
437 assert(overlap != NULL);
438 mdclrerror(ep);
439 ep->info.errclass = MDEC_OVERLAP;
440 ip->errnum = errnum;
441 ip->overlap = Strdup(overlap);
442 ip->where = NULL;
443 if (where != NULL)
444 ip->where = Strdup(where);
445
446 metacookerror(ep, name);
447 return (-1);
448 }
449
450 /*
451 * metadevice error
452 */
453 int
mdmderror(md_error_t * ep,md_md_errno_t errnum,minor_t mnum,char * name)454 mdmderror(
455 md_error_t *ep,
456 md_md_errno_t errnum,
457 minor_t mnum,
458 char *name
459 )
460 {
461 md_md_error_t *ip = &ep->info.md_error_info_t_u.md_error;
462
463 mdclrerror(ep);
464 ep->info.errclass = MDEC_MD;
465 ip->errnum = errnum;
466 ip->mnum = mnum;
467
468 metacookerror(ep, name);
469 return (-1);
470 }
471
472 /*
473 * component error
474 */
475 int
mdcomperror(md_error_t * ep,md_comp_errno_t errnum,minor_t mnum,md_dev64_t dev,char * name)476 mdcomperror(
477 md_error_t *ep,
478 md_comp_errno_t errnum,
479 minor_t mnum,
480 md_dev64_t dev,
481 char *name
482 )
483 {
484 md_comp_error_t *ip = &ep->info.md_error_info_t_u.comp_error;
485
486 mdclrerror(ep);
487 ep->info.errclass = MDEC_COMP;
488 ip->errnum = errnum;
489 ip->comp.mnum = mnum;
490 ip->comp.dev = dev;
491
492 metacookerror(ep, name);
493 return (-1);
494 }
495
496 /*
497 * hotspare pool error
498 */
499 int
mdhsperror(md_error_t * ep,md_hsp_errno_t errnum,hsp_t hsp,char * name)500 mdhsperror(
501 md_error_t *ep,
502 md_hsp_errno_t errnum,
503 hsp_t hsp,
504 char *name
505 )
506 {
507 md_hsp_error_t *ip = &ep->info.md_error_info_t_u.hsp_error;
508
509 mdclrerror(ep);
510 ep->info.errclass = MDEC_HSP;
511 ip->errnum = errnum;
512 ip->hsp = hsp;
513
514 metacookerror(ep, name);
515 return (-1);
516 }
517
518 /*
519 * hotspare error
520 */
521 int
mdhserror(md_error_t * ep,md_hs_errno_t errnum,hsp_t hsp,md_dev64_t dev,char * name)522 mdhserror(
523 md_error_t *ep,
524 md_hs_errno_t errnum,
525 hsp_t hsp,
526 md_dev64_t dev,
527 char *name
528 )
529 {
530 md_hs_error_t *ip = &ep->info.md_error_info_t_u.hs_error;
531
532 mdclrerror(ep);
533 ep->info.errclass = MDEC_HS;
534 ip->errnum = errnum;
535 ip->hs.hsp = hsp;
536 ip->hs.dev = dev;
537
538 metacookerror(ep, name);
539 return (-1);
540 }
541
542 /*
543 * MDDB error
544 */
545 int
mdmddberror(md_error_t * ep,md_mddb_errno_t errnum,minor_t mnum,set_t setno,size_t size,char * name)546 mdmddberror(
547 md_error_t *ep,
548 md_mddb_errno_t errnum,
549 minor_t mnum,
550 set_t setno,
551 size_t size,
552 char *name
553 )
554 {
555 md_mddb_error_t *ip = &ep->info.md_error_info_t_u.mddb_error;
556
557 mdclrerror(ep);
558 ep->info.errclass = MDEC_MDDB;
559 ip->errnum = errnum;
560 ip->mnum = mnum;
561 ip->setno = setno;
562 ip->size = size;
563
564 metacookerror(ep, name);
565 return (-1);
566 }
567
568 /*
569 * metadevice diskset (ds) error
570 */
571 int
mddserror(md_error_t * ep,md_ds_errno_t errnum,set_t setno,char * node,char * drive,char * name)572 mddserror(
573 md_error_t *ep,
574 md_ds_errno_t errnum,
575 set_t setno,
576 char *node,
577 char *drive,
578 char *name
579 )
580 {
581 md_ds_error_t *ip = &ep->info.md_error_info_t_u.ds_error;
582
583 mdclrerror(ep);
584 ep->info.errclass = MDEC_DS;
585 ip->errnum = errnum;
586 ip->setno = setno;
587 ip->node = ((node != NULL) ? Strdup(node) : NULL);
588 ip->drive = ((drive != NULL) ? Strdup(drive) : NULL);
589
590 metacookerror(ep, name);
591 return (-1);
592 }
593
594 /*
595 * clear/attach extra context information
596 */
597 void
mderrorextra(md_error_t * ep,char * extra)598 mderrorextra(
599 md_error_t *ep,
600 char *extra
601 )
602 {
603 if (ep->extra != NULL)
604 Free(ep->extra);
605 if (extra != NULL)
606 ep->extra = Strdup(extra);
607 else
608 ep->extra = NULL;
609 }
610
611 /*
612 * steal (copy) an error code safely
613 */
614 int
mdstealerror(md_error_t * to,md_error_t * from)615 mdstealerror(
616 md_error_t *to,
617 md_error_t *from
618 )
619 {
620 mdclrerror(to);
621 *to = *from;
622 (void) memset(from, '\0', sizeof (*from));
623 return (-1);
624 }
625
626 /*
627 * do an ioctl, cook the error, and return status
628 */
629 int
metaioctl(int cmd,void * data,md_error_t * ep,char * name)630 metaioctl(
631 int cmd,
632 void *data,
633 md_error_t *ep,
634 char *name
635 )
636 {
637 int fd;
638
639 /* open admin device */
640 if ((fd = open_admin(ep)) < 0)
641 return (-1);
642
643 /* do ioctl */
644 mdclrerror(ep);
645 if (ioctl(fd, cmd, data) != 0) {
646 return (mdsyserror(ep, errno, name));
647 } else if (! mdisok(ep)) {
648 metacookerror(ep, name);
649 return (-1);
650 }
651
652 /* return success */
653 return (0);
654 }
655
656 /*
657 * print void class errors
658 */
659 static char *
void_to_str(md_error_t * ep,char * buf,size_t size)660 void_to_str(
661 md_error_t *ep,
662 char *buf,
663 size_t size
664 )
665 {
666 md_void_error_t *ip = &ep->info.md_error_info_t_u.void_error;
667 char *p = buf + strlen(buf);
668 size_t psize = size - strlen(buf);
669
670 switch (ip->errnum) {
671 case MDE_NONE:
672 (void) snprintf(p, psize,
673 dgettext(TEXT_DOMAIN, "no error"));
674 break;
675 case MDE_UNIT_NOT_FOUND:
676 (void) snprintf(p, psize,
677 dgettext(TEXT_DOMAIN, "unit not found"));
678 break;
679 case MDE_DUPDRIVE:
680 (void) snprintf(p, psize,
681 dgettext(TEXT_DOMAIN, "drive specified more than once"));
682 break;
683 case MDE_INVAL_HSOP:
684 (void) snprintf(p, psize,
685 dgettext(TEXT_DOMAIN, "illegal hot spare operation"));
686 break;
687 case MDE_NO_SET:
688 (void) snprintf(p, psize,
689 dgettext(TEXT_DOMAIN, "no such set"));
690 break;
691 case MDE_SET_DIFF:
692 (void) snprintf(p, psize,
693 dgettext(TEXT_DOMAIN, "set name is inconsistent"));
694 break;
695 case MDE_BAD_RD_OPT:
696 (void) snprintf(p, psize,
697 dgettext(TEXT_DOMAIN, "invalid read option"));
698 break;
699 case MDE_BAD_WR_OPT:
700 (void) snprintf(p, psize,
701 dgettext(TEXT_DOMAIN, "invalid write option"));
702 break;
703 case MDE_BAD_PASS_NUM:
704 (void) snprintf(p, psize,
705 dgettext(TEXT_DOMAIN, "invalid pass number"));
706 break;
707 case MDE_BAD_RESYNC_OPT:
708 (void) snprintf(p, psize,
709 dgettext(TEXT_DOMAIN, "invalid resync option"));
710 break;
711 case MDE_BAD_INTERLACE:
712 (void) snprintf(p, psize,
713 dgettext(TEXT_DOMAIN, "invalid interlace"));
714 break;
715 case MDE_NO_HSPS:
716 (void) snprintf(p, psize,
717 dgettext(TEXT_DOMAIN, "no hotspare pools found"));
718 break;
719 case MDE_NOTENOUGH_DB:
720 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
721 "must have at least 1 database (-f overrides)"));
722 break;
723 case MDE_DELDB_NOTALLOWED:
724 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
725 "cannot delete the last database replica in the diskset"));
726 break;
727 case MDE_DEL_VALIDDB_NOTALLOWED:
728 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
729 "Deleting specified valid replicas results in stale "
730 "state database. Configuration changes with stale "
731 "database result in panic(-f overrides)"));
732 break;
733 case MDE_SYSTEM_FILE:
734 (void) snprintf(p, psize,
735 dgettext(TEXT_DOMAIN, "error in system file"));
736 break;
737 case MDE_MDDB_FILE:
738 (void) snprintf(p, psize,
739 dgettext(TEXT_DOMAIN, "error in mddb.cf file"));
740 break;
741 case MDE_MDDB_CKSUM:
742 (void) snprintf(p, psize,
743 dgettext(TEXT_DOMAIN, "checksum error in mddb.cf file"));
744 break;
745 case MDE_VFSTAB_FILE:
746 (void) snprintf(p, psize,
747 dgettext(TEXT_DOMAIN, "error in vfstab file"));
748 break;
749 case MDE_NOSLICE:
750 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
751 "invalid slice number for drive name"));
752 break;
753 case MDE_SYNTAX:
754 (void) snprintf(p, psize,
755 dgettext(TEXT_DOMAIN, "syntax error"));
756 break;
757 case MDE_OPTION:
758 (void) snprintf(p, psize,
759 dgettext(TEXT_DOMAIN, "illegal option"));
760 break;
761 case MDE_TAKE_OWN:
762 (void) snprintf(p, psize,
763 dgettext(TEXT_DOMAIN, "failed to reserve any drives"));
764 break;
765 case MDE_NOT_DRIVENAME:
766 (void) snprintf(p, psize,
767 dgettext(TEXT_DOMAIN, "not a valid drive name"));
768 break;
769 case MDE_RESERVED:
770 (void) snprintf(p, psize,
771 dgettext(TEXT_DOMAIN, "reserved by another host"));
772 break;
773 case MDE_DVERSION:
774 (void) snprintf(p, psize,
775 dgettext(TEXT_DOMAIN, "driver version mismatch"));
776 break;
777 case MDE_MVERSION:
778 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
779 "metadevice state database version mismatch"));
780 break;
781 case MDE_TESTERROR:
782 (void) snprintf(p, psize,
783 dgettext(TEXT_DOMAIN, "TEST ERROR MESSAGE"));
784 break;
785 case MDE_BAD_ORIG_NCOL:
786 (void) snprintf(p, psize,
787 dgettext(TEXT_DOMAIN, "invalid column count"));
788 break;
789 case MDE_RAID_INVALID:
790 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
791 "devices were not RAIDed previously or "
792 "are specified in the wrong order"));
793 break;
794 case MDE_MED_ERROR:
795 break;
796 case MDE_TOOMANYMED:
797 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
798 "too many mediator hosts requested"));
799 break;
800 case MDE_NOMED:
801 (void) snprintf(p, psize,
802 dgettext(TEXT_DOMAIN, "no mediator hosts found"));
803 break;
804 case MDE_ONLYNODENAME:
805 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
806 "only the nodename of a host is required for deletes"));
807 break;
808 case MDE_RAID_BAD_PW_CNT:
809 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
810 "simultaneous writes out of range"));
811 break;
812 case MDE_DEVID_TOOBIG:
813 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
814 "relocation information size is greater than reported"));
815 break;
816 case MDE_NOPERM:
817 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
818 "Permission denied. You must have root privilege "
819 "to execute this command."));
820 break;
821 case MDE_NODEVID:
822 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
823 "Device relocation information not available "
824 "for this device"));
825 break;
826 case MDE_NOROOT:
827 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
828 "no root filesystem in /etc/mnttab"));
829 break;
830 case MDE_EOF_TRANS:
831 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
832 MD_EOF_TRANS_MSG));
833 break;
834 case MDE_NOT_MN:
835 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
836 "option only valid within a multi-owner set"));
837 break;
838 case MDE_ABR_SET:
839 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
840 "Invalid command for mirror with ABR set"));
841 break;
842 case MDE_INVAL_MNOP:
843 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
844 "Invalid operation on multi-owner set"));
845 break;
846 case MDE_MNSET_NOTRANS:
847 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
848 "Trans metadevice not supported on multi-owner set"));
849 break;
850 case MDE_MNSET_NORAID:
851 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
852 "RAID-5 metadevice not supported on multi-owner set"));
853 break;
854 case MDE_FORCE_DEL_ALL_DRV:
855 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
856 "Must specify -f option to delete all drives from set"));
857 break;
858 case MDE_STRIPE_TRUNC_SINGLE:
859 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
860 "The necessary rounding would result in data loss. "
861 "You can avoid this by concatenating additional devices "
862 "totaling at least %s blocks, or by increasing the size "
863 "of the specified component by exactly %s blocks."),
864 ep->extra, ep->extra);
865 break;
866 case MDE_STRIPE_TRUNC_MULTIPLE:
867 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
868 "The necessary rounding would result in data loss. "
869 "You can avoid this by concatenating additional devices "
870 "totaling at least %s blocks."), ep->extra);
871 break;
872 case MDE_SMF_FAIL:
873 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
874 "failed to enable/disable SVM service"));
875 break;
876 case MDE_SMF_NO_SERVICE:
877 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
878 "service(s) not online in SMF"));
879 break;
880 case MDE_AMBIGUOUS_DEV:
881 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
882 "Specify complete path to avoid ambiguity."));
883 break;
884 case MDE_NAME_IN_USE:
885 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
886 "Name already in use for metadevice or hot spare pool."));
887 break;
888 case MDE_NAME_ILLEGAL:
889 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
890 "Invalid name for metadevice or hot spare pool."));
891 break;
892 case MDE_ZONE_ADMIN:
893 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
894 "Volume administration unavailable within non-global zones."));
895 break;
896 case MDE_MISSING_DEVID_DISK:
897 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
898 "device id does not exist."));
899 break;
900 default:
901 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
902 "unknown void error code %d"), ip->errnum);
903 break;
904 }
905
906 return (buf);
907 }
908
909 /*
910 * print sys class errors
911 */
912 static char *
sys_to_str(md_error_t * ep,char * buf,size_t size)913 sys_to_str(
914 md_error_t *ep,
915 char *buf,
916 size_t size
917 )
918 {
919 md_sys_error_t *ip = &ep->info.md_error_info_t_u.sys_error;
920 char *emsg;
921 char *p = buf + strlen(buf);
922 size_t psize = size - strlen(buf);
923
924 if ((emsg = strerror(ip->errnum)) == NULL) {
925 (void) snprintf(p, psize,
926 dgettext(TEXT_DOMAIN, "unknown errno %d out of range"),
927 ip->errnum);
928 } else {
929 (void) snprintf(p, psize, "%s", emsg);
930 }
931
932 return (buf);
933 }
934
935 /*
936 * print RPC class errors
937 */
938 static char *
rpc_to_str(md_error_t * ep,char * buf,size_t size)939 rpc_to_str(
940 md_error_t *ep,
941 char *buf,
942 size_t size
943 )
944 {
945 md_rpc_error_t *ip = &ep->info.md_error_info_t_u.rpc_error;
946 char *p = buf + strlen(buf);
947 size_t psize = size - strlen(buf);
948
949 (void) snprintf(p, psize, "%s", clnt_sperrno(ip->errnum));
950 return (buf);
951 }
952
953 /*
954 * print dev class errors
955 */
956 static char *
dev_to_str(md_error_t * ep,char * buf,size_t size)957 dev_to_str(
958 md_error_t *ep,
959 char *buf,
960 size_t size
961 )
962 {
963 md_dev_error_t *ip = &ep->info.md_error_info_t_u.dev_error;
964 char *p = buf + strlen(buf);
965 size_t psize = size - strlen(buf);
966
967 switch (ip->errnum) {
968 case MDE_INVAL_HS:
969 (void) snprintf(p, psize,
970 dgettext(TEXT_DOMAIN, "hotspare doesn't exist"));
971 break;
972 case MDE_FIX_INVAL_STATE:
973 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
974 "cannot enable hotspared device"));
975 break;
976 case MDE_FIX_INVAL_HS_STATE:
977 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
978 "hotspare isn't broken, can't enable"));
979 break;
980 case MDE_NOT_META:
981 (void) snprintf(p, psize,
982 dgettext(TEXT_DOMAIN, "not a metadevice"));
983 break;
984 case MDE_IS_DUMP:
985 (void) snprintf(p, psize,
986 dgettext(TEXT_DOMAIN, "is a dump device"));
987 break;
988 case MDE_IS_META:
989 (void) snprintf(p, psize,
990 dgettext(TEXT_DOMAIN, "is a metadevice"));
991 break;
992 case MDE_IS_SWAPPED:
993 (void) snprintf(p, psize,
994 dgettext(TEXT_DOMAIN, "is swapped on"));
995 break;
996 case MDE_NAME_SPACE:
997 (void) snprintf(p, psize,
998 dgettext(TEXT_DOMAIN, "namespace error"));
999 break;
1000 case MDE_IN_SHARED_SET:
1001 (void) snprintf(p, psize,
1002 dgettext(TEXT_DOMAIN, "device in shared set"));
1003 break;
1004 case MDE_NOT_IN_SET:
1005 (void) snprintf(p, psize,
1006 dgettext(TEXT_DOMAIN, "device not in set"));
1007 break;
1008 case MDE_NOT_DISK:
1009 (void) snprintf(p, psize,
1010 dgettext(TEXT_DOMAIN, "not a disk device"));
1011 break;
1012 case MDE_CANT_CONFIRM:
1013 (void) snprintf(p, psize,
1014 dgettext(TEXT_DOMAIN, "can't confirm device"));
1015 break;
1016 case MDE_INVALID_PART:
1017 (void) snprintf(p, psize,
1018 dgettext(TEXT_DOMAIN, "invalid partition"));
1019 break;
1020 case MDE_HAS_MDDB:
1021 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1022 "has a metadevice database replica"));
1023 break;
1024 case MDE_NO_DB:
1025 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1026 "no metadevice database replica on device"));
1027 break;
1028 case MDE_CANTVERIFY_VTOC:
1029 (void) snprintf(p, psize,
1030 dgettext(TEXT_DOMAIN, "unable to verify the vtoc"));
1031 break;
1032 case MDE_NOT_LOCAL:
1033 (void) snprintf(p, psize,
1034 dgettext(TEXT_DOMAIN, "not in local set"));
1035 break;
1036 case MDE_DEVICES_NAME:
1037 (void) snprintf(p, psize,
1038 dgettext(TEXT_DOMAIN, "can't parse /devices name"));
1039 break;
1040 case MDE_REPCOMP_INVAL:
1041 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1042 "replica slice is not usable as a metadevice component"));
1043 break;
1044 case MDE_REPCOMP_ONLY:
1045 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1046 "only replica slice is usable for a diskset "
1047 "database replica"));
1048 break;
1049 case MDE_INV_ROOT:
1050 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1051 "invalid root device for this operation"));
1052 break;
1053 case MDE_MULTNM:
1054 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1055 "multiple entries for device in Solaris Volume Manager "
1056 "configuration"));
1057 break;
1058 case MDE_TOO_MANY_PARTS:
1059 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1060 "Disks with more than %d partitions are not supported "
1061 "in Solaris Volume Manager"), MD_MAX_PARTS);
1062 break;
1063 case MDE_REPART_REPLICA:
1064 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1065 "cannot repartition a slice with an existing replica"));
1066 break;
1067 case MDE_DISKNAMETOOLONG:
1068 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1069 "disk name is too long with device ids disabled "
1070 "in Solaris Volume Manager. Check /kernel/drv/md.conf "
1071 "for md_devid_destroy, remove it and reboot"));
1072 break;
1073 default:
1074 (void) snprintf(p, psize,
1075 dgettext(TEXT_DOMAIN, "unknown dev error code %d"),
1076 ip->errnum);
1077 break;
1078 }
1079
1080 return (buf);
1081 }
1082
1083 /*
1084 * print overlap class errors
1085 */
1086 static char *
overlap_to_str(md_error_t * ep,char * buf,size_t size)1087 overlap_to_str(
1088 md_error_t *ep,
1089 char *buf,
1090 size_t size
1091 )
1092 {
1093 md_overlap_error_t *ip =
1094 &ep->info.md_error_info_t_u.overlap_error;
1095 char *p = buf + strlen(buf);
1096 size_t psize = size - strlen(buf);
1097
1098 switch (ip->errnum) {
1099 case MDE_OVERLAP_MOUNTED:
1100 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1101 "overlaps with %s which is mounted as \'%s\'"),
1102 ip->overlap, ip->where);
1103 break;
1104 case MDE_OVERLAP_SWAP:
1105 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1106 "overlaps with %s which is a swap device"), ip->overlap);
1107 break;
1108 case MDE_OVERLAP_DUMP:
1109 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1110 "overlaps with %s which is the dump device"), ip->overlap);
1111 break;
1112 default:
1113 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1114 "unknown overlap error code %d"), ip->errnum);
1115 break;
1116 }
1117
1118 return (buf);
1119 }
1120
1121 /*
1122 * print use class errors
1123 */
1124 static char *
use_to_str(md_error_t * ep,char * buf,size_t size)1125 use_to_str(
1126 md_error_t *ep,
1127 char *buf,
1128 size_t size
1129 )
1130 {
1131 md_use_error_t *ip = &ep->info.md_error_info_t_u.use_error;
1132 char *p = buf + strlen(buf);
1133 size_t psize = size - strlen(buf);
1134
1135 switch (ip->errnum) {
1136 case MDE_IS_MOUNTED:
1137 (void) snprintf(p, psize,
1138 dgettext(TEXT_DOMAIN, "is mounted on %s"),
1139 ip->where);
1140 break;
1141 case MDE_ALREADY:
1142 /*
1143 * when the object of the error (existing device that
1144 * would being used by SVM) is the metadb then it is necessary
1145 * to explicitly specify the string in the error message so
1146 * that it can be successfully localized for the Asian locales.
1147 */
1148 if (strcmp(ip->where, MDB_STR) != 0) {
1149 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1150 "has appeared more than once in the "
1151 "specification of %s"), ip->where);
1152 } else {
1153 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1154 "has appeared more than once in the "
1155 "specification of " MDB_STR));
1156 }
1157 break;
1158 case MDE_OVERLAP:
1159 /*
1160 * when the object of the error (existing device that
1161 * would overlap) is the metadb then it is necessary
1162 * to explicitly specify the string in the error message so
1163 * that it can be successfully localized for the Asian locales.
1164 */
1165 if (strcmp(ip->where, MDB_STR) != 0) {
1166 (void) snprintf(p, psize,
1167 dgettext(TEXT_DOMAIN, "overlaps with device in %s"),
1168 ip->where);
1169 } else {
1170 (void) snprintf(p, psize,
1171 dgettext(TEXT_DOMAIN, "overlaps with device in "
1172 MDB_STR));
1173 }
1174 break;
1175 case MDE_SAME_DEVID:
1176 /*
1177 * when the object of the error (existing device in the
1178 * metaconfiguration that has the same devid)
1179 * is the metadb then it is necessary
1180 * to explicitly specify the string in the error message so
1181 * that it can be successfully localized for the Asian locales.
1182 */
1183 if (strcmp(ip->where, MDB_STR) != 0) {
1184 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1185 "identical devid detected on %s"), ip->where);
1186 } else {
1187 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1188 "identical devid detected in " MDB_STR));
1189 }
1190 break;
1191 default:
1192 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1193 "unknown dev error code %d"), ip->errnum);
1194 break;
1195 }
1196
1197 return (buf);
1198 }
1199
1200 /*
1201 * print md class errors
1202 */
1203 static char *
md_to_str(md_error_t * ep,char * buf,size_t size)1204 md_to_str(
1205 md_error_t *ep,
1206 char *buf,
1207 size_t size
1208 )
1209 {
1210 md_md_error_t *ip = &ep->info.md_error_info_t_u.md_error;
1211 char *p = buf + strlen(buf);
1212 size_t psize = size - strlen(buf);
1213
1214 switch (ip->errnum) {
1215 case MDE_INVAL_UNIT:
1216 (void) snprintf(p, psize,
1217 dgettext(TEXT_DOMAIN, "invalid unit"));
1218 break;
1219 case MDE_UNIT_NOT_SETUP:
1220 (void) snprintf(p, psize,
1221 dgettext(TEXT_DOMAIN, "unit not set up"));
1222 break;
1223 case MDE_UNIT_ALREADY_SETUP:
1224 (void) snprintf(p, psize,
1225 dgettext(TEXT_DOMAIN, "unit already set up"));
1226 break;
1227 case MDE_NOT_MM:
1228 (void) snprintf(p, psize,
1229 dgettext(TEXT_DOMAIN, "unit is not a mirror"));
1230 break;
1231 case MDE_IS_SM:
1232 (void) snprintf(p, psize,
1233 dgettext(TEXT_DOMAIN, "illegal to clear submirror"));
1234 break;
1235 case MDE_IS_OPEN:
1236 (void) snprintf(p, psize,
1237 dgettext(TEXT_DOMAIN, "metadevice is open"));
1238 break;
1239 case MDE_C_WITH_INVAL_SM:
1240 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1241 "attempted to clear mirror with submirror(s) "
1242 "in invalid state"));
1243 break;
1244 case MDE_RESYNC_ACTIVE:
1245 (void) snprintf(p, psize,
1246 dgettext(TEXT_DOMAIN, "resync in progress"));
1247 break;
1248 case MDE_LAST_SM_RE:
1249 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1250 "attempt to replace a component on the last "
1251 "running submirror"));
1252 break;
1253 case MDE_MIRROR_FULL:
1254 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1255 "mirror has maximum number of submirrors"));
1256 break;
1257 case MDE_IN_UNAVAIL_STATE:
1258 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1259 "component is in unavailable state; run 'metastat -i'"));
1260 break;
1261 case MDE_IN_USE:
1262 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1263 "metadevice in use"));
1264 break;
1265 case MDE_SM_TOO_SMALL:
1266 (void) snprintf(p, psize,
1267 dgettext(TEXT_DOMAIN, "submirror too small to attach"));
1268 break;
1269 case MDE_NO_LABELED_SM:
1270 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1271 "can't attach labeled submirror to an unlabeled mirror"));
1272 break;
1273 case MDE_SM_OPEN_ERR:
1274 (void) snprintf(p, psize,
1275 dgettext(TEXT_DOMAIN, "submirror open error"));
1276 break;
1277 case MDE_CANT_FIND_SM:
1278 (void) snprintf(p, psize,
1279 dgettext(TEXT_DOMAIN, "can't find submirror in mirror"));
1280 break;
1281 case MDE_LAST_SM:
1282 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1283 "attempt to detach last running submirror"));
1284 break;
1285 case MDE_NO_READABLE_SM:
1286 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1287 "operation would result in no readable submirrors"));
1288 break;
1289 case MDE_SM_FAILED_COMPS:
1290 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1291 "attempt an operation on a submirror "
1292 "that has erred components"));
1293 break;
1294 case MDE_ILLEGAL_SM_STATE:
1295 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1296 "attempt operation on a submirror in illegal state"));
1297 break;
1298 case MDE_RR_ALLOC_ERROR:
1299 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1300 "attach failed, unable to allocate new resync info"));
1301 break;
1302 case MDE_MIRROR_OPEN_FAILURE:
1303 (void) snprintf(p, psize,
1304 dgettext(TEXT_DOMAIN, "insufficient devices to open"));
1305 break;
1306 case MDE_MIRROR_THREAD_FAILURE:
1307 (void) snprintf(p, psize,
1308 dgettext(TEXT_DOMAIN, "mirror thread failure"));
1309 break;
1310 case MDE_GROW_DELAYED:
1311 (void) snprintf(p, psize,
1312 dgettext(TEXT_DOMAIN, "growing of metadevice delayed"));
1313 break;
1314 case MDE_NOT_MT:
1315 (void) snprintf(p, psize,
1316 dgettext(TEXT_DOMAIN, "unit is not a trans"));
1317 break;
1318 case MDE_HS_IN_USE:
1319 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1320 "can't modify hot spare pool, hot spare in use"));
1321 break;
1322 case MDE_HAS_LOG:
1323 (void) snprintf(p, psize,
1324 dgettext(TEXT_DOMAIN, "already has log"));
1325 break;
1326 case MDE_UNKNOWN_TYPE:
1327 (void) snprintf(p, psize,
1328 dgettext(TEXT_DOMAIN, "unknown metadevice type"));
1329 break;
1330 case MDE_NOT_STRIPE:
1331 (void) snprintf(p, psize,
1332 dgettext(TEXT_DOMAIN, "unit is not a concat/stripe"));
1333 break;
1334 case MDE_NOT_RAID:
1335 (void) snprintf(p, psize,
1336 dgettext(TEXT_DOMAIN, "unit is not a RAID"));
1337 break;
1338 case MDE_NROWS:
1339 (void) snprintf(p, psize,
1340 dgettext(TEXT_DOMAIN, "not enough stripes specified"));
1341 break;
1342 case MDE_NCOMPS:
1343 (void) snprintf(p, psize,
1344 dgettext(TEXT_DOMAIN, "not enough components specified"));
1345 break;
1346 case MDE_NSUBMIRS:
1347 (void) snprintf(p, psize,
1348 dgettext(TEXT_DOMAIN, "not enough submirrors specified"));
1349 break;
1350 case MDE_BAD_STRIPE:
1351 (void) snprintf(p, psize,
1352 dgettext(TEXT_DOMAIN, "invalid stripe configuration"));
1353 break;
1354 case MDE_BAD_MIRROR:
1355 (void) snprintf(p, psize,
1356 dgettext(TEXT_DOMAIN, "invalid mirror configuration"));
1357 break;
1358 case MDE_BAD_TRANS:
1359 (void) snprintf(p, psize,
1360 dgettext(TEXT_DOMAIN, "invalid trans configuration"));
1361 break;
1362 case MDE_BAD_RAID:
1363 (void) snprintf(p, psize,
1364 dgettext(TEXT_DOMAIN, "invalid RAID configuration"));
1365 break;
1366 case MDE_RAID_OPEN_FAILURE:
1367 (void) snprintf(p, psize,
1368 dgettext(TEXT_DOMAIN, "resync unable to open RAID unit"));
1369 break;
1370 case MDE_RAID_THREAD_FAILURE:
1371 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1372 "attempt to start resync thread failed"));
1373 break;
1374 case MDE_RAID_NEED_FORCE:
1375 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1376 "operation requires -f (force) flag"));
1377 break;
1378 case MDE_NO_LOG:
1379 (void) snprintf(p, psize,
1380 dgettext(TEXT_DOMAIN, "log has already been detached"));
1381 break;
1382 case MDE_RAID_DOI:
1383 (void) snprintf(p, psize,
1384 dgettext(TEXT_DOMAIN, "only valid action is metaclear"));
1385 break;
1386 case MDE_RAID_LAST_ERRED:
1387 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1388 "in Last Erred state, "
1389 "errored components must be replaced"));
1390 break;
1391 case MDE_RAID_NOT_OKAY:
1392 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1393 "all components must be Okay to perform this operation"));
1394 break;
1395 case MDE_RENAME_BUSY:
1396 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1397 "metadevice is temporarily too busy for renames"));
1398 break;
1399 case MDE_RENAME_SOURCE_BAD:
1400 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1401 "source metadevice is not able to be renamed"));
1402 break;
1403 case MDE_RENAME_TARGET_BAD:
1404 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1405 "target metadevice is not able to be renamed"));
1406 break;
1407 case MDE_RENAME_TARGET_UNRELATED:
1408 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1409 "target metadevice is not related to source metadevice"));
1410 break;
1411 case MDE_RENAME_CONFIG_ERROR:
1412 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1413 "metadevice driver configuration error; "
1414 "rename can't occur"));
1415 break;
1416 case MDE_RENAME_ORDER:
1417 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1418 "units may not be renamed in that order"));
1419 break;
1420 case MDE_RECOVER_FAILED:
1421 (void) snprintf(p, psize,
1422 dgettext(TEXT_DOMAIN, "recovery failed"));
1423 break;
1424 case MDE_SP_NOSPACE:
1425 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1426 "not enough space available for request"));
1427 break;
1428 case MDE_SP_BADWMREAD:
1429 (void) snprintf(p, psize,
1430 dgettext(TEXT_DOMAIN, "error reading extent header"));
1431 break;
1432 case MDE_SP_BADWMWRITE:
1433 (void) snprintf(p, psize,
1434 dgettext(TEXT_DOMAIN, "error writing extent header"));
1435 break;
1436 case MDE_SP_BADWMMAGIC:
1437 (void) snprintf(p, psize,
1438 dgettext(TEXT_DOMAIN, "bad magic number in extent header"));
1439 break;
1440 case MDE_SP_BADWMCRC:
1441 (void) snprintf(p, psize,
1442 dgettext(TEXT_DOMAIN, "bad checksum in extent header"));
1443 break;
1444 case MDE_NOT_SP:
1445 (void) snprintf(p, psize,
1446 dgettext(TEXT_DOMAIN, "unit is not a soft partition"));
1447 break;
1448 case MDE_SP_OVERLAP:
1449 (void) snprintf(p, psize,
1450 dgettext(TEXT_DOMAIN, "overlapping extents specified"));
1451 break;
1452 case MDE_SP_BAD_LENGTH:
1453 (void) snprintf(p, psize,
1454 dgettext(TEXT_DOMAIN, "bad length specified"));
1455 break;
1456 case MDE_SP_NOSP:
1457 (void) snprintf(p, psize,
1458 dgettext(TEXT_DOMAIN, "no soft partitions on this device"));
1459 break;
1460 case MDE_UNIT_TOO_LARGE:
1461 (void) snprintf(p, psize,
1462 dgettext(TEXT_DOMAIN, "Volume size cannot exceed 1 TByte"));
1463 break;
1464 case MDE_LOG_TOO_LARGE:
1465 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1466 "Trans log size must be less than 1 TByte"));
1467 break;
1468 default:
1469 (void) snprintf(p, psize,
1470 dgettext(TEXT_DOMAIN, "unknown md error code %d"),
1471 ip->errnum);
1472 break;
1473 }
1474
1475 return (buf);
1476 }
1477
1478 /*
1479 * print comp class errors
1480 */
1481 static char *
comp_to_str(md_error_t * ep,char * buf,size_t size)1482 comp_to_str(
1483 md_error_t *ep,
1484 char *buf,
1485 size_t size
1486 )
1487 {
1488 md_comp_error_t *ip = &ep->info.md_error_info_t_u.comp_error;
1489 char *p = buf + strlen(buf);
1490 size_t psize = size - strlen(buf);
1491
1492 switch (ip->errnum) {
1493 case MDE_CANT_FIND_COMP:
1494 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1495 "can't find component in unit"));
1496 break;
1497 case MDE_REPL_INVAL_STATE:
1498 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1499 "component in invalid state to replace - "
1500 "Replace \"Maintenance\" components first"));
1501 break;
1502 case MDE_COMP_TOO_SMALL:
1503 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1504 "replace failure, new component is too small"));
1505 break;
1506 case MDE_COMP_OPEN_ERR:
1507 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1508 "unable to open concat/stripe component"));
1509 break;
1510 case MDE_RAID_COMP_ERRED:
1511 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1512 "must replace errored component first"));
1513 break;
1514 case MDE_MAXIO:
1515 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1516 "maxtransfer is too small"));
1517 break;
1518 case MDE_SP_COMP_OPEN_ERR:
1519 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1520 "error opening device under soft partition. Check"
1521 " device status, then use metadevadm(1M)."));
1522 break;
1523 default:
1524 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1525 "unknown comp error code %d"), ip->errnum);
1526 break;
1527 }
1528
1529 return (buf);
1530 }
1531
1532 /*
1533 * print hsp class errors
1534 */
1535 static char *
hsp_to_str(md_error_t * ep,char * buf,size_t size)1536 hsp_to_str(
1537 md_error_t *ep,
1538 char *buf,
1539 size_t size
1540 )
1541 {
1542 md_hsp_error_t *ip = &ep->info.md_error_info_t_u.hsp_error;
1543 char *p = buf + strlen(buf);
1544 size_t psize = size - strlen(buf);
1545
1546 switch (ip->errnum) {
1547 case MDE_HSP_CREATE_FAILURE:
1548 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1549 "hotspare pool database create failure"));
1550 break;
1551 case MDE_HSP_IN_USE:
1552 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1553 "hotspare pool in use"));
1554 break;
1555 case MDE_INVAL_HSP:
1556 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1557 "invalid hotspare pool"));
1558 break;
1559 case MDE_HSP_BUSY:
1560 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1561 "hotspare pool is busy"));
1562 break;
1563 case MDE_HSP_REF:
1564 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1565 "hotspare pool is referenced"));
1566 break;
1567 case MDE_HSP_ALREADY_SETUP:
1568 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1569 "hotspare pool is already setup"));
1570 break;
1571 case MDE_BAD_HSP:
1572 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1573 "invalid hotspare pool configuration"));
1574 break;
1575 case MDE_HSP_UNIT_TOO_LARGE:
1576 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1577 "units in the hotspare pool cannot exceed 1 TByte"));
1578 break;
1579 default:
1580 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1581 "unknown hsp error code %d"), ip->errnum);
1582 break;
1583 }
1584
1585 return (buf);
1586 }
1587
1588 /*
1589 * print hs class errors
1590 */
1591 static char *
hs_to_str(md_error_t * ep,char * buf,size_t size)1592 hs_to_str(
1593 md_error_t *ep,
1594 char *buf,
1595 size_t size
1596 )
1597 {
1598 md_hs_error_t *ip = &ep->info.md_error_info_t_u.hs_error;
1599 char *p = buf + strlen(buf);
1600 size_t psize = size - strlen(buf);
1601
1602 switch (ip->errnum) {
1603 case MDE_HS_RESVD:
1604 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1605 "hotspare is in use"));
1606 break;
1607 case MDE_HS_CREATE_FAILURE:
1608 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1609 "hotspare database create failure"));
1610 break;
1611 case MDE_HS_INUSE:
1612 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1613 "add or replace failed, hot spare is already in use"));
1614 break;
1615 case MDE_HS_UNIT_TOO_LARGE:
1616 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1617 "hotspare size cannot exceed 1 TByte"));
1618 break;
1619 default:
1620 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1621 "unknown hs error code %d"), ip->errnum);
1622 break;
1623 }
1624
1625 return (buf);
1626 }
1627
1628 /*
1629 * print mddb class errors
1630 */
1631 static char *
mddb_to_str(md_error_t * ep,char * buf,size_t size)1632 mddb_to_str(
1633 md_error_t *ep,
1634 char *buf,
1635 size_t size
1636 )
1637 {
1638 md_mddb_error_t *ip = &ep->info.md_error_info_t_u.mddb_error;
1639 char *p = buf + strlen(buf);
1640 size_t psize = size - strlen(buf);
1641
1642 switch (ip->errnum) {
1643 case MDE_TOOMANY_REPLICAS:
1644 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1645 "%d metadevice database replicas is too many; the maximum is %d"),
1646 ip->size, MDDB_NLB);
1647 break;
1648 case MDE_REPLICA_TOOSMALL:
1649 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1650 "device size %d is too small for metadevice database replica"),
1651 ip->size);
1652 break;
1653 case MDE_NOTVERIFIED:
1654 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1655 "data not returned correctly from disk"));
1656 break;
1657 case MDE_DB_INVALID:
1658 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1659 "invalid argument"));
1660 break;
1661 case MDE_DB_EXISTS:
1662 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1663 "metadevice database replica exists on device"));
1664 break;
1665 case MDE_DB_MASTER:
1666 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1667 "has bad master block on device"));
1668 break;
1669 case MDE_DB_TOOSMALL:
1670 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1671 "device is too small"));
1672 break;
1673 case MDE_DB_NORECORD:
1674 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1675 "no such metadevice database record"));
1676 break;
1677 case MDE_DB_NOSPACE:
1678 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1679 "metadevice database is full, can't create new records"));
1680 break;
1681 case MDE_DB_NOTNOW:
1682 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1683 "metadevice database has too few replicas, for "
1684 "metadevice database operation"));
1685 break;
1686 case MDE_DB_NODB:
1687 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1688 "there are no existing databases"));
1689 break;
1690 case MDE_DB_NOTOWNER:
1691 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1692 "not owner of metadevice database"));
1693 break;
1694 case MDE_DB_STALE:
1695 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1696 "stale databases"));
1697 break;
1698 case MDE_DB_TOOFEW:
1699 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1700 "not enough databases"));
1701 break;
1702 case MDE_DB_TAGDATA:
1703 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1704 "tagged data detected, user intervention required"));
1705 break;
1706 case MDE_DB_ACCOK:
1707 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1708 "50% replicas & 50% mediator hosts available, "
1709 "user intervention required"));
1710 break;
1711 case MDE_DB_NTAGDATA:
1712 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1713 "no tagged data available or only one tag found"));
1714 break;
1715 case MDE_DB_ACCNOTOK:
1716 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1717 "50% replicas & 50% mediator hosts not available"));
1718 break;
1719 case MDE_DB_NOLOCBLK:
1720 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1721 "no valid locator blocks were found"));
1722 break;
1723 case MDE_DB_NOLOCNMS:
1724 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1725 "no valid locator name information was found"));
1726 break;
1727 case MDE_DB_NODIRBLK:
1728 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1729 "no valid directory blocks were found"));
1730 break;
1731 case MDE_DB_NOTAGREC:
1732 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1733 "no tag record was allocated, so data "
1734 "tagging is disabled"));
1735 break;
1736 case MDE_DB_NOTAG:
1737 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1738 "no tag records exist or no matching tag was found"));
1739 break;
1740 case MDE_DB_BLKRANGE:
1741 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1742 "logical block number %d out of range"), ip->size);
1743 break;
1744 default:
1745 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1746 "unknown mddb error code %d"), ip->errnum);
1747 break;
1748 }
1749
1750 return (buf);
1751 }
1752
1753 /*
1754 * print diskset (ds) class errors
1755 */
1756 static char *
ds_to_str(md_error_t * ep,char * buf,size_t size)1757 ds_to_str(
1758 md_error_t *ep,
1759 char *buf,
1760 size_t size
1761 )
1762 {
1763 md_ds_error_t *ip = &ep->info.md_error_info_t_u.ds_error;
1764 char *p = buf + strlen(buf);
1765 size_t psize = size - strlen(buf);
1766
1767 switch (ip->errnum) {
1768 case MDE_DS_DUPHOST:
1769 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1770 "host %s is specified more than once"), ip->node);
1771 break;
1772 case MDE_DS_NOTNODENAME:
1773 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1774 "\"%s\" is not a nodename, but a network name"), ip->node);
1775 break;
1776 case MDE_DS_SELFNOTIN:
1777 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1778 "nodename of host %s creating the set must be included"),
1779 ip->node);
1780 break;
1781 case MDE_DS_NODEHASSET:
1782 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1783 "host %s already has set"), ip->node);
1784 break;
1785 case MDE_DS_NODENOSET:
1786 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1787 "host %s does not have set"), ip->node);
1788 break;
1789 case MDE_DS_NOOWNER:
1790 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1791 "must be owner of the set for this command"));
1792 break;
1793 case MDE_DS_NOTOWNER:
1794 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1795 "only the current owner %s may operate on this set"),
1796 ip->node);
1797 break;
1798 case MDE_DS_NODEISNOTOWNER:
1799 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1800 "host %s is not the owner"), ip->node);
1801 break;
1802 case MDE_DS_NODEINSET:
1803 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1804 "host %s is already in the set"), ip->node);
1805 break;
1806 case MDE_DS_NODENOTINSET:
1807 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1808 "host %s is not in the set"), ip->node);
1809 break;
1810 case MDE_DS_SETNUMBUSY:
1811 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1812 "host %s already has a set numbered %ld"),
1813 ip->node, ip->setno);
1814 break;
1815 case MDE_DS_SETNUMNOTAVAIL:
1816 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1817 "no available set numbers"));
1818 break;
1819 case MDE_DS_SETNAMEBUSY:
1820 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1821 "set name is in-use or invalid on host %s"), ip->node);
1822 break;
1823 case MDE_DS_DRIVENOTCOMMON:
1824 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1825 "drive %s is not common with host %s"),
1826 ip->drive, ip->node);
1827 break;
1828 case MDE_DS_DRIVEINSET:
1829 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1830 "drive %s is in set %s"), ip->drive, ip->node);
1831 break;
1832 case MDE_DS_DRIVENOTINSET:
1833 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1834 "drive %s is not in set"), ip->drive);
1835 break;
1836 case MDE_DS_DRIVEINUSE:
1837 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1838 "drive %s is in use"), ip->drive);
1839 break;
1840 case MDE_DS_DUPDRIVE:
1841 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1842 "drive %s is specified more than once"), ip->drive);
1843 break;
1844 case MDE_DS_INVALIDSETNAME:
1845 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1846 "set name contains invalid characters"));
1847 break;
1848 case MDE_DS_HASDRIVES:
1849 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1850 "unable to delete set, it still has drives"));
1851 break;
1852 case MDE_DS_SIDENUMNOTAVAIL:
1853 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1854 "maximum number of nodenames exceeded"));
1855 break;
1856 case MDE_DS_SETNAMETOOLONG:
1857 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1858 "set name is too long"));
1859 break;
1860 case MDE_DS_NODENAMETOOLONG:
1861 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1862 "host name %s is too long"), ip->node);
1863 break;
1864 case MDE_DS_OHACANTDELSELF:
1865 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1866 "administrator host %s deletion disallowed in one host admin mode"),
1867 ip->node);
1868 break;
1869 case MDE_DS_HOSTNOSIDE:
1870 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1871 "side information missing for host %s"), ip->node);
1872 break;
1873 case MDE_DS_SETLOCKED:
1874 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1875 "host %s is modifying set - try later or restart rpc.metad"),
1876 ip->drive);
1877 break;
1878 case MDE_DS_ULKSBADKEY:
1879 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1880 "set unlock failed - bad key"));
1881 break;
1882 case MDE_DS_LKSBADKEY:
1883 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1884 "set lock failed - bad key"));
1885 break;
1886 case MDE_DS_WRITEWITHSULK:
1887 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1888 "write operation attempted on set with set unlocked"));
1889 break;
1890 case MDE_DS_SETCLEANUP:
1891 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1892 "set \"%s\" is out of date - cleaning up - take failed"),
1893 ip->node);
1894 break;
1895 case MDE_DS_CANTDELSELF:
1896 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1897 "administrator host %s can't be deleted, other hosts still in set\n"
1898 "Use -f to override"), ip->node);
1899 break;
1900 case MDE_DS_HASMED:
1901 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1902 "unable to delete set, it still has mediator hosts"));
1903 break;
1904 case MDE_DS_TOOMANYALIAS:
1905 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1906 "%s causes there to be more aliases than allowed"),
1907 ip->node);
1908 break;
1909 case MDE_DS_ISMED:
1910 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1911 "%s is already a mediator host"), ip->node);
1912 break;
1913 case MDE_DS_ISNOTMED:
1914 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1915 "%s is not a mediator host"), ip->node);
1916 break;
1917 case MDE_DS_INVALIDMEDNAME:
1918 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1919 "mediator name \"%s\" contains invalid characters"),
1920 ip->node);
1921 break;
1922 case MDE_DS_ALIASNOMATCH:
1923 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1924 "mediator alias \"%s\" is not an alias for host "
1925 "\"%s\""), ip->node, ip->drive);
1926 break;
1927 case MDE_DS_NOMEDONHOST:
1928 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1929 "unable to contact %s on host \"%s\""),
1930 MED_SERVNAME, ip->node);
1931 break;
1932 case MDE_DS_DRIVENOTONHOST:
1933 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1934 "drive %s is not present on host %s"),
1935 ip->drive, ip->node);
1936 break;
1937 case MDE_DS_CANTDELMASTER:
1938 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1939 "master %s can't be deleted, other hosts still in set"),
1940 ip->node);
1941 break;
1942 case MDE_DS_NOTINMEMBERLIST:
1943 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1944 "node %s is not in membership list"),
1945 ip->node);
1946 break;
1947 case MDE_DS_MNCANTDELSELF:
1948 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1949 "host %s can't delete self from multi-owner set\n"
1950 "while other hosts still in set"),
1951 ip->node);
1952 break;
1953 case MDE_DS_RPCVERSMISMATCH:
1954 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1955 "host %s does not support multi-owner diskset"),
1956 ip->node);
1957 break;
1958 case MDE_DS_WITHDRAWMASTER:
1959 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1960 "master host %s cannot withdraw from multi-owner diskset "
1961 "when other owner nodes are still present in diskset"),
1962 ip->node);
1963 break;
1964 case MDE_DS_CANTRESNARF:
1965 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1966 "imported set could not be loaded"));
1967 break;
1968 case MDE_DS_INSUFQUORUM:
1969 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1970 "insufficient replica quorum detected. Use "
1971 "-f to force import of the set"));
1972 break;
1973 case MDE_DS_EXTENDEDNM:
1974 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1975 "multiple namespace records detected"));
1976 break;
1977 case MDE_DS_COMMDCTL_SUSPEND_NYD:
1978 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1979 "rpc.mdcommd on host %s is not yet drained during "
1980 "suspend operation"),
1981 ip->node);
1982 break;
1983 case MDE_DS_COMMDCTL_SUSPEND_FAIL:
1984 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1985 "rpc.mdcommd on host %s failed suspend operation"),
1986 ip->node);
1987 break;
1988 case MDE_DS_COMMDCTL_REINIT_FAIL:
1989 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1990 "rpc.mdcommd on host %s failed reinitialization operation"),
1991 ip->node);
1992 break;
1993 case MDE_DS_COMMDCTL_RESUME_FAIL:
1994 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
1995 "rpc.mdcommd on host %s failed resume operation"),
1996 ip->node);
1997 break;
1998 case MDE_DS_NOTNOW_RECONFIG:
1999 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
2000 "command terminated, host %s starting reconfig cycle"),
2001 ip->node);
2002 break;
2003 case MDE_DS_NOTNOW_CMD:
2004 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
2005 "metaset or metadb command already running on diskset "
2006 "on host %s"), ip->node);
2007 break;
2008 case MDE_DS_COMMD_SEND_FAIL:
2009 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
2010 "rpc.mdcommd on host %s failed operation"),
2011 ip->node);
2012 break;
2013 case MDE_DS_MASTER_ONLY:
2014 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
2015 "this command must be run on the master node of the set,"
2016 " which is currently %s"), ip->node);
2017 break;
2018 case MDE_DS_SINGLEHOST:
2019 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
2020 "diskset is auto-take; cannot accept additional hosts"));
2021 break;
2022 case MDE_DS_AUTONOTSET:
2023 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
2024 "auto-take is not enabled on diskset"));
2025 break;
2026 case MDE_DS_INVALIDDEVID:
2027 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
2028 "Invalid device id on drive %s on host %s"), ip->drive,
2029 ip->node);
2030 break;
2031 case MDE_DS_SETNOTIMP:
2032 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
2033 "Unable to import set on node %s"), ip->node);
2034 break;
2035 case MDE_DS_NOTSELFIDENTIFY:
2036 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
2037 "Drive %s won't be self identifying"), ip->drive);
2038 break;
2039 default:
2040 (void) snprintf(p, psize, dgettext(TEXT_DOMAIN,
2041 "unknown diskset error code %d"), ip->errnum);
2042 break;
2043 }
2044
2045 return (buf);
2046 }
2047
2048 /*
2049 * convert error to printable string
2050 */
2051 static char *
mde_to_str(md_error_t * ep)2052 mde_to_str(
2053 md_error_t *ep
2054 )
2055 {
2056 static char buf[BUFSIZ];
2057 size_t bufsz;
2058
2059 /* intialize buf */
2060 buf[0] = '\0';
2061 bufsz = sizeof (buf);
2062
2063 /* class specific */
2064 switch (ep->info.errclass) {
2065 case MDEC_VOID:
2066 return (void_to_str(ep, buf, bufsz));
2067 case MDEC_SYS:
2068 return (sys_to_str(ep, buf, bufsz));
2069 case MDEC_RPC:
2070 return (rpc_to_str(ep, buf, bufsz));
2071 case MDEC_DEV:
2072 return (dev_to_str(ep, buf, bufsz));
2073 case MDEC_USE:
2074 return (use_to_str(ep, buf, bufsz));
2075 case MDEC_MD:
2076 return (md_to_str(ep, buf, bufsz));
2077 case MDEC_COMP:
2078 return (comp_to_str(ep, buf, bufsz));
2079 case MDEC_HSP:
2080 return (hsp_to_str(ep, buf, bufsz));
2081 case MDEC_HS:
2082 return (hs_to_str(ep, buf, bufsz));
2083 case MDEC_MDDB:
2084 return (mddb_to_str(ep, buf, bufsz));
2085 case MDEC_DS:
2086 return (ds_to_str(ep, buf, bufsz));
2087 case MDEC_OVERLAP:
2088 return (overlap_to_str(ep, buf, bufsz));
2089 default:
2090 (void) snprintf(buf, bufsz,
2091 dgettext(TEXT_DOMAIN, "unknown error class %d"),
2092 ep->info.errclass);
2093 return (buf);
2094 }
2095 }
2096
2097 /*
2098 * print log prefix
2099 */
2100 void
md_logpfx(FILE * fp)2101 md_logpfx(
2102 FILE *fp
2103 )
2104 {
2105 time_t t;
2106 struct tm *tm;
2107 char buf[100];
2108
2109 if ((time(&t) != (time_t)-1) &&
2110 ((tm = localtime(&t)) != NULL) &&
2111 (strftime(buf, sizeof (buf), (char *)0, tm) < sizeof (buf))) {
2112 (void) fprintf(fp, "%s: ", buf);
2113 }
2114 (void) fprintf(fp, "%s: ", myname);
2115 }
2116
2117 /*
2118 * varargs sperror()
2119 */
2120 /*PRINTFLIKE2*/
2121 static char *
mde_vsperror(md_error_t * ep,const char * fmt,va_list ap)2122 mde_vsperror(
2123 md_error_t *ep,
2124 const char *fmt,
2125 va_list ap
2126 )
2127 {
2128 static char buf[BUFSIZ];
2129 size_t bufsz = sizeof (buf);
2130 char *p = buf;
2131 char *host1 = "";
2132 char *host2 = "";
2133 char *extra1 = "";
2134 char *extra2 = "";
2135 char *name1 = "";
2136 char *name2 = "";
2137
2138 /* get stuff */
2139 if ((ep->host != NULL) && (*(ep->host) != '\0')) {
2140 host1 = ep->host;
2141 host2 = ": ";
2142 }
2143 if ((ep->extra != NULL) && (*(ep->extra) != '\0')) {
2144 extra1 = ep->extra;
2145 extra2 = ": ";
2146 }
2147 if ((ep->name != NULL) && (*(ep->name) != '\0')) {
2148 name1 = ep->name;
2149 name2 = ": ";
2150 }
2151
2152 /* context */
2153 (void) snprintf(p, bufsz, "%s%s%s%s%s%s",
2154 host1, host2, extra1, extra2, name1, name2);
2155 p = &buf[strlen(buf)];
2156 bufsz -= strlen(buf);
2157
2158 /* user defined part */
2159 if ((fmt != NULL) && (*fmt != '\0')) {
2160 (void) vsnprintf(p, bufsz, fmt, ap);
2161 p = &buf[strlen(buf)];
2162 bufsz = sizeof (buf) - strlen(buf);
2163 (void) snprintf(p, bufsz, ": ");
2164 p = &buf[strlen(buf)];
2165 bufsz = sizeof (buf) - strlen(buf);
2166 }
2167
2168 /* error code */
2169 (void) snprintf(p, bufsz, "%s\n", mde_to_str(ep));
2170
2171 /* return error message */
2172 return (buf);
2173 }
2174
2175 /*
2176 * printf-like sperror()
2177 */
2178 /*PRINTFLIKE2*/
2179 char *
mde_sperror(md_error_t * ep,const char * fmt,...)2180 mde_sperror(
2181 md_error_t *ep,
2182 const char *fmt,
2183 ...
2184 )
2185 {
2186 va_list ap;
2187 char *emsg;
2188
2189 va_start(ap, fmt);
2190 emsg = mde_vsperror(ep, fmt, ap);
2191 va_end(ap);
2192 return (emsg);
2193 }
2194
2195 /*
2196 * printf-like perror()
2197 */
2198 /*PRINTFLIKE2*/
2199 void
mde_perror(md_error_t * ep,const char * fmt,...)2200 mde_perror(
2201 md_error_t *ep,
2202 const char *fmt,
2203 ...
2204 )
2205 {
2206 va_list ap;
2207 char *emsg;
2208
2209 /* get error message */
2210 va_start(ap, fmt);
2211 emsg = mde_vsperror(ep, fmt, ap);
2212 va_end(ap);
2213 assert((emsg != NULL) && (*emsg != '\0'));
2214
2215 /* stderr */
2216 (void) fprintf(stderr, "%s: %s\n", myname, emsg);
2217 (void) fflush(stderr);
2218
2219 /* metalog */
2220 if (metalogfp != NULL) {
2221 md_logpfx(metalogfp);
2222 (void) fprintf(metalogfp, "%s\n", emsg);
2223 (void) fflush(metalogfp);
2224 (void) fsync(fileno(metalogfp));
2225 }
2226
2227 /* syslog */
2228 if (metasyslog) {
2229 syslog(LOG_ERR, emsg);
2230 }
2231 }
2232
2233 /*
2234 * printf-like perror()
2235 */
2236 /*PRINTFLIKE1*/
2237 void
md_perror(const char * fmt,...)2238 md_perror(
2239 const char *fmt,
2240 ...
2241 )
2242 {
2243 md_error_t status = mdnullerror;
2244 va_list ap;
2245 char *emsg;
2246
2247 /* get error message */
2248 (void) mdsyserror(&status, errno, NULL);
2249 va_start(ap, fmt);
2250 emsg = mde_vsperror(&status, fmt, ap);
2251 va_end(ap);
2252 assert((emsg != NULL) && (*emsg != '\0'));
2253 mdclrerror(&status);
2254
2255 /* stderr */
2256 (void) fprintf(stderr, "%s: %s\n", myname, emsg);
2257 (void) fflush(stderr);
2258
2259 /* metalog */
2260 if (metalogfp != NULL) {
2261 md_logpfx(metalogfp);
2262 (void) fprintf(metalogfp, "%s\n", emsg);
2263 (void) fflush(metalogfp);
2264 (void) fsync(fileno(metalogfp));
2265 }
2266
2267 /* syslog */
2268 if (metasyslog) {
2269 syslog(LOG_ERR, emsg);
2270 }
2271 }
2272
2273 /*
2274 * printf-like log
2275 */
2276 /*PRINTFLIKE1*/
2277 void
md_eprintf(const char * fmt,...)2278 md_eprintf(
2279 const char *fmt,
2280 ...
2281 )
2282 {
2283 va_list ap;
2284
2285 /* begin */
2286 va_start(ap, fmt);
2287
2288 /* stderr */
2289 (void) fprintf(stderr, "%s: ", myname);
2290 (void) vfprintf(stderr, fmt, ap);
2291 (void) fflush(stderr);
2292
2293 /* metalog */
2294 if (metalogfp != NULL) {
2295 md_logpfx(metalogfp);
2296 (void) vfprintf(metalogfp, fmt, ap);
2297 (void) fflush(metalogfp);
2298 (void) fsync(fileno(metalogfp));
2299 }
2300
2301 /* syslog */
2302 if (metasyslog) {
2303 vsyslog(LOG_ERR, fmt, ap);
2304 }
2305
2306 /* end */
2307 va_end(ap);
2308 }
2309
2310 /*
2311 * metaclust timing messages logging routine
2312 *
2313 * level - The class of the message to be logged. Message will be logged
2314 * if this is less than or equal to the verbosity level.
2315 */
2316 void
meta_mc_log(int level,const char * fmt,...)2317 meta_mc_log(int level, const char *fmt, ...)
2318 {
2319 va_list args;
2320
2321 va_start(args, fmt);
2322 /*
2323 * Log all messages upto MC_LOG2 to syslog regardless of the
2324 * verbosity level
2325 */
2326 if (metasyslog && (level <= MC_LOG2)) {
2327 if (level <= MC_LOG1)
2328 (void) vsyslog(LOG_ERR, fmt, args);
2329 else
2330 (void) vsyslog(LOG_INFO, fmt, args);
2331 }
2332 /*
2333 * Print all messages to stderr provided the message level is
2334 * within the verbosity level
2335 */
2336 if (level <= verbosity) {
2337 (void) fprintf(stderr, "%s: ", myname);
2338 (void) vfprintf(stderr, fmt, args);
2339 (void) fprintf(stderr, "\n");
2340 (void) fflush(stderr);
2341 }
2342 va_end(args);
2343 }
2344