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 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #include <strings.h>
28 #include <stdlib.h>
29 #include <netdir.h>
30 #include <errno.h>
31 #include <alloca.h>
32 #include <locale.h>
33 #include <uuid/uuid.h>
34
35 #include <sys/fm/protocol.h>
36 #include <fmd_adm_impl.h>
37 #include <fmd_rpc_adm.h>
38
39 static const uint_t _fmd_adm_bufsize = 128 * 1024;
40 static const char _url_fallback[] = "http://illumos.org/msg/";
41
42 fmd_adm_t *
43 fmd_adm_open(const char *host, uint32_t prog, int version)
44 {
45 fmd_adm_t *ap;
46 CLIENT *c;
47 rpcvers_t v;
48
49 if (version != FMD_ADM_VERSION) {
50 errno = ENOTSUP;
51 return (NULL);
52 }
53
54 if (host == NULL)
55 host = HOST_SELF;
56
57 if (prog == FMD_ADM_PROGRAM)
58 prog = FMD_ADM;
59
60 if ((ap = malloc(sizeof (fmd_adm_t))) == NULL)
61 return (NULL);
62
63 if (strcmp(host, HOST_SELF) == 0) {
64 c = clnt_door_create(prog, FMD_ADM_VERSION_1, _fmd_adm_bufsize);
65 ap->adm_maxretries = 1;
66 } else {
67 c = clnt_create_vers(host, prog, &v,
68 FMD_ADM_VERSION_1, FMD_ADM_VERSION_1, NULL);
69 ap->adm_maxretries = 0;
70 }
71
72 if (c == NULL) {
73 errno = EPROTO;
74 free(ap);
75 return (NULL);
76 }
77
78 ap->adm_prog = prog;
79 ap->adm_clnt = c;
80 ap->adm_version = version;
81 ap->adm_svcerr = 0;
82 ap->adm_errno = 0;
83
84 return (ap);
85 }
86
87 void
88 fmd_adm_close(fmd_adm_t *ap)
89 {
90 if (ap == NULL)
91 return; /* permit NULL to simply caller code */
92
93 clnt_destroy(ap->adm_clnt);
94 free(ap);
95 }
96
97 static const char *
98 fmd_adm_svc_errmsg(enum fmd_adm_error err)
99 {
100 switch (err) {
101 case FMD_ADM_ERR_NOMEM:
102 return ("unable to perform request due to allocation failure");
103 case FMD_ADM_ERR_PERM:
104 return ("operation requires additional privilege");
105 case FMD_ADM_ERR_MODSRCH:
106 return ("specified module is not loaded in fault manager");
107 case FMD_ADM_ERR_MODBUSY:
108 return ("module is in use and cannot be unloaded");
109 case FMD_ADM_ERR_MODFAIL:
110 return ("module failed and can no longer export statistics");
111 case FMD_ADM_ERR_MODNOENT:
112 return ("file missing or cannot be accessed by fault manager");
113 case FMD_ADM_ERR_MODEXIST:
114 return ("module using same name is already loaded");
115 case FMD_ADM_ERR_MODINIT:
116 return ("module failed to initialize (consult fmd(1M) log)");
117 case FMD_ADM_ERR_MODLOAD:
118 return ("module failed to load (consult fmd(1M) log)");
119 case FMD_ADM_ERR_RSRCSRCH:
120 return ("specified resource is not cached by fault manager");
121 case FMD_ADM_ERR_RSRCNOTF:
122 return ("specified resource is not known to be faulty");
123 case FMD_ADM_ERR_SERDSRCH:
124 return ("specified serd engine not present in module");
125 case FMD_ADM_ERR_SERDFIRED:
126 return ("specified serd engine has already fired");
127 case FMD_ADM_ERR_ROTSRCH:
128 return ("invalid log file name");
129 case FMD_ADM_ERR_ROTFAIL:
130 return ("failed to rotate log file (consult fmd(1M) log)");
131 case FMD_ADM_ERR_ROTBUSY:
132 return ("log file is too busy to rotate (try again later)");
133 case FMD_ADM_ERR_CASESRCH:
134 return ("specified UUID is invalid or has been repaired");
135 case FMD_ADM_ERR_CASEOPEN:
136 return ("specified UUID is still being diagnosed");
137 case FMD_ADM_ERR_XPRTSRCH:
138 return ("specified transport ID is invalid or has been closed");
139 case FMD_ADM_ERR_CASEXPRT:
140 return ("specified UUID is owned by a different fault manager");
141 case FMD_ADM_ERR_RSRCNOTR:
142 return ("specified resource has not been replaced");
143 default:
144 return ("unknown fault manager error");
145 }
146 }
147
148 const char *
149 fmd_adm_errmsg(fmd_adm_t *ap)
150 {
151 if (ap == NULL) {
152 switch (errno) {
153 case ENOTSUP:
154 return ("client requires newer libfmd_adm version");
155 case EPROTO:
156 return (clnt_spcreateerror("failed to connect to fmd"));
157 }
158 }
159
160 switch (ap ? ap->adm_errno : errno) {
161 case EPROTO:
162 return (clnt_sperror(ap->adm_clnt, "rpc call failed"));
163 case EREMOTE:
164 return (fmd_adm_svc_errmsg(ap->adm_svcerr));
165 default:
166 return (strerror(ap->adm_errno));
167 }
168 }
169
170 static int
171 fmd_adm_set_svcerr(fmd_adm_t *ap, enum fmd_adm_error err)
172 {
173 if (err != 0) {
174 ap->adm_svcerr = err;
175 ap->adm_errno = EREMOTE;
176 return (-1);
177 } else {
178 ap->adm_svcerr = err;
179 ap->adm_errno = 0;
180 return (0);
181 }
182 }
183
184 static int
185 fmd_adm_set_errno(fmd_adm_t *ap, int err)
186 {
187 ap->adm_errno = err;
188 errno = err;
189 return (-1);
190 }
191
192 static int
193 fmd_adm_stats_cmp(const void *lp, const void *rp)
194 {
195 return (strcmp(((fmd_stat_t *)lp)->fmds_name,
196 ((fmd_stat_t *)rp)->fmds_name));
197 }
198
199 /*
200 * If the server (fmd) is restarted, this will cause all future door calls to
201 * fail. Unfortunately, once the server comes back up, we have no way of
202 * reestablishing the connection. To get around this, if the error indicates
203 * that the RPC call failed, we reopen the client handle and try again. For
204 * simplicity we only deal with the door case, as it's unclear whether the
205 * remote case suffers from the same pathology.
206 */
207 boolean_t
208 fmd_adm_retry(fmd_adm_t *ap, enum clnt_stat cs, uint_t *retries)
209 {
210 CLIENT *c;
211 struct rpc_err err;
212
213 if (cs == RPC_SUCCESS || *retries == ap->adm_maxretries)
214 return (B_FALSE);
215
216 clnt_geterr(ap->adm_clnt, &err);
217 if (err.re_status != RPC_CANTSEND)
218 return (B_FALSE);
219
220 if ((c = clnt_door_create(ap->adm_prog, FMD_ADM_VERSION_1,
221 _fmd_adm_bufsize)) == NULL)
222 return (B_FALSE);
223
224 (*retries)++;
225
226 clnt_destroy(ap->adm_clnt);
227 ap->adm_clnt = c;
228
229 return (B_TRUE);
230 }
231
232 int
233 fmd_adm_stats_read(fmd_adm_t *ap, const char *name, fmd_adm_stats_t *sp)
234 {
235 struct fmd_rpc_modstat rms;
236 enum clnt_stat cs;
237 uint_t retries = 0;
238
239 if (sp == NULL)
240 return (fmd_adm_set_errno(ap, EINVAL));
241
242 bzero(&rms, sizeof (rms)); /* tell xdr to allocate memory for us */
243
244 do {
245 if (name != NULL)
246 cs = fmd_adm_modcstat_1((char *)name, &rms,
247 ap->adm_clnt);
248 else
249 cs = fmd_adm_modgstat_1(&rms, ap->adm_clnt);
250 } while (fmd_adm_retry(ap, cs, &retries));
251
252 if (cs != RPC_SUCCESS)
253 return (fmd_adm_set_errno(ap, EPROTO));
254
255 if (rms.rms_err != 0) {
256 xdr_free(xdr_fmd_rpc_modstat, (char *)&rms);
257 return (fmd_adm_set_svcerr(ap, rms.rms_err));
258 }
259
260 sp->ams_buf = rms.rms_buf.rms_buf_val;
261 sp->ams_len = rms.rms_buf.rms_buf_len;
262
263 if (sp->ams_len != 0) {
264 qsort(sp->ams_buf, sp->ams_len,
265 sizeof (fmd_stat_t), fmd_adm_stats_cmp);
266 }
267
268 return (0);
269 }
270
271 int
272 fmd_adm_stats_free(fmd_adm_t *ap, fmd_adm_stats_t *sp)
273 {
274 struct fmd_rpc_modstat rms;
275
276 if (sp == NULL)
277 return (fmd_adm_set_errno(ap, EINVAL));
278
279 rms.rms_buf.rms_buf_val = sp->ams_buf;
280 rms.rms_buf.rms_buf_len = sp->ams_len;
281 rms.rms_err = 0;
282
283 xdr_free(xdr_fmd_rpc_modstat, (char *)&rms);
284 bzero(sp, sizeof (fmd_adm_stats_t));
285
286 return (0);
287 }
288
289 static int
290 fmd_adm_module_cmp(const void *lp, const void *rp)
291 {
292 return (strcmp((*(struct fmd_rpc_modinfo **)lp)->rmi_name,
293 (*(struct fmd_rpc_modinfo **)rp)->rmi_name));
294 }
295
296 int
297 fmd_adm_module_iter(fmd_adm_t *ap, fmd_adm_module_f *func, void *arg)
298 {
299 struct fmd_rpc_modinfo *rmi, **rms, **rmp;
300 struct fmd_rpc_modlist rml;
301 fmd_adm_modinfo_t ami;
302 enum clnt_stat cs;
303 uint_t retries = 0;
304
305 bzero(&rml, sizeof (rml)); /* tell xdr to allocate memory for us */
306
307 do {
308 cs = fmd_adm_modinfo_1(&rml, ap->adm_clnt);
309 } while (fmd_adm_retry(ap, cs, &retries));
310
311 if (cs != RPC_SUCCESS)
312 return (fmd_adm_set_errno(ap, EPROTO));
313
314 if (rml.rml_err != 0 || rml.rml_len == 0) {
315 xdr_free(xdr_fmd_rpc_modlist, (char *)&rml);
316 return (fmd_adm_set_svcerr(ap, rml.rml_err));
317 }
318
319 if ((rms = rmp = malloc(sizeof (void *) * rml.rml_len)) == NULL) {
320 xdr_free(xdr_fmd_rpc_modlist, (char *)&rml);
321 return (fmd_adm_set_errno(ap, EAGAIN));
322 }
323
324 for (rmi = rml.rml_list; rmi != NULL; rmi = rmi->rmi_next)
325 *rmp++ = rmi; /* store copy of pointer in array for sorting */
326
327 qsort(rms, rml.rml_len, sizeof (void *), fmd_adm_module_cmp);
328
329 for (rmp = rms; rmp < rms + rml.rml_len; rmp++) {
330 rmi = *rmp;
331
332 ami.ami_name = rmi->rmi_name;
333 ami.ami_desc = rmi->rmi_desc;
334 ami.ami_vers = rmi->rmi_vers;
335 ami.ami_flags = 0;
336
337 if (rmi->rmi_faulty)
338 ami.ami_flags |= FMD_ADM_MOD_FAILED;
339
340 if (func(&ami, arg) != 0)
341 break;
342 }
343
344 free(rms);
345 xdr_free(xdr_fmd_rpc_modlist, (char *)&rml);
346 return (0);
347 }
348
349 int
350 fmd_adm_module_load(fmd_adm_t *ap, const char *path)
351 {
352 char *str = (char *)path;
353 int err;
354 enum clnt_stat cs;
355 uint_t retries = 0;
356
357 if (path == NULL || path[0] != '/')
358 return (fmd_adm_set_errno(ap, EINVAL));
359
360 do {
361 cs = fmd_adm_modload_1(str, &err, ap->adm_clnt);
362 } while (fmd_adm_retry(ap, cs, &retries));
363
364 if (cs != RPC_SUCCESS)
365 return (fmd_adm_set_errno(ap, EPROTO));
366
367 return (fmd_adm_set_svcerr(ap, err));
368 }
369
370 int
371 fmd_adm_module_unload(fmd_adm_t *ap, const char *name)
372 {
373 char *str = (char *)name;
374 int err;
375 enum clnt_stat cs;
376 uint_t retries = 0;
377
378 if (name == NULL || strchr(name, '/') != NULL)
379 return (fmd_adm_set_errno(ap, EINVAL));
380
381 do {
382 cs = fmd_adm_modunload_1(str, &err, ap->adm_clnt);
383 } while (fmd_adm_retry(ap, cs, &retries));
384
385 if (cs != RPC_SUCCESS)
386 return (fmd_adm_set_errno(ap, EPROTO));
387
388 return (fmd_adm_set_svcerr(ap, err));
389 }
390
391 int
392 fmd_adm_module_reset(fmd_adm_t *ap, const char *name)
393 {
394 char *str = (char *)name;
395 int err;
396 enum clnt_stat cs;
397 uint_t retries = 0;
398
399 if (name == NULL || strchr(name, '/') != NULL)
400 return (fmd_adm_set_errno(ap, EINVAL));
401
402 do {
403 cs = fmd_adm_modreset_1(str, &err, ap->adm_clnt);
404 } while (fmd_adm_retry(ap, cs, &retries));
405
406 if (cs != RPC_SUCCESS)
407 return (fmd_adm_set_errno(ap, EPROTO));
408
409 return (fmd_adm_set_svcerr(ap, err));
410 }
411
412 int
413 fmd_adm_module_gc(fmd_adm_t *ap, const char *name)
414 {
415 char *str = (char *)name;
416 int err;
417 enum clnt_stat cs;
418 uint_t retries = 0;
419
420 if (name == NULL || strchr(name, '/') != NULL)
421 return (fmd_adm_set_errno(ap, EINVAL));
422
423 do {
424 cs = fmd_adm_modgc_1(str, &err, ap->adm_clnt);
425 } while (fmd_adm_retry(ap, cs, &retries));
426
427 if (cs != RPC_SUCCESS)
428 return (fmd_adm_set_errno(ap, EPROTO));
429
430 return (fmd_adm_set_svcerr(ap, err));
431 }
432
433 int
434 fmd_adm_module_stats(fmd_adm_t *ap, const char *name, fmd_adm_stats_t *sp)
435 {
436 struct fmd_rpc_modstat rms;
437 enum clnt_stat cs;
438 uint_t retries = 0;
439
440 if (name == NULL || sp == NULL)
441 return (fmd_adm_set_errno(ap, EINVAL));
442
443 bzero(&rms, sizeof (rms)); /* tell xdr to allocate memory for us */
444
445 do {
446 cs = fmd_adm_moddstat_1((char *)name, &rms, ap->adm_clnt);
447 } while (fmd_adm_retry(ap, cs, &retries));
448
449 if (cs != RPC_SUCCESS)
450 return (fmd_adm_set_errno(ap, EPROTO));
451
452 if (rms.rms_err != 0) {
453 xdr_free(xdr_fmd_rpc_modstat, (char *)&rms);
454 return (fmd_adm_set_svcerr(ap, rms.rms_err));
455 }
456
457 sp->ams_buf = rms.rms_buf.rms_buf_val;
458 sp->ams_len = rms.rms_buf.rms_buf_len;
459
460 return (0);
461 }
462
463 int
464 fmd_adm_rsrc_count(fmd_adm_t *ap, int all, uint32_t *rcp)
465 {
466 struct fmd_rpc_rsrclist rrl;
467 enum clnt_stat cs;
468 uint_t retries = 0;
469
470 if (rcp == NULL)
471 return (fmd_adm_set_errno(ap, EINVAL));
472
473 bzero(&rrl, sizeof (rrl)); /* tell xdr to allocate memory for us */
474
475 do {
476 cs = fmd_adm_rsrclist_1(all, &rrl, ap->adm_clnt);
477 } while (fmd_adm_retry(ap, cs, &retries));
478
479 if (cs != RPC_SUCCESS)
480 return (fmd_adm_set_errno(ap, EPROTO));
481
482 if (rrl.rrl_err != 0) {
483 xdr_free(xdr_fmd_rpc_rsrclist, (char *)&rrl);
484 return (fmd_adm_set_svcerr(ap, rrl.rrl_err));
485 }
486
487 *rcp = rrl.rrl_cnt;
488 xdr_free(xdr_fmd_rpc_rsrclist, (char *)&rrl);
489 return (0);
490 }
491
492 static int
493 fmd_adm_rsrc_cmp(const void *lp, const void *rp)
494 {
495 return (strcmp(*(char **)lp, *(char **)rp));
496 }
497
498 int
499 fmd_adm_rsrc_iter(fmd_adm_t *ap, int all, fmd_adm_rsrc_f *func, void *arg)
500 {
501 struct fmd_rpc_rsrclist rrl;
502 struct fmd_rpc_rsrcinfo rri;
503 fmd_adm_rsrcinfo_t ari;
504 char **fmris, *p;
505 int i, rv;
506 enum clnt_stat cs;
507 uint_t retries = 0;
508
509 bzero(&rrl, sizeof (rrl)); /* tell xdr to allocate memory for us */
510
511 do {
512 cs = fmd_adm_rsrclist_1(all, &rrl, ap->adm_clnt);
513 } while (fmd_adm_retry(ap, cs, &retries));
514
515 if (cs != RPC_SUCCESS)
516 return (fmd_adm_set_errno(ap, EPROTO));
517
518 if (rrl.rrl_err != 0) {
519 xdr_free(xdr_fmd_rpc_rsrclist, (char *)&rrl);
520 return (fmd_adm_set_svcerr(ap, rrl.rrl_err));
521 }
522
523 if ((fmris = malloc(sizeof (char *) * rrl.rrl_cnt)) == NULL) {
524 xdr_free(xdr_fmd_rpc_rsrclist, (char *)&rrl);
525 return (fmd_adm_set_errno(ap, EAGAIN));
526 }
527
528 /*
529 * The fmd_adm_rsrclist_1 request returns an opaque XDR buffer that is
530 * a string table of FMRIs (e.g. "fmriA\0fmriB\0...") where rrl_cnt is
531 * the number of strings in the table and rrl_buf_val is its address.
532 * We construct an array of pointers into the string table and sort it.
533 */
534 p = rrl.rrl_buf.rrl_buf_val;
535
536 for (i = 0; i < rrl.rrl_cnt; i++, p += strlen(p) + 1)
537 fmris[i] = p; /* store fmri pointer in array for sorting */
538
539 qsort(fmris, rrl.rrl_cnt, sizeof (char *), fmd_adm_rsrc_cmp);
540
541 /*
542 * For each FMRI in the resource cache snapshot, use fmd_adm_rsrcinfo_1
543 * to get more information and the invoke the callback function. If
544 * FMD_ADM_ERR_RSRCSRCH is returned, the FMRI has been purged from the
545 * cache since our snapshot: this error is therefore silently ignored.
546 */
547 for (i = 0; i < rrl.rrl_cnt; i++) {
548 bzero(&rri, sizeof (rri));
549
550 retries = 0;
551 do {
552 cs = fmd_adm_rsrcinfo_1(fmris[i], &rri, ap->adm_clnt);
553 } while (fmd_adm_retry(ap, cs, &retries));
554
555 if (cs != RPC_SUCCESS) {
556 free(fmris);
557 xdr_free(xdr_fmd_rpc_rsrclist, (char *)&rrl);
558 return (fmd_adm_set_errno(ap, EPROTO));
559 }
560
561 if (rri.rri_err != 0 && rri.rri_err != FMD_ADM_ERR_RSRCSRCH) {
562 xdr_free(xdr_fmd_rpc_rsrcinfo, (char *)&rri);
563 free(fmris);
564 xdr_free(xdr_fmd_rpc_rsrclist, (char *)&rrl);
565 return (fmd_adm_set_svcerr(ap, rri.rri_err));
566 }
567
568 if (rri.rri_err == FMD_ADM_ERR_RSRCSRCH) {
569 xdr_free(xdr_fmd_rpc_rsrcinfo, (char *)&rri);
570 continue;
571 }
572
573 ari.ari_fmri = rri.rri_fmri;
574 ari.ari_uuid = rri.rri_uuid;
575 ari.ari_case = rri.rri_case;
576 ari.ari_flags = 0;
577
578 if (rri.rri_faulty)
579 ari.ari_flags |= FMD_ADM_RSRC_FAULTY;
580 if (rri.rri_unusable)
581 ari.ari_flags |= FMD_ADM_RSRC_UNUSABLE;
582 if (rri.rri_invisible)
583 ari.ari_flags |= FMD_ADM_RSRC_INVISIBLE;
584
585 rv = func(&ari, arg);
586 xdr_free(xdr_fmd_rpc_rsrcinfo, (char *)&rri);
587
588 if (rv != 0)
589 break;
590 }
591
592 free(fmris);
593 xdr_free(xdr_fmd_rpc_rsrclist, (char *)&rrl);
594 return (0);
595 }
596
597 int
598 fmd_adm_rsrc_flush(fmd_adm_t *ap, const char *fmri)
599 {
600 char *str = (char *)fmri;
601 int err;
602 enum clnt_stat cs;
603 uint_t retries = 0;
604
605 if (fmri == NULL)
606 return (fmd_adm_set_errno(ap, EINVAL));
607
608 do {
609 cs = fmd_adm_rsrcflush_1(str, &err, ap->adm_clnt);
610 } while (fmd_adm_retry(ap, cs, &retries));
611
612 if (cs != RPC_SUCCESS)
613 return (fmd_adm_set_errno(ap, EPROTO));
614
615 return (fmd_adm_set_svcerr(ap, err));
616 }
617
618 int
619 fmd_adm_rsrc_repaired(fmd_adm_t *ap, const char *fmri)
620 {
621 char *str = (char *)fmri;
622 int err;
623 enum clnt_stat cs;
624 uint_t retries = 0;
625
626 if (fmri == NULL)
627 return (fmd_adm_set_errno(ap, EINVAL));
628
629 do {
630 cs = fmd_adm_rsrcrepaired_1(str, &err, ap->adm_clnt);
631 } while (fmd_adm_retry(ap, cs, &retries));
632
633 if (cs != RPC_SUCCESS)
634 return (fmd_adm_set_errno(ap, EPROTO));
635
636 return (fmd_adm_set_svcerr(ap, err));
637 }
638
639 int
640 fmd_adm_rsrc_replaced(fmd_adm_t *ap, const char *fmri)
641 {
642 char *str = (char *)fmri;
643 int err;
644 enum clnt_stat cs;
645 uint_t retries = 0;
646
647 if (fmri == NULL)
648 return (fmd_adm_set_errno(ap, EINVAL));
649
650 do {
651 cs = fmd_adm_rsrcreplaced_1(str, &err, ap->adm_clnt);
652 } while (fmd_adm_retry(ap, cs, &retries));
653
654 if (cs != RPC_SUCCESS)
655 return (fmd_adm_set_errno(ap, EPROTO));
656
657 return (fmd_adm_set_svcerr(ap, err));
658 }
659
660 int
661 fmd_adm_rsrc_acquit(fmd_adm_t *ap, const char *fmri, const char *uuid)
662 {
663 char *str = (char *)fmri;
664 char *str2 = (char *)uuid;
665 int err;
666 enum clnt_stat cs;
667 uint_t retries = 0;
668
669 if (fmri == NULL)
670 return (fmd_adm_set_errno(ap, EINVAL));
671
672 do {
673 cs = fmd_adm_rsrcacquit_1(str, str2, &err, ap->adm_clnt);
674 } while (fmd_adm_retry(ap, cs, &retries));
675
676 if (cs != RPC_SUCCESS)
677 return (fmd_adm_set_errno(ap, EPROTO));
678
679 return (fmd_adm_set_svcerr(ap, err));
680 }
681
682 int
683 fmd_adm_case_repair(fmd_adm_t *ap, const char *uuid)
684 {
685 char *str = (char *)uuid;
686 int err;
687 enum clnt_stat cs;
688 uint_t retries = 0;
689
690 if (uuid == NULL)
691 return (fmd_adm_set_errno(ap, EINVAL));
692
693 do {
694 cs = fmd_adm_caserepair_1(str, &err, ap->adm_clnt);
695 } while (fmd_adm_retry(ap, cs, &retries));
696
697 if (cs != RPC_SUCCESS)
698 return (fmd_adm_set_errno(ap, EPROTO));
699
700 return (fmd_adm_set_svcerr(ap, err));
701 }
702
703 int
704 fmd_adm_case_acquit(fmd_adm_t *ap, const char *uuid)
705 {
706 char *str = (char *)uuid;
707 int err;
708 enum clnt_stat cs;
709 uint_t retries = 0;
710
711 if (uuid == NULL)
712 return (fmd_adm_set_errno(ap, EINVAL));
713
714 do {
715 cs = fmd_adm_caseacquit_1(str, &err, ap->adm_clnt);
716 } while (fmd_adm_retry(ap, cs, &retries));
717
718 if (cs != RPC_SUCCESS)
719 return (fmd_adm_set_errno(ap, EPROTO));
720
721 return (fmd_adm_set_svcerr(ap, err));
722 }
723
724 static int
725 fmd_adm_case_cmp(const void *lp, const void *rp)
726 {
727 return (strcmp(*(char **)lp, *(char **)rp));
728 }
729
730 static int
731 fmd_adm_case_one(fmd_adm_caseinfo_t *acp, const char *url_token,
732 fmd_adm_case_f *func, void *arg)
733 {
734 char *p, *urlcode, *dict, *olang;
735 const char *url;
736 size_t len;
737
738 if ((p = strchr(acp->aci_code, '-')) == NULL ||
739 p == acp->aci_code) {
740 acp->aci_url = NULL;
741 } else {
742 dict = alloca((size_t)(p - acp->aci_code) + 1);
743 (void) strncpy(dict, acp->aci_code,
744 (size_t)(p - acp->aci_code));
745 dict[(size_t)(p - acp->aci_code)] = '\0';
746
747 /*
748 * If we're given a token to use in looking up the URL, try
749 * to use it. Otherwise, or if we don't find it that way,
750 * use the fallback.
751 */
752 if (url_token == NULL) {
753 url = _url_fallback;
754 } else if ((url = dgettext(dict, url_token)) == url_token) {
755 /*
756 * We didn't find a translation in the
757 * dictionary for the current language. Fall
758 * back to C and try again.
759 */
760 olang = setlocale(LC_MESSAGES, NULL);
761 (void) setlocale(LC_MESSAGES, "C");
762 if ((url = dgettext(dict, url_token)) == url_token)
763 url = _url_fallback;
764 (void) setlocale(LC_MESSAGES, olang);
765 }
766 len = strlen(url);
767 if (url[len - 1] == '/') {
768 len += strlen(acp->aci_code) + 1;
769 urlcode = alloca(len);
770 (void) snprintf(urlcode, len, "%s%s", url,
771 acp->aci_code);
772 } else {
773 urlcode = (char *)url;
774 }
775 acp->aci_url = urlcode;
776 }
777
778 return (func(acp, arg));
779 }
780
781 /*
782 * Our approach to cases is the same as for resources: we first obtain a
783 * list of UUIDs, sort them, then obtain the case information for each.
784 */
785 int
786 fmd_adm_case_iter(fmd_adm_t *ap, const char *url_token, fmd_adm_case_f *func,
787 void *arg)
788 {
789 struct fmd_rpc_caselist rcl;
790 struct fmd_rpc_caseinfo rci;
791 fmd_adm_caseinfo_t aci;
792 char **uuids, *p;
793 int i, rv;
794 enum clnt_stat cs;
795 uint_t retries = 0;
796
797 bzero(&rcl, sizeof (rcl)); /* tell xdr to allocate memory for us */
798
799 do {
800 cs = fmd_adm_caselist_1(&rcl, ap->adm_clnt);
801 } while (fmd_adm_retry(ap, cs, &retries));
802
803 if (cs != RPC_SUCCESS)
804 return (fmd_adm_set_errno(ap, EPROTO));
805
806 if (rcl.rcl_err != 0) {
807 xdr_free(xdr_fmd_rpc_caselist, (char *)&rcl);
808 return (fmd_adm_set_svcerr(ap, rcl.rcl_err));
809 }
810
811 if ((uuids = malloc(sizeof (char *) * rcl.rcl_cnt)) == NULL) {
812 xdr_free(xdr_fmd_rpc_caselist, (char *)&rcl);
813 return (fmd_adm_set_errno(ap, EAGAIN));
814 }
815
816 p = rcl.rcl_buf.rcl_buf_val;
817
818 for (i = 0; i < rcl.rcl_cnt; i++, p += strlen(p) + 1)
819 uuids[i] = p;
820
821 qsort(uuids, rcl.rcl_cnt, sizeof (char *), fmd_adm_case_cmp);
822
823 for (i = 0; i < rcl.rcl_cnt; i++) {
824 bzero(&rci, sizeof (rci));
825
826 retries = 0;
827 do {
828 cs = fmd_adm_caseinfo_1(uuids[i], &rci, ap->adm_clnt);
829 } while (fmd_adm_retry(ap, cs, &retries));
830
831 if (cs != RPC_SUCCESS) {
832 free(uuids);
833 xdr_free(xdr_fmd_rpc_caselist, (char *)&rcl);
834 return (fmd_adm_set_errno(ap, EPROTO));
835 }
836
837 if (rci.rci_err != 0 && rci.rci_err != FMD_ADM_ERR_CASESRCH) {
838 xdr_free(xdr_fmd_rpc_caseinfo, (char *)&rci);
839 free(uuids);
840 xdr_free(xdr_fmd_rpc_caselist, (char *)&rcl);
841 return (fmd_adm_set_svcerr(ap, rci.rci_err));
842 }
843
844 if (rci.rci_err == FMD_ADM_ERR_CASESRCH) {
845 xdr_free(xdr_fmd_rpc_caseinfo, (char *)&rci);
846 continue;
847 }
848
849 bzero(&aci, sizeof (aci));
850
851 if ((rv = nvlist_unpack(rci.rci_evbuf.rci_evbuf_val,
852 rci.rci_evbuf.rci_evbuf_len, &aci.aci_event, 0)) != 0) {
853 xdr_free(xdr_fmd_rpc_caseinfo, (char *)&rci);
854 free(uuids);
855 xdr_free(xdr_fmd_rpc_caselist, (char *)&rcl);
856 return (fmd_adm_set_errno(ap, rv));
857 }
858
859 if ((rv = nvlist_lookup_string(aci.aci_event, FM_SUSPECT_UUID,
860 (char **)&aci.aci_uuid)) != 0) {
861 xdr_free(xdr_fmd_rpc_caseinfo, (char *)&rci);
862 free(uuids);
863 xdr_free(xdr_fmd_rpc_caselist, (char *)&rcl);
864 nvlist_free(aci.aci_event);
865 return (fmd_adm_set_errno(ap, rv));
866 }
867 if ((rv = nvlist_lookup_string(aci.aci_event,
868 FM_SUSPECT_DIAG_CODE, (char **)&aci.aci_code)) != 0) {
869 xdr_free(xdr_fmd_rpc_caseinfo, (char *)&rci);
870 free(uuids);
871 xdr_free(xdr_fmd_rpc_caselist, (char *)&rcl);
872 nvlist_free(aci.aci_event);
873 return (fmd_adm_set_errno(ap, rv));
874 }
875
876 rv = fmd_adm_case_one(&aci, url_token, func, arg);
877
878 xdr_free(xdr_fmd_rpc_caseinfo, (char *)&rci);
879 nvlist_free(aci.aci_event);
880
881 if (rv != 0)
882 break;
883 }
884
885 free(uuids);
886 xdr_free(xdr_fmd_rpc_caselist, (char *)&rcl);
887 return (0);
888 }
889
890 static int
891 fmd_adm_serd_cmp(const void *lp, const void *rp)
892 {
893 return (strcmp(*(char **)lp, *(char **)rp));
894 }
895
896 int
897 fmd_adm_serd_iter(fmd_adm_t *ap, const char *name,
898 fmd_adm_serd_f *func, void *arg)
899 {
900 struct fmd_rpc_serdlist rsl;
901 struct fmd_rpc_serdinfo rsi;
902 char **serds, *p;
903 fmd_adm_serdinfo_t asi;
904 enum clnt_stat cs;
905 uint_t retries = 0;
906 int i, rv;
907
908 bzero(&rsl, sizeof (rsl)); /* tell xdr to allocate memory for us */
909
910 do {
911 cs = fmd_adm_serdlist_1((char *)name, &rsl, ap->adm_clnt);
912 } while (fmd_adm_retry(ap, cs, &retries));
913
914 if (cs != RPC_SUCCESS)
915 return (fmd_adm_set_errno(ap, EPROTO));
916
917 if (rsl.rsl_err != 0 || rsl.rsl_len == 0) {
918 xdr_free(xdr_fmd_rpc_serdlist, (char *)&rsl);
919 return (fmd_adm_set_svcerr(ap, rsl.rsl_err));
920 }
921
922 if ((serds = malloc(sizeof (char *) * rsl.rsl_cnt)) == NULL) {
923 xdr_free(xdr_fmd_rpc_serdlist, (char *)&rsl);
924 return (fmd_adm_set_errno(ap, EAGAIN));
925 }
926
927 p = rsl.rsl_buf.rsl_buf_val;
928
929 for (i = 0; i < rsl.rsl_cnt; i++, p += strlen(p) + 1)
930 serds[i] = p;
931
932 qsort(serds, rsl.rsl_cnt, sizeof (char *), fmd_adm_serd_cmp);
933
934 for (i = 0; i < rsl.rsl_cnt; i++) {
935 bzero(&rsi, sizeof (rsi));
936
937 retries = 0;
938 do {
939 cs = fmd_adm_serdinfo_1((char *)name, serds[i], &rsi,
940 ap->adm_clnt);
941 } while (fmd_adm_retry(ap, cs, &retries));
942
943 if (cs != RPC_SUCCESS) {
944 free(serds);
945 xdr_free(xdr_fmd_rpc_serdlist, (char *)&rsl);
946 return (fmd_adm_set_errno(ap, EPROTO));
947 }
948
949 if (rsi.rsi_err != 0 && rsi.rsi_err != FMD_ADM_ERR_SERDSRCH) {
950 free(serds);
951 xdr_free(xdr_fmd_rpc_serdinfo, (char *)&rsi);
952 xdr_free(xdr_fmd_rpc_serdlist, (char *)&rsl);
953 return (fmd_adm_set_svcerr(ap, rsi.rsi_err));
954 }
955
956 if (rsi.rsi_err == FMD_ADM_ERR_SERDSRCH) {
957 xdr_free(xdr_fmd_rpc_serdinfo, (char *)&rsi);
958 continue;
959 }
960
961 bzero(&asi, sizeof (asi));
962
963 asi.asi_name = rsi.rsi_name;
964 asi.asi_delta = rsi.rsi_delta;
965 asi.asi_n = rsi.rsi_n;
966 asi.asi_t = rsi.rsi_t;
967 asi.asi_count = rsi.rsi_count;
968 asi.asi_flags = 0;
969
970 if (rsi.rsi_fired)
971 asi.asi_flags |= FMD_ADM_SERD_FIRED;
972
973 rv = func(&asi, arg);
974
975 xdr_free(xdr_fmd_rpc_serdinfo, (char *)&rsi);
976
977 if (rv != 0)
978 break;
979 }
980
981 free(serds);
982 xdr_free(xdr_fmd_rpc_serdlist, (char *)&rsl);
983 return (0);
984 }
985
986 int
987 fmd_adm_serd_reset(fmd_adm_t *ap, const char *mod, const char *name)
988 {
989 char *s1 = (char *)mod, *s2 = (char *)name;
990 int err;
991 enum clnt_stat cs;
992 uint_t retries = 0;
993
994 if (mod == NULL || name == NULL || strchr(mod, '/') != NULL)
995 return (fmd_adm_set_errno(ap, EINVAL));
996
997 do {
998 cs = fmd_adm_serdreset_1(s1, s2, &err, ap->adm_clnt);
999 } while (fmd_adm_retry(ap, cs, &retries));
1000
1001 if (cs != RPC_SUCCESS)
1002 return (fmd_adm_set_errno(ap, EPROTO));
1003
1004 return (fmd_adm_set_svcerr(ap, err));
1005 }
1006
1007 int
1008 fmd_adm_xprt_iter(fmd_adm_t *ap, fmd_adm_xprt_f *func, void *arg)
1009 {
1010 struct fmd_rpc_xprtlist rxl;
1011 uint_t i;
1012 enum clnt_stat cs;
1013 uint_t retries = 0;
1014
1015 bzero(&rxl, sizeof (rxl)); /* tell xdr to allocate memory for us */
1016
1017 do {
1018 cs = fmd_adm_xprtlist_1(&rxl, ap->adm_clnt);
1019 } while (fmd_adm_retry(ap, cs, &retries));
1020
1021 if (cs != RPC_SUCCESS)
1022 return (fmd_adm_set_errno(ap, EPROTO));
1023
1024 if (rxl.rxl_err != 0) {
1025 xdr_free(xdr_fmd_rpc_xprtlist, (char *)&rxl);
1026 return (fmd_adm_set_svcerr(ap, rxl.rxl_err));
1027 }
1028
1029 for (i = 0; i < rxl.rxl_len; i++)
1030 func(rxl.rxl_buf.rxl_buf_val[i], arg);
1031
1032 xdr_free(xdr_fmd_rpc_xprtlist, (char *)&rxl);
1033 return (0);
1034 }
1035
1036 int
1037 fmd_adm_xprt_stats(fmd_adm_t *ap, id_t id, fmd_adm_stats_t *sp)
1038 {
1039 struct fmd_rpc_modstat rms;
1040 enum clnt_stat cs;
1041 uint_t retries = 0;
1042
1043 if (sp == NULL)
1044 return (fmd_adm_set_errno(ap, EINVAL));
1045
1046 bzero(&rms, sizeof (rms)); /* tell xdr to allocate memory for us */
1047
1048 do {
1049 cs = fmd_adm_xprtstat_1(id, &rms, ap->adm_clnt);
1050 } while (fmd_adm_retry(ap, cs, &retries));
1051
1052 if (cs != RPC_SUCCESS)
1053 return (fmd_adm_set_errno(ap, EPROTO));
1054
1055 if (rms.rms_err != 0) {
1056 xdr_free(xdr_fmd_rpc_modstat, (char *)&rms);
1057 return (fmd_adm_set_svcerr(ap, rms.rms_err));
1058 }
1059
1060 sp->ams_buf = rms.rms_buf.rms_buf_val;
1061 sp->ams_len = rms.rms_buf.rms_buf_len;
1062
1063 return (0);
1064 }
1065
1066 int
1067 fmd_adm_log_rotate(fmd_adm_t *ap, const char *log)
1068 {
1069 int err;
1070 enum clnt_stat cs;
1071 uint_t retries = 0;
1072
1073 if (log == NULL)
1074 return (fmd_adm_set_errno(ap, EINVAL));
1075
1076 do {
1077 cs = fmd_adm_logrotate_1((char *)log, &err, ap->adm_clnt);
1078 } while (fmd_adm_retry(ap, cs, &retries));
1079
1080 if (cs != RPC_SUCCESS)
1081 return (fmd_adm_set_errno(ap, EPROTO));
1082
1083 return (fmd_adm_set_svcerr(ap, err));
1084 }
1085
1086 /*
1087 * Custom XDR routine for our API structure fmd_stat_t. This function must
1088 * match the definition of fmd_stat_t in <fm/fmd_api.h> and must also match
1089 * the corresponding routine in usr/src/cmd/fm/fmd/common/fmd_rpc_adm.c.
1090 */
1091 bool_t
1092 xdr_fmd_stat(XDR *xp, fmd_stat_t *sp)
1093 {
1094 bool_t rv = TRUE;
1095
1096 rv &= xdr_opaque(xp, sp->fmds_name, sizeof (sp->fmds_name));
1097 rv &= xdr_u_int(xp, &sp->fmds_type);
1098 rv &= xdr_opaque(xp, sp->fmds_desc, sizeof (sp->fmds_desc));
1099
1100 switch (sp->fmds_type) {
1101 case FMD_TYPE_BOOL:
1102 rv &= xdr_int(xp, &sp->fmds_value.bool);
1103 break;
1104 case FMD_TYPE_INT32:
1105 rv &= xdr_int32_t(xp, &sp->fmds_value.i32);
1106 break;
1107 case FMD_TYPE_UINT32:
1108 rv &= xdr_uint32_t(xp, &sp->fmds_value.ui32);
1109 break;
1110 case FMD_TYPE_INT64:
1111 rv &= xdr_int64_t(xp, &sp->fmds_value.i64);
1112 break;
1113 case FMD_TYPE_UINT64:
1114 case FMD_TYPE_TIME:
1115 case FMD_TYPE_SIZE:
1116 rv &= xdr_uint64_t(xp, &sp->fmds_value.ui64);
1117 break;
1118 case FMD_TYPE_STRING:
1119 rv &= xdr_string(xp, &sp->fmds_value.str, ~0);
1120 break;
1121 }
1122
1123 return (rv);
1124 }