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, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 23 /* 24 * Copyright 2004 Sun Microsystems, Inc. All rights reserved. 25 * Use is subject to license terms. 26 * Copyright 2017 Nexenta Systems, Inc. 27 */ 28 29 #include <unistd.h> 30 #include <stdlib.h> 31 #include <errno.h> 32 #include <ftw.h> 33 #include <string.h> 34 #include <thread.h> 35 #include <synch.h> 36 #include <sys/types.h> 37 #include <sys/stat.h> 38 #include <fcntl.h> 39 #include <sys/modctl.h> 40 #include <strings.h> 41 42 #include <libdevinfo.h> 43 #include "libdevid.h" 44 45 /* 46 * Get Device Id from an open file descriptor 47 */ 48 int devid_get(int fd,ddi_devid_t * devidp)49 devid_get(int fd, ddi_devid_t *devidp) 50 { 51 int len = 0; 52 dev_t dev; 53 struct stat statb; 54 ddi_devid_t mydevid; 55 56 if (fstat(fd, &statb) != 0) 57 return (-1); 58 59 /* If not char or block device, then error */ 60 if (!S_ISCHR(statb.st_mode) && !S_ISBLK(statb.st_mode)) 61 return (-1); 62 63 /* Get the device id size */ 64 dev = statb.st_rdev; 65 if (modctl(MODSIZEOF_DEVID, dev, &len) != 0) 66 return (-1); 67 68 /* Allocate space to return device id */ 69 if ((mydevid = (ddi_devid_t)malloc(len)) == NULL) 70 return (-1); 71 72 /* Get the device id */ 73 if (modctl(MODGETDEVID, dev, len, mydevid) != 0) { 74 free(mydevid); 75 return (-1); 76 } 77 78 /* Return the device id copy */ 79 *devidp = mydevid; 80 return (0); 81 } 82 83 /* 84 * Get the minor name 85 */ 86 int devid_get_minor_name(int fd,char ** minor_namep)87 devid_get_minor_name(int fd, char **minor_namep) 88 { 89 int len = 0; 90 dev_t dev; 91 int spectype; 92 char *myminor_name; 93 struct stat statb; 94 95 if (fstat(fd, &statb) != 0) 96 return (-1); 97 98 /* If not a char or block device, then return an error */ 99 if (!S_ISCHR(statb.st_mode) && !S_ISBLK(statb.st_mode)) 100 return (-1); 101 102 spectype = statb.st_mode & S_IFMT; 103 dev = statb.st_rdev; 104 105 /* Get the minor name size */ 106 if (modctl(MODSIZEOF_MINORNAME, dev, spectype, &len) != 0) 107 return (-1); 108 109 /* Allocate space for the minor name */ 110 if ((myminor_name = (char *)malloc(len)) == NULL) 111 return (-1); 112 113 /* Get the minor name */ 114 if (modctl(MODGETMINORNAME, dev, spectype, len, myminor_name) != 0) { 115 free(myminor_name); 116 return (-1); 117 } 118 119 /* return the minor name copy */ 120 *minor_namep = myminor_name; 121 return (0); 122 } 123 124 char * devid_str_from_path(const char * path)125 devid_str_from_path(const char *path) 126 { 127 int fd; 128 ddi_devid_t devid; 129 char *minor, *ret = NULL; 130 131 if ((fd = open(path, O_RDONLY)) < 0) 132 return (NULL); 133 134 if (devid_get(fd, &devid) == 0) { 135 if (devid_get_minor_name(fd, &minor) != 0) 136 minor = NULL; 137 ret = devid_str_encode(devid, minor); 138 if (minor != NULL) 139 devid_str_free(minor); 140 devid_free(devid); 141 } 142 (void) close(fd); 143 144 return (ret); 145 } 146 147 /* list element of devid_nmlist_t information */ 148 struct nmlist { 149 struct nmlist *nl_next; 150 char *nl_devname; 151 dev_t nl_dev; 152 }; 153 154 /* add list element to end of nmlist headed by *nlhp */ 155 struct nmlist * nmlist_add(struct nmlist ** nlhp,char * path)156 nmlist_add(struct nmlist **nlhp, char *path) 157 { 158 struct stat statb; 159 dev_t dev; 160 struct nmlist *nl; 161 162 /* stat and get the devt for char or block */ 163 if ((stat(path, &statb) == 0) && 164 (S_ISCHR(statb.st_mode) || S_ISBLK(statb.st_mode))) 165 dev = statb.st_rdev; 166 else 167 dev = NODEV; 168 169 /* find the end of the list */ 170 for (; (nl = *nlhp) != NULL; nlhp = &nl->nl_next) 171 ; 172 173 /* allocate and initialize new entry */ 174 if ((nl = malloc(sizeof (*nl))) == NULL) 175 return (NULL); 176 177 if ((nl->nl_devname = strdup(path)) == NULL) { 178 free(nl); 179 return (NULL); 180 } 181 nl->nl_next = NULL; 182 nl->nl_dev = dev; 183 184 /* link new entry at end */ 185 *nlhp = nl; 186 return (nl); 187 } 188 189 /* information needed by devlink_callback to call nmlist_add */ 190 struct devlink_cbinfo { 191 struct nmlist **cbi_nlhp; 192 char *cbi_search_path; 193 int cbi_error; 194 }; 195 196 /* di_devlink callback to add a /dev entry to nmlist */ 197 static int devlink_callback(di_devlink_t dl,void * arg)198 devlink_callback(di_devlink_t dl, void *arg) 199 { 200 struct devlink_cbinfo *cbip = (struct devlink_cbinfo *)arg; 201 char *devpath = (char *)di_devlink_path(dl); 202 203 if (strncmp(devpath, cbip->cbi_search_path, 204 strlen(cbip->cbi_search_path)) == 0) { 205 if (nmlist_add(cbip->cbi_nlhp, devpath) == NULL) { 206 cbip->cbi_error = 1; 207 return (DI_WALK_TERMINATE); 208 } 209 } 210 return (DI_WALK_CONTINUE); 211 } 212 213 /* 214 * Resolve /dev names to DI_PRIMARY_LINK, DI_SECONDARY_LINK, or both. 215 * The default is to resolve to just the DI_PRIMARY_LINK. 216 */ 217 int devid_deviceid_to_nmlist_link = DI_PRIMARY_LINK; 218 219 /* 220 * Options for the devid_deviceid_to_nmlist implementation: 221 * 222 * DEVICEID_NMLIST_SLINK - reduce overhead by reuse the previous 223 * di_devlink_init. 224 */ 225 #define DEVICEID_NMLIST_SLINK 1 226 int devid_deviceid_to_nmlist_flg = 0; 227 static di_devlink_handle_t devid_deviceid_to_nmlist_dlh = NULL; /* SLINK */ 228 229 #define DEVICEID_NMLIST_NRETRY 10 230 231 /* 232 * Convert the specified devid/minor_name into a devid_nmlist_t array 233 * with names that resolve into /devices or /dev depending on search_path. 234 * 235 * The man page indicates that: 236 * 237 * This function traverses the file tree, starting at search_path. 238 * 239 * This is not true, we reverse engineer the paths relative to 240 * the specified search path to avoid attaching all devices. 241 */ 242 int devid_deviceid_to_nmlist(char * search_path,ddi_devid_t devid,char * minor_name,devid_nmlist_t ** retlist)243 devid_deviceid_to_nmlist(char *search_path, ddi_devid_t devid, char *minor_name, 244 devid_nmlist_t **retlist) 245 { 246 char *cp; 247 int dev; 248 char *paths = NULL; 249 char *path; 250 int lens; 251 di_devlink_handle_t dlh = NULL; 252 int ret = -1; 253 struct devlink_cbinfo cbi; 254 struct nmlist *nlh = NULL; 255 struct nmlist *nl; 256 devid_nmlist_t *rl; 257 int nret; 258 int nagain = 0; 259 int err = 0; 260 261 *retlist = NULL; 262 263 /* verify valid search path starts with "/devices" or "/dev" */ 264 if ((strcmp(search_path, "/devices") == 0) || 265 (strncmp(search_path, "/devices/", 9) == 0)) 266 dev = 0; 267 else if ((strcmp(search_path, "/dev") == 0) || 268 (strncmp(search_path, "/dev/", 5) == 0)) 269 dev = 1; 270 else { 271 errno = EINVAL; 272 return (-1); 273 } 274 275 276 /* translate devid/minor_name to /devices paths */ 277 again: if (modctl(MODDEVID2PATHS, devid, minor_name, 0, &lens, NULL) != 0) 278 goto out; 279 if ((paths = (char *)malloc(lens)) == NULL) 280 goto out; 281 if (modctl(MODDEVID2PATHS, devid, minor_name, 0, &lens, paths) != 0) { 282 if ((errno == EAGAIN) && (nagain++ < DEVICEID_NMLIST_NRETRY)) { 283 free(paths); 284 paths = NULL; 285 goto again; 286 } 287 goto out; 288 } 289 290 /* 291 * initialize for /devices path to /dev path translation. To reduce 292 * overhead we reuse the last snapshot if DEVICEID_NMLIST_SLINK is set. 293 */ 294 if (dev) { 295 dlh = devid_deviceid_to_nmlist_dlh; 296 if (dlh && 297 !(devid_deviceid_to_nmlist_flg & DEVICEID_NMLIST_SLINK)) { 298 (void) di_devlink_fini(&dlh); 299 dlh = devid_deviceid_to_nmlist_dlh = NULL; 300 } 301 if ((dlh == NULL) && 302 ((dlh = di_devlink_init(NULL, 0)) == NULL)) 303 goto out; 304 } 305 306 /* 307 * iterate over all the devtspectype resolutions of the devid and 308 * convert them into the appropriate path form and add items to return 309 * to the nmlist list; 310 */ 311 for (path = paths; *path; path += strlen(path) + 1) { 312 if (dev) { 313 /* add /dev entries */ 314 cbi.cbi_nlhp = &nlh; 315 cbi.cbi_search_path = search_path; 316 cbi.cbi_error = 0; 317 318 (void) di_devlink_walk(dlh, NULL, path, 319 devid_deviceid_to_nmlist_link, 320 (void *)&cbi, devlink_callback); 321 if (cbi.cbi_error) 322 goto out; 323 } else { 324 /* add /devices entry */ 325 cp = malloc(strlen("/devices") + strlen(path) + 1); 326 (void) strcpy(cp, "/devices"); 327 (void) strcat(cp, path); 328 if (strncmp(cp, search_path, 329 strlen(search_path)) == 0) { 330 if (nmlist_add(&nlh, cp) == NULL) { 331 free(cp); 332 goto out; 333 } 334 } 335 free(cp); 336 } 337 } 338 339 /* convert from nmlist to retlist array */ 340 for (nl = nlh, nret = 0; nl; nl = nl->nl_next) 341 nret++; 342 if (nret == 0) { 343 err = ENODEV; 344 goto out; 345 } 346 if ((*retlist = calloc(nret + 1, sizeof (devid_nmlist_t))) == NULL) { 347 err = ENOMEM; 348 goto out; 349 } 350 for (nl = nlh, rl = *retlist; nl; nl = nl->nl_next, rl++) { 351 rl->devname = nl->nl_devname; 352 rl->dev = nl->nl_dev; 353 } 354 rl->devname = NULL; 355 rl->dev = NODEV; 356 357 ret = 0; 358 359 out: 360 while ((nl = nlh) != NULL) { /* free the nmlist */ 361 nlh = nl->nl_next; 362 free(nl); 363 } 364 if (paths) 365 free(paths); 366 if (dlh) { 367 if ((ret == 0) && 368 (devid_deviceid_to_nmlist_flg & DEVICEID_NMLIST_SLINK)) 369 devid_deviceid_to_nmlist_dlh = dlh; 370 else 371 (void) di_devlink_fini(&dlh); 372 } 373 if (ret && *retlist) 374 free(*retlist); 375 if (ret && err != 0) 376 errno = err; 377 return (ret); 378 } 379 380 /* 381 * Free Device Id Name List 382 */ 383 void devid_free_nmlist(devid_nmlist_t * list)384 devid_free_nmlist(devid_nmlist_t *list) 385 { 386 devid_nmlist_t *p = list; 387 388 if (list == NULL) 389 return; 390 391 /* Free all the device names */ 392 while (p->devname != NULL) { 393 free(p->devname); 394 p++; 395 } 396 397 /* Free the array */ 398 free(list); 399 } 400