17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 57c478bd9Sstevel@tonic-gate * Common Development and Distribution License, Version 1.0 only 67c478bd9Sstevel@tonic-gate * (the "License"). You may not use this file except in compliance 77c478bd9Sstevel@tonic-gate * with the License. 87c478bd9Sstevel@tonic-gate * 97c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 107c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 117c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 127c478bd9Sstevel@tonic-gate * and limitations under the License. 137c478bd9Sstevel@tonic-gate * 147c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 157c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 167c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 177c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 187c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 197c478bd9Sstevel@tonic-gate * 207c478bd9Sstevel@tonic-gate * CDDL HEADER END 217c478bd9Sstevel@tonic-gate */ 227c478bd9Sstevel@tonic-gate /* 23*46a2abf2Seschrock * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate #include <fcntl.h> 307c478bd9Sstevel@tonic-gate #include <libdevinfo.h> 317c478bd9Sstevel@tonic-gate #include <stdio.h> 327c478bd9Sstevel@tonic-gate #include <sys/sunddi.h> 337c478bd9Sstevel@tonic-gate #include <sys/types.h> 347c478bd9Sstevel@tonic-gate #include <unistd.h> 357c478bd9Sstevel@tonic-gate #include <stdlib.h> 367c478bd9Sstevel@tonic-gate #include <string.h> 373e1bd7a2Ssjelinek #include <libintl.h> 383e1bd7a2Ssjelinek #include <locale.h> 393e1bd7a2Ssjelinek #include <sys/debug.h> 407c478bd9Sstevel@tonic-gate 417c478bd9Sstevel@tonic-gate #include "libdiskmgt.h" 427c478bd9Sstevel@tonic-gate #include "disks_private.h" 437c478bd9Sstevel@tonic-gate #include "partition.h" 447c478bd9Sstevel@tonic-gate 453e1bd7a2Ssjelinek extern char *getfullblkname(); 463e1bd7a2Ssjelinek 477c478bd9Sstevel@tonic-gate 487c478bd9Sstevel@tonic-gate extern dm_desc_type_t drive_assoc_types[]; 497c478bd9Sstevel@tonic-gate extern dm_desc_type_t bus_assoc_types[]; 507c478bd9Sstevel@tonic-gate extern dm_desc_type_t controller_assoc_types[]; 517c478bd9Sstevel@tonic-gate extern dm_desc_type_t media_assoc_types[]; 527c478bd9Sstevel@tonic-gate extern dm_desc_type_t slice_assoc_types[]; 537c478bd9Sstevel@tonic-gate extern dm_desc_type_t partition_assoc_types[]; 547c478bd9Sstevel@tonic-gate extern dm_desc_type_t path_assoc_types[]; 557c478bd9Sstevel@tonic-gate extern dm_desc_type_t alias_assoc_types[]; 567c478bd9Sstevel@tonic-gate 573e1bd7a2Ssjelinek 587c478bd9Sstevel@tonic-gate static dm_descriptor_t *ptr_array_to_desc_array(descriptor_t **ptrs, int *errp); 597c478bd9Sstevel@tonic-gate static descriptor_t **desc_array_to_ptr_array(dm_descriptor_t *da, int *errp); 603e1bd7a2Ssjelinek static int build_usage_string(char *dname, char *by, char *data, char **use, 613e1bd7a2Ssjelinek int *found, int *errp); 627c478bd9Sstevel@tonic-gate 637c478bd9Sstevel@tonic-gate void 647c478bd9Sstevel@tonic-gate dm_free_descriptor(dm_descriptor_t desc) 657c478bd9Sstevel@tonic-gate { 667c478bd9Sstevel@tonic-gate descriptor_t *dp; 677c478bd9Sstevel@tonic-gate 687c478bd9Sstevel@tonic-gate if (desc == NULL) { 697c478bd9Sstevel@tonic-gate return; 707c478bd9Sstevel@tonic-gate } 7169fb9702Smike_s dp = (descriptor_t *)(uintptr_t)desc; 727c478bd9Sstevel@tonic-gate 737c478bd9Sstevel@tonic-gate cache_wlock(); 747c478bd9Sstevel@tonic-gate cache_free_descriptor(dp); 757c478bd9Sstevel@tonic-gate cache_unlock(); 767c478bd9Sstevel@tonic-gate } 777c478bd9Sstevel@tonic-gate 787c478bd9Sstevel@tonic-gate void 797c478bd9Sstevel@tonic-gate dm_free_descriptors(dm_descriptor_t *desc_list) 807c478bd9Sstevel@tonic-gate { 817c478bd9Sstevel@tonic-gate descriptor_t **dp; 827c478bd9Sstevel@tonic-gate int error; 837c478bd9Sstevel@tonic-gate 847c478bd9Sstevel@tonic-gate if (desc_list == NULL) { 857c478bd9Sstevel@tonic-gate return; 867c478bd9Sstevel@tonic-gate } 877c478bd9Sstevel@tonic-gate dp = desc_array_to_ptr_array(desc_list, &error); 887c478bd9Sstevel@tonic-gate if (error != 0) { 897c478bd9Sstevel@tonic-gate free(desc_list); 907c478bd9Sstevel@tonic-gate return; 917c478bd9Sstevel@tonic-gate } 927c478bd9Sstevel@tonic-gate 937c478bd9Sstevel@tonic-gate cache_wlock(); 947c478bd9Sstevel@tonic-gate cache_free_descriptors(dp); 957c478bd9Sstevel@tonic-gate cache_unlock(); 967c478bd9Sstevel@tonic-gate } 977c478bd9Sstevel@tonic-gate 987c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 997c478bd9Sstevel@tonic-gate void 1007c478bd9Sstevel@tonic-gate dm_free_name(char *name) 1017c478bd9Sstevel@tonic-gate { 1027c478bd9Sstevel@tonic-gate free(name); 1037c478bd9Sstevel@tonic-gate } 1047c478bd9Sstevel@tonic-gate 1057c478bd9Sstevel@tonic-gate dm_descriptor_t * 1067c478bd9Sstevel@tonic-gate dm_get_associated_descriptors(dm_descriptor_t desc, dm_desc_type_t type, 1077c478bd9Sstevel@tonic-gate int *errp) 1087c478bd9Sstevel@tonic-gate { 1097c478bd9Sstevel@tonic-gate descriptor_t **descs = NULL; 1107c478bd9Sstevel@tonic-gate descriptor_t *dp; 1117c478bd9Sstevel@tonic-gate 1127c478bd9Sstevel@tonic-gate 11369fb9702Smike_s dp = (descriptor_t *)(uintptr_t)desc; 1147c478bd9Sstevel@tonic-gate 1157c478bd9Sstevel@tonic-gate cache_wlock(); 1167c478bd9Sstevel@tonic-gate 1177c478bd9Sstevel@tonic-gate if (!cache_is_valid_desc(dp)) { 1187c478bd9Sstevel@tonic-gate cache_unlock(); 1197c478bd9Sstevel@tonic-gate *errp = EBADF; 1207c478bd9Sstevel@tonic-gate return (NULL); 1217c478bd9Sstevel@tonic-gate } 1227c478bd9Sstevel@tonic-gate 1237c478bd9Sstevel@tonic-gate /* verify that the descriptor is still valid */ 1247c478bd9Sstevel@tonic-gate if (dp->p.generic == NULL) { 1257c478bd9Sstevel@tonic-gate cache_unlock(); 1267c478bd9Sstevel@tonic-gate *errp = ENODEV; 1277c478bd9Sstevel@tonic-gate return (NULL); 1287c478bd9Sstevel@tonic-gate } 1297c478bd9Sstevel@tonic-gate 1307c478bd9Sstevel@tonic-gate switch (dp->type) { 1317c478bd9Sstevel@tonic-gate case DM_DRIVE: 1327c478bd9Sstevel@tonic-gate descs = drive_get_assoc_descriptors(dp, type, errp); 1337c478bd9Sstevel@tonic-gate break; 1347c478bd9Sstevel@tonic-gate case DM_BUS: 1357c478bd9Sstevel@tonic-gate descs = bus_get_assoc_descriptors(dp, type, errp); 1367c478bd9Sstevel@tonic-gate break; 1377c478bd9Sstevel@tonic-gate case DM_CONTROLLER: 1387c478bd9Sstevel@tonic-gate descs = controller_get_assoc_descriptors(dp, type, errp); 1397c478bd9Sstevel@tonic-gate break; 1407c478bd9Sstevel@tonic-gate case DM_MEDIA: 1417c478bd9Sstevel@tonic-gate descs = media_get_assoc_descriptors(dp, type, errp); 1427c478bd9Sstevel@tonic-gate break; 1437c478bd9Sstevel@tonic-gate case DM_SLICE: 1447c478bd9Sstevel@tonic-gate descs = slice_get_assoc_descriptors(dp, type, errp); 1457c478bd9Sstevel@tonic-gate break; 1467c478bd9Sstevel@tonic-gate case DM_PARTITION: 1477c478bd9Sstevel@tonic-gate descs = partition_get_assoc_descriptors(dp, type, errp); 1487c478bd9Sstevel@tonic-gate break; 1497c478bd9Sstevel@tonic-gate case DM_PATH: 1507c478bd9Sstevel@tonic-gate descs = path_get_assoc_descriptors(dp, type, errp); 1517c478bd9Sstevel@tonic-gate break; 1527c478bd9Sstevel@tonic-gate case DM_ALIAS: 1537c478bd9Sstevel@tonic-gate descs = alias_get_assoc_descriptors(dp, type, errp); 1547c478bd9Sstevel@tonic-gate break; 1557c478bd9Sstevel@tonic-gate default: 1567c478bd9Sstevel@tonic-gate *errp = EINVAL; 1577c478bd9Sstevel@tonic-gate break; 1587c478bd9Sstevel@tonic-gate } 1597c478bd9Sstevel@tonic-gate 1607c478bd9Sstevel@tonic-gate cache_unlock(); 1617c478bd9Sstevel@tonic-gate 1627c478bd9Sstevel@tonic-gate return (ptr_array_to_desc_array(descs, errp)); 1637c478bd9Sstevel@tonic-gate } 1647c478bd9Sstevel@tonic-gate 1657c478bd9Sstevel@tonic-gate dm_desc_type_t * 1667c478bd9Sstevel@tonic-gate dm_get_associated_types(dm_desc_type_t type) 1677c478bd9Sstevel@tonic-gate { 1687c478bd9Sstevel@tonic-gate switch (type) { 1697c478bd9Sstevel@tonic-gate case DM_DRIVE: 1707c478bd9Sstevel@tonic-gate return (drive_assoc_types); 1717c478bd9Sstevel@tonic-gate case DM_BUS: 1727c478bd9Sstevel@tonic-gate return (bus_assoc_types); 1737c478bd9Sstevel@tonic-gate case DM_CONTROLLER: 1747c478bd9Sstevel@tonic-gate return (controller_assoc_types); 1757c478bd9Sstevel@tonic-gate case DM_MEDIA: 1767c478bd9Sstevel@tonic-gate return (media_assoc_types); 1777c478bd9Sstevel@tonic-gate case DM_SLICE: 1787c478bd9Sstevel@tonic-gate return (slice_assoc_types); 1797c478bd9Sstevel@tonic-gate case DM_PARTITION: 1807c478bd9Sstevel@tonic-gate return (partition_assoc_types); 1817c478bd9Sstevel@tonic-gate case DM_PATH: 1827c478bd9Sstevel@tonic-gate return (path_assoc_types); 1837c478bd9Sstevel@tonic-gate case DM_ALIAS: 1847c478bd9Sstevel@tonic-gate return (alias_assoc_types); 1857c478bd9Sstevel@tonic-gate } 1867c478bd9Sstevel@tonic-gate 1877c478bd9Sstevel@tonic-gate return (NULL); 1887c478bd9Sstevel@tonic-gate } 1897c478bd9Sstevel@tonic-gate 1907c478bd9Sstevel@tonic-gate nvlist_t * 1917c478bd9Sstevel@tonic-gate dm_get_attributes(dm_descriptor_t desc, int *errp) 1927c478bd9Sstevel@tonic-gate { 1937c478bd9Sstevel@tonic-gate descriptor_t *dp; 1947c478bd9Sstevel@tonic-gate nvlist_t *attrs = NULL; 1957c478bd9Sstevel@tonic-gate 1967c478bd9Sstevel@tonic-gate 19769fb9702Smike_s dp = (descriptor_t *)(uintptr_t)desc; 1987c478bd9Sstevel@tonic-gate 1997c478bd9Sstevel@tonic-gate cache_rlock(); 2007c478bd9Sstevel@tonic-gate 2017c478bd9Sstevel@tonic-gate if (!cache_is_valid_desc(dp)) { 2027c478bd9Sstevel@tonic-gate cache_unlock(); 2037c478bd9Sstevel@tonic-gate *errp = EBADF; 2047c478bd9Sstevel@tonic-gate return (NULL); 2057c478bd9Sstevel@tonic-gate } 2067c478bd9Sstevel@tonic-gate 2077c478bd9Sstevel@tonic-gate /* verify that the descriptor is still valid */ 2087c478bd9Sstevel@tonic-gate if (dp->p.generic == NULL) { 2097c478bd9Sstevel@tonic-gate cache_unlock(); 2107c478bd9Sstevel@tonic-gate *errp = ENODEV; 2117c478bd9Sstevel@tonic-gate return (NULL); 2127c478bd9Sstevel@tonic-gate } 2137c478bd9Sstevel@tonic-gate 2147c478bd9Sstevel@tonic-gate switch (dp->type) { 2157c478bd9Sstevel@tonic-gate case DM_DRIVE: 2167c478bd9Sstevel@tonic-gate attrs = drive_get_attributes(dp, errp); 2177c478bd9Sstevel@tonic-gate break; 2187c478bd9Sstevel@tonic-gate case DM_BUS: 2197c478bd9Sstevel@tonic-gate attrs = bus_get_attributes(dp, errp); 2207c478bd9Sstevel@tonic-gate break; 2217c478bd9Sstevel@tonic-gate case DM_CONTROLLER: 2227c478bd9Sstevel@tonic-gate attrs = controller_get_attributes(dp, errp); 2237c478bd9Sstevel@tonic-gate break; 2247c478bd9Sstevel@tonic-gate case DM_MEDIA: 2257c478bd9Sstevel@tonic-gate attrs = media_get_attributes(dp, errp); 2267c478bd9Sstevel@tonic-gate break; 2277c478bd9Sstevel@tonic-gate case DM_SLICE: 2287c478bd9Sstevel@tonic-gate attrs = slice_get_attributes(dp, errp); 2297c478bd9Sstevel@tonic-gate break; 2307c478bd9Sstevel@tonic-gate case DM_PARTITION: 2317c478bd9Sstevel@tonic-gate attrs = partition_get_attributes(dp, errp); 2327c478bd9Sstevel@tonic-gate break; 2337c478bd9Sstevel@tonic-gate case DM_PATH: 2347c478bd9Sstevel@tonic-gate attrs = path_get_attributes(dp, errp); 2357c478bd9Sstevel@tonic-gate break; 2367c478bd9Sstevel@tonic-gate case DM_ALIAS: 2377c478bd9Sstevel@tonic-gate attrs = alias_get_attributes(dp, errp); 2387c478bd9Sstevel@tonic-gate break; 2397c478bd9Sstevel@tonic-gate default: 2407c478bd9Sstevel@tonic-gate *errp = EINVAL; 2417c478bd9Sstevel@tonic-gate break; 2427c478bd9Sstevel@tonic-gate } 2437c478bd9Sstevel@tonic-gate 2447c478bd9Sstevel@tonic-gate cache_unlock(); 2457c478bd9Sstevel@tonic-gate 2467c478bd9Sstevel@tonic-gate return (attrs); 2477c478bd9Sstevel@tonic-gate } 2487c478bd9Sstevel@tonic-gate 2497c478bd9Sstevel@tonic-gate dm_descriptor_t 2507c478bd9Sstevel@tonic-gate dm_get_descriptor_by_name(dm_desc_type_t desc_type, char *name, int *errp) 2517c478bd9Sstevel@tonic-gate { 2527c478bd9Sstevel@tonic-gate dm_descriptor_t desc = NULL; 2537c478bd9Sstevel@tonic-gate 2547c478bd9Sstevel@tonic-gate 2557c478bd9Sstevel@tonic-gate cache_wlock(); 2567c478bd9Sstevel@tonic-gate 2577c478bd9Sstevel@tonic-gate switch (desc_type) { 2587c478bd9Sstevel@tonic-gate case DM_DRIVE: 2597c478bd9Sstevel@tonic-gate desc = (uintptr_t)drive_get_descriptor_by_name(name, errp); 2607c478bd9Sstevel@tonic-gate break; 2617c478bd9Sstevel@tonic-gate case DM_BUS: 2627c478bd9Sstevel@tonic-gate desc = (uintptr_t)bus_get_descriptor_by_name(name, errp); 2637c478bd9Sstevel@tonic-gate break; 2647c478bd9Sstevel@tonic-gate case DM_CONTROLLER: 2657c478bd9Sstevel@tonic-gate desc = (uintptr_t)controller_get_descriptor_by_name(name, 2667c478bd9Sstevel@tonic-gate errp); 2677c478bd9Sstevel@tonic-gate break; 2687c478bd9Sstevel@tonic-gate case DM_MEDIA: 2697c478bd9Sstevel@tonic-gate desc = (uintptr_t)media_get_descriptor_by_name(name, errp); 2707c478bd9Sstevel@tonic-gate break; 2717c478bd9Sstevel@tonic-gate case DM_SLICE: 2727c478bd9Sstevel@tonic-gate desc = (uintptr_t)slice_get_descriptor_by_name(name, errp); 2737c478bd9Sstevel@tonic-gate break; 2747c478bd9Sstevel@tonic-gate case DM_PARTITION: 2757c478bd9Sstevel@tonic-gate desc = (uintptr_t)partition_get_descriptor_by_name(name, 2767c478bd9Sstevel@tonic-gate errp); 2777c478bd9Sstevel@tonic-gate break; 2787c478bd9Sstevel@tonic-gate case DM_PATH: 2797c478bd9Sstevel@tonic-gate desc = (uintptr_t)path_get_descriptor_by_name(name, errp); 2807c478bd9Sstevel@tonic-gate break; 2817c478bd9Sstevel@tonic-gate case DM_ALIAS: 2827c478bd9Sstevel@tonic-gate desc = (uintptr_t)alias_get_descriptor_by_name(name, errp); 2837c478bd9Sstevel@tonic-gate break; 2847c478bd9Sstevel@tonic-gate default: 2857c478bd9Sstevel@tonic-gate *errp = EINVAL; 2867c478bd9Sstevel@tonic-gate break; 2877c478bd9Sstevel@tonic-gate } 2887c478bd9Sstevel@tonic-gate 2897c478bd9Sstevel@tonic-gate cache_unlock(); 2907c478bd9Sstevel@tonic-gate 2917c478bd9Sstevel@tonic-gate return (desc); 2927c478bd9Sstevel@tonic-gate } 2937c478bd9Sstevel@tonic-gate 2947c478bd9Sstevel@tonic-gate dm_descriptor_t * 2957c478bd9Sstevel@tonic-gate dm_get_descriptors(dm_desc_type_t type, int filter[], int *errp) 2967c478bd9Sstevel@tonic-gate { 2977c478bd9Sstevel@tonic-gate descriptor_t **descs = NULL; 2987c478bd9Sstevel@tonic-gate 2997c478bd9Sstevel@tonic-gate 3007c478bd9Sstevel@tonic-gate cache_wlock(); 3017c478bd9Sstevel@tonic-gate 3027c478bd9Sstevel@tonic-gate switch (type) { 3037c478bd9Sstevel@tonic-gate case DM_DRIVE: 3047c478bd9Sstevel@tonic-gate descs = drive_get_descriptors(filter, errp); 3057c478bd9Sstevel@tonic-gate break; 3067c478bd9Sstevel@tonic-gate case DM_BUS: 3077c478bd9Sstevel@tonic-gate descs = bus_get_descriptors(filter, errp); 3087c478bd9Sstevel@tonic-gate break; 3097c478bd9Sstevel@tonic-gate case DM_CONTROLLER: 3107c478bd9Sstevel@tonic-gate descs = controller_get_descriptors(filter, errp); 3117c478bd9Sstevel@tonic-gate break; 3127c478bd9Sstevel@tonic-gate case DM_MEDIA: 3137c478bd9Sstevel@tonic-gate descs = media_get_descriptors(filter, errp); 3147c478bd9Sstevel@tonic-gate break; 3157c478bd9Sstevel@tonic-gate case DM_SLICE: 3167c478bd9Sstevel@tonic-gate descs = slice_get_descriptors(filter, errp); 3177c478bd9Sstevel@tonic-gate break; 3187c478bd9Sstevel@tonic-gate case DM_PARTITION: 3197c478bd9Sstevel@tonic-gate descs = partition_get_descriptors(filter, errp); 3207c478bd9Sstevel@tonic-gate break; 3217c478bd9Sstevel@tonic-gate case DM_PATH: 3227c478bd9Sstevel@tonic-gate descs = path_get_descriptors(filter, errp); 3237c478bd9Sstevel@tonic-gate break; 3247c478bd9Sstevel@tonic-gate case DM_ALIAS: 3257c478bd9Sstevel@tonic-gate descs = alias_get_descriptors(filter, errp); 3267c478bd9Sstevel@tonic-gate break; 3277c478bd9Sstevel@tonic-gate default: 3287c478bd9Sstevel@tonic-gate *errp = EINVAL; 3297c478bd9Sstevel@tonic-gate break; 3307c478bd9Sstevel@tonic-gate } 3317c478bd9Sstevel@tonic-gate 3327c478bd9Sstevel@tonic-gate cache_unlock(); 3337c478bd9Sstevel@tonic-gate 3347c478bd9Sstevel@tonic-gate return (ptr_array_to_desc_array(descs, errp)); 3357c478bd9Sstevel@tonic-gate } 3367c478bd9Sstevel@tonic-gate 3377c478bd9Sstevel@tonic-gate char * 3387c478bd9Sstevel@tonic-gate dm_get_name(dm_descriptor_t desc, int *errp) 3397c478bd9Sstevel@tonic-gate { 3407c478bd9Sstevel@tonic-gate descriptor_t *dp; 3417c478bd9Sstevel@tonic-gate char *nm = NULL; 3427c478bd9Sstevel@tonic-gate char *name = NULL; 3437c478bd9Sstevel@tonic-gate 34469fb9702Smike_s dp = (descriptor_t *)(uintptr_t)desc; 3457c478bd9Sstevel@tonic-gate 3467c478bd9Sstevel@tonic-gate cache_rlock(); 3477c478bd9Sstevel@tonic-gate 3487c478bd9Sstevel@tonic-gate if (!cache_is_valid_desc(dp)) { 3497c478bd9Sstevel@tonic-gate cache_unlock(); 3507c478bd9Sstevel@tonic-gate *errp = EBADF; 3517c478bd9Sstevel@tonic-gate return (NULL); 3527c478bd9Sstevel@tonic-gate } 3537c478bd9Sstevel@tonic-gate 3547c478bd9Sstevel@tonic-gate /* verify that the descriptor is still valid */ 3557c478bd9Sstevel@tonic-gate if (dp->p.generic == NULL) { 3567c478bd9Sstevel@tonic-gate cache_unlock(); 3577c478bd9Sstevel@tonic-gate *errp = ENODEV; 3587c478bd9Sstevel@tonic-gate return (NULL); 3597c478bd9Sstevel@tonic-gate } 3607c478bd9Sstevel@tonic-gate 3617c478bd9Sstevel@tonic-gate switch (dp->type) { 3627c478bd9Sstevel@tonic-gate case DM_DRIVE: 3637c478bd9Sstevel@tonic-gate nm = (drive_get_name(dp)); 3647c478bd9Sstevel@tonic-gate break; 3657c478bd9Sstevel@tonic-gate case DM_BUS: 3667c478bd9Sstevel@tonic-gate nm = (bus_get_name(dp)); 3677c478bd9Sstevel@tonic-gate break; 3687c478bd9Sstevel@tonic-gate case DM_CONTROLLER: 3697c478bd9Sstevel@tonic-gate nm = (controller_get_name(dp)); 3707c478bd9Sstevel@tonic-gate break; 3717c478bd9Sstevel@tonic-gate case DM_MEDIA: 3727c478bd9Sstevel@tonic-gate nm = (media_get_name(dp)); 3737c478bd9Sstevel@tonic-gate break; 3747c478bd9Sstevel@tonic-gate case DM_SLICE: 3757c478bd9Sstevel@tonic-gate nm = (slice_get_name(dp)); 3767c478bd9Sstevel@tonic-gate break; 3777c478bd9Sstevel@tonic-gate case DM_PARTITION: 3787c478bd9Sstevel@tonic-gate nm = (partition_get_name(dp)); 3797c478bd9Sstevel@tonic-gate break; 3807c478bd9Sstevel@tonic-gate case DM_PATH: 3817c478bd9Sstevel@tonic-gate nm = (path_get_name(dp)); 3827c478bd9Sstevel@tonic-gate break; 3837c478bd9Sstevel@tonic-gate case DM_ALIAS: 3847c478bd9Sstevel@tonic-gate nm = (alias_get_name(dp)); 3857c478bd9Sstevel@tonic-gate break; 3867c478bd9Sstevel@tonic-gate } 3877c478bd9Sstevel@tonic-gate 3887c478bd9Sstevel@tonic-gate cache_unlock(); 3897c478bd9Sstevel@tonic-gate 3907c478bd9Sstevel@tonic-gate *errp = 0; 3917c478bd9Sstevel@tonic-gate if (nm != NULL) { 3927c478bd9Sstevel@tonic-gate name = strdup(nm); 3937c478bd9Sstevel@tonic-gate if (name == NULL) { 3947c478bd9Sstevel@tonic-gate *errp = ENOMEM; 3957c478bd9Sstevel@tonic-gate return (NULL); 3967c478bd9Sstevel@tonic-gate } 3977c478bd9Sstevel@tonic-gate return (name); 3987c478bd9Sstevel@tonic-gate } 3997c478bd9Sstevel@tonic-gate return (NULL); 4007c478bd9Sstevel@tonic-gate } 4017c478bd9Sstevel@tonic-gate 4027c478bd9Sstevel@tonic-gate nvlist_t * 4037c478bd9Sstevel@tonic-gate dm_get_stats(dm_descriptor_t desc, int stat_type, int *errp) 4047c478bd9Sstevel@tonic-gate { 4057c478bd9Sstevel@tonic-gate descriptor_t *dp; 4067c478bd9Sstevel@tonic-gate nvlist_t *stats = NULL; 4077c478bd9Sstevel@tonic-gate 4087c478bd9Sstevel@tonic-gate 40969fb9702Smike_s dp = (descriptor_t *)(uintptr_t)desc; 4107c478bd9Sstevel@tonic-gate 4117c478bd9Sstevel@tonic-gate cache_rlock(); 4127c478bd9Sstevel@tonic-gate 4137c478bd9Sstevel@tonic-gate if (!cache_is_valid_desc(dp)) { 4143e1bd7a2Ssjelinek cache_unlock(); 4153e1bd7a2Ssjelinek *errp = EBADF; 4163e1bd7a2Ssjelinek return (NULL); 4177c478bd9Sstevel@tonic-gate } 4187c478bd9Sstevel@tonic-gate 4197c478bd9Sstevel@tonic-gate /* verify that the descriptor is still valid */ 4207c478bd9Sstevel@tonic-gate if (dp->p.generic == NULL) { 4213e1bd7a2Ssjelinek cache_unlock(); 4223e1bd7a2Ssjelinek *errp = ENODEV; 4233e1bd7a2Ssjelinek return (NULL); 4247c478bd9Sstevel@tonic-gate } 4257c478bd9Sstevel@tonic-gate 4267c478bd9Sstevel@tonic-gate switch (dp->type) { 4277c478bd9Sstevel@tonic-gate case DM_DRIVE: 4283e1bd7a2Ssjelinek stats = drive_get_stats(dp, stat_type, errp); 4293e1bd7a2Ssjelinek break; 4307c478bd9Sstevel@tonic-gate case DM_BUS: 4313e1bd7a2Ssjelinek stats = bus_get_stats(dp, stat_type, errp); 4323e1bd7a2Ssjelinek break; 4337c478bd9Sstevel@tonic-gate case DM_CONTROLLER: 4343e1bd7a2Ssjelinek stats = controller_get_stats(dp, stat_type, errp); 4353e1bd7a2Ssjelinek break; 4367c478bd9Sstevel@tonic-gate case DM_MEDIA: 4373e1bd7a2Ssjelinek stats = media_get_stats(dp, stat_type, errp); 4383e1bd7a2Ssjelinek break; 4397c478bd9Sstevel@tonic-gate case DM_SLICE: 4403e1bd7a2Ssjelinek if (stat_type == DM_SLICE_STAT_USE) { 4413e1bd7a2Ssjelinek /* 4423e1bd7a2Ssjelinek * If NOINUSE_CHECK is set, we do not perform 4433e1bd7a2Ssjelinek * the in use checking if the user has set stat_type 4443e1bd7a2Ssjelinek * DM_SLICE_STAT_USE 4453e1bd7a2Ssjelinek */ 44682d71480Ssjelinek if (NOINUSE_SET) { 4473e1bd7a2Ssjelinek stats = NULL; 4483e1bd7a2Ssjelinek break; 4493e1bd7a2Ssjelinek } 4503e1bd7a2Ssjelinek } 4513e1bd7a2Ssjelinek stats = slice_get_stats(dp, stat_type, errp); 4523e1bd7a2Ssjelinek break; 4537c478bd9Sstevel@tonic-gate case DM_PARTITION: 4543e1bd7a2Ssjelinek stats = partition_get_stats(dp, stat_type, errp); 4553e1bd7a2Ssjelinek break; 4567c478bd9Sstevel@tonic-gate case DM_PATH: 4573e1bd7a2Ssjelinek stats = path_get_stats(dp, stat_type, errp); 4583e1bd7a2Ssjelinek break; 4597c478bd9Sstevel@tonic-gate case DM_ALIAS: 4603e1bd7a2Ssjelinek stats = alias_get_stats(dp, stat_type, errp); 4613e1bd7a2Ssjelinek break; 4627c478bd9Sstevel@tonic-gate default: 4633e1bd7a2Ssjelinek *errp = EINVAL; 4643e1bd7a2Ssjelinek break; 4657c478bd9Sstevel@tonic-gate } 4667c478bd9Sstevel@tonic-gate 4677c478bd9Sstevel@tonic-gate cache_unlock(); 4687c478bd9Sstevel@tonic-gate 4697c478bd9Sstevel@tonic-gate return (stats); 4707c478bd9Sstevel@tonic-gate } 4717c478bd9Sstevel@tonic-gate 4727c478bd9Sstevel@tonic-gate dm_desc_type_t 4737c478bd9Sstevel@tonic-gate dm_get_type(dm_descriptor_t desc) 4747c478bd9Sstevel@tonic-gate { 4757c478bd9Sstevel@tonic-gate descriptor_t *dp; 4767c478bd9Sstevel@tonic-gate 47769fb9702Smike_s dp = (descriptor_t *)(uintptr_t)desc; 4787c478bd9Sstevel@tonic-gate 4797c478bd9Sstevel@tonic-gate cache_rlock(); 4807c478bd9Sstevel@tonic-gate 4817c478bd9Sstevel@tonic-gate if (!cache_is_valid_desc(dp)) { 4827c478bd9Sstevel@tonic-gate cache_unlock(); 4837c478bd9Sstevel@tonic-gate return (-1); 4847c478bd9Sstevel@tonic-gate } 4857c478bd9Sstevel@tonic-gate 4867c478bd9Sstevel@tonic-gate cache_unlock(); 4877c478bd9Sstevel@tonic-gate 4887c478bd9Sstevel@tonic-gate return (dp->type); 4897c478bd9Sstevel@tonic-gate } 4903e1bd7a2Ssjelinek /* 4913e1bd7a2Ssjelinek * Returns, via slices paramater, a dm_descriptor_t list of 4923e1bd7a2Ssjelinek * slices for the named disk drive. 4933e1bd7a2Ssjelinek */ 4943e1bd7a2Ssjelinek void 4953e1bd7a2Ssjelinek dm_get_slices(char *drive, dm_descriptor_t **slices, int *errp) 4963e1bd7a2Ssjelinek { 4973e1bd7a2Ssjelinek dm_descriptor_t alias; 4983e1bd7a2Ssjelinek dm_descriptor_t *media; 4993e1bd7a2Ssjelinek dm_descriptor_t *disk; 5007c478bd9Sstevel@tonic-gate 5013e1bd7a2Ssjelinek *slices = NULL; 5023e1bd7a2Ssjelinek *errp = 0; 5033e1bd7a2Ssjelinek 5043e1bd7a2Ssjelinek if (drive == NULL) { 5053e1bd7a2Ssjelinek return; 5063e1bd7a2Ssjelinek } 5073e1bd7a2Ssjelinek 5083e1bd7a2Ssjelinek alias = dm_get_descriptor_by_name(DM_ALIAS, drive, errp); 5093e1bd7a2Ssjelinek 5103e1bd7a2Ssjelinek /* 5113e1bd7a2Ssjelinek * Errors must be handled by the caller. The dm_descriptor_t * 5123e1bd7a2Ssjelinek * values will be NULL if an error occured in these calls. 5133e1bd7a2Ssjelinek */ 5143e1bd7a2Ssjelinek 5153e1bd7a2Ssjelinek if (alias != NULL) { 5163e1bd7a2Ssjelinek disk = dm_get_associated_descriptors(alias, DM_DRIVE, errp); 5173e1bd7a2Ssjelinek dm_free_descriptor(alias); 5183e1bd7a2Ssjelinek if (disk != NULL) { 5193e1bd7a2Ssjelinek media = dm_get_associated_descriptors(*disk, 5203e1bd7a2Ssjelinek DM_MEDIA, errp); 5213e1bd7a2Ssjelinek dm_free_descriptors(disk); 5223e1bd7a2Ssjelinek if (media != NULL) { 5233e1bd7a2Ssjelinek *slices = dm_get_associated_descriptors(*media, 5243e1bd7a2Ssjelinek DM_SLICE, errp); 5253e1bd7a2Ssjelinek dm_free_descriptors(media); 5263e1bd7a2Ssjelinek } 5273e1bd7a2Ssjelinek } 5283e1bd7a2Ssjelinek } 5293e1bd7a2Ssjelinek } 5303e1bd7a2Ssjelinek /* 5313e1bd7a2Ssjelinek * Convenience function to get slice stats 5323e1bd7a2Ssjelinek */ 5333e1bd7a2Ssjelinek void 5343e1bd7a2Ssjelinek dm_get_slice_stats(char *slice, nvlist_t **dev_stats, int *errp) 5353e1bd7a2Ssjelinek { 5363e1bd7a2Ssjelinek dm_descriptor_t devp; 5373e1bd7a2Ssjelinek 5383e1bd7a2Ssjelinek *dev_stats = NULL; 5393e1bd7a2Ssjelinek *errp = 0; 5403e1bd7a2Ssjelinek 5413e1bd7a2Ssjelinek if (slice == NULL) { 5423e1bd7a2Ssjelinek return; 5433e1bd7a2Ssjelinek } 5443e1bd7a2Ssjelinek 5453e1bd7a2Ssjelinek /* 5463e1bd7a2Ssjelinek * Errors must be handled by the caller. The dm_descriptor_t * 5473e1bd7a2Ssjelinek * values will be NULL if an error occured in these calls. 5483e1bd7a2Ssjelinek */ 5493e1bd7a2Ssjelinek devp = dm_get_descriptor_by_name(DM_SLICE, slice, errp); 5503e1bd7a2Ssjelinek if (devp != NULL) { 5513e1bd7a2Ssjelinek *dev_stats = dm_get_stats(devp, DM_SLICE_STAT_USE, 5523e1bd7a2Ssjelinek errp); 5533e1bd7a2Ssjelinek dm_free_descriptor(devp); 5543e1bd7a2Ssjelinek } 5553e1bd7a2Ssjelinek } 5563e1bd7a2Ssjelinek 557*46a2abf2Seschrock /* 558*46a2abf2Seschrock * Checks for overlapping slices. If the given device is a slice, and it 559*46a2abf2Seschrock * overlaps with any non-backup slice on the disk, return true with a detailed 560*46a2abf2Seschrock * description similar to dm_inuse(). 561*46a2abf2Seschrock */ 562*46a2abf2Seschrock int 563*46a2abf2Seschrock dm_isoverlapping(char *slicename, char **overlaps_with, int *errp) 564*46a2abf2Seschrock { 565*46a2abf2Seschrock dm_descriptor_t slice = NULL; 566*46a2abf2Seschrock dm_descriptor_t *media = NULL; 567*46a2abf2Seschrock dm_descriptor_t *slices = NULL; 568*46a2abf2Seschrock int i = 0; 569*46a2abf2Seschrock uint32_t in_snum; 570*46a2abf2Seschrock uint64_t start_block = 0; 571*46a2abf2Seschrock uint64_t end_block = 0; 572*46a2abf2Seschrock uint64_t media_size = 0; 573*46a2abf2Seschrock uint64_t size = 0; 574*46a2abf2Seschrock nvlist_t *media_attrs = NULL; 575*46a2abf2Seschrock nvlist_t *slice_attrs = NULL; 576*46a2abf2Seschrock int ret = 0; 577*46a2abf2Seschrock 578*46a2abf2Seschrock slice = dm_get_descriptor_by_name(DM_SLICE, slicename, errp); 579*46a2abf2Seschrock if (slice == NULL) 580*46a2abf2Seschrock goto out; 581*46a2abf2Seschrock 582*46a2abf2Seschrock /* 583*46a2abf2Seschrock * Get the list of slices be fetching the associated media, and then all 584*46a2abf2Seschrock * associated slices. 585*46a2abf2Seschrock */ 586*46a2abf2Seschrock media = dm_get_associated_descriptors(slice, DM_MEDIA, errp); 587*46a2abf2Seschrock if (media == NULL || *media == NULL || *errp != 0) 588*46a2abf2Seschrock goto out; 589*46a2abf2Seschrock 590*46a2abf2Seschrock slices = dm_get_associated_descriptors(*media, DM_SLICE, errp); 591*46a2abf2Seschrock if (slices == NULL || *slices == NULL || *errp != 0) 592*46a2abf2Seschrock goto out; 593*46a2abf2Seschrock 594*46a2abf2Seschrock media_attrs = dm_get_attributes(*media, errp); 595*46a2abf2Seschrock if (media_attrs == NULL || *errp) 596*46a2abf2Seschrock goto out; 597*46a2abf2Seschrock 598*46a2abf2Seschrock *errp = nvlist_lookup_uint64(media_attrs, DM_NACCESSIBLE, &media_size); 599*46a2abf2Seschrock if (*errp != 0) 600*46a2abf2Seschrock goto out; 601*46a2abf2Seschrock 602*46a2abf2Seschrock slice_attrs = dm_get_attributes(slice, errp); 603*46a2abf2Seschrock if (slice_attrs == NULL || *errp != 0) 604*46a2abf2Seschrock goto out; 605*46a2abf2Seschrock 606*46a2abf2Seschrock *errp = nvlist_lookup_uint64(slice_attrs, DM_START, &start_block); 607*46a2abf2Seschrock if (*errp != 0) 608*46a2abf2Seschrock goto out; 609*46a2abf2Seschrock 610*46a2abf2Seschrock *errp = nvlist_lookup_uint64(slice_attrs, DM_SIZE, &size); 611*46a2abf2Seschrock if (*errp != 0) 612*46a2abf2Seschrock goto out; 613*46a2abf2Seschrock 614*46a2abf2Seschrock *errp = nvlist_lookup_uint32(slice_attrs, DM_INDEX, &in_snum); 615*46a2abf2Seschrock if (*errp != 0) 616*46a2abf2Seschrock goto out; 617*46a2abf2Seschrock 618*46a2abf2Seschrock end_block = (start_block + size) - 1; 619*46a2abf2Seschrock 620*46a2abf2Seschrock for (i = 0; slices[i]; i ++) { 621*46a2abf2Seschrock uint64_t other_start; 622*46a2abf2Seschrock uint64_t other_end; 623*46a2abf2Seschrock uint64_t other_size; 624*46a2abf2Seschrock uint32_t snum; 625*46a2abf2Seschrock 626*46a2abf2Seschrock nvlist_t *other_attrs = dm_get_attributes(slices[i], errp); 627*46a2abf2Seschrock 628*46a2abf2Seschrock if (other_attrs == NULL) 629*46a2abf2Seschrock continue; 630*46a2abf2Seschrock 631*46a2abf2Seschrock if (*errp != 0) 632*46a2abf2Seschrock goto out; 633*46a2abf2Seschrock 634*46a2abf2Seschrock *errp = nvlist_lookup_uint64(other_attrs, DM_START, 635*46a2abf2Seschrock &other_start); 636*46a2abf2Seschrock if (*errp) { 637*46a2abf2Seschrock nvlist_free(other_attrs); 638*46a2abf2Seschrock goto out; 639*46a2abf2Seschrock } 640*46a2abf2Seschrock 641*46a2abf2Seschrock *errp = nvlist_lookup_uint64(other_attrs, DM_SIZE, 642*46a2abf2Seschrock &other_size); 643*46a2abf2Seschrock 644*46a2abf2Seschrock if (*errp) { 645*46a2abf2Seschrock nvlist_free(other_attrs); 646*46a2abf2Seschrock ret = -1; 647*46a2abf2Seschrock goto out; 648*46a2abf2Seschrock } 649*46a2abf2Seschrock 650*46a2abf2Seschrock other_end = (other_size + other_start) - 1; 651*46a2abf2Seschrock 652*46a2abf2Seschrock *errp = nvlist_lookup_uint32(other_attrs, DM_INDEX, 653*46a2abf2Seschrock &snum); 654*46a2abf2Seschrock 655*46a2abf2Seschrock if (*errp) { 656*46a2abf2Seschrock nvlist_free(other_attrs); 657*46a2abf2Seschrock ret = -1; 658*46a2abf2Seschrock goto out; 659*46a2abf2Seschrock } 660*46a2abf2Seschrock 661*46a2abf2Seschrock /* 662*46a2abf2Seschrock * Check to see if there are > 2 overlapping regions 663*46a2abf2Seschrock * on this media in the same region as this slice. 664*46a2abf2Seschrock * This is done by assuming the following: 665*46a2abf2Seschrock * Slice 2 is the backup slice if it is the size 666*46a2abf2Seschrock * of the whole disk 667*46a2abf2Seschrock * If slice 2 is the overlap and slice 2 is the size of 668*46a2abf2Seschrock * the whole disk, continue. If another slice is found 669*46a2abf2Seschrock * that overlaps with our slice, return it. 670*46a2abf2Seschrock * There is the potential that there is more than one slice 671*46a2abf2Seschrock * that our slice overlaps with, however, we only return 672*46a2abf2Seschrock * the first overlapping slice we find. 673*46a2abf2Seschrock * 674*46a2abf2Seschrock */ 675*46a2abf2Seschrock if (start_block >= other_start && start_block <= other_end) { 676*46a2abf2Seschrock if ((snum == 2 && (other_size == media_size)) || 677*46a2abf2Seschrock snum == in_snum) { 678*46a2abf2Seschrock continue; 679*46a2abf2Seschrock } else { 680*46a2abf2Seschrock char *str = dm_get_name(slices[i], errp); 681*46a2abf2Seschrock if (*errp != 0) { 682*46a2abf2Seschrock nvlist_free(other_attrs); 683*46a2abf2Seschrock ret = -1; 684*46a2abf2Seschrock goto out; 685*46a2abf2Seschrock } 686*46a2abf2Seschrock *overlaps_with = strdup(str); 687*46a2abf2Seschrock dm_free_name(str); 688*46a2abf2Seschrock nvlist_free(other_attrs); 689*46a2abf2Seschrock ret = 1; 690*46a2abf2Seschrock goto out; 691*46a2abf2Seschrock } 692*46a2abf2Seschrock } else if (other_start >= start_block && 693*46a2abf2Seschrock other_start <= end_block) { 694*46a2abf2Seschrock if ((snum == 2 && (other_size == media_size)) || 695*46a2abf2Seschrock snum == in_snum) { 696*46a2abf2Seschrock continue; 697*46a2abf2Seschrock } else { 698*46a2abf2Seschrock char *str = dm_get_name(slices[i], errp); 699*46a2abf2Seschrock if (*errp != 0) { 700*46a2abf2Seschrock nvlist_free(other_attrs); 701*46a2abf2Seschrock ret = -1; 702*46a2abf2Seschrock goto out; 703*46a2abf2Seschrock } 704*46a2abf2Seschrock *overlaps_with = strdup(str); 705*46a2abf2Seschrock dm_free_name(str); 706*46a2abf2Seschrock nvlist_free(other_attrs); 707*46a2abf2Seschrock ret = 1; 708*46a2abf2Seschrock goto out; 709*46a2abf2Seschrock } 710*46a2abf2Seschrock } 711*46a2abf2Seschrock nvlist_free(other_attrs); 712*46a2abf2Seschrock } 713*46a2abf2Seschrock 714*46a2abf2Seschrock out: 715*46a2abf2Seschrock if (media_attrs) 716*46a2abf2Seschrock nvlist_free(media_attrs); 717*46a2abf2Seschrock if (slice_attrs) 718*46a2abf2Seschrock nvlist_free(slice_attrs); 719*46a2abf2Seschrock 720*46a2abf2Seschrock if (slices) 721*46a2abf2Seschrock dm_free_descriptors(slices); 722*46a2abf2Seschrock if (media) 723*46a2abf2Seschrock dm_free_descriptors(media); 724*46a2abf2Seschrock if (slice) 725*46a2abf2Seschrock dm_free_descriptor(slice); 726*46a2abf2Seschrock 727*46a2abf2Seschrock return (ret); 728*46a2abf2Seschrock } 729*46a2abf2Seschrock 7303e1bd7a2Ssjelinek /* 7313e1bd7a2Ssjelinek * Returns 'in use' details, if found, about a specific dev_name, 7323e1bd7a2Ssjelinek * based on the caller(who). It is important to note that it is possible 7333e1bd7a2Ssjelinek * for there to be more than one 'in use' statistic regarding a dev_name. 7343e1bd7a2Ssjelinek * The **msg parameter returns a list of 'in use' details. This message 7353e1bd7a2Ssjelinek * is formatted via gettext(). 7363e1bd7a2Ssjelinek */ 7373e1bd7a2Ssjelinek int 7383e1bd7a2Ssjelinek dm_inuse(char *dev_name, char **msg, dm_who_type_t who, int *errp) 7393e1bd7a2Ssjelinek { 7403e1bd7a2Ssjelinek nvlist_t *dev_stats = NULL; 7413e1bd7a2Ssjelinek char *by, *data; 7423e1bd7a2Ssjelinek nvpair_t *nvwhat = NULL; 7433e1bd7a2Ssjelinek nvpair_t *nvdesc = NULL; 7443e1bd7a2Ssjelinek int found = 0; 7453e1bd7a2Ssjelinek char *dname = NULL; 7463e1bd7a2Ssjelinek 74782d71480Ssjelinek 7483e1bd7a2Ssjelinek *errp = 0; 7493e1bd7a2Ssjelinek *msg = NULL; 7503e1bd7a2Ssjelinek 75182d71480Ssjelinek /* 75282d71480Ssjelinek * If the user doesn't want to do in use checking, return. 75382d71480Ssjelinek */ 75482d71480Ssjelinek 75582d71480Ssjelinek if (NOINUSE_SET) 75682d71480Ssjelinek return (0); 75782d71480Ssjelinek 7583e1bd7a2Ssjelinek dname = getfullblkname(dev_name); 7593e1bd7a2Ssjelinek /* 7603e1bd7a2Ssjelinek * If we cannot find the block name, we cannot check the device 7613e1bd7a2Ssjelinek * for in use statistics. So, return found, which is == 0. 7623e1bd7a2Ssjelinek */ 7633e1bd7a2Ssjelinek if (dname == NULL || *dname == '\0') { 7643e1bd7a2Ssjelinek return (found); 7653e1bd7a2Ssjelinek } 7663e1bd7a2Ssjelinek 7673e1bd7a2Ssjelinek dm_get_slice_stats(dname, &dev_stats, errp); 7683e1bd7a2Ssjelinek if (dev_stats == NULL) { 7693e1bd7a2Ssjelinek /* 7703e1bd7a2Ssjelinek * If there is an error, but it isn't a no device found error 7713e1bd7a2Ssjelinek * return the error as recorded. Otherwise, with a full 7723e1bd7a2Ssjelinek * block name, we might not be able to get the slice 7733e1bd7a2Ssjelinek * associated, and will get an ENODEV error. For example, 7743e1bd7a2Ssjelinek * an SVM metadevice will return a value from getfullblkname() 7753e1bd7a2Ssjelinek * but libdiskmgt won't be able to find this device for 7763e1bd7a2Ssjelinek * statistics gathering. This is expected and we should not 7773e1bd7a2Ssjelinek * report errnoneous errors. 7783e1bd7a2Ssjelinek */ 7793e1bd7a2Ssjelinek if (*errp) { 7803e1bd7a2Ssjelinek if (*errp == ENODEV) { 7813e1bd7a2Ssjelinek *errp = 0; 7823e1bd7a2Ssjelinek } 7833e1bd7a2Ssjelinek } 7843e1bd7a2Ssjelinek free(dname); 7853e1bd7a2Ssjelinek return (found); 7863e1bd7a2Ssjelinek } 7873e1bd7a2Ssjelinek 7883e1bd7a2Ssjelinek for (;;) { 7893e1bd7a2Ssjelinek 7903e1bd7a2Ssjelinek nvwhat = nvlist_next_nvpair(dev_stats, nvdesc); 7913e1bd7a2Ssjelinek nvdesc = nvlist_next_nvpair(dev_stats, nvwhat); 7923e1bd7a2Ssjelinek 7933e1bd7a2Ssjelinek /* 7943e1bd7a2Ssjelinek * End of the list found. 7953e1bd7a2Ssjelinek */ 7963e1bd7a2Ssjelinek if (nvwhat == NULL || nvdesc == NULL) { 7973e1bd7a2Ssjelinek break; 7983e1bd7a2Ssjelinek } 7993e1bd7a2Ssjelinek /* 8003e1bd7a2Ssjelinek * Otherwise, we check to see if this client(who) cares 8013e1bd7a2Ssjelinek * about this in use scenario 8023e1bd7a2Ssjelinek */ 8033e1bd7a2Ssjelinek 8043e1bd7a2Ssjelinek ASSERT(strcmp(nvpair_name(nvwhat), DM_USED_BY) == 0); 8053e1bd7a2Ssjelinek ASSERT(strcmp(nvpair_name(nvdesc), DM_USED_NAME) == 0); 8063e1bd7a2Ssjelinek /* 8073e1bd7a2Ssjelinek * If we error getting the string value continue on 8083e1bd7a2Ssjelinek * to the next pair(if there is one) 8093e1bd7a2Ssjelinek */ 8103e1bd7a2Ssjelinek if (nvpair_value_string(nvwhat, &by)) { 8113e1bd7a2Ssjelinek continue; 8123e1bd7a2Ssjelinek } 8133e1bd7a2Ssjelinek if (nvpair_value_string(nvdesc, &data)) { 8143e1bd7a2Ssjelinek continue; 8153e1bd7a2Ssjelinek } 8163e1bd7a2Ssjelinek 8173e1bd7a2Ssjelinek switch (who) { 8183e1bd7a2Ssjelinek case DM_WHO_MKFS: 8193e1bd7a2Ssjelinek /* 8203e1bd7a2Ssjelinek * mkfs is not in use for these cases. 8213e1bd7a2Ssjelinek * All others are in use. 8223e1bd7a2Ssjelinek */ 8233e1bd7a2Ssjelinek if (strcmp(by, DM_USE_LU) == 0 || 824*46a2abf2Seschrock strcmp(by, DM_USE_FS) == 0 || 825*46a2abf2Seschrock strcmp(by, DM_USE_EXPORTED_ZPOOL) == 0) { 8263e1bd7a2Ssjelinek break; 8273e1bd7a2Ssjelinek } 8283e1bd7a2Ssjelinek if (build_usage_string(dname, 8293e1bd7a2Ssjelinek by, data, msg, &found, errp) != 0) { 8303e1bd7a2Ssjelinek if (*errp) { 8313e1bd7a2Ssjelinek goto out; 8323e1bd7a2Ssjelinek } 8333e1bd7a2Ssjelinek } 8343e1bd7a2Ssjelinek break; 8353e1bd7a2Ssjelinek case DM_WHO_SWAP: 8363e1bd7a2Ssjelinek /* 8373e1bd7a2Ssjelinek * Not in use for this. 8383e1bd7a2Ssjelinek */ 8393e1bd7a2Ssjelinek if (strcmp(by, DM_USE_DUMP) == 0 || 840*46a2abf2Seschrock strcmp(by, DM_USE_FS) == 0 || 841*46a2abf2Seschrock strcmp(by, DM_USE_EXPORTED_ZPOOL) == 0) { 8423e1bd7a2Ssjelinek break; 8433e1bd7a2Ssjelinek } 8443e1bd7a2Ssjelinek 8453e1bd7a2Ssjelinek if (build_usage_string(dname, 8463e1bd7a2Ssjelinek by, data, msg, &found, errp) != 0) { 8473e1bd7a2Ssjelinek if (*errp) { 8483e1bd7a2Ssjelinek goto out; 8493e1bd7a2Ssjelinek } 8503e1bd7a2Ssjelinek } 8513e1bd7a2Ssjelinek break; 8523e1bd7a2Ssjelinek case DM_WHO_DUMP: 8533e1bd7a2Ssjelinek /* 8543e1bd7a2Ssjelinek * Not in use for this. 8553e1bd7a2Ssjelinek */ 8563e1bd7a2Ssjelinek if ((strcmp(by, DM_USE_MOUNT) == 0 && 8573e1bd7a2Ssjelinek strcmp(data, "swap") == 0) || 8583e1bd7a2Ssjelinek strcmp(by, DM_USE_DUMP) == 0 || 859*46a2abf2Seschrock strcmp(by, DM_USE_FS) == 0 || 860*46a2abf2Seschrock strcmp(by, DM_USE_EXPORTED_ZPOOL) == 0) { 8613e1bd7a2Ssjelinek break; 8623e1bd7a2Ssjelinek } 8633e1bd7a2Ssjelinek if (build_usage_string(dname, 8643e1bd7a2Ssjelinek by, data, msg, &found, errp)) { 8653e1bd7a2Ssjelinek if (*errp) { 8663e1bd7a2Ssjelinek goto out; 8673e1bd7a2Ssjelinek } 8683e1bd7a2Ssjelinek } 8693e1bd7a2Ssjelinek break; 8703e1bd7a2Ssjelinek 8713e1bd7a2Ssjelinek case DM_WHO_FORMAT: 872*46a2abf2Seschrock if (strcmp(by, DM_USE_FS) == 0 || 873*46a2abf2Seschrock strcmp(by, DM_USE_EXPORTED_ZPOOL) == 0) 8743e1bd7a2Ssjelinek break; 8753e1bd7a2Ssjelinek if (build_usage_string(dname, 8763e1bd7a2Ssjelinek by, data, msg, &found, errp) != 0) { 8773e1bd7a2Ssjelinek if (*errp) { 8783e1bd7a2Ssjelinek goto out; 8793e1bd7a2Ssjelinek } 8803e1bd7a2Ssjelinek } 8813e1bd7a2Ssjelinek break; 882*46a2abf2Seschrock 883*46a2abf2Seschrock case DM_WHO_ZPOOL_FORCE: 884*46a2abf2Seschrock if (strcmp(by, DM_USE_FS) == 0 || 885*46a2abf2Seschrock strcmp(by, DM_USE_EXPORTED_ZPOOL) == 0) 886*46a2abf2Seschrock break; 887*46a2abf2Seschrock /* FALLTHROUGH */ 888*46a2abf2Seschrock case DM_WHO_ZPOOL: 889*46a2abf2Seschrock if (build_usage_string(dname, 890*46a2abf2Seschrock by, data, msg, &found, errp) != 0) { 891*46a2abf2Seschrock if (*errp) 892*46a2abf2Seschrock goto out; 893*46a2abf2Seschrock } 894*46a2abf2Seschrock break; 895*46a2abf2Seschrock 8963e1bd7a2Ssjelinek default: 8973e1bd7a2Ssjelinek /* 8983e1bd7a2Ssjelinek * nothing found in use for this client 8993e1bd7a2Ssjelinek * of libdiskmgt. Default is 'not in use'. 9003e1bd7a2Ssjelinek */ 9013e1bd7a2Ssjelinek break; 9023e1bd7a2Ssjelinek } 9033e1bd7a2Ssjelinek } 9043e1bd7a2Ssjelinek out: 9053e1bd7a2Ssjelinek if (dname != NULL) 9063e1bd7a2Ssjelinek free(dname); 9073e1bd7a2Ssjelinek if (dev_stats != NULL) 9083e1bd7a2Ssjelinek nvlist_free(dev_stats); 9093e1bd7a2Ssjelinek 9103e1bd7a2Ssjelinek return (found); 9113e1bd7a2Ssjelinek } 9123e1bd7a2Ssjelinek 9133e1bd7a2Ssjelinek void 9143e1bd7a2Ssjelinek dm_get_usage_string(char *what, char *how, char **usage_string) 9153e1bd7a2Ssjelinek { 9163e1bd7a2Ssjelinek 9173e1bd7a2Ssjelinek 9183e1bd7a2Ssjelinek if (usage_string == NULL || what == NULL) { 9193e1bd7a2Ssjelinek return; 9203e1bd7a2Ssjelinek } 9213e1bd7a2Ssjelinek *usage_string = NULL; 9223e1bd7a2Ssjelinek 9233e1bd7a2Ssjelinek if (strcmp(what, DM_USE_MOUNT) == 0) { 9243e1bd7a2Ssjelinek if (strcmp(how, "swap") == 0) { 9253e1bd7a2Ssjelinek *usage_string = dgettext(TEXT_DOMAIN, 9263e1bd7a2Ssjelinek "%s is currently used by swap. Please see swap(1M)." 9273e1bd7a2Ssjelinek "\n"); 9283e1bd7a2Ssjelinek } else { 9293e1bd7a2Ssjelinek *usage_string = dgettext(TEXT_DOMAIN, 9303e1bd7a2Ssjelinek "%s is currently mounted on %s." 9313e1bd7a2Ssjelinek " Please see umount(1M).\n"); 9323e1bd7a2Ssjelinek } 9333e1bd7a2Ssjelinek } else if (strcmp(what, DM_USE_VFSTAB) == 0) { 9343e1bd7a2Ssjelinek *usage_string = dgettext(TEXT_DOMAIN, 9353e1bd7a2Ssjelinek "%s is normally mounted on %s according to /etc/vfstab. " 9363e1bd7a2Ssjelinek "Please remove this entry to use this device.\n"); 9373e1bd7a2Ssjelinek } else if (strcmp(what, DM_USE_FS) == 0) { 9383e1bd7a2Ssjelinek *usage_string = dgettext(TEXT_DOMAIN, 939*46a2abf2Seschrock "%s contains a %s filesystem.\n"); 9403e1bd7a2Ssjelinek } else if (strcmp(what, DM_USE_SVM) == 0) { 9413e1bd7a2Ssjelinek if (strcmp(how, "mdb") == 0) { 9423e1bd7a2Ssjelinek *usage_string = dgettext(TEXT_DOMAIN, 9433e1bd7a2Ssjelinek "%s contains an SVM %s. Please see " 9443e1bd7a2Ssjelinek "metadb(1M).\n"); 9453e1bd7a2Ssjelinek } else { 9463e1bd7a2Ssjelinek *usage_string = dgettext(TEXT_DOMAIN, 9473e1bd7a2Ssjelinek "%s is part of SVM volume %s. " 9483e1bd7a2Ssjelinek "Please see metaclear(1M).\n"); 9493e1bd7a2Ssjelinek } 9503e1bd7a2Ssjelinek } else if (strcmp(what, DM_USE_VXVM) == 0) { 9513e1bd7a2Ssjelinek *usage_string = dgettext(TEXT_DOMAIN, 9523e1bd7a2Ssjelinek "%s is part of VxVM volume %s.\n"); 9533e1bd7a2Ssjelinek } else if (strcmp(what, DM_USE_LU) == 0) { 9543e1bd7a2Ssjelinek *usage_string = dgettext(TEXT_DOMAIN, 9553e1bd7a2Ssjelinek "%s is in use for live upgrade %s. Please see ludelete(1M)." 9563e1bd7a2Ssjelinek "\n"); 9573e1bd7a2Ssjelinek } else if (strcmp(what, DM_USE_DUMP) == 0) { 9583e1bd7a2Ssjelinek *usage_string = dgettext(TEXT_DOMAIN, 9593e1bd7a2Ssjelinek "%s is in use by %s. Please see dumpadm(1M)." 9603e1bd7a2Ssjelinek "\n"); 961*46a2abf2Seschrock } else if (strcmp(what, DM_USE_EXPORTED_ZPOOL) == 0) { 962*46a2abf2Seschrock *usage_string = dgettext(TEXT_DOMAIN, 963*46a2abf2Seschrock "%s is part of exported or potentially active ZFS pool %s. " 964*46a2abf2Seschrock "Please see zpool(1M).\n"); 965*46a2abf2Seschrock } else if (strcmp(what, DM_USE_ACTIVE_ZPOOL) == 0) { 9663e1bd7a2Ssjelinek *usage_string = dgettext(TEXT_DOMAIN, 967*46a2abf2Seschrock "%s is part of active ZFS pool %s. Please see zpool(1M)." 9683e1bd7a2Ssjelinek "\n"); 9693e1bd7a2Ssjelinek } 9703e1bd7a2Ssjelinek } 9717c478bd9Sstevel@tonic-gate void 9727c478bd9Sstevel@tonic-gate libdiskmgt_add_str(nvlist_t *attrs, char *name, char *val, int *errp) 9737c478bd9Sstevel@tonic-gate { 9747c478bd9Sstevel@tonic-gate if (*errp == 0) { 9757c478bd9Sstevel@tonic-gate *errp = nvlist_add_string(attrs, name, val); 9767c478bd9Sstevel@tonic-gate } 9777c478bd9Sstevel@tonic-gate } 9787c478bd9Sstevel@tonic-gate 9797c478bd9Sstevel@tonic-gate descriptor_t ** 9807c478bd9Sstevel@tonic-gate libdiskmgt_empty_desc_array(int *errp) 9817c478bd9Sstevel@tonic-gate { 9827c478bd9Sstevel@tonic-gate descriptor_t **empty; 9837c478bd9Sstevel@tonic-gate 9847c478bd9Sstevel@tonic-gate empty = (descriptor_t **)calloc(1, sizeof (descriptor_t *)); 9857c478bd9Sstevel@tonic-gate if (empty == NULL) { 9867c478bd9Sstevel@tonic-gate *errp = ENOMEM; 9877c478bd9Sstevel@tonic-gate return (NULL); 9887c478bd9Sstevel@tonic-gate } 9897c478bd9Sstevel@tonic-gate empty[0] = NULL; 9907c478bd9Sstevel@tonic-gate 9917c478bd9Sstevel@tonic-gate *errp = 0; 9927c478bd9Sstevel@tonic-gate return (empty); 9937c478bd9Sstevel@tonic-gate } 9947c478bd9Sstevel@tonic-gate 9957c478bd9Sstevel@tonic-gate void 9967c478bd9Sstevel@tonic-gate libdiskmgt_init_debug() 9977c478bd9Sstevel@tonic-gate { 9987c478bd9Sstevel@tonic-gate char *valp; 9997c478bd9Sstevel@tonic-gate 10007c478bd9Sstevel@tonic-gate if ((valp = getenv(DM_DEBUG)) != NULL) { 10017c478bd9Sstevel@tonic-gate dm_debug = atoi(valp); 10027c478bd9Sstevel@tonic-gate } 10037c478bd9Sstevel@tonic-gate } 10047c478bd9Sstevel@tonic-gate 10057c478bd9Sstevel@tonic-gate int 10067c478bd9Sstevel@tonic-gate libdiskmgt_str_eq(char *nm1, char *nm2) 10077c478bd9Sstevel@tonic-gate { 10087c478bd9Sstevel@tonic-gate if (nm1 == NULL) { 10097c478bd9Sstevel@tonic-gate if (dm_debug) { 10107c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "WARNING: str_eq nm1 NULL\n"); 10117c478bd9Sstevel@tonic-gate } 10127c478bd9Sstevel@tonic-gate 10137c478bd9Sstevel@tonic-gate if (nm2 == NULL) { 10147c478bd9Sstevel@tonic-gate return (1); 10157c478bd9Sstevel@tonic-gate } else { 10167c478bd9Sstevel@tonic-gate return (0); 10177c478bd9Sstevel@tonic-gate } 10187c478bd9Sstevel@tonic-gate } 10197c478bd9Sstevel@tonic-gate 10207c478bd9Sstevel@tonic-gate /* nm1 != NULL */ 10217c478bd9Sstevel@tonic-gate 10227c478bd9Sstevel@tonic-gate if (nm2 == NULL) { 10237c478bd9Sstevel@tonic-gate if (dm_debug) { 10247c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "WARNING: str_eq nm2 NULL\n"); 10257c478bd9Sstevel@tonic-gate } 10267c478bd9Sstevel@tonic-gate return (0); 10277c478bd9Sstevel@tonic-gate } 10287c478bd9Sstevel@tonic-gate 10297c478bd9Sstevel@tonic-gate if (strcmp(nm1, nm2) == 0) { 10307c478bd9Sstevel@tonic-gate return (1); 10317c478bd9Sstevel@tonic-gate } 10327c478bd9Sstevel@tonic-gate 10337c478bd9Sstevel@tonic-gate return (0); 10347c478bd9Sstevel@tonic-gate } 10357c478bd9Sstevel@tonic-gate 10367c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 10377c478bd9Sstevel@tonic-gate static descriptor_t ** 10387c478bd9Sstevel@tonic-gate desc_array_to_ptr_array(dm_descriptor_t *descs, int *errp) 10397c478bd9Sstevel@tonic-gate { 10407c478bd9Sstevel@tonic-gate #ifdef _LP64 10417c478bd9Sstevel@tonic-gate return ((descriptor_t **)descs); 10427c478bd9Sstevel@tonic-gate #else 10437c478bd9Sstevel@tonic-gate /* convert the 64 bit descriptors to 32 bit ptrs */ 10447c478bd9Sstevel@tonic-gate int cnt; 10457c478bd9Sstevel@tonic-gate int i; 10467c478bd9Sstevel@tonic-gate descriptor_t **da; 10477c478bd9Sstevel@tonic-gate 10487c478bd9Sstevel@tonic-gate for (cnt = 0; descs[cnt]; cnt++); 10497c478bd9Sstevel@tonic-gate 10507c478bd9Sstevel@tonic-gate da = (descriptor_t **)calloc(cnt + 1, sizeof (descriptor_t *)); 10517c478bd9Sstevel@tonic-gate if (da == NULL) { 10527c478bd9Sstevel@tonic-gate *errp = ENOMEM; 10537c478bd9Sstevel@tonic-gate return (NULL); 10547c478bd9Sstevel@tonic-gate } 10557c478bd9Sstevel@tonic-gate 10567c478bd9Sstevel@tonic-gate for (i = 0; descs[i]; i++) { 105769fb9702Smike_s da[i] = (descriptor_t *)(uintptr_t)descs[i]; 10587c478bd9Sstevel@tonic-gate } 10597c478bd9Sstevel@tonic-gate *errp = 0; 10607c478bd9Sstevel@tonic-gate free(descs); 10617c478bd9Sstevel@tonic-gate 10627c478bd9Sstevel@tonic-gate return (da); 10637c478bd9Sstevel@tonic-gate #endif 10647c478bd9Sstevel@tonic-gate } 10657c478bd9Sstevel@tonic-gate 10667c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 10677c478bd9Sstevel@tonic-gate static dm_descriptor_t * 10687c478bd9Sstevel@tonic-gate ptr_array_to_desc_array(descriptor_t **ptrs, int *errp) 10697c478bd9Sstevel@tonic-gate { 10707c478bd9Sstevel@tonic-gate #ifdef _LP64 10717c478bd9Sstevel@tonic-gate return ((dm_descriptor_t *)ptrs); 10727c478bd9Sstevel@tonic-gate #else 10737c478bd9Sstevel@tonic-gate /* convert the 32 bit ptrs to the 64 bit descriptors */ 10747c478bd9Sstevel@tonic-gate int cnt; 10757c478bd9Sstevel@tonic-gate int i; 10767c478bd9Sstevel@tonic-gate dm_descriptor_t *da; 10777c478bd9Sstevel@tonic-gate 10787c478bd9Sstevel@tonic-gate if (*errp != 0 || ptrs == NULL) { 10797c478bd9Sstevel@tonic-gate return (NULL); 10807c478bd9Sstevel@tonic-gate } 10817c478bd9Sstevel@tonic-gate 10827c478bd9Sstevel@tonic-gate for (cnt = 0; ptrs[cnt]; cnt++); 10837c478bd9Sstevel@tonic-gate 10847c478bd9Sstevel@tonic-gate da = (dm_descriptor_t *)calloc(cnt + 1, sizeof (dm_descriptor_t)); 10857c478bd9Sstevel@tonic-gate if (da == NULL) { 10867c478bd9Sstevel@tonic-gate *errp = ENOMEM; 10877c478bd9Sstevel@tonic-gate return (NULL); 10887c478bd9Sstevel@tonic-gate } 10897c478bd9Sstevel@tonic-gate 10907c478bd9Sstevel@tonic-gate for (i = 0; ptrs[i]; i++) { 10917c478bd9Sstevel@tonic-gate da[i] = (uintptr_t)ptrs[i]; 10927c478bd9Sstevel@tonic-gate } 10937c478bd9Sstevel@tonic-gate *errp = 0; 10947c478bd9Sstevel@tonic-gate free(ptrs); 10957c478bd9Sstevel@tonic-gate 10967c478bd9Sstevel@tonic-gate return (da); 10977c478bd9Sstevel@tonic-gate #endif 10987c478bd9Sstevel@tonic-gate } 10993e1bd7a2Ssjelinek /* 11003e1bd7a2Ssjelinek * Build the usage string for the in use data. Return the build string in 11013e1bd7a2Ssjelinek * the msg parameter. This function takes care of reallocing all the memory 11023e1bd7a2Ssjelinek * for this usage string. Usage string is returned already formatted for 11033e1bd7a2Ssjelinek * localization. 11043e1bd7a2Ssjelinek */ 11053e1bd7a2Ssjelinek static int 11063e1bd7a2Ssjelinek build_usage_string(char *dname, char *by, char *data, char **msg, 11073e1bd7a2Ssjelinek int *found, int *errp) 11083e1bd7a2Ssjelinek { 11093e1bd7a2Ssjelinek int len0; 11103e1bd7a2Ssjelinek int len1; 11113e1bd7a2Ssjelinek char *use; 11123e1bd7a2Ssjelinek char *p; 11133e1bd7a2Ssjelinek 11143e1bd7a2Ssjelinek *errp = 0; 11153e1bd7a2Ssjelinek 11163e1bd7a2Ssjelinek dm_get_usage_string(by, data, &use); 11173e1bd7a2Ssjelinek if (!use) { 11183e1bd7a2Ssjelinek return (-1); 11193e1bd7a2Ssjelinek } 11203e1bd7a2Ssjelinek 11213e1bd7a2Ssjelinek if (*msg) 11223e1bd7a2Ssjelinek len0 = strlen(*msg); 11233e1bd7a2Ssjelinek else 11243e1bd7a2Ssjelinek len0 = 0; 11253e1bd7a2Ssjelinek /* LINTED */ 11263e1bd7a2Ssjelinek len1 = snprintf(NULL, 0, use, dname, data); 11273e1bd7a2Ssjelinek 11283e1bd7a2Ssjelinek /* 11293e1bd7a2Ssjelinek * If multiple in use details they 11303e1bd7a2Ssjelinek * are listed 1 per line for ease of 11313e1bd7a2Ssjelinek * reading. dm_find_usage_string 11323e1bd7a2Ssjelinek * formats these appropriately. 11333e1bd7a2Ssjelinek */ 11343e1bd7a2Ssjelinek if ((p = realloc(*msg, len0 + len1 + 1)) == NULL) { 11353e1bd7a2Ssjelinek *errp = errno; 11363e1bd7a2Ssjelinek free(*msg); 11373e1bd7a2Ssjelinek return (-1); 11383e1bd7a2Ssjelinek } 11393e1bd7a2Ssjelinek *msg = p; 11403e1bd7a2Ssjelinek 11413e1bd7a2Ssjelinek /* LINTED */ 11423e1bd7a2Ssjelinek (void) snprintf(*msg + len0, len1 + 1, use, dname, data); 11433e1bd7a2Ssjelinek (*found)++; 11443e1bd7a2Ssjelinek return (0); 11453e1bd7a2Ssjelinek } 1146