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