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 2008 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 * RCM module supporting multiplexed I/O controllers (MPxIO).
30 */
31 #include <stdlib.h>
32 #include <stdarg.h>
33 #include <unistd.h>
34 #include <assert.h>
35 #include <syslog.h>
36 #include <string.h>
37 #include <synch.h>
38 #include <libintl.h>
39 #include <locale.h>
40 #include <ctype.h>
41 #include <errno.h>
42 #include <libdevinfo.h>
43 #include <sys/types.h>
44 #include "rcm_module.h"
45
46 #define MPXIO_PROP_NAME "mpxio-component"
47 #define MPXIO_PROP_CLIENT "client"
48
49 #define CMD_GETINFO 0
50 #define CMD_OFFLINE 1
51 #define CMD_ONLINE 2
52 #define CMD_REMOVE 3
53
54 #define CACHE_NEW 0
55 #define CACHE_REFERENCED 1
56 #define CACHE_STALE 2
57
58 #define MPXIO_MSG_CACHEFAIL gettext("Internal analysis failure.")
59 #define MPXIO_MSG_LASTPATH gettext("Last path to busy resources.")
60 #define MPXIO_MSG_USAGE gettext("SCSI Multipathing PHCI (%s)")
61 #define MPXIO_MSG_USAGEUNKNOWN gettext("SCSI Multipathing PHCI (<unknown>)")
62
63 typedef struct {
64 char *path;
65 di_path_state_t state;
66 } phci_t;
67
68 typedef struct phci_list {
69 phci_t phci;
70 int referenced;
71 struct phci_list *next;
72 } phci_list_t;
73
74 typedef struct group {
75 int offline;
76 int nphcis;
77 int nclients;
78 phci_t *phcis;
79 char **clients;
80 struct group *next;
81 } group_t;
82
83 static int mpxio_register(rcm_handle_t *);
84 static int mpxio_unregister(rcm_handle_t *);
85 static int mpxio_getinfo(rcm_handle_t *, char *, id_t, uint_t, char **, char **,
86 nvlist_t *, rcm_info_t **);
87 static int mpxio_suspend(rcm_handle_t *, char *, id_t, timespec_t *, uint_t,
88 char **, rcm_info_t **);
89 static int mpxio_resume(rcm_handle_t *, char *, id_t, uint_t, char **,
90 rcm_info_t **);
91 static int mpxio_offline(rcm_handle_t *, char *, id_t, uint_t, char **,
92 rcm_info_t **);
93 static int mpxio_online(rcm_handle_t *, char *, id_t, uint_t, char **,
94 rcm_info_t **);
95 static int mpxio_remove(rcm_handle_t *, char *, id_t, uint_t, char **,
96 rcm_info_t **);
97 static int get_nclients(di_node_t, void *);
98 static int build_groups(di_node_t, void *);
99 static void refresh_regs(rcm_handle_t *);
100 static int get_affected_clients(rcm_handle_t *, char *, int, int, char ***);
101 static int detect_client_change(rcm_handle_t *, int, int, group_t *, char *);
102 static int merge_clients(int *, char ***, group_t *);
103 static phci_list_t *lookup_phci(char *);
104 static int is_client(di_node_t);
105 static char *get_rsrcname(di_node_t);
106 static char *s_state(di_path_state_t);
107 static int compare_phci(const void *, const void *);
108 static void free_grouplist();
109 static void free_group(group_t *);
110 static void free_clients(int, char **);
111 static void free_phcis(int, phci_t *);
112
113 static struct rcm_mod_ops mpxio_ops =
114 {
115 RCM_MOD_OPS_VERSION,
116 mpxio_register,
117 mpxio_unregister,
118 mpxio_getinfo,
119 mpxio_suspend,
120 mpxio_resume,
121 mpxio_offline,
122 mpxio_online,
123 mpxio_remove,
124 NULL,
125 NULL,
126 NULL
127 };
128
129 static group_t *group_list;
130 static phci_list_t *reg_list;
131 static mutex_t mpxio_lock;
132
133 extern int errno;
134
135 /*
136 * Return the mod-ops vector for initialization.
137 */
138 struct rcm_mod_ops *
rcm_mod_init()139 rcm_mod_init()
140 {
141 rcm_log_message(RCM_TRACE1, "MPXIO: rcm_mod_init()\n");
142
143 return (&mpxio_ops);
144 }
145
146 /*
147 * Return name and version number for mod_info.
148 */
149 const char *
rcm_mod_info()150 rcm_mod_info()
151 {
152 rcm_log_message(RCM_TRACE1, "MPXIO: rcm_mod_info()\n");
153
154 return (gettext("RCM MPxIO module 1.6"));
155 }
156
157 /*
158 * Destroy the cache and mutex lock when being unloaded.
159 */
160 int
rcm_mod_fini()161 rcm_mod_fini()
162 {
163 phci_list_t *reg;
164 phci_list_t *next;
165
166 rcm_log_message(RCM_TRACE1, "MPXIO: rcm_mod_fini()\n");
167
168 /* Free the cache of MPxIO group information */
169 free_grouplist();
170
171 /* Free the cache of registrants */
172 reg = reg_list;
173 while (reg) {
174 next = reg->next;
175 free(reg->phci.path);
176 free(reg);
177 reg = next;
178 }
179
180 /* Destroy the mutex for locking the caches */
181 (void) mutex_destroy(&mpxio_lock);
182
183 return (RCM_SUCCESS);
184 }
185
186 /*
187 * During each register callback: totally rebuild the group list from a new
188 * libdevinfo snapshot, and then update the registrants.
189 */
190 static int
mpxio_register(rcm_handle_t * hdl)191 mpxio_register(rcm_handle_t *hdl)
192 {
193 int nclients = 0;
194 di_node_t devroot;
195
196 rcm_log_message(RCM_TRACE1, "MPXIO: register()\n");
197
198 (void) mutex_lock(&mpxio_lock);
199
200 /* Destroy the previous group list */
201 free_grouplist();
202
203 /* Get a current libdevinfo snapshot */
204 if ((devroot = di_init("/", DINFOCPYALL | DINFOPATH)) == DI_NODE_NIL) {
205 rcm_log_message(RCM_ERROR,
206 "MPXIO: libdevinfo initialization failed (%s).\n",
207 strerror(errno));
208 (void) mutex_unlock(&mpxio_lock);
209 return (RCM_FAILURE);
210 }
211
212 /*
213 * First count the total number of clients. This'll be a useful
214 * upper bound when allocating client arrays within each group.
215 */
216 (void) di_walk_node(devroot, DI_WALK_CLDFIRST, &nclients, get_nclients);
217
218 rcm_log_message(RCM_TRACE2, gettext("MPXIO: found %d clients.\n"),
219 nclients);
220
221 /*
222 * Then walk the libdevinfo snapshot, building up the new group list
223 * along the way. Pass in the total number of clients (from above) to
224 * assist in group construction.
225 */
226 (void) di_walk_node(devroot, DI_WALK_CLDFIRST, &nclients, build_groups);
227
228 /* Now with a new group list constructed, refresh the registrants */
229 refresh_regs(hdl);
230
231 /* Free the libdevinfo snapshot */
232 di_fini(devroot);
233
234 (void) mutex_unlock(&mpxio_lock);
235
236 return (0);
237 }
238
239 /*
240 * Unregister all PHCIs and mark the whole registrants list as stale.
241 */
242 static int
mpxio_unregister(rcm_handle_t * hdl)243 mpxio_unregister(rcm_handle_t *hdl)
244 {
245 phci_list_t *reg;
246
247 rcm_log_message(RCM_TRACE1, "MPXIO: unregister()\n");
248
249 (void) mutex_lock(&mpxio_lock);
250
251 for (reg = reg_list; reg != NULL; reg = reg->next) {
252 (void) rcm_unregister_interest(hdl, reg->phci.path, 0);
253 reg->referenced = CACHE_STALE;
254 }
255
256 (void) mutex_unlock(&mpxio_lock);
257
258 return (RCM_SUCCESS);
259 }
260
261 /*
262 * To return usage information, just lookup the PHCI in the cache and return
263 * a string identifying that it's a PHCI and describing its cached MPxIO state.
264 * Recurse with the cached list of disks if dependents are to be included.
265 */
266 static int
mpxio_getinfo(rcm_handle_t * hdl,char * rsrc,id_t id,uint_t flags,char ** infostr,char ** errstr,nvlist_t * props,rcm_info_t ** infop)267 mpxio_getinfo(rcm_handle_t *hdl, char *rsrc, id_t id, uint_t flags,
268 char **infostr, char **errstr, nvlist_t *props, rcm_info_t **infop)
269 {
270 size_t len;
271 int rv = RCM_SUCCESS;
272 char *buf = NULL;
273 char **clients = NULL;
274 phci_list_t *reg;
275 char c;
276
277 rcm_log_message(RCM_TRACE1, "MPXIO: getinfo(%s)\n", rsrc);
278
279 *infostr = NULL;
280 *errstr = NULL;
281
282 (void) mutex_lock(&mpxio_lock);
283
284 if ((reg = lookup_phci(rsrc)) == NULL) {
285 *errstr = strdup(MPXIO_MSG_CACHEFAIL);
286 (void) mutex_unlock(&mpxio_lock);
287 return (RCM_FAILURE);
288 }
289
290 len = snprintf(&c, 1, MPXIO_MSG_USAGE, s_state(reg->phci.state));
291 buf = calloc(len + 1, sizeof (char));
292 if ((buf == NULL) || (snprintf(buf, len + 1, MPXIO_MSG_USAGE,
293 s_state(reg->phci.state)) > len + 1)) {
294 *infostr = strdup(MPXIO_MSG_USAGEUNKNOWN);
295 *errstr = strdup(gettext("Cannot construct usage string."));
296 (void) mutex_unlock(&mpxio_lock);
297 if (buf)
298 free(buf);
299 return (RCM_FAILURE);
300 }
301 *infostr = buf;
302
303 if (flags & RCM_INCLUDE_DEPENDENT) {
304 rcm_log_message(RCM_TRACE2, "MPXIO: getting clients\n");
305 if (get_affected_clients(hdl, rsrc, CMD_GETINFO, flags,
306 &clients) < 0) {
307 *errstr = strdup(gettext("Cannot lookup clients."));
308 (void) mutex_unlock(&mpxio_lock);
309 return (RCM_FAILURE);
310 }
311 if (clients) {
312 rv = rcm_get_info_list(hdl, clients, flags, infop);
313 free(clients);
314 } else {
315 rcm_log_message(RCM_TRACE2, "MPXIO: none found\n");
316 }
317 }
318
319 (void) mutex_unlock(&mpxio_lock);
320 return (rv);
321 }
322
323 /*
324 * Nothing is implemented for suspend operations.
325 */
326 static int
mpxio_suspend(rcm_handle_t * hdl,char * rsrc,id_t id,timespec_t * interval,uint_t flags,char ** errstr,rcm_info_t ** infop)327 mpxio_suspend(rcm_handle_t *hdl, char *rsrc, id_t id, timespec_t *interval,
328 uint_t flags, char **errstr, rcm_info_t **infop)
329 {
330 rcm_log_message(RCM_TRACE1, "MPXIO: suspend(%s)\n", rsrc);
331
332 return (RCM_SUCCESS);
333 }
334
335 /*
336 * Nothing is implemented for resume operations.
337 */
338 static int
mpxio_resume(rcm_handle_t * hdl,char * rsrc,id_t id,uint_t flags,char ** errstr,rcm_info_t ** infop)339 mpxio_resume(rcm_handle_t *hdl, char *rsrc, id_t id, uint_t flags,
340 char **errstr, rcm_info_t **infop)
341 {
342 rcm_log_message(RCM_TRACE1, "MPXIO: resume(%s)\n", rsrc);
343
344 return (RCM_SUCCESS);
345 }
346
347 /*
348 * MPxIO has no policy against offlining. If disks will be affected, then
349 * base the return value for this request on the results of offlining the
350 * list of disks. Otherwise succeed.
351 */
352 static int
mpxio_offline(rcm_handle_t * hdl,char * rsrc,id_t id,uint_t flags,char ** errstr,rcm_info_t ** infop)353 mpxio_offline(rcm_handle_t *hdl, char *rsrc, id_t id, uint_t flags,
354 char **errstr, rcm_info_t **infop)
355 {
356 char **clients = NULL;
357 int rv = RCM_SUCCESS;
358
359 rcm_log_message(RCM_TRACE1, "MPXIO: offline(%s)\n", rsrc);
360
361 (void) mutex_lock(&mpxio_lock);
362
363 if (get_affected_clients(hdl, rsrc, CMD_OFFLINE, flags, &clients) < 0) {
364 *errstr = strdup(gettext("Cannot lookup clients."));
365 (void) mutex_unlock(&mpxio_lock);
366 return (RCM_FAILURE);
367 }
368
369 if (clients) {
370 rv = rcm_request_offline_list(hdl, clients, flags, infop);
371 if (rv != RCM_SUCCESS)
372 *errstr = strdup(MPXIO_MSG_LASTPATH);
373 free(clients);
374 }
375
376 (void) mutex_unlock(&mpxio_lock);
377
378 return (rv);
379 }
380
381 /*
382 * If disks are affected, then they are probably offline and we need to
383 * propagate this online notification to them.
384 */
385 static int
mpxio_online(rcm_handle_t * hdl,char * rsrc,id_t id,uint_t flags,char ** errstr,rcm_info_t ** infop)386 mpxio_online(rcm_handle_t *hdl, char *rsrc, id_t id, uint_t flags,
387 char **errstr, rcm_info_t **infop)
388 {
389 char **clients;
390 int rv = RCM_SUCCESS;
391
392 rcm_log_message(RCM_TRACE1, "MPXIO: online(%s)\n", rsrc);
393
394 (void) mutex_lock(&mpxio_lock);
395
396 if (get_affected_clients(hdl, rsrc, CMD_ONLINE, flags, &clients) < 0) {
397 *errstr = strdup(gettext("Cannot lookup clients."));
398 (void) mutex_unlock(&mpxio_lock);
399 return (RCM_FAILURE);
400 }
401
402 if (clients) {
403 rv = rcm_notify_online_list(hdl, clients, flags, infop);
404 free(clients);
405 }
406
407 (void) mutex_unlock(&mpxio_lock);
408
409 return (rv);
410 }
411
412 /*
413 * If clients are affected, then they are probably offline and we need to
414 * propagate this removal notification to them. We can also remove the
415 * cache entry for this PHCI. If that leaves its group empty, then the
416 * group will be removed during the next register callback.
417 */
418 static int
mpxio_remove(rcm_handle_t * hdl,char * rsrc,id_t id,uint_t flags,char ** errstr,rcm_info_t ** infop)419 mpxio_remove(rcm_handle_t *hdl, char *rsrc, id_t id, uint_t flags,
420 char **errstr, rcm_info_t **infop)
421 {
422 char **clients;
423 int rv = RCM_SUCCESS;
424
425 rcm_log_message(RCM_TRACE1, "MPXIO: remove(%s)\n", rsrc);
426
427 (void) mutex_lock(&mpxio_lock);
428
429 if (get_affected_clients(hdl, rsrc, CMD_REMOVE, flags, &clients) < 0) {
430 *errstr = strdup(gettext("Cannot lookup clients."));
431 (void) mutex_unlock(&mpxio_lock);
432 return (RCM_FAILURE);
433 }
434
435 if (clients) {
436 rv = rcm_notify_remove_list(hdl, clients, flags, infop);
437 free(clients);
438 }
439
440 (void) mutex_unlock(&mpxio_lock);
441
442 return (rv);
443 }
444
445
446 /*
447 * Returns a string representation of a given libdevinfo path state.
448 */
449 static char *
s_state(di_path_state_t state)450 s_state(di_path_state_t state)
451 {
452 switch (state) {
453 case DI_PATH_STATE_ONLINE:
454 return ("online");
455 case DI_PATH_STATE_OFFLINE:
456 return ("offline");
457 case DI_PATH_STATE_STANDBY:
458 return ("standby");
459 case DI_PATH_STATE_FAULT:
460 return ("faulted");
461 default:
462 return ("<unknown>");
463 }
464 }
465
466 static int
get_affected_clients(rcm_handle_t * hdl,char * rsrc,int cmd,int flags,char *** clientsp)467 get_affected_clients(rcm_handle_t *hdl, char *rsrc, int cmd, int flags,
468 char ***clientsp)
469 {
470 int nclients = 0;
471 phci_t phci;
472 group_t *group;
473 char **clients = NULL;
474
475 /* Build a dummy phci_t for use with bsearch(). */
476 phci.path = rsrc;
477
478 /* Analyze the effects upon each group. */
479 for (group = group_list; group != NULL; group = group->next) {
480
481 /* If the PHCI isn't in the group, then no effects. Skip. */
482 if (bsearch(&phci, group->phcis, group->nphcis, sizeof (phci_t),
483 compare_phci) == NULL)
484 continue;
485
486 /*
487 * Merge in the clients. All clients are merged in for getinfo
488 * operations. Otherwise it's contingent upon a state change
489 * being transferred to the clients as a result of changing
490 * the PHCI's state.
491 */
492 if ((cmd == CMD_GETINFO) ||
493 detect_client_change(hdl, cmd, flags, group, rsrc)) {
494 if (merge_clients(&nclients, &clients, group) < 0) {
495 free_clients(nclients, clients);
496 return (-1);
497 }
498 }
499 }
500
501 /* Return the array of affected disks */
502 *clientsp = clients;
503 return (0);
504 }
505
506 /*
507 * Iterates through the members of a PHCI list, returning the entry
508 * corresponding to the named PHCI resource. Returns NULL when the lookup
509 * fails.
510 */
511 static phci_list_t *
lookup_phci(char * rsrc)512 lookup_phci(char *rsrc)
513 {
514 phci_list_t *reg;
515
516 for (reg = reg_list; reg != NULL; reg = reg->next) {
517 if (strcmp(reg->phci.path, rsrc) == 0)
518 return (reg);
519 }
520
521 return (NULL);
522 }
523
524 /*
525 * Tests whether or not an operation on a specific PHCI resource would affect
526 * the array of client devices attached to the PHCI's MPxIO group.
527 *
528 * Returns: 1 if clients would be affected, 0 if not.
529 */
530 static int
detect_client_change(rcm_handle_t * hdl,int cmd,int flags,group_t * group,char * rsrc)531 detect_client_change(rcm_handle_t *hdl, int cmd, int flags, group_t *group,
532 char *rsrc)
533 {
534 int i;
535 int state;
536
537 /*
538 * Perform a full set analysis on the set of redundant PHCIs. When
539 * there are no unaffected and online PHCIs, then changing the state
540 * of the named PHCI results in a client state change.
541 */
542 for (i = 0; i < group->nphcis; i++) {
543
544 /* Filter the named resource out of the analysis */
545 if (strcmp(group->phcis[i].path, rsrc) == 0)
546 continue;
547
548 /*
549 * If we find a path that's in the ONLINE or STANDBY state
550 * that would be left over in the system after completing
551 * whatever DR or hotplugging operation is in progress, then
552 * return a 0.
553 */
554 if ((group->phcis[i].state == DI_PATH_STATE_ONLINE) ||
555 (group->phcis[i].state == DI_PATH_STATE_STANDBY)) {
556 if (rcm_get_rsrcstate(hdl, group->phcis[i].path, &state)
557 != RCM_SUCCESS) {
558 rcm_log_message(RCM_ERROR,
559 "MPXIO: Failed to query resource state\n");
560 continue;
561 }
562 rcm_log_message(RCM_TRACE2, "MPXIO: state of %s: %d\n",
563 group->phcis[i].path, state);
564 if (state == RCM_STATE_ONLINE) {
565 return (0);
566 }
567 }
568 }
569
570 /*
571 * The analysis above didn't find a redundant path to take over. So
572 * report that the state of the client resources will change.
573 */
574 return (1);
575 }
576
577 /*
578 * Merges the client disks connected to a particular MPxIO group in with a
579 * previous array of disk clients. The result is to adjust the 'nclients'
580 * value with the new count of disks in the array, and to adjust the 'disks'
581 * value to be a larger array of disks including its original contents along
582 * with the current group's contents merged in.
583 */
584 static int
merge_clients(int * nclients,char *** clientsp,group_t * group)585 merge_clients(int *nclients, char ***clientsp, group_t *group)
586 {
587 int i;
588 int old_nclients;
589 char **clients_new;
590
591 if (group->nclients) {
592 old_nclients = *nclients;
593 *nclients += group->nclients;
594 clients_new = realloc(*clientsp,
595 ((*nclients) + 1) * sizeof (char *));
596 if (clients_new == NULL) {
597 rcm_log_message(RCM_ERROR,
598 "MPXIO: cannot reallocate client array (%s).\n",
599 strerror(errno));
600 return (-1);
601 }
602 for (i = old_nclients; i < (*nclients); i++) {
603 /*
604 * Don't allocate space for individual disks in the
605 * merged list. Just make references to the previously
606 * allocated strings in the group_t structs themselves.
607 */
608 clients_new[i] = group->clients[i - old_nclients];
609 }
610 clients_new[(*nclients)] = NULL;
611 *clientsp = clients_new;
612 }
613
614 return (0);
615 }
616
617 /*
618 * A libdevinfo di_walk_node() callback. It's passed an integer pointer as an
619 * argument, and it increments the integer each time it encounters an MPxIO
620 * client. By initializing the integer to zero and doing a libdevinfo walk with
621 * this function, the total count of MPxIO clients in the system can be found.
622 */
623 static int
get_nclients(di_node_t dinode,void * arg)624 get_nclients(di_node_t dinode, void *arg)
625 {
626 int *nclients = arg;
627
628 if (is_client(dinode))
629 (*nclients)++;
630
631 return (DI_WALK_CONTINUE);
632 }
633
634 /*
635 * Tests a libdevinfo node to determine if it's an MPxIO client.
636 *
637 * Returns: non-zero for true, 0 for false.
638 */
639 static int
is_client(di_node_t dinode)640 is_client(di_node_t dinode)
641 {
642 return (di_path_client_next_path(dinode, DI_PATH_NIL) != DI_PATH_NIL);
643 }
644
645 /*
646 * After a new group_list has been constructed, this refreshes the RCM
647 * registrations and the reg_list contents. It uses a clock like algorithm
648 * with reference bits in the reg_list to know which registrants are new or
649 * old.
650 */
651 static void
refresh_regs(rcm_handle_t * hdl)652 refresh_regs(rcm_handle_t *hdl)
653 {
654 int i;
655 group_t *group;
656 phci_list_t *reg;
657 phci_list_t *prev_reg;
658
659 /*
660 * First part of the clock-like algorithm: clear reference bits.
661 */
662 for (reg = reg_list; reg != NULL; reg = reg->next)
663 reg->referenced = CACHE_STALE;
664
665 /*
666 * Second part of the clock-like algorithm: set the reference bits
667 * on every registrant that's still active. (Also add new list nodes
668 * for new registrants.)
669 */
670 for (group = group_list; group != NULL; group = group->next) {
671 for (i = 0; i < group->nphcis; i++) {
672
673 /*
674 * If already stale in the registrants list, just set
675 * its reference bit to REFERENCED and update its state.
676 */
677 if ((reg = lookup_phci(group->phcis[i].path)) != NULL) {
678 if (reg->referenced == CACHE_STALE)
679 reg->referenced = CACHE_REFERENCED;
680 reg->phci.state = group->phcis[i].state;
681 continue;
682 }
683
684 /*
685 * Otherwise, build a new list node and mark it NEW.
686 */
687 reg = (phci_list_t *)calloc(1, sizeof (*reg));
688 if (reg == NULL) {
689 rcm_log_message(RCM_ERROR,
690 "MPXIO: cannot allocate phci_list (%s).\n",
691 strerror(errno));
692 continue;
693 }
694 reg->phci.path = strdup(group->phcis[i].path);
695 if (reg->phci.path == NULL) {
696 free(reg);
697 rcm_log_message(RCM_ERROR,
698 "MPXIO: cannot allocate phci path (%s).\n",
699 strerror(errno));
700 continue;
701 }
702 reg->phci.state = group->phcis[i].state;
703 reg->referenced = CACHE_NEW;
704
705 /* Link it at the head of reg_list */
706 reg->next = reg_list;
707 reg_list = reg;
708 }
709 }
710
711 /*
712 * Final part of the clock algorithm: unregister stale entries, and
713 * register new entries. Stale entries get removed from the list.
714 */
715 reg = reg_list;
716 prev_reg = NULL;
717 while (reg) {
718
719 /* Unregister and remove stale entries. */
720 if (reg->referenced == CACHE_STALE) {
721 (void) rcm_unregister_interest(hdl, reg->phci.path, 0);
722 free(reg->phci.path);
723 if (prev_reg == NULL) {
724 reg_list = reg->next;
725 free(reg);
726 reg = reg_list;
727 } else {
728 prev_reg->next = reg->next;
729 free(reg);
730 reg = prev_reg->next;
731 }
732 continue;
733 }
734
735 /* Register new entries. */
736 if (reg->referenced == CACHE_NEW) {
737 if (rcm_register_interest(hdl, reg->phci.path, 0, NULL)
738 != RCM_SUCCESS) {
739 rcm_log_message(RCM_ERROR,
740 "MPXIO: failed to register %s (%s).\n",
741 reg->phci.path, strerror(errno));
742 }
743 }
744
745 prev_reg = reg;
746 reg = reg->next;
747 }
748 }
749
750
751 /*
752 * A libdevinfo di_walk_node() callback that builds up the MPxIO group list.
753 *
754 * Every node encountered that's a client node is added into a group's client
755 * list. Whenever a group doesn't already exist with a matching set of
756 * related PHCIs, then a new group is constructed and put at the head of the
757 * group list.
758 */
759 static int
build_groups(di_node_t dinode,void * arg)760 build_groups(di_node_t dinode, void *arg)
761 {
762 int i = 0;
763 int nphcis = 0;
764 int *nclients = (int *)arg;
765 phci_t *phcis;
766 group_t *group;
767 di_node_t phcinode;
768 di_path_t dipath = DI_PATH_NIL;
769
770 /* Safety check */
771 if (nclients == NULL)
772 return (DI_WALK_TERMINATE);
773
774 /*
775 * Build a sorted array of PHCIs pertaining to the client.
776 */
777 while ((dipath =
778 di_path_client_next_path(dinode, dipath)) != DI_PATH_NIL)
779 nphcis++;
780
781 /* Skip non-clients. */
782 if (nphcis == 0)
783 return (DI_WALK_CONTINUE);
784
785 if ((phcis = (phci_t *)calloc(nphcis, sizeof (phci_t))) == NULL) {
786 rcm_log_message(RCM_ERROR,
787 "MPXIO: failed to allocate client's PHCIs (%s).\n",
788 strerror(errno));
789 return (DI_WALK_TERMINATE);
790 }
791 while ((dipath =
792 di_path_client_next_path(dinode, dipath)) != DI_PATH_NIL) {
793 phcinode = di_path_phci_node(dipath);
794 if (phcinode == DI_NODE_NIL) {
795 free_phcis(i, phcis); /* free preceeding PHCIs */
796 rcm_log_message(RCM_ERROR,
797 "MPXIO: client appears to have no PHCIs.\n");
798 return (DI_WALK_TERMINATE);
799 }
800 if ((phcis[i].path = get_rsrcname(phcinode)) == NULL) {
801 free_phcis(i, phcis);
802 return (DI_WALK_TERMINATE);
803 }
804 phcis[i].state = di_path_state(dipath);
805 i++;
806 }
807 qsort(phcis, nphcis, sizeof (phci_t), compare_phci);
808
809 /*
810 * Compare that PHCI set to each existing group's set. We just add
811 * the client to the group and exit successfully once a match is made.
812 * Falling out of this loop means no match was found.
813 */
814 for (group = group_list; group != NULL; group = group->next) {
815
816 /* There is no match if the number of PHCIs is inequal */
817 if (nphcis != group->nphcis)
818 continue;
819
820 /* Compare the PHCIs linearly (which is okay; they're sorted) */
821 for (i = 0; i < nphcis; i++)
822 if (strcmp(phcis[i].path, group->phcis[i].path) != 0)
823 break;
824
825 /*
826 * If the loop above completed, we have a match. Add the client
827 * to the group's disk array in that case, and return
828 * successfully.
829 */
830 if (i == nphcis) {
831 free_phcis(nphcis, phcis);
832 if ((group->clients[group->nclients] =
833 get_rsrcname(dinode)) == NULL)
834 return (DI_WALK_TERMINATE);
835 group->nclients++;
836 return (DI_WALK_CONTINUE);
837 }
838 }
839
840 /* The loop above didn't find a match. So build a new group. */
841 if ((group = (group_t *)calloc(1, sizeof (*group))) == NULL) {
842 rcm_log_message(RCM_ERROR,
843 "MPXIO: failed to allocate PHCI group (%s).\n",
844 strerror(errno));
845 free_phcis(nphcis, phcis);
846 return (DI_WALK_TERMINATE);
847 }
848 if ((group->clients = (char **)calloc(*nclients, sizeof (char *))) ==
849 NULL) {
850 free(group);
851 free_phcis(nphcis, phcis);
852 return (DI_WALK_TERMINATE);
853 }
854 group->nphcis = nphcis;
855 group->phcis = phcis;
856 if ((group->clients[0] = get_rsrcname(dinode)) == NULL) {
857 free_group(group);
858 return (DI_WALK_TERMINATE);
859 }
860 group->nclients = 1;
861
862 /* Link the group into the group list and return successfully. */
863 group->next = group_list;
864 group_list = group;
865 return (DI_WALK_CONTINUE);
866 }
867
868 /*
869 * For bsearch() and qsort(). Returns the results of a strcmp() on the names
870 * of two phci_t's.
871 */
872 static int
compare_phci(const void * arg1,const void * arg2)873 compare_phci(const void *arg1, const void *arg2)
874 {
875 phci_t *p1 = (phci_t *)arg1;
876 phci_t *p2 = (phci_t *)arg2;
877
878 if ((p1 == NULL) || (p2 == NULL)) {
879 if (p1 != NULL)
880 return (-1);
881 else if (p2 != NULL)
882 return (1);
883 return (0);
884 }
885
886 return (strcmp(p1->path, p2->path));
887 }
888
889 /*
890 * Free the whole list of group's in the global group_list.
891 */
892 static void
free_grouplist()893 free_grouplist()
894 {
895 group_t *group = group_list;
896 group_t *next;
897
898 while (group) {
899 next = group->next;
900 free_group(group);
901 group = next;
902 }
903
904 group_list = NULL;
905 }
906
907 /*
908 * Free the contents of a single group_t.
909 */
910 static void
free_group(group_t * group)911 free_group(group_t *group)
912 {
913 if (group) {
914 free_phcis(group->nphcis, group->phcis);
915 free_clients(group->nclients, group->clients);
916 free(group);
917 }
918 }
919
920 /*
921 * Free an array of clients.
922 */
923 static void
free_clients(int nclients,char ** clients)924 free_clients(int nclients, char **clients)
925 {
926 int i;
927
928 if (clients != NULL) {
929 if (nclients > 0) {
930 for (i = 0; i < nclients; i++)
931 if (clients[i])
932 free(clients[i]);
933 }
934 free(clients);
935 }
936 }
937
938 /*
939 * Free an array of phci_t's.
940 */
941 static void
free_phcis(int nphcis,phci_t * phcis)942 free_phcis(int nphcis, phci_t *phcis)
943 {
944 int i;
945
946 if ((phcis != NULL) && (nphcis > 0)) {
947 for (i = 0; i < nphcis; i++)
948 if (phcis[i].path)
949 free(phcis[i].path);
950 free(phcis);
951 }
952 }
953
954 /*
955 * Converts a libdevinfo node into a /devices path. Caller must free results.
956 */
957 static char *
get_rsrcname(di_node_t dinode)958 get_rsrcname(di_node_t dinode)
959 {
960 int len;
961 char *rsrcname;
962 char *devfspath;
963 char name[MAXPATHLEN];
964
965 if ((devfspath = di_devfs_path(dinode)) == NULL) {
966 rcm_log_message(RCM_ERROR, "MPXIO: resource has null path.\n");
967 return (NULL);
968 }
969
970 len = snprintf(name, sizeof (name), "/devices%s", devfspath);
971 di_devfs_path_free(devfspath);
972 if (len >= sizeof (name)) {
973 rcm_log_message(RCM_ERROR, "MPXIO: resource path too long.\n");
974 return (NULL);
975 }
976
977 if ((rsrcname = strdup(name)) == NULL)
978 rcm_log_message(RCM_ERROR,
979 "MPXIO: failed to allocate resource name (%s).\n",
980 strerror(errno));
981
982 return (rsrcname);
983 }
984