?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
feature_tests.h: always use largefile interfaces
[unleashed.git] / usr / src / lib / libdevinfo / devinfo_retire.c
blob274e8934a609df0542b08526213911827b295d51
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 (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 #include <libdevinfo.h>
27 #include <sys/modctl.h>
28 #include <sys/stat.h>
29 #include <string.h>
30 #include <librcm.h>
31 #include <dlfcn.h>
32
33 #undef NDEBUG
34 #include <assert.h>
35
36 typedef struct rio_path {
37 char rpt_path[PATH_MAX];
38 struct rio_path *rpt_next;
39 } rio_path_t;
40
41 typedef struct rcm_arg {
42 char *rcm_root;
43 di_node_t rcm_node;
44 int rcm_supp;
45 rcm_handle_t *rcm_handle;
46 int rcm_retcode;
47 di_retire_t *rcm_dp;
48 rio_path_t *rcm_cons_nodes;
49 rio_path_t *rcm_rsrc_minors;
50 int (*rcm_offline)();
51 int (*rcm_online)();
52 int (*rcm_remove)();
53 } rcm_arg_t;
54
55 typedef struct selector {
56 char *sel_name;
57 int (*sel_selector)(di_node_t node, rcm_arg_t *rp);
58 } di_selector_t;
59
60 static void rio_assert(di_retire_t *dp, const char *EXstr, int line,
61 const char *file);
62
63 #define LIBRCM_PATH "/usr/lib/librcm.so"
64 #define RIO_ASSERT(d, x) \
65 {if (!(x)) rio_assert(d, #x, __LINE__, __FILE__); }
66
67 static int disk_select(di_node_t node, rcm_arg_t *rp);
68 static int nexus_select(di_node_t node, rcm_arg_t *rp);
69 static int enclosure_select(di_node_t node, rcm_arg_t *rp);
70 static int smp_select(di_node_t node, rcm_arg_t *rp);
71
72 di_selector_t supported_devices[] = {
73 {"disk", disk_select},
74 {"nexus", nexus_select},
75 {"enclosure", enclosure_select},
76 {"smp", smp_select},
77 {NULL, NULL}
78 };
79
80 void *
81 s_calloc(size_t nelem, size_t elsize, int fail)
82 {
83 if (fail) {
84 errno = ENOMEM;
85 return (NULL);
86 } else {
87 return (calloc(nelem, elsize));
88 }
89 }
90
91 static void
92 rio_assert(di_retire_t *dp, const char *EXstr, int line, const char *file)
93 {
94 char buf[PATH_MAX];
95
96 if (dp->rt_abort == NULL)
97 assert(0);
98
99 (void) snprintf(buf, sizeof (buf),
100 "Assertion failed: %s, file %s, line %d\n",
101 EXstr, file, line);
102 dp->rt_abort(dp->rt_hdl, buf);
103 }
104
105 /*ARGSUSED*/
106 static int
107 enclosure_minor(di_node_t node, di_minor_t minor, void *arg)
108 {
109 rcm_arg_t *rp = (rcm_arg_t *)arg;
110 di_retire_t *dp = rp->rcm_dp;
111
112 rp->rcm_supp = 1;
113 dp->rt_debug(dp->rt_hdl, "[INFO]: enclosure_minor: "
114 "IDed this node as enclosure\n");
115 return (DI_WALK_TERMINATE);
116 }
117
118 static int
119 enclosure_select(di_node_t node, rcm_arg_t *rp)
120 {
121 rcm_arg_t rarg;
122 di_retire_t *dp = rp->rcm_dp;
123
124 rarg.rcm_dp = dp;
125
126 /*
127 * Check if this is an enclosure minor. If any one minor is DDI_NT_SGEN
128 * or DDI_NT_SCSI_ENCLOSURE we assume it is an enclosure.
129 */
130 rarg.rcm_supp = 0;
131 if (di_walk_minor(node, DDI_NT_SCSI_ENCLOSURE, 0, &rarg,
132 enclosure_minor) != 0) {
133 dp->rt_debug(dp->rt_hdl, "[INFO]: enclosure_select:"
134 "di_walk_minor failed. Returning NOTSUP\n");
135 return (0);
136 }
137 if (di_walk_minor(node, "ddi_generic:scsi", 0, &rarg,
138 enclosure_minor) != 0) {
139 dp->rt_debug(dp->rt_hdl, "[INFO]: enclosure_select:"
140 "di_walk_minor failed. Returning NOTSUP\n");
141 return (0);
142 }
143
144 return (rarg.rcm_supp);
145 }
146
147 /*ARGSUSED*/
148 static int
149 smp_minor(di_node_t node, di_minor_t minor, void *arg)
150 {
151 rcm_arg_t *rp = (rcm_arg_t *)arg;
152 di_retire_t *dp = rp->rcm_dp;
153
154 rp->rcm_supp = 1;
155 dp->rt_debug(dp->rt_hdl, "[INFO]: smp_minor: "
156 "IDed this node as smp\n");
157 return (DI_WALK_TERMINATE);
158 }
159
160 static int
161 smp_select(di_node_t node, rcm_arg_t *rp)
162 {
163 rcm_arg_t rarg;
164 di_retire_t *dp = rp->rcm_dp;
165
166 rarg.rcm_dp = dp;
167
168 /*
169 * Check if this is an smp minor. If any one minor is DDI_NT_SMP
170 * we assume it is an smp.
171 */
172 rarg.rcm_supp = 0;
173 if (di_walk_minor(node, DDI_NT_SMP, 0, &rarg, smp_minor) != 0) {
174 dp->rt_debug(dp->rt_hdl, "[INFO]: smp_select:"
175 "di_walk_minor failed. Returning NOTSUP\n");
176 return (0);
177 }
178
179 return (rarg.rcm_supp);
180 }
181
182 /*ARGSUSED*/
183 static int
184 disk_minor(di_node_t node, di_minor_t minor, void *arg)
185 {
186 rcm_arg_t *rp = (rcm_arg_t *)arg;
187 di_retire_t *dp = rp->rcm_dp;
188
189 if (di_minor_spectype(minor) == S_IFBLK) {
190 rp->rcm_supp = 1;
191 dp->rt_debug(dp->rt_hdl, "[INFO]: disk_minor: is disk minor. "
192 "IDed this node as disk\n");
193 return (DI_WALK_TERMINATE);
194 }
195
196 dp->rt_debug(dp->rt_hdl, "[INFO]: disk_minor: Not a disk minor. "
197 "Continuing minor walk\n");
198 return (DI_WALK_CONTINUE);
199 }
200
201 static int
202 disk_select(di_node_t node, rcm_arg_t *rp)
203 {
204 rcm_arg_t rarg;
205 di_retire_t *dp = rp->rcm_dp;
206
207 rarg.rcm_dp = dp;
208
209 /*
210 * Check if this is a disk minor. If any one minor is DDI_NT_BLOCK
211 * we assume it is a disk
212 */
213 rarg.rcm_supp = 0;
214 if (di_walk_minor(node, DDI_NT_BLOCK, 0, &rarg, disk_minor) != 0) {
215 dp->rt_debug(dp->rt_hdl, "[INFO]: disk_select: di_walk_minor "
216 "failed. Returning NOTSUP\n");
217 return (0);
218 }
219
220 return (rarg.rcm_supp);
221 }
222
223 static int
224 nexus_select(di_node_t node, rcm_arg_t *rp)
225 {
226 int select;
227 char *path;
228
229 di_retire_t *dp = rp->rcm_dp;
230
231 path = di_devfs_path(node);
232 if (path == NULL) {
233 dp->rt_debug(dp->rt_hdl, "[INFO]: nexus_select: "
234 "di_devfs_path() is NULL. Returning NOTSUP\n");
235 return (0);
236 }
237
238 /*
239 * Check if it is a nexus
240 */
241 if (di_driver_ops(node) & DI_BUS_OPS) {
242 dp->rt_debug(dp->rt_hdl, "[INFO]: nexus_select: is nexus %s\n",
243 path);
244 select = 1;
245 } else {
246 dp->rt_debug(dp->rt_hdl, "[INFO]: nexus_select: not nexus %s\n",
247 path);
248 select = 0;
249 }
250
251 di_devfs_path_free(path);
252
253 return (select);
254 }
255
256 static int
257 node_select(di_node_t node, void *arg)
258 {
259 rcm_arg_t *rp = (rcm_arg_t *)arg;
260 di_retire_t *dp;
261 int sel;
262 int i;
263 char *path;
264 uint_t state;
265
266 dp = rp->rcm_dp;
267
268 /* skip pseudo nodes - we only retire real hardware */
269 path = di_devfs_path(node);
270 if (strncmp(path, "/pseudo/", strlen("/pseudo/")) == 0 ||
271 strcmp(path, "/pseudo") == 0) {
272 dp->rt_debug(dp->rt_hdl, "[INFO]: node_select: "
273 "pseudo device in subtree - returning NOTSUP: %s\n",
274 path);
275 rp->rcm_supp = 0;
276 di_devfs_path_free(path);
277 return (DI_WALK_TERMINATE);
278 }
279 di_devfs_path_free(path);
280
281 /*
282 * If a device is offline/detached/down it is
283 * retireable irrespective of the type of device,
284 * presumably the system is able to function without
285 * it.
286 */
287 state = di_state(node);
288 if ((state & DI_DRIVER_DETACHED) || (state & DI_DEVICE_OFFLINE) ||
289 (state & DI_BUS_DOWN)) {
290 dp->rt_debug(dp->rt_hdl, "[INFO]: node_select: device "
291 "is offline/detached. Assuming retire supported\n");
292 return (DI_WALK_CONTINUE);
293 }
294
295 sel = 0;
296 for (i = 0; supported_devices[i].sel_name != NULL; i++) {
297 sel = supported_devices[i].sel_selector(node, rp);
298 if (sel == 1) {
299 dp->rt_debug(dp->rt_hdl, "[INFO]: node_select: "
300 "found supported device: %s\n",
301 supported_devices[i].sel_name);
302 break;
303 }
304 }
305
306 if (sel != 1) {
307 /*
308 * This node is not a supported device. Retire cannot proceed
309 */
310 dp->rt_debug(dp->rt_hdl, "[INFO]: node_select: found "
311 "unsupported device. Returning NOTSUP\n");
312 rp->rcm_supp = 0;
313 return (DI_WALK_TERMINATE);
314 }
315
316 /*
317 * This node is supported. Check other nodes in this subtree.
318 */
319 dp->rt_debug(dp->rt_hdl, "[INFO]: node_select: This node supported. "
320 "Checking other nodes in subtree: %s\n", rp->rcm_root);
321 return (DI_WALK_CONTINUE);
322 }
323
324
325
326 /*
327 * when in doubt assume that retire is not supported for this device.
328 */
329 static int
330 retire_supported(rcm_arg_t *rp)
331 {
332 di_retire_t *dp;
333 di_node_t rnode = rp->rcm_node;
334
335 dp = rp->rcm_dp;
336
337 /*
338 * We should not be here if devinfo snapshot is NULL.
339 */
340 RIO_ASSERT(dp, rnode != DI_NODE_NIL);
341
342 /*
343 * Note: We initally set supported to 1, then walk the
344 * subtree rooted at devpath, allowing each node the
345 * opportunity to veto the support. We cannot do things
346 * the other way around i.e. assume "not supported" and
347 * let individual nodes indicate that they are supported.
348 * In the latter case, the supported flag would be set
349 * if any one node in the subtree was supported which is
350 * not what we want.
351 */
352 rp->rcm_supp = 1;
353 if (di_walk_node(rnode, DI_WALK_CLDFIRST, rp, node_select) != 0) {
354 dp->rt_debug(dp->rt_hdl, "[ERROR]: retire_supported: "
355 "di_walk_node: failed. Returning NOTSUP\n");
356 rp->rcm_supp = 0;
357 }
358
359 if (rp->rcm_supp) {
360 dp->rt_debug(dp->rt_hdl, "[INFO]: retire IS supported\n");
361 }
362
363 return (rp->rcm_supp);
364 }
365
366 static void
367 rcm_finalize(rcm_arg_t *rp, int retcode)
368 {
369 rio_path_t *p;
370 rio_path_t *tmp;
371 int flags = RCM_RETIRE_NOTIFY;
372 int retval;
373 int error;
374 di_retire_t *dp;
375
376 dp = rp->rcm_dp;
377
378 RIO_ASSERT(dp, retcode == 0 || retcode == -1);
379
380 dp->rt_debug(dp->rt_hdl, "[INFO]: rcm_finalize: retcode=%d: dev=%s\n",
381 retcode, rp->rcm_root);
382
383 for (p = rp->rcm_cons_nodes; p; ) {
384 tmp = p;
385 p = tmp->rpt_next;
386 free(tmp);
387 }
388 rp->rcm_cons_nodes = NULL;
389
390 dp->rt_debug(dp->rt_hdl, "[INFO]: rcm_finalize: cons_nodes NULL\n");
391
392 for (p = rp->rcm_rsrc_minors; p; ) {
393 tmp = p;
394 p = tmp->rpt_next;
395 if (retcode == 0) {
396 retval = rp->rcm_remove(rp->rcm_handle,
397 tmp->rpt_path, flags, NULL);
398 error = errno;
399 } else {
400 RIO_ASSERT(dp, retcode == -1);
401 retval = rp->rcm_online(rp->rcm_handle,
402 tmp->rpt_path, flags, NULL);
403 error = errno;
404 }
405 if (retval != RCM_SUCCESS) {
406 dp->rt_debug(dp->rt_hdl, "[ERROR]: rcm_finalize: "
407 "rcm_%s: retval=%d: error=%s: path=%s\n",
408 retcode == 0 ? "remove" : "online", retval,
409 strerror(error), tmp->rpt_path);
410 } else {
411 dp->rt_debug(dp->rt_hdl, "[INFO]: rcm_finalize: "
412 "rcm_%s: SUCCESS: path=%s\n",
413 retcode == 0 ? "remove" : "online", tmp->rpt_path);
414 }
415 free(tmp);
416 }
417 rp->rcm_rsrc_minors = NULL;
418 }
419 /*ARGSUSED*/
420 static int
421 call_offline(di_node_t node, di_minor_t minor, void *arg)
422 {
423 rcm_arg_t *rp = (rcm_arg_t *)arg;
424 di_retire_t *dp = rp->rcm_dp;
425 char *mnp;
426 rio_path_t *rpt;
427 int retval;
428
429 mnp = di_devfs_minor_path(minor);
430 if (mnp == NULL) {
431 dp->rt_debug(dp->rt_hdl, "[ERROR]: di_devfs_minor_path "
432 "failed. Returning RCM FAILURE: %s\n", rp->rcm_root);
433 rp->rcm_retcode = RCM_FAILURE;
434 return (DI_WALK_TERMINATE);
435 }
436
437 rpt = s_calloc(1, sizeof (rio_path_t), 0);
438 if (rpt == NULL) {
439 dp->rt_debug(dp->rt_hdl, "[ERROR]: calloc failed. "
440 "Returning RCM FAILURE: %s\n", rp->rcm_root);
441 di_devfs_path_free(mnp);
442 rp->rcm_retcode = RCM_FAILURE;
443 return (DI_WALK_TERMINATE);
444 }
445
446 (void) snprintf(rpt->rpt_path, sizeof (rpt->rpt_path),
447 "/devices%s", mnp);
448
449 di_devfs_path_free(mnp);
450
451 retval = rp->rcm_offline(rp->rcm_handle, rpt->rpt_path,
452 RCM_RETIRE_REQUEST, NULL);
453
454 rpt->rpt_next = rp->rcm_rsrc_minors;
455 rp->rcm_rsrc_minors = rpt;
456
457 if (retval == RCM_FAILURE) {
458 dp->rt_debug(dp->rt_hdl, "[ERROR]: RCM OFFLINE failed "
459 "for: %s\n", rpt->rpt_path);
460 rp->rcm_retcode = RCM_FAILURE;
461 return (DI_WALK_TERMINATE);
462 } else if (retval == RCM_SUCCESS) {
463 rp->rcm_retcode = RCM_SUCCESS;
464 dp->rt_debug(dp->rt_hdl, "[INFO]: RCM OFFLINE returned "
465 "RCM_SUCCESS: %s\n", rpt->rpt_path);
466 } else if (retval != RCM_NO_CONSTRAINT) {
467 dp->rt_debug(dp->rt_hdl, "[ERROR]: RCM OFFLINE returned "
468 "invalid value for: %s\n", rpt->rpt_path);
469 rp->rcm_retcode = RCM_FAILURE;
470 return (DI_WALK_TERMINATE);
471 } else {
472 dp->rt_debug(dp->rt_hdl, "[INFO]: RCM OFFLINE returned "
473 "RCM_NO_CONSTRAINT: %s\n", rpt->rpt_path);
474 }
475
476 return (DI_WALK_CONTINUE);
477 }
478
479 static int
480 offline_one(di_node_t node, void *arg)
481 {
482 rcm_arg_t *rp = (rcm_arg_t *)arg;
483 rio_path_t *rpt;
484 di_retire_t *dp = rp->rcm_dp;
485 char *path;
486
487 /*
488 * We should already have terminated the walk
489 * in case of failure
490 */
491 RIO_ASSERT(dp, rp->rcm_retcode == RCM_SUCCESS ||
492 rp->rcm_retcode == RCM_NO_CONSTRAINT);
493
494 dp->rt_debug(dp->rt_hdl, "[INFO]: offline_one: entered\n");
495
496 rp->rcm_retcode = RCM_NO_CONSTRAINT;
497
498 rpt = s_calloc(1, sizeof (rio_path_t), 0);
499 if (rpt == NULL) {
500 dp->rt_debug(dp->rt_hdl, "[ERROR]: rio_path_t calloc "
501 "failed: error: %s\n", strerror(errno));
502 goto fail;
503 }
504
505 path = di_devfs_path(node);
506 if (path == NULL) {
507 dp->rt_debug(dp->rt_hdl, "[ERROR]: di_devfs_path "
508 "failed: error: %s\n", strerror(errno));
509 free(rpt);
510 goto fail;
511 }
512
513 (void) strlcpy(rpt->rpt_path, path, sizeof (rpt->rpt_path));
514
515 di_devfs_path_free(path);
516
517 if (di_walk_minor(node, NULL, 0, rp, call_offline) != 0) {
518 dp->rt_debug(dp->rt_hdl, "[ERROR]: di_walk_minor "
519 "failed: error: %s: %s\n", strerror(errno), path);
520 free(rpt);
521 goto fail;
522 }
523
524 if (rp->rcm_retcode == RCM_FAILURE) {
525 dp->rt_debug(dp->rt_hdl, "[ERROR]: di_walk_minor "
526 "returned: RCM_FAILURE: %s\n", rpt->rpt_path);
527 free(rpt);
528 goto fail;
529 } else if (rp->rcm_retcode == RCM_SUCCESS) {
530 dp->rt_debug(dp->rt_hdl, "[INFO]: di_walk_minor "
531 "returned: RCM_SUCCESS: %s\n", rpt->rpt_path);
532 rpt->rpt_next = rp->rcm_cons_nodes;
533 rp->rcm_cons_nodes = rpt;
534 } else if (rp->rcm_retcode != RCM_NO_CONSTRAINT) {
535 dp->rt_debug(dp->rt_hdl, "[ERROR]: di_walk_minor "
536 "returned: unknown RCM error code: %d, %s\n",
537 rp->rcm_retcode, rpt->rpt_path);
538 free(rpt);
539 goto fail;
540 } else {
541 dp->rt_debug(dp->rt_hdl, "[INFO]: di_walk_minor "
542 "returned: RCM_NO_CONSTRAINT: %s\n", rpt->rpt_path);
543 free(rpt);
544 }
545
546 /*
547 * RCM_SUCCESS or RCM_NO_CONSTRAINT.
548 * RCM_SUCCESS implies we overcame a constraint, so keep walking.
549 * RCM_NO_CONSTRAINT implies no constraints applied via RCM.
550 * Continue walking in the hope that contracts or LDI will
551 * apply constraints
552 * set retcode to RCM_SUCCESS to show that at least 1 node
553 * completely walked
554 */
555 rp->rcm_retcode = RCM_SUCCESS;
556 return (DI_WALK_CONTINUE);
557
558 fail:
559 rp->rcm_retcode = RCM_FAILURE;
560 return (DI_WALK_TERMINATE);
561 }
562
563 /*
564 * Returns:
565 * RCM_SUCCESS: RCM constraints (if any) were applied. The
566 * device paths for which constraints were applied is passed
567 * back via the pp argument
568 *
569 * RCM_FAILURE: Either RCM constraints prevent a retire or
570 * an error occurred
571 */
572 static int
573 rcm_notify(rcm_arg_t *rp, char **pp, size_t *clen)
574 {
575 size_t len;
576 rio_path_t *p;
577 rio_path_t *tmp;
578 char *plistp;
579 char *s;
580 di_retire_t *dp;
581 di_node_t rnode;
582
583 dp = rp->rcm_dp;
584
585 dp->rt_debug(dp->rt_hdl, "[INFO]: rcm_notify() entered\n");
586
587 RIO_ASSERT(dp, rp->rcm_root);
588
589 *pp = NULL;
590
591 rnode = rp->rcm_node;
592 if (rnode == DI_NODE_NIL) {
593 dp->rt_debug(dp->rt_hdl, "[ERROR]: devinfo snapshot "
594 "NULL. Returning no RCM constraint: %s\n", rp->rcm_root);
595 return (RCM_NO_CONSTRAINT);
596 }
597
598 rp->rcm_retcode = RCM_NO_CONSTRAINT;
599 rp->rcm_cons_nodes = NULL;
600 rp->rcm_rsrc_minors = NULL;
601 if (di_walk_node(rnode, DI_WALK_CLDFIRST, rp, offline_one) != 0) {
602 dp->rt_debug(dp->rt_hdl, "[ERROR]: di_walk_node "
603 "failed: error: %s: %s\n", strerror(errno), rp->rcm_root);
604 /* online is idempotent - safe to online non-offlined nodes */
605 rcm_finalize(rp, -1);
606 rp->rcm_retcode = RCM_FAILURE;
607 goto out;
608 }
609
610 if (rp->rcm_retcode == RCM_FAILURE) {
611 dp->rt_debug(dp->rt_hdl, "[ERROR]: walk_node "
612 "returned retcode of RCM_FAILURE: %s\n", rp->rcm_root);
613 rcm_finalize(rp, -1);
614 goto out;
615 }
616
617 if (rp->rcm_retcode == RCM_NO_CONSTRAINT) {
618 dp->rt_debug(dp->rt_hdl, "[ERROR]: di_walk_node "
619 " - no nodes walked: RCM_NO_CONSTRAINT: %s\n",
620 rp->rcm_root);
621 } else {
622 dp->rt_debug(dp->rt_hdl, "[INFO]: walk_node: RCM_SUCCESS\n");
623 }
624
625 /*
626 * Convert to a sequence of NUL separated strings terminated by '\0'\0'
627 */
628 for (len = 0, p = rp->rcm_cons_nodes; p; p = p->rpt_next) {
629 RIO_ASSERT(dp, p->rpt_path);
630 RIO_ASSERT(dp, strlen(p->rpt_path) > 0);
631 len += (strlen(p->rpt_path) + 1);
632 }
633 len++; /* list terminating '\0' */
634
635 dp->rt_debug(dp->rt_hdl, "[INFO]: len of constraint str = %lu\n", len);
636
637 plistp = s_calloc(1, len, 0);
638 if (plistp == NULL) {
639 dp->rt_debug(dp->rt_hdl, "[ERROR]: fail to alloc "
640 "constraint list: error: %s: %s\n", strerror(errno),
641 rp->rcm_root);
642 rcm_finalize(rp, -1);
643 rp->rcm_retcode = RCM_FAILURE;
644 goto out;
645 }
646
647 for (s = plistp, p = rp->rcm_cons_nodes; p; ) {
648 tmp = p;
649 p = tmp->rpt_next;
650 (void) strcpy(s, tmp->rpt_path);
651 s += strlen(s) + 1;
652 RIO_ASSERT(dp, s - plistp < len);
653 free(tmp);
654 }
655 rp->rcm_cons_nodes = NULL;
656 RIO_ASSERT(dp, s - plistp == len - 1);
657 *s = '\0';
658
659 dp->rt_debug(dp->rt_hdl, "[INFO]: constraint str = %p\n", plistp);
660
661 *pp = plistp;
662 *clen = len;
663
664 rp->rcm_retcode = RCM_SUCCESS;
665 out:
666 return (rp->rcm_retcode);
667 }
668
669
670 /*ARGSUSED*/
671 int
672 di_retire_device(char *devpath, di_retire_t *dp, int flags)
673 {
674 char path[PATH_MAX];
675 struct stat sb;
676 int retval = EINVAL;
677 char *constraint = NULL;
678 size_t clen;
679 void *librcm_hdl;
680 rcm_arg_t rarg = {0};
681 int (*librcm_alloc_handle)();
682 int (*librcm_free_handle)();
683
684 if (dp == NULL || dp->rt_debug == NULL || dp->rt_hdl == NULL)
685 return (EINVAL);
686
687 if (devpath == NULL || devpath[0] == '\0') {
688 dp->rt_debug(dp->rt_hdl, "[ERROR]: NULL argument(s)\n");
689 return (EINVAL);
690 }
691
692 if (devpath[0] != '/' || strlen(devpath) >= PATH_MAX ||
693 strncmp(devpath, "/devices/", strlen("/devices/")) == 0 ||
694 strstr(devpath, "../devices/") || strrchr(devpath, ':')) {
695 dp->rt_debug(dp->rt_hdl, "[ERROR]: invalid devpath: %s\n",
696 devpath);
697 return (EINVAL);
698 }
699
700 if (flags != 0) {
701 dp->rt_debug(dp->rt_hdl, "[ERROR]: flags should be 0: %d\n",
702 flags);
703 return (EINVAL);
704 }
705
706 /*
707 * dlopen rather than link against librcm since libdevinfo
708 * resides in / and librcm resides in /usr. The dlopen is
709 * safe to do since fmd which invokes the retire code
710 * resides on /usr and will not come here until /usr is
711 * mounted.
712 */
713 librcm_hdl = dlopen(LIBRCM_PATH, RTLD_LAZY);
714 if (librcm_hdl == NULL) {
715 char *errstr = dlerror();
716 dp->rt_debug(dp->rt_hdl, "[ERROR]: Cannot dlopen librcm: %s\n",
717 errstr ? errstr : "Unknown error");
718 return (ENOSYS);
719 }
720
721 librcm_alloc_handle = (int (*)())dlsym(librcm_hdl, "rcm_alloc_handle");
722 rarg.rcm_offline = (int (*)())dlsym(librcm_hdl, "rcm_request_offline");
723 rarg.rcm_online = (int (*)())dlsym(librcm_hdl, "rcm_notify_online");
724 rarg.rcm_remove = (int (*)())dlsym(librcm_hdl, "rcm_notify_remove");
725 librcm_free_handle = (int (*)())dlsym(librcm_hdl, "rcm_free_handle");
726
727 if (librcm_alloc_handle == NULL ||
728 rarg.rcm_offline == NULL ||
729 rarg.rcm_online == NULL ||
730 rarg.rcm_remove == NULL ||
731 librcm_free_handle == NULL) {
732 dp->rt_debug(dp->rt_hdl, "[ERROR]: dlsym failed\n");
733 retval = ENOSYS;
734 goto out;
735 }
736
737 /*
738 * Take a libdevinfo snapshot here because we cannot do so
739 * after device is retired. If device doesn't attach, we retire
740 * anyway i.e. it is not fatal.
741 */
742 rarg.rcm_node = di_init(devpath, DINFOCPYALL);
743 if (rarg.rcm_node == DI_NODE_NIL) {
744 dp->rt_debug(dp->rt_hdl, "[ERROR]: device doesn't attach, "
745 "retiring anyway: %s\n", devpath);
746 }
747
748 rarg.rcm_handle = NULL;
749 if (librcm_alloc_handle(NULL, 0, NULL, &rarg.rcm_handle)
750 != RCM_SUCCESS) {
751 retval = errno;
752 dp->rt_debug(dp->rt_hdl, "[ERROR]: failed to alloc "
753 "RCM handle. Returning RCM failure: %s\n", devpath);
754 rarg.rcm_handle = NULL;
755 goto out;
756 }
757
758 rarg.rcm_root = devpath;
759 rarg.rcm_dp = dp;
760
761 /*
762 * If device is already detached/nonexistent and cannot be
763 * attached, allow retire without checking device type.
764 * XXX
765 * Else, check if retire is supported for this device type.
766 */
767 (void) snprintf(path, sizeof (path), "/devices%s", devpath);
768 if (stat(path, &sb) == -1 || !S_ISDIR(sb.st_mode)) {
769 dp->rt_debug(dp->rt_hdl, "[ERROR]: detached or nonexistent "
770 "device. Bypassing retire_supported: %s\n", devpath);
771 } else if (!retire_supported(&rarg)) {
772 dp->rt_debug(dp->rt_hdl, "[ERROR]: retire not supported for "
773 "device type: %s\n", devpath);
774 retval = ENOTSUP;
775 goto out;
776 }
777
778 clen = 0;
779 constraint = NULL;
780 retval = rcm_notify(&rarg, &constraint, &clen);
781 if (retval == RCM_FAILURE) {
782 /* retire not permitted */
783 dp->rt_debug(dp->rt_hdl, "[ERROR]: RCM constraints block "
784 "retire: %s\n", devpath);
785 retval = EBUSY;
786 goto out;
787 } else if (retval == RCM_SUCCESS) {
788 dp->rt_debug(dp->rt_hdl, "[INFO]: RCM constraints applied"
789 ": %s\n", devpath);
790 } else if (retval == RCM_NO_CONSTRAINT) {
791 dp->rt_debug(dp->rt_hdl, "[INFO]: No RCM constraints applied"
792 ": %s\n", devpath);
793 } else {
794 dp->rt_debug(dp->rt_hdl, "[ERROR]: notify returned unknown "
795 "return code: %d: %s\n", retval, devpath);
796 retval = ESRCH;
797 goto out;
798 }
799
800 if (modctl(MODRETIRE, devpath, constraint, clen) != 0) {
801 retval = errno;
802 dp->rt_debug(dp->rt_hdl, "[ERROR]: retire modctl() failed: "
803 "%s: %s\n", devpath, strerror(retval));
804 rcm_finalize(&rarg, -1);
805 goto out;
806 }
807
808 dp->rt_debug(dp->rt_hdl, "[INFO]: retire modctl() succeeded: %s\n",
809 devpath);
810
811 rcm_finalize(&rarg, 0);
812
813 retval = 0;
814
815 out:
816 if (rarg.rcm_handle)
817 (void) librcm_free_handle(rarg.rcm_handle);
818
819 RIO_ASSERT(dp, rarg.rcm_cons_nodes == NULL);
820 RIO_ASSERT(dp, rarg.rcm_rsrc_minors == NULL);
821
822 (void) dlclose(librcm_hdl);
823
824 free(constraint);
825
826 if (rarg.rcm_node != DI_NODE_NIL)
827 di_fini(rarg.rcm_node);
828
829 return (retval);
830 }
831
832 /*ARGSUSED*/
833 int
834 di_unretire_device(char *devpath, di_retire_t *dp)
835 {
836 if (dp == NULL || dp->rt_debug == NULL || dp->rt_hdl == NULL)
837 return (EINVAL);
838
839 if (devpath == NULL || devpath[0] == '\0') {
840 dp->rt_debug(dp->rt_hdl, "[ERROR]: NULL devpath\n");
841 return (EINVAL);
842 }
843
844 if (devpath[0] != '/' || strlen(devpath) >= PATH_MAX ||
845 strncmp(devpath, "/devices/", strlen("/devices/")) == 0 ||
846 strstr(devpath, "../devices/") || strrchr(devpath, ':')) {
847 dp->rt_debug(dp->rt_hdl, "[ERROR]: invalid devpath: %s\n",
848 devpath);
849 return (EINVAL);
850 }
851
852 if (modctl(MODUNRETIRE, devpath) != 0) {
853 int err = errno;
854 dp->rt_debug(dp->rt_hdl, "[ERROR]: unretire modctl() failed: "
855 "%s: %s\n", devpath, strerror(err));
856 return (err);
857 }
858
859 dp->rt_debug(dp->rt_hdl, "[INFO]: unretire modctl() done: %s\n",
860 devpath);
861
862 return (0);
863 }
Unleashed OS