?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / lib / libdiskmgt / common / findevs.c
blob68384c1ca151437bc7c73848da16dcc3208cb5ea
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 2010 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 * Copyright (c) 2011 by Delphix. All rights reserved.
25 * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
26 */
27
28 #include <fcntl.h>
29 #include <libdevinfo.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <sys/stat.h>
34 #include <sys/sunddi.h>
35 #include <sys/types.h>
36 #include <sys/mkdev.h>
37 #include <ctype.h>
38 #include <libgen.h>
39 #include <unistd.h>
40 #include <devid.h>
41 #include <sys/fs/zfs.h>
42
43 #include "libdiskmgt.h"
44 #include "disks_private.h"
45
46 #define CLUSTER_DEV "did"
47
48 /* specify which disk links to use in the /dev directory */
49 #define DEVLINK_REGEX "rdsk/.*"
50 #define DEVLINK_FLOPPY_REGEX "rdiskette[0-9]"
51 #define DEVLINK_DID_REGEX "did/rdsk/.*"
52
53 #define FLOPPY_NAME "rdiskette"
54
55 #define MAXPROPLEN 1024
56 #define DEVICE_ID_PROP "devid"
57 #define PROD_ID_PROP "inquiry-product-id"
58 #define PROD_ID_USB_PROP "usb-product-name"
59 #define REMOVABLE_PROP "removable-media"
60 #define HOTPLUGGABLE_PROP "hotpluggable"
61 #define SCSI_OPTIONS_PROP "scsi-options"
62 #define VENDOR_ID_PROP "inquiry-vendor-id"
63 #define VENDOR_ID_USB_PROP "usb-vendor-name"
64 #define WWN_PROP "node-wwn"
65
66 static char *ctrltypes[] = {
67 DDI_NT_SCSI_NEXUS,
68 DDI_NT_SCSI_ATTACHMENT_POINT,
69 DDI_NT_FC_ATTACHMENT_POINT,
70 NULL
71 };
72
73 static char *bustypes[] = {
74 "sbus",
75 "pci",
76 "usb",
77 NULL
78 };
79
80 static bus_t *add_bus(struct search_args *args, di_node_t node,
81 di_minor_t minor, controller_t *cp);
82 static int add_cluster_devs(di_node_t node, di_minor_t minor,
83 void *arg);
84 static controller_t *add_controller(struct search_args *args,
85 di_node_t node, di_minor_t minor);
86 static int add_devpath(di_devlink_t devlink, void *arg);
87 static int add_devs(di_node_t node, di_minor_t minor, void *arg);
88 static int add_disk2controller(disk_t *diskp,
89 struct search_args *args);
90 static int add_disk2path(disk_t *dp, path_t *pp,
91 di_path_state_t st, char *wwn);
92 static int add_int2array(int p, int **parray);
93 static int add_ptr2array(void *p, void ***parray);
94 static char *bus_type(di_node_t node, di_minor_t minor,
95 di_prom_handle_t ph);
96 static void remove_controller(controller_t *cp,
97 controller_t *currp);
98 static void clean_paths(struct search_args *args);
99 static disk_t *create_disk(char *deviceid, char *kernel_name,
100 struct search_args *args);
101 static char *ctype(di_node_t node, di_minor_t minor);
102 static boolean_t disk_is_cdrom(const char *type);
103 static alias_t *find_alias(disk_t *diskp, char *kernel_name);
104 static bus_t *find_bus(struct search_args *args, char *name);
105 static controller_t *find_controller(struct search_args *args, char *name);
106 static int fix_cluster_devpath(di_devlink_t devlink, void *arg);
107 static disk_t *get_disk_by_deviceid(disk_t *listp, char *devid);
108 static void get_disk_name_from_path(char *path, char *name,
109 int size);
110 static char *get_byte_prop(char *prop_name, di_node_t node);
111 static di_node_t get_parent_bus(di_node_t node,
112 struct search_args *args);
113 static int get_prom_int(char *prop_name, di_node_t node,
114 di_prom_handle_t ph);
115 static char *get_prom_str(char *prop_name, di_node_t node,
116 di_prom_handle_t ph);
117 static int get_prop(char *prop_name, di_node_t node);
118 static char *get_str_prop(char *prop_name, di_node_t node);
119 static int have_disk(struct search_args *args, char *devid,
120 char *kernel_name, disk_t **diskp);
121 static int is_cluster_disk(di_node_t node, di_minor_t minor);
122 static int is_ctds(char *name);
123 static int is_drive(di_minor_t minor);
124 static int is_zvol(di_node_t node, di_minor_t minor);
125 static int is_HBA(di_node_t node, di_minor_t minor);
126 static int new_alias(disk_t *diskp, char *kernel_path,
127 char *devlink_path, struct search_args *args);
128 static int new_devpath(alias_t *ap, char *devpath);
129 static path_t *new_path(controller_t *cp, disk_t *diskp,
130 di_node_t node, di_path_state_t st, char *wwn);
131 static void remove_invalid_controller(char *name,
132 controller_t *currp, struct search_args *args);
133 static char *str_case_index(register char *s1, register char *s2);
134
135 /*
136 * The functions in this file do a dev tree walk to build up a model of the
137 * disks, controllers and paths on the system. This model is returned in the
138 * args->disk_listp and args->controller_listp members of the args param.
139 * There is no global data for this file so it is thread safe. It is up to
140 * the caller to merge the resulting model with any existing model that is
141 * cached. The caller must also free the memory for this model when it is
142 * no longer needed.
143 */
144 void
145 findevs(struct search_args *args)
146 {
147 uint_t flags;
148 di_node_t di_root;
149
150 args->dev_walk_status = 0;
151 args->disk_listp = NULL;
152 args->controller_listp = NULL;
153 args->bus_listp = NULL;
154
155 args->handle = di_devlink_init(NULL, 0);
156
157 /*
158 * Have to make several passes at this with the new devfs caching.
159 * First, we find non-mpxio devices. Then we find mpxio/multipath
160 * devices. Finally, we get cluster devices.
161 */
162 flags = DINFOCACHE;
163 di_root = di_init("/", flags);
164 args->ph = di_prom_init();
165 (void) di_walk_minor(di_root, NULL, 0, args, add_devs);
166 di_fini(di_root);
167
168 flags = DINFOCPYALL | DINFOPATH;
169 di_root = di_init("/", flags);
170 (void) di_walk_minor(di_root, NULL, 0, args, add_devs);
171 di_fini(di_root);
172
173 /* do another pass to clean up cluster devpaths */
174 flags = DINFOCACHE;
175 di_root = di_init("/", flags);
176 (void) di_walk_minor(di_root, DDI_PSEUDO, 0, args, add_cluster_devs);
177 if (args->ph != DI_PROM_HANDLE_NIL) {
178 (void) di_prom_fini(args->ph);
179 }
180 di_fini(di_root);
181
182 (void) di_devlink_fini(&(args->handle));
183
184 clean_paths(args);
185 }
186
187 /*
188 * Definitions of private functions
189 */
190
191 static bus_t *
192 add_bus(struct search_args *args, di_node_t node, di_minor_t minor,
193 controller_t *cp)
194 {
195 char *btype;
196 char *devpath;
197 bus_t *bp;
198 char kstat_name[MAXPATHLEN];
199 di_node_t pnode;
200
201 if (node == DI_NODE_NIL) {
202 return (NULL);
203 }
204
205 if ((btype = bus_type(node, minor, args->ph)) == NULL) {
206 return (add_bus(args, di_parent_node(node),
207 di_minor_next(di_parent_node(node), NULL), cp));
208 }
209
210 devpath = di_devfs_path(node);
211
212 if ((bp = find_bus(args, devpath)) != NULL) {
213 di_devfs_path_free((void *) devpath);
214
215 if (cp != NULL) {
216 if (add_ptr2array(cp,
217 (void ***)&bp->controllers) != 0) {
218 args->dev_walk_status = ENOMEM;
219 return (NULL);
220 }
221 }
222 return (bp);
223 }
224
225 /* Special handling for root node. */
226 if (strcmp(devpath, "/") == 0) {
227 di_devfs_path_free((void *) devpath);
228 return (NULL);
229 }
230
231 if (dm_debug) {
232 (void) fprintf(stderr, "INFO: add_bus %s\n", devpath);
233 }
234
235 bp = (bus_t *)calloc(1, sizeof (bus_t));
236 if (bp == NULL) {
237 return (NULL);
238 }
239
240 bp->name = strdup(devpath);
241 di_devfs_path_free((void *) devpath);
242 if (bp->name == NULL) {
243 args->dev_walk_status = ENOMEM;
244 cache_free_bus(bp);
245 return (NULL);
246 }
247
248 bp->btype = strdup(btype);
249 if (bp->btype == NULL) {
250 args->dev_walk_status = ENOMEM;
251 cache_free_bus(bp);
252 return (NULL);
253 }
254
255 (void) snprintf(kstat_name, sizeof (kstat_name), "%s%d",
256 di_node_name(node), di_instance(node));
257
258 if ((bp->kstat_name = strdup(kstat_name)) == NULL) {
259 args->dev_walk_status = ENOMEM;
260 cache_free_bus(bp);
261 return (NULL);
262 }
263
264 /* if parent node is a bus, get its name */
265 if ((pnode = get_parent_bus(node, args)) != NULL) {
266 devpath = di_devfs_path(pnode);
267 bp->pname = strdup(devpath);
268 di_devfs_path_free((void *) devpath);
269 if (bp->pname == NULL) {
270 args->dev_walk_status = ENOMEM;
271 cache_free_bus(bp);
272 return (NULL);
273 }
274
275 } else {
276 bp->pname = NULL;
277 }
278
279 bp->freq = get_prom_int("clock-frequency", node, args->ph);
280
281 bp->controllers = (controller_t **)calloc(1, sizeof (controller_t *));
282 if (bp->controllers == NULL) {
283 args->dev_walk_status = ENOMEM;
284 cache_free_bus(bp);
285 return (NULL);
286 }
287 bp->controllers[0] = NULL;
288
289 if (cp != NULL) {
290 if (add_ptr2array(cp, (void ***)&bp->controllers) != 0) {
291 args->dev_walk_status = ENOMEM;
292 return (NULL);
293 }
294 }
295
296 bp->next = args->bus_listp;
297 args->bus_listp = bp;
298
299 return (bp);
300 }
301
302 static int
303 add_cluster_devs(di_node_t node, di_minor_t minor, void *arg)
304 {
305 struct search_args *args;
306 char *devpath;
307 char slice_path[MAXPATHLEN];
308 int result = DI_WALK_CONTINUE;
309
310 if (!is_cluster_disk(node, minor)) {
311 return (DI_WALK_CONTINUE);
312 }
313
314 args = (struct search_args *)arg;
315
316 if (dm_debug > 1) {
317 /* This is all just debugging code */
318 char *devpath;
319 char dev_name[MAXPATHLEN];
320
321 devpath = di_devfs_path(node);
322 (void) snprintf(dev_name, sizeof (dev_name), "%s:%s", devpath,
323 di_minor_name(minor));
324 di_devfs_path_free((void *) devpath);
325
326 (void) fprintf(stderr, "INFO: cluster dev: %s\n", dev_name);
327 }
328
329 args->node = node;
330 args->minor = minor;
331 args->dev_walk_status = 0;
332
333 /*
334 * Fix the devpaths for the cluster drive.
335 *
336 * We will come through here once for each raw slice device name.
337 */
338 devpath = di_devfs_path(node);
339 (void) snprintf(slice_path, sizeof (slice_path), "%s:%s", devpath,
340 di_minor_name(minor));
341 di_devfs_path_free((void *) devpath);
342
343 /* Walk the /dev tree to get the cluster devlinks. */
344 (void) di_devlink_walk(args->handle, DEVLINK_DID_REGEX, slice_path,
345 DI_PRIMARY_LINK, arg, fix_cluster_devpath);
346
347 if (args->dev_walk_status != 0) {
348 result = DI_WALK_TERMINATE;
349 }
350
351 return (result);
352 }
353
354 static controller_t *
355 add_controller(struct search_args *args, di_node_t node, di_minor_t minor)
356 {
357 char *devpath;
358 controller_t *cp;
359 char kstat_name[MAXPATHLEN];
360 char *c_type = DM_CTYPE_UNKNOWN;
361
362 devpath = di_devfs_path(node);
363
364 if ((cp = find_controller(args, devpath)) != NULL) {
365 di_devfs_path_free((void *) devpath);
366 return (cp);
367 }
368
369 /* Special handling for fp attachment node. */
370 if (strcmp(di_node_name(node), "fp") == 0) {
371 di_node_t pnode;
372
373 pnode = di_parent_node(node);
374 if (pnode != DI_NODE_NIL) {
375 di_devfs_path_free((void *) devpath);
376 devpath = di_devfs_path(pnode);
377
378 if ((cp = find_controller(args, devpath)) != NULL) {
379 di_devfs_path_free((void *) devpath);
380 return (cp);
381 }
382
383 /* not in the list, create it */
384 node = pnode;
385 c_type = DM_CTYPE_FIBRE;
386 }
387 }
388
389 if (dm_debug) {
390 (void) fprintf(stderr, "INFO: add_controller %s\n", devpath);
391 }
392
393 cp = (controller_t *)calloc(1, sizeof (controller_t));
394 if (cp == NULL) {
395 return (NULL);
396 }
397
398 cp->name = strdup(devpath);
399 di_devfs_path_free((void *) devpath);
400 if (cp->name == NULL) {
401 cache_free_controller(cp);
402 return (NULL);
403 }
404
405 if (strcmp(c_type, DM_CTYPE_UNKNOWN) == 0) {
406 c_type = ctype(node, minor);
407 }
408 cp->ctype = c_type;
409
410 (void) snprintf(kstat_name, sizeof (kstat_name), "%s%d",
411 di_node_name(node), di_instance(node));
412
413 if ((cp->kstat_name = strdup(kstat_name)) == NULL) {
414 cache_free_controller(cp);
415 return (NULL);
416 }
417
418 if (libdiskmgt_str_eq(cp->ctype, "scsi")) {
419 cp->scsi_options = get_prop(SCSI_OPTIONS_PROP, node);
420 }
421
422 if (libdiskmgt_str_eq(di_node_name(node), "scsi_vhci")) {
423 cp->multiplex = 1;
424 } else {
425 cp->multiplex = 0;
426 }
427
428 cp->freq = get_prom_int("clock-frequency", node, args->ph);
429
430 cp->disks = (disk_t **)calloc(1, sizeof (disk_t *));
431 if (cp->disks == NULL) {
432 cache_free_controller(cp);
433 return (NULL);
434 }
435 cp->disks[0] = NULL;
436
437 cp->next = args->controller_listp;
438 args->controller_listp = cp;
439
440 cp->bus = add_bus(args, di_parent_node(node),
441 di_minor_next(di_parent_node(node), NULL), cp);
442
443 return (cp);
444 }
445
446 static int
447 add_devpath(di_devlink_t devlink, void *arg)
448 {
449 struct search_args *args;
450 char *devidstr;
451 disk_t *diskp;
452 char kernel_name[MAXPATHLEN];
453
454 args = (struct search_args *)arg;
455
456 /*
457 * Get the diskp value from calling have_disk. Can either be found
458 * by kernel name or devid.
459 */
460
461 diskp = NULL;
462 devidstr = get_str_prop(DEVICE_ID_PROP, args->node);
463 (void) snprintf(kernel_name, sizeof (kernel_name), "%s%d",
464 di_node_name(args->node), di_instance(args->node));
465
466 (void) have_disk(args, devidstr, kernel_name, &diskp);
467
468 /*
469 * The devlink_path is usually of the form /dev/rdsk/c0t0d0s0.
470 * For diskettes it is /dev/rdiskette*.
471 * On Intel we would also get each fdisk partition as well
472 * (e.g. /dev/rdsk/c0t0d0p0).
473 */
474 if (diskp != NULL) {
475 alias_t *ap;
476 char *devlink_path;
477
478 if (diskp->drv_type != DM_DT_FLOPPY) {
479 /*
480 * Add other controllers for multipath disks.
481 * This will have no effect if the controller
482 * relationship is already set up.
483 */
484 if (add_disk2controller(diskp, args) != 0) {
485 args->dev_walk_status = ENOMEM;
486 }
487 }
488
489 (void) snprintf(kernel_name, sizeof (kernel_name), "%s%d",
490 di_node_name(args->node), di_instance(args->node));
491 devlink_path = (char *)di_devlink_path(devlink);
492
493 if (dm_debug > 1) {
494 (void) fprintf(stderr,
495 "INFO: devpath %s\n", devlink_path);
496 }
497
498 if ((ap = find_alias(diskp, kernel_name)) == NULL) {
499 if (new_alias(diskp, kernel_name, devlink_path,
500 args) != 0) {
501 args->dev_walk_status = ENOMEM;
502 }
503 } else {
504 /*
505 * It is possible that we have already added this
506 * devpath. Do not add it again. new_devpath will
507 * return a 0 if found, and not add the path.
508 */
509 if (new_devpath(ap, devlink_path) != 0) {
510 args->dev_walk_status = ENOMEM;
511 }
512 }
513 }
514
515 return (DI_WALK_CONTINUE);
516 }
517
518 static int
519 add_devs(di_node_t node, di_minor_t minor, void *arg)
520 {
521 struct search_args *args;
522 int result = DI_WALK_CONTINUE;
523
524 args = (struct search_args *)arg;
525
526 if (dm_debug > 1) {
527 /* This is all just debugging code */
528 char *devpath;
529 char dev_name[MAXPATHLEN];
530
531 devpath = di_devfs_path(node);
532 (void) snprintf(dev_name, sizeof (dev_name), "%s:%s", devpath,
533 di_minor_name(minor));
534 di_devfs_path_free((void *) devpath);
535
536 (void) fprintf(stderr,
537 "INFO: dev: %s, node: %s%d, minor: 0x%x, type: %s\n",
538 dev_name, di_node_name(node), di_instance(node),
539 di_minor_spectype(minor),
540 (di_minor_nodetype(minor) != NULL ?
541 di_minor_nodetype(minor) : "NULL"));
542 }
543
544 if (bus_type(node, minor, args->ph) != NULL) {
545 if (add_bus(args, node, minor, NULL) == NULL) {
546 args->dev_walk_status = ENOMEM;
547 result = DI_WALK_TERMINATE;
548 }
549
550 } else if (is_HBA(node, minor)) {
551 if (add_controller(args, node, minor) == NULL) {
552 args->dev_walk_status = ENOMEM;
553 result = DI_WALK_TERMINATE;
554 }
555
556 } else if (di_minor_spectype(minor) == S_IFCHR &&
557 (is_drive(minor) || is_zvol(node, minor))) {
558 char *devidstr;
559 char kernel_name[MAXPATHLEN];
560 disk_t *diskp;
561
562 (void) snprintf(kernel_name, sizeof (kernel_name), "%s%d",
563 di_node_name(node), di_instance(node));
564 devidstr = get_str_prop(DEVICE_ID_PROP, node);
565
566 args->node = node;
567 args->minor = minor;
568 /*
569 * Check if we already got this disk and
570 * this is another slice.
571 */
572 if (!have_disk(args, devidstr, kernel_name, &diskp)) {
573 args->dev_walk_status = 0;
574 /*
575 * This is a newly found disk, create the
576 * disk structure.
577 */
578 diskp = create_disk(devidstr, kernel_name, args);
579 if (diskp == NULL) {
580 args->dev_walk_status = ENOMEM;
581 }
582
583 if (diskp->drv_type != DM_DT_FLOPPY) {
584 /* add the controller relationship */
585 if (args->dev_walk_status == 0) {
586 if (add_disk2controller(diskp,
587 args) != 0) {
588 args->dev_walk_status = ENOMEM;
589 }
590 }
591 }
592 }
593 if (is_zvol(node, minor)) {
594 char zvdsk[MAXNAMELEN];
595 char *str;
596 alias_t *ap;
597
598 if (di_prop_lookup_strings(di_minor_devt(minor),
599 node, "name", &str) == -1)
600 return (DI_WALK_CONTINUE);
601 (void) snprintf(zvdsk, MAXNAMELEN, "/dev/zvol/rdsk/%s",
602 str);
603 if ((ap = find_alias(diskp, kernel_name)) == NULL) {
604 if (new_alias(diskp, kernel_name,
605 zvdsk, args) != 0) {
606 args->dev_walk_status = ENOMEM;
607 }
608 } else {
609 /*
610 * It is possible that we have already added
611 * this devpath.
612 * Do not add it again. new_devpath will
613 * return a 0 if found, and not add the path.
614 */
615 if (new_devpath(ap, zvdsk) != 0) {
616 args->dev_walk_status = ENOMEM;
617 }
618 }
619 }
620
621 /* Add the devpaths for the drive. */
622 if (args->dev_walk_status == 0) {
623 char *devpath;
624 char slice_path[MAXPATHLEN];
625 char *pattern;
626
627 /*
628 * We will come through here once for each of
629 * the raw slice device names.
630 */
631 devpath = di_devfs_path(node);
632 (void) snprintf(slice_path,
633 sizeof (slice_path), "%s:%s",
634 devpath, di_minor_name(minor));
635 di_devfs_path_free((void *) devpath);
636
637 if (libdiskmgt_str_eq(di_minor_nodetype(minor),
638 DDI_NT_FD)) {
639 pattern = DEVLINK_FLOPPY_REGEX;
640 } else {
641 pattern = DEVLINK_REGEX;
642 }
643
644 /* Walk the /dev tree to get the devlinks. */
645 (void) di_devlink_walk(args->handle, pattern,
646 slice_path, DI_PRIMARY_LINK, arg, add_devpath);
647 }
648
649 if (args->dev_walk_status != 0) {
650 result = DI_WALK_TERMINATE;
651 }
652 }
653
654 return (result);
655 }
656
657 static int
658 add_disk2controller(disk_t *diskp, struct search_args *args)
659 {
660 di_node_t pnode;
661 controller_t *cp;
662 di_minor_t minor;
663 di_node_t node;
664 int i;
665
666 node = args->node;
667
668 pnode = di_parent_node(node);
669 if (pnode == DI_NODE_NIL) {
670 return (0);
671 }
672
673 minor = di_minor_next(pnode, NULL);
674 if (minor == NULL) {
675 return (0);
676 }
677
678 if ((cp = add_controller(args, pnode, minor)) == NULL) {
679 return (ENOMEM);
680 }
681
682 /* check if the disk <-> ctrl assoc is already there */
683 for (i = 0; diskp->controllers[i]; i++) {
684 if (cp == diskp->controllers[i]) {
685 return (0);
686 }
687 }
688
689 /* this is a new controller for this disk */
690
691 /* add the disk to the controlller */
692 if (add_ptr2array(diskp, (void ***)&cp->disks) != 0) {
693 return (ENOMEM);
694 }
695
696 /* add the controlller to the disk */
697 if (add_ptr2array(cp, (void ***)&diskp->controllers) != 0) {
698 return (ENOMEM);
699 }
700
701 /*
702 * Set up paths for mpxio controlled drives.
703 */
704 if (libdiskmgt_str_eq(di_node_name(pnode), "scsi_vhci")) {
705 /* note: mpxio di_path stuff is all consolidation private */
706 di_path_t pi = DI_PATH_NIL;
707
708 while (
709 (pi = di_path_client_next_path(node, pi)) != DI_PATH_NIL) {
710 int cnt;
711 uchar_t *bytes;
712 char str[MAXPATHLEN];
713 char *wwn;
714
715 di_node_t phci_node = di_path_phci_node(pi);
716
717 /* get the node wwn */
718 cnt = di_path_prop_lookup_bytes(pi, WWN_PROP, &bytes);
719 wwn = NULL;
720 if (cnt > 0) {
721 int i;
722 str[0] = 0;
723
724 for (i = 0; i < cnt; i++) {
725 /*
726 * A byte is only 2 hex chars + null.
727 */
728 char bstr[8];
729
730 (void) snprintf(bstr,
731 sizeof (bstr), "%.2x", bytes[i]);
732 (void) strlcat(str, bstr, sizeof (str));
733 }
734 wwn = str;
735 }
736
737 if (new_path(cp, diskp, phci_node,
738 di_path_state(pi), wwn) == NULL) {
739 return (ENOMEM);
740 }
741 }
742 }
743
744 return (0);
745 }
746
747 static int
748 add_disk2path(disk_t *dp, path_t *pp, di_path_state_t st, char *wwn)
749 {
750 /* add the disk to the path */
751 if (add_ptr2array(dp, (void ***)&pp->disks) != 0) {
752 cache_free_path(pp);
753 return (0);
754 }
755
756 /* add the path to the disk */
757 if (add_ptr2array(pp, (void ***)&dp->paths) != 0) {
758 cache_free_path(pp);
759 return (0);
760 }
761
762 /* add the path state for this disk */
763 if (add_int2array(st, &pp->states) != 0) {
764 cache_free_path(pp);
765 return (0);
766 }
767
768 /* add the path state for this disk */
769 if (wwn != NULL) {
770 char *wp;
771
772 if ((wp = strdup(wwn)) != NULL) {
773 if (add_ptr2array(wp, (void ***)(&pp->wwns)) != 0) {
774 cache_free_path(pp);
775 return (0);
776 }
777 }
778 }
779
780 return (1);
781 }
782
783 static int
784 add_int2array(int p, int **parray)
785 {
786 int i;
787 int cnt;
788 int *pa;
789 int *new_array;
790
791 pa = *parray;
792
793 cnt = 0;
794 if (pa != NULL) {
795 for (; pa[cnt] != -1; cnt++)
796 ;
797 }
798
799 new_array = (int *)calloc(cnt + 2, sizeof (int *));
800 if (new_array == NULL) {
801 return (ENOMEM);
802 }
803
804 /* copy the existing array */
805 for (i = 0; i < cnt; i++) {
806 new_array[i] = pa[i];
807 }
808
809 new_array[i] = p;
810 new_array[i + 1] = -1;
811
812 free(pa);
813 *parray = new_array;
814
815 return (0);
816 }
817
818 static int
819 add_ptr2array(void *p, void ***parray)
820 {
821 int i;
822 int cnt;
823 void **pa;
824 void **new_array;
825
826 pa = *parray;
827
828 cnt = 0;
829 if (pa != NULL) {
830 for (; pa[cnt]; cnt++)
831 ;
832 }
833
834 new_array = (void **)calloc(cnt + 2, sizeof (void *));
835 if (new_array == NULL) {
836 return (ENOMEM);
837 }
838
839 /* copy the existing array */
840 for (i = 0; i < cnt; i++) {
841 new_array[i] = pa[i];
842 }
843
844 new_array[i] = p;
845 new_array[i + 1] = NULL;
846
847 free(pa);
848 *parray = new_array;
849
850 return (0);
851 }
852
853 /*
854 * This function checks to see if a controller has other associations
855 * that may be valid. If we are calling this function, we have found that
856 * a controller for an mpxio device is showing up independently of the
857 * mpxio controller, noted as /scsi_vhci. This can happen with some FC
858 * cards that have inbound management devices that show up as well, with
859 * the real controller data associated. We do not want to display these
860 * 'devices' as real devices in libdiskmgt.
861 */
862 static void
863 remove_controller(controller_t *cp, controller_t *currp)
864 {
865 int i;
866
867 if (cp == currp) {
868 if (dm_debug) {
869 (void) fprintf(stderr, "ERROR: removing current"
870 " controller\n");
871 }
872 return;
873 }
874
875 if (cp->disks != NULL && cp->disks[0] != NULL) {
876 if (dm_debug) {
877 (void) fprintf(stderr,
878 "INFO: removing inbound management controller"
879 " with disk ptrs.\n");
880 }
881 /*
882 * loop through the disks and remove the reference to the
883 * controller for this disk structure. The disk itself
884 * is still a valid device, the controller being removed
885 * is a 'path' so any disk that has a reference to it
886 * as a controller needs to have this reference removed.
887 */
888 for (i = 0; cp->disks[i]; i++) {
889 disk_t *dp = cp->disks[i];
890 int j;
891
892 for (j = 0; dp->controllers[j]; j++) {
893 int k;
894
895 if (libdiskmgt_str_eq(dp->controllers[j]->name,
896 cp->name)) {
897
898 if (dm_debug) {
899 (void) fprintf(stderr,
900 "INFO: REMOVING disk %s on "
901 "controller %s\n",
902 dp->kernel_name, cp->name);
903 }
904 for (k = j; dp->controllers[k]; k++) {
905 dp->controllers[k] =
906 dp->controllers[k + 1];
907 }
908 }
909 }
910 }
911 }
912 /*
913 * Paths are removed with the call to cache_free_controller()
914 * below.
915 */
916
917 if (cp->paths != NULL && cp->paths[0] != NULL) {
918 if (dm_debug) {
919 (void) fprintf(stderr,
920 "INFO: removing inbound management controller"
921 " with path ptrs. \n");
922 }
923 }
924 cache_free_controller(cp);
925 }
926
927 /*
928 * If we have a controller in the list that is really a path then we need to
929 * take that controller out of the list since nodes that are paths are not
930 * considered to be controllers.
931 */
932 static void
933 clean_paths(struct search_args *args)
934 {
935 controller_t *cp;
936
937 cp = args->controller_listp;
938 while (cp != NULL) {
939 path_t **pp;
940
941 pp = cp->paths;
942 if (pp != NULL) {
943 int i;
944
945 for (i = 0; pp[i]; i++) {
946 remove_invalid_controller(pp[i]->name, cp,
947 args);
948 }
949 }
950 cp = cp->next;
951 }
952 }
953
954 static disk_t *
955 create_disk(char *deviceid, char *kernel_name, struct search_args *args)
956 {
957 disk_t *diskp;
958 char *type;
959 char *prod_id;
960 char *vendor_id;
961
962 if (dm_debug) {
963 (void) fprintf(stderr, "INFO: create_disk %s\n", kernel_name);
964 }
965
966 diskp = calloc(1, sizeof (disk_t));
967 if (diskp == NULL) {
968 return (NULL);
969 }
970
971 diskp->controllers = (controller_t **)
972 calloc(1, sizeof (controller_t *));
973 if (diskp->controllers == NULL) {
974 cache_free_disk(diskp);
975 return (NULL);
976 }
977 diskp->controllers[0] = NULL;
978
979 diskp->devid = NULL;
980 if (deviceid != NULL) {
981 if ((diskp->device_id = strdup(deviceid)) == NULL) {
982 cache_free_disk(diskp);
983 return (NULL);
984 }
985 (void) devid_str_decode(deviceid, &(diskp->devid), NULL);
986 }
987
988 if (kernel_name != NULL) {
989 diskp->kernel_name = strdup(kernel_name);
990 if (diskp->kernel_name == NULL) {
991 cache_free_disk(diskp);
992 return (NULL);
993 }
994 }
995
996 diskp->paths = NULL;
997 diskp->aliases = NULL;
998
999 diskp->cd_rom = 0;
1000 diskp->rpm = 0;
1001 diskp->solid_state = -1;
1002 type = di_minor_nodetype(args->minor);
1003
1004 prod_id = get_str_prop(PROD_ID_PROP, args->node);
1005 if (prod_id != NULL) {
1006 if ((diskp->product_id = strdup(prod_id)) == NULL) {
1007 cache_free_disk(diskp);
1008 return (NULL);
1009 }
1010 } else {
1011 prod_id = get_str_prop(PROD_ID_USB_PROP, args->node);
1012 if (prod_id != NULL) {
1013 if ((diskp->product_id = strdup(prod_id)) == NULL) {
1014 cache_free_disk(diskp);
1015 return (NULL);
1016 }
1017 }
1018 }
1019
1020 vendor_id = get_str_prop(VENDOR_ID_PROP, args->node);
1021 if (vendor_id != NULL) {
1022 if ((diskp->vendor_id = strdup(vendor_id)) == NULL) {
1023 cache_free_disk(diskp);
1024 return (NULL);
1025 }
1026 } else {
1027 vendor_id = get_str_prop(VENDOR_ID_USB_PROP, args->node);
1028 if (vendor_id != NULL) {
1029 if ((diskp->vendor_id = strdup(vendor_id)) == NULL) {
1030 cache_free_disk(diskp);
1031 return (NULL);
1032 }
1033 }
1034 }
1035
1036 /*
1037 * DVD, CD-ROM, CD-RW, MO, etc. are all reported as CD-ROMS.
1038 * We try to use uscsi later to determine the real type.
1039 * The cd_rom flag tells us that the kernel categorized the drive
1040 * as a CD-ROM. We leave the drv_type as UKNOWN for now.
1041 * The combination of the cd_rom flag being set with the drv_type of
1042 * unknown is what triggers the uscsi probe in drive.c.
1043 */
1044 if (disk_is_cdrom(type)) {
1045 diskp->drv_type = DM_DT_UNKNOWN;
1046 diskp->cd_rom = 1;
1047 diskp->removable = 1;
1048 } else if (libdiskmgt_str_eq(type, DDI_NT_FD)) {
1049 diskp->drv_type = DM_DT_FLOPPY;
1050 diskp->removable = 1;
1051 } else {
1052 /* not a "CD-ROM" or Floppy */
1053 diskp->removable = get_prop(REMOVABLE_PROP, args->node);
1054
1055 if (diskp->removable == -1) {
1056 diskp->removable = 0;
1057 #if defined(i386) || defined(__amd64)
1058 /*
1059 * x86 does not have removable property.
1060 * Check for common removable drives, zip & jaz,
1061 * and mark those correctly.
1062 */
1063 if (vendor_id != NULL && prod_id != NULL) {
1064 if (str_case_index(vendor_id,
1065 "iomega") != NULL) {
1066 if (str_case_index(prod_id,
1067 "jaz") != NULL) {
1068 diskp->removable = 1;
1069 } else if (str_case_index(prod_id,
1070 "zip") != NULL) {
1071 diskp->removable = 1;
1072 }
1073 }
1074 }
1075 #endif
1076 }
1077
1078 if (diskp->removable) {
1079 /*
1080 * For removable jaz or zip drives there is no way
1081 * to get the drive type unless media is inserted,so
1082 * we look at the product-id for a hint.
1083 */
1084 diskp->drv_type = DM_DT_UNKNOWN;
1085
1086 if (prod_id != NULL) {
1087 if (str_case_index(prod_id, "jaz") != NULL) {
1088 diskp->drv_type = DM_DT_JAZ;
1089 } else if (str_case_index(prod_id,
1090 "zip") != NULL) {
1091 diskp->drv_type = DM_DT_ZIP;
1092 }
1093 }
1094 } else {
1095 diskp->drv_type = DM_DT_FIXED;
1096 }
1097 }
1098
1099 diskp->next = args->disk_listp;
1100 args->disk_listp = diskp;
1101
1102 return (diskp);
1103 }
1104
1105 static char *
1106 ctype(di_node_t node, di_minor_t minor)
1107 {
1108 char *type;
1109 char *name;
1110
1111 type = di_minor_nodetype(minor);
1112 name = di_node_name(node);
1113
1114 /* IDE disks use SCSI nexus as the type, so handle this special case */
1115 if (libdiskmgt_str_eq(name, "ide")) {
1116 return (DM_CTYPE_ATA);
1117 }
1118
1119 if (libdiskmgt_str_eq(di_minor_name(minor), "scsa2usb")) {
1120 return (DM_CTYPE_USB);
1121 }
1122
1123 if (libdiskmgt_str_eq(type, DDI_NT_SCSI_NEXUS) ||
1124 libdiskmgt_str_eq(type, DDI_NT_SCSI_ATTACHMENT_POINT)) {
1125 return (DM_CTYPE_SCSI);
1126 }
1127
1128 if (libdiskmgt_str_eq(type, DDI_NT_FC_ATTACHMENT_POINT)) {
1129 return (DM_CTYPE_FIBRE);
1130 }
1131
1132 if (libdiskmgt_str_eq(type, DDI_NT_NEXUS) &&
1133 libdiskmgt_str_eq(name, "fp")) {
1134 return (DM_CTYPE_FIBRE);
1135 }
1136
1137 if (libdiskmgt_str_eq(type, DDI_PSEUDO) &&
1138 libdiskmgt_str_eq(name, "ide")) {
1139 return (DM_CTYPE_ATA);
1140 }
1141
1142 return (DM_CTYPE_UNKNOWN);
1143 }
1144
1145 static boolean_t
1146 disk_is_cdrom(const char *type)
1147 {
1148 return (strncmp(type, DDI_NT_CD, strlen(DDI_NT_CD)) == 0);
1149 }
1150
1151 static alias_t *
1152 find_alias(disk_t *diskp, char *kernel_name)
1153 {
1154 alias_t *ap;
1155
1156 ap = diskp->aliases;
1157 while (ap != NULL) {
1158 if (libdiskmgt_str_eq(ap->kstat_name, kernel_name)) {
1159 return (ap);
1160 }
1161 ap = ap->next;
1162 }
1163
1164 return (NULL);
1165 }
1166
1167 static bus_t *
1168 find_bus(struct search_args *args, char *name)
1169 {
1170 bus_t *listp;
1171
1172 listp = args->bus_listp;
1173 while (listp != NULL) {
1174 if (libdiskmgt_str_eq(listp->name, name)) {
1175 return (listp);
1176 }
1177 listp = listp->next;
1178 }
1179
1180 return (NULL);
1181 }
1182
1183 static controller_t *
1184 find_controller(struct search_args *args, char *name)
1185 {
1186 controller_t *listp;
1187
1188 listp = args->controller_listp;
1189 while (listp != NULL) {
1190 if (libdiskmgt_str_eq(listp->name, name)) {
1191 return (listp);
1192 }
1193 listp = listp->next;
1194 }
1195
1196 return (NULL);
1197 }
1198
1199 static int
1200 fix_cluster_devpath(di_devlink_t devlink, void *arg)
1201 {
1202 int fd;
1203 struct search_args *args;
1204 char *devlink_path;
1205 disk_t *diskp = NULL;
1206 alias_t *ap = NULL;
1207
1208 /*
1209 * The devlink_path is of the form /dev/did/rdsk/d1s0.
1210 */
1211
1212 args = (struct search_args *)arg;
1213
1214 /* Find the disk by the deviceid we read from the cluster disk. */
1215 devlink_path = (char *)di_devlink_path(devlink);
1216 if (devlink_path == NULL) {
1217 return (DI_WALK_CONTINUE);
1218 }
1219
1220 if ((fd = open(devlink_path, O_RDONLY|O_NDELAY)) >= 0) {
1221 ddi_devid_t devid;
1222
1223 if (dm_debug > 1) {
1224 (void) fprintf(stderr, "INFO: cluster devpath %s\n",
1225 devlink_path);
1226 }
1227
1228 if (devid_get(fd, &devid) == 0) {
1229 char *minor;
1230 char *devidstr;
1231
1232 minor = di_minor_name(args->minor);
1233
1234 if ((devidstr =
1235 devid_str_encode(devid, minor)) != NULL) {
1236 diskp = get_disk_by_deviceid(args->disk_listp,
1237 devidstr);
1238 /*
1239 * This really shouldn't happen, since
1240 * we should have found all of the disks
1241 * during our first pass through
1242 * the dev tree, but just in case...
1243 */
1244 if (diskp == NULL) {
1245 if (dm_debug > 1) {
1246 (void) fprintf(stderr,
1247 "INFO: cluster create"
1248 " disk\n");
1249 }
1250
1251 diskp = create_disk(devidstr,
1252 NULL, args);
1253 if (diskp == NULL) {
1254 args->dev_walk_status = ENOMEM;
1255 }
1256
1257 /* add the controller relationship */
1258 if (args->dev_walk_status == 0) {
1259 if (add_disk2controller(diskp,
1260 args) != 0) {
1261 args->dev_walk_status
1262 = ENOMEM;
1263 }
1264 }
1265
1266 if (new_alias(diskp, NULL,
1267 devlink_path, args) != 0) {
1268 args->dev_walk_status = ENOMEM;
1269 }
1270 }
1271 devid_str_free(devidstr);
1272 }
1273 devid_free(devid);
1274 }
1275 (void) close(fd);
1276 }
1277
1278
1279 if (diskp != NULL) {
1280 if (dm_debug > 1) {
1281 (void) fprintf(stderr, "INFO: cluster found"
1282 " disk\n");
1283 }
1284 ap = diskp->aliases;
1285 }
1286
1287 if (ap != NULL) {
1288 /*
1289 * NOTE: if ap->next != NULL have cluster
1290 * disks w/ multiple paths.
1291 */
1292
1293 if (!ap->cluster) {
1294 char *basep;
1295 char *namep;
1296 int cnt = 0;
1297 int size;
1298 char alias[MAXPATHLEN];
1299
1300 /*
1301 * First time; save the /dev/rdsk devpaths and
1302 * update the alias info with the new alias name.
1303 */
1304 ap->orig_paths = ap->devpaths;
1305 ap->devpaths = NULL;
1306
1307 free(ap->alias);
1308
1309 /* get the new cluster alias name */
1310 basep = strrchr(devlink_path, '/');
1311 if (basep == NULL) {
1312 basep = devlink_path;
1313 } else {
1314 basep++;
1315 }
1316 size = sizeof (alias) - 1;
1317 namep = alias;
1318
1319 while (*basep != 0 && *basep != 's' && cnt < size) {
1320 *namep++ = *basep++;
1321 cnt++;
1322 }
1323 *namep = 0;
1324
1325 if ((ap->alias = strdup(alias)) == NULL) {
1326 args->dev_walk_status = ENOMEM;
1327 }
1328
1329 ap->cluster = 1;
1330 }
1331
1332 if (new_devpath(ap, devlink_path) != 0) {
1333 args->dev_walk_status = ENOMEM;
1334 }
1335 }
1336
1337 return (DI_WALK_CONTINUE);
1338 }
1339
1340 /*
1341 * Check if we have the drive in our list, based upon the device id.
1342 * We got the device id from the dev tree walk. This is encoded
1343 * using devid_str_encode(3DEVID). In order to check the device ids we need
1344 * to use the devid_compare(3DEVID) function, so we need to decode the
1345 * string representation of the device id.
1346 */
1347 static disk_t *
1348 get_disk_by_deviceid(disk_t *listp, char *devidstr)
1349 {
1350 ddi_devid_t devid;
1351
1352 if (devidstr == NULL || devid_str_decode(devidstr, &devid, NULL) != 0) {
1353 return (NULL);
1354 }
1355
1356 while (listp != NULL) {
1357 if (listp->devid != NULL &&
1358 devid_compare(listp->devid, devid) == 0) {
1359 break;
1360 }
1361 listp = listp->next;
1362 }
1363
1364 devid_free(devid);
1365 return (listp);
1366 }
1367
1368 /*
1369 * Get the base disk name with no path prefix and no slice (if there is one).
1370 * The name parameter should be big enough to hold the name.
1371 * This handles diskette names ok (/dev/rdiskette0) since there is no slice,
1372 * and converts the raw diskette name.
1373 * But, we don't know how to strip off the slice from third party drive
1374 * names. That just means that their drive name will include a slice on
1375 * it.
1376 */
1377 static void
1378 get_disk_name_from_path(char *path, char *name, int size)
1379 {
1380 char *basep;
1381 int cnt = 0;
1382
1383 basep = strrchr(path, '/');
1384 if (basep == NULL) {
1385 basep = path;
1386 } else {
1387 basep++;
1388 }
1389
1390 size = size - 1; /* leave room for terminating 0 */
1391
1392 if (is_ctds(basep)) {
1393 while (*basep != 0 && *basep != 's' && cnt < size) {
1394 *name++ = *basep++;
1395 cnt++;
1396 }
1397 *name = 0;
1398 } else {
1399 if (strncmp(basep, FLOPPY_NAME,
1400 sizeof (FLOPPY_NAME) - 1) == 0) {
1401 /*
1402 * a floppy, convert rdiskette name to diskette name,
1403 * by skipping over the 'r' for raw diskette
1404 */
1405 basep++;
1406 }
1407
1408 /* not a ctds name, just copy it */
1409 (void) strlcpy(name, basep, size);
1410 }
1411 }
1412
1413 static char *
1414 get_byte_prop(char *prop_name, di_node_t node)
1415 {
1416 int cnt;
1417 uchar_t *bytes;
1418 int i;
1419 char str[MAXPATHLEN];
1420
1421 cnt = di_prop_lookup_bytes(DDI_DEV_T_ANY, node, prop_name, &bytes);
1422 if (cnt < 1) {
1423 return (NULL);
1424 }
1425
1426 str[0] = 0;
1427 for (i = 0; i < cnt; i++) {
1428 char bstr[8]; /* a byte is only 2 hex chars + null */
1429
1430 (void) snprintf(bstr, sizeof (bstr), "%.2x", bytes[i]);
1431 (void) strlcat(str, bstr, sizeof (str));
1432 }
1433 return (strdup(str));
1434 }
1435
1436 static di_node_t
1437 get_parent_bus(di_node_t node, struct search_args *args)
1438 {
1439 di_node_t pnode;
1440
1441 pnode = di_parent_node(node);
1442 if (pnode == DI_NODE_NIL) {
1443 return (NULL);
1444 }
1445
1446 if (bus_type(pnode, di_minor_next(pnode, NULL), args->ph) != NULL) {
1447 return (pnode);
1448 }
1449
1450 return (get_parent_bus(pnode, args));
1451 }
1452
1453 static int
1454 get_prom_int(char *prop_name, di_node_t node, di_prom_handle_t ph)
1455 {
1456 int *n;
1457
1458 if (di_prom_prop_lookup_ints(ph, node, prop_name, &n) == 1) {
1459 return (*n);
1460 }
1461
1462 return (0);
1463 }
1464
1465 static char *
1466 get_prom_str(char *prop_name, di_node_t node, di_prom_handle_t ph)
1467 {
1468 char *str;
1469
1470 if (di_prom_prop_lookup_strings(ph, node, prop_name, &str) == 1) {
1471 return (str);
1472 }
1473
1474 return (NULL);
1475 }
1476
1477 /*
1478 * Get one of the positive int or boolean properties.
1479 */
1480 static int
1481 get_prop(char *prop_name, di_node_t node)
1482 {
1483 int num;
1484 int *ip;
1485
1486 if ((num = di_prop_lookup_ints(DDI_DEV_T_ANY, node, prop_name, &ip))
1487 >= 0) {
1488 if (num == 0) {
1489 /* boolean */
1490 return (1);
1491 } else if (num == 1) {
1492 /* single int */
1493 return (*ip);
1494 }
1495 }
1496 return (-1);
1497 }
1498
1499 static char *
1500 get_str_prop(char *prop_name, di_node_t node)
1501 {
1502 char *str;
1503
1504 if (di_prop_lookup_strings(DDI_DEV_T_ANY, node, prop_name, &str) == 1) {
1505 return (str);
1506 }
1507
1508 return (NULL);
1509 }
1510
1511 /*
1512 * Check if we have the drive in our list, based upon the device id, if the
1513 * drive has a device id, or the kernel name, if it doesn't have a device id.
1514 */
1515 static int
1516 have_disk(struct search_args *args, char *devidstr, char *kernel_name,
1517 disk_t **diskp)
1518 {
1519 disk_t *listp;
1520
1521 *diskp = NULL;
1522 listp = args->disk_listp;
1523 if (devidstr != NULL) {
1524 if ((*diskp = get_disk_by_deviceid(listp, devidstr)) != NULL) {
1525 return (1);
1526 }
1527
1528 } else {
1529 /* no devid, try matching the kernel names on the drives */
1530 while (listp != NULL) {
1531 if (libdiskmgt_str_eq(kernel_name,
1532 listp->kernel_name)) {
1533 *diskp = listp;
1534 return (1);
1535 }
1536 listp = listp->next;
1537 }
1538 }
1539 return (0);
1540 }
1541
1542 static char *
1543 bus_type(di_node_t node, di_minor_t minor, di_prom_handle_t ph)
1544 {
1545 char *type;
1546 int i;
1547
1548 type = get_prom_str("device_type", node, ph);
1549 if (type == NULL) {
1550 type = di_node_name(node);
1551 }
1552
1553 for (i = 0; bustypes[i]; i++) {
1554 if (libdiskmgt_str_eq(type, bustypes[i])) {
1555 return (type);
1556 }
1557 }
1558
1559 if (minor != NULL && strcmp(di_minor_nodetype(minor),
1560 DDI_NT_USB_ATTACHMENT_POINT) == 0) {
1561 return ("usb");
1562 }
1563
1564 return (NULL);
1565 }
1566
1567 static int
1568 is_cluster_disk(di_node_t node, di_minor_t minor)
1569 {
1570 if (di_minor_spectype(minor) == S_IFCHR &&
1571 libdiskmgt_str_eq(di_minor_nodetype(minor), DDI_PSEUDO) &&
1572 libdiskmgt_str_eq(di_node_name(node), CLUSTER_DEV)) {
1573 return (1);
1574 }
1575
1576 return (0);
1577 }
1578
1579 /*
1580 * If the input name is in c[t]ds format then return 1, otherwise return 0.
1581 */
1582 static int
1583 is_ctds(char *name)
1584 {
1585 char *p;
1586
1587 p = name;
1588
1589 if (*p++ != 'c') {
1590 return (0);
1591 }
1592 /* skip controller digits */
1593 while (isdigit(*p)) {
1594 p++;
1595 }
1596
1597 /* handle optional target */
1598 if (*p == 't') {
1599 p++;
1600 /* skip over target */
1601 while (isdigit(*p) || isupper(*p)) {
1602 p++;
1603 }
1604 }
1605
1606 if (*p++ != 'd') {
1607 return (0);
1608 }
1609 while (isdigit(*p)) {
1610 p++;
1611 }
1612
1613 if (*p++ != 's') {
1614 return (0);
1615 }
1616
1617 /* check the slice number */
1618 while (isdigit(*p)) {
1619 p++;
1620 }
1621
1622 if (*p != 0) {
1623 return (0);
1624 }
1625
1626 return (1);
1627 }
1628
1629 static int
1630 is_drive(di_minor_t minor)
1631 {
1632 return (strncmp(di_minor_nodetype(minor), DDI_NT_BLOCK,
1633 strlen(DDI_NT_BLOCK)) == 0);
1634 }
1635
1636 static int
1637 is_zvol(di_node_t node, di_minor_t minor)
1638 {
1639 if ((strncmp(di_node_name(node), ZFS_DRIVER, 3) == 0) &&
1640 minor(di_minor_devt(minor)))
1641 return (1);
1642 return (0);
1643 }
1644
1645 static int
1646 is_HBA(di_node_t node, di_minor_t minor)
1647 {
1648 char *type;
1649 char *name;
1650 int type_index;
1651
1652 type = di_minor_nodetype(minor);
1653 type_index = 0;
1654
1655 while (ctrltypes[type_index] != NULL) {
1656 if (libdiskmgt_str_eq(type, ctrltypes[type_index])) {
1657 return (1);
1658 }
1659 type_index++;
1660 }
1661
1662 name = di_node_name(node);
1663 if (libdiskmgt_str_eq(type, DDI_PSEUDO) &&
1664 libdiskmgt_str_eq(name, "ide")) {
1665 return (1);
1666 }
1667
1668 return (0);
1669 }
1670
1671 static int
1672 new_alias(disk_t *diskp, char *kernel_name, char *devlink_path,
1673 struct search_args *args)
1674 {
1675 alias_t *aliasp;
1676 char alias[MAXPATHLEN];
1677 di_node_t pnode;
1678
1679 aliasp = malloc(sizeof (alias_t));
1680 if (aliasp == NULL) {
1681 return (ENOMEM);
1682 }
1683
1684 aliasp->alias = NULL;
1685 aliasp->kstat_name = NULL;
1686 aliasp->wwn = NULL;
1687 aliasp->devpaths = NULL;
1688 aliasp->orig_paths = NULL;
1689
1690 get_disk_name_from_path(devlink_path, alias, sizeof (alias));
1691
1692 aliasp->alias = strdup(alias);
1693 if (aliasp->alias == NULL) {
1694 cache_free_alias(aliasp);
1695 return (ENOMEM);
1696 }
1697
1698 if (kernel_name != NULL) {
1699 aliasp->kstat_name = strdup(kernel_name);
1700 if (aliasp->kstat_name == NULL) {
1701 cache_free_alias(aliasp);
1702 return (ENOMEM);
1703 }
1704 } else {
1705 aliasp->kstat_name = NULL;
1706 }
1707
1708 aliasp->cluster = 0;
1709 aliasp->lun = get_prop(DM_LUN, args->node);
1710 aliasp->target = get_prop(DM_TARGET, args->node);
1711 aliasp->wwn = get_byte_prop(WWN_PROP, args->node);
1712
1713 pnode = di_parent_node(args->node);
1714 if (pnode != DI_NODE_NIL) {
1715 char prop_name[MAXPROPLEN];
1716
1717 (void) snprintf(prop_name, sizeof (prop_name),
1718 "target%d-sync-speed", aliasp->target);
1719 diskp->sync_speed = get_prop(prop_name, pnode);
1720 (void) snprintf(prop_name, sizeof (prop_name), "target%d-wide",
1721 aliasp->target);
1722 diskp->wide = get_prop(prop_name, pnode);
1723 }
1724
1725 if (new_devpath(aliasp, devlink_path) != 0) {
1726 cache_free_alias(aliasp);
1727 return (ENOMEM);
1728 }
1729
1730 aliasp->next = diskp->aliases;
1731 diskp->aliases = aliasp;
1732
1733 return (0);
1734 }
1735
1736 /*
1737 * Append the new devpath to the end of the devpath list. This is important
1738 * since we may want to use the order of the devpaths to match up the vtoc
1739 * entries.
1740 */
1741 static int
1742 new_devpath(alias_t *ap, char *devpath)
1743 {
1744 slice_t *newdp;
1745 slice_t *alistp;
1746
1747 /*
1748 * First, search the alias list to be sure that this devpath is
1749 * not already there.
1750 */
1751
1752 for (alistp = ap->devpaths; alistp != NULL; alistp = alistp->next) {
1753 if (libdiskmgt_str_eq(alistp->devpath, devpath)) {
1754 return (0);
1755 }
1756 }
1757
1758 /*
1759 * Otherwise, not found so add this new devpath to the list.
1760 */
1761
1762 newdp = malloc(sizeof (slice_t));
1763 if (newdp == NULL) {
1764 return (ENOMEM);
1765 }
1766
1767 newdp->devpath = strdup(devpath);
1768 if (newdp->devpath == NULL) {
1769 free(newdp);
1770 return (ENOMEM);
1771 }
1772 newdp->slice_num = -1;
1773 newdp->next = NULL;
1774
1775 if (ap->devpaths == NULL) {
1776 ap->devpaths = newdp;
1777 } else {
1778 /* append the devpath to the end of the list */
1779 slice_t *dp;
1780
1781 dp = ap->devpaths;
1782 while (dp->next != NULL) {
1783 dp = dp->next;
1784 }
1785
1786 dp->next = newdp;
1787 }
1788
1789 return (0);
1790 }
1791
1792 static path_t *
1793 new_path(controller_t *cp, disk_t *dp, di_node_t node, di_path_state_t st,
1794 char *wwn)
1795 {
1796 char *devpath;
1797 path_t *pp;
1798 di_minor_t minor;
1799
1800 /* Special handling for fp attachment node. */
1801 if (strcmp(di_node_name(node), "fp") == 0) {
1802 di_node_t pnode;
1803
1804 pnode = di_parent_node(node);
1805 if (pnode != DI_NODE_NIL) {
1806 node = pnode;
1807 }
1808 }
1809
1810 devpath = di_devfs_path(node);
1811
1812 /* check if the path is already there */
1813 pp = NULL;
1814 if (cp->paths != NULL) {
1815 int i;
1816
1817 for (i = 0; cp->paths[i]; i++) {
1818 if (libdiskmgt_str_eq(devpath, cp->paths[i]->name)) {
1819 pp = cp->paths[i];
1820 break;
1821 }
1822 }
1823 }
1824
1825 if (pp != NULL) {
1826 /* the path exists, add this disk to it */
1827
1828 di_devfs_path_free((void *) devpath);
1829 if (!add_disk2path(dp, pp, st, wwn)) {
1830 return (NULL);
1831 }
1832 return (pp);
1833 }
1834
1835 /* create a new path */
1836
1837 pp = calloc(1, sizeof (path_t));
1838 if (pp == NULL) {
1839 di_devfs_path_free((void *) devpath);
1840 return (NULL);
1841 }
1842
1843 pp->name = strdup(devpath);
1844 di_devfs_path_free((void *) devpath);
1845 if (pp->name == NULL) {
1846 cache_free_path(pp);
1847 return (NULL);
1848 }
1849
1850 /* add the disk to the path */
1851 if (!add_disk2path(dp, pp, st, wwn)) {
1852 return (NULL);
1853 }
1854
1855 /* add the path to the controller */
1856 if (add_ptr2array(pp, (void ***)&cp->paths) != 0) {
1857 cache_free_path(pp);
1858 return (NULL);
1859 }
1860
1861 /* add the controller to the path */
1862 pp->controller = cp;
1863
1864 minor = di_minor_next(node, NULL);
1865 if (minor != NULL) {
1866 pp->ctype = ctype(node, minor);
1867 } else {
1868 pp->ctype = DM_CTYPE_UNKNOWN;
1869 }
1870
1871 return (pp);
1872 }
1873
1874 /*
1875 * We pass in the current controller pointer (currp) so we can double check
1876 * that we aren't corrupting the list by removing the element we are on. This
1877 * should never happen, but it doesn't hurt to double check.
1878 */
1879 static void
1880 remove_invalid_controller(char *name, controller_t *currp,
1881 struct search_args *args)
1882 {
1883 controller_t *cp;
1884 bus_t *bp;
1885 controller_t *prevp;
1886
1887 bp = args->bus_listp;
1888 while (bp != NULL) {
1889 int i;
1890
1891 for (i = 0; bp->controllers[i]; i++) {
1892 if (libdiskmgt_str_eq(bp->controllers[i]->name, name)) {
1893 int j;
1894 /*
1895 * remove pointer to invalid controller.
1896 * (it is a path)
1897 */
1898 for (j = i; bp->controllers[j]; j++) {
1899 bp->controllers[j] =
1900 bp->controllers[j + 1];
1901 }
1902 }
1903 }
1904 bp = bp->next;
1905 }
1906
1907 if (args->controller_listp == NULL) {
1908 return;
1909 }
1910
1911 cp = args->controller_listp;
1912 if (libdiskmgt_str_eq(cp->name, name)) {
1913 args->controller_listp = cp->next;
1914 if (dm_debug) {
1915 (void) fprintf(stderr,
1916 "INFO: Removed controller %s from list\n",
1917 cp->name);
1918 }
1919 remove_controller(cp, currp);
1920 return;
1921 }
1922
1923 prevp = cp;
1924 cp = cp->next;
1925 while (cp != NULL) {
1926 if (libdiskmgt_str_eq(cp->name, name)) {
1927 if (dm_debug) {
1928 (void) fprintf(stderr,
1929 "INFO: Removed controller %s from list\n",
1930 cp->name);
1931 }
1932 prevp->next = cp->next;
1933 remove_controller(cp, currp);
1934 return;
1935 }
1936 prevp = cp;
1937 cp = cp->next;
1938 }
1939 }
1940
1941 /*
1942 * This is the standard strstr code modified for case independence.
1943 */
1944 static char *
1945 str_case_index(register char *s1, register char *s2)
1946 {
1947 uint_t s2len = strlen(s2); /* length of the second string */
1948
1949 /* If the length of the second string is 0, return the first arg. */
1950 if (s2len == 0) {
1951 return (s1);
1952 }
1953
1954 while (strlen(s1) >= s2len) {
1955 if (strncasecmp(s1, s2, s2len) == 0) {
1956 return (s1);
1957 }
1958 s1++;
1959 }
1960 return (NULL);
1961 }
unleashed repo fork