xref: /titanic_51/usr/src/cmd/fs.d/preenlib.c (revision 1e49577a7fcde812700ded04431b49d67cc57d6d) 
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 #pragma ident	"%Z%%M%	%I%	%E% SMI"
23 /*
24  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
25  * Use is subject to license terms.
26  */
27 
28 /*
29  * common routines for parallelization (used by both fsck and quotacheck)
30  */
31 #include <stdio.h>
32 #include <fcntl.h>
33 #include <dlfcn.h>
34 #include <macros.h>
35 #include <sys/types.h>
36 #include <sys/wait.h>
37 #include <sys/mntent.h>
38 #include <sys/dkio.h>
39 
40 /*
41  * data structures for parallelization
42  */
43 struct driver {
44 	char 	*name;			/* driver name (from DKIOCINFO) */
45 	uint_t	mapsize;		/* size of `busymap' */
46 	uint_t	*busymap;		/* bitmask of active units */
47 	int	(*choosefunc)();	/* driver specific chooser */
48 	void	*data;			/* driver private data */
49 };
50 
51 struct onedev {
52 	int	drvid;			/* index in driver array */
53 	uint_t	mapsize;		/* size of `unitmap' */
54 	uint_t	*unitmap;		/* unit #'s (from DKIOCINFO) */
55 	struct onedev *nxtdev;
56 };
57 
58 struct rawdev {
59 	char	*devname;		/* name passed to preen_addev */
60 	struct	onedev *alldevs;	/* info about each component device */
61 	struct rawdev *nxtrd;		/* next entry in list */
62 };
63 
64 static int debug = 0;
65 
66 /*
67  * defines used in building shared object names
68  */
69 
70 /* the directory where we find shared objects */
71 #define	OBJECT_DIRECTORY	"/usr/lib/drv"
72 
73 /* a shared object name is OBJECT_PREFIX || driver_name */
74 #define	OBJECT_PREFIX		"preen_"
75 
76 /* the version of the driver interface we support */
77 #define	OBJECT_VERSION		1
78 
79 /* the "build" entry point for a driver specific object is named this */
80 #define	BUILD_ENTRY		preen_build_devs
81 #define	BUILD_NAME		"preen_build_devs"
82 
83 #define	DRIVER_ALLOC	10
84 static int ndrivers, ndalloc;
85 static struct driver *dlist;
86 
87 static struct rawdev *unchecked, *active, *get_runnable();
88 static struct onedev *alloc_dev();
89 static int chooseone();
90 
91 #define	WORDSIZE	(NBBY * sizeof (uint_t))
92 
93 void 	preen_addunit(void *, char *, int (*)(), void *, uint_t);
94 int 	preen_subdev(char *, struct dk_cinfo *, void *);
95 
96 static int 	alloc_driver(char *, int (*)(), void *);
97 static void 	addunit(struct onedev *, uint_t);
98 static void	makebusy(struct onedev *);
99 static void	notbusy(struct rawdev *);
100 
101 /*
102  * add the given device to the list of devices to be checked
103  */
104 int
105 preen_addev(char *devnm)
106 {
107 	struct rawdev *rdp;
108 	int fd;
109 	struct dk_cinfo dki;
110 	extern char *strdup();
111 
112 	if ((fd = open64(devnm, O_RDONLY)) == -1) {
113 		perror(devnm);
114 		return (-1);
115 	}
116 	if (ioctl(fd, DKIOCINFO, &dki) == -1) {
117 		perror("DKIOCINFO");
118 		fprintf(stderr, "device: `%s'\n", devnm);
119 		(void) close(fd);
120 		return (-1);
121 	}
122 	(void) close(fd);
123 	if ((rdp = (struct rawdev *)malloc(sizeof (struct rawdev))) == NULL) {
124 		(void) fprintf(stderr, "out of memory in preenlib\n");
125 		return (-1);
126 	}
127 	if ((rdp->devname = strdup(devnm)) == NULL) {
128 		(void) fprintf(stderr, "out of memory in preenlib\n");
129 		return (-1);
130 	}
131 	rdp->alldevs = NULL;
132 	rdp->nxtrd = NULL;
133 
134 	if (preen_subdev(devnm, &dki, (void *)rdp)) {
135 		preen_addunit(rdp, dki.dki_dname, NULL, NULL, dki.dki_unit);
136 	}
137 
138 	rdp->nxtrd = unchecked;
139 	unchecked = rdp;
140 	return (0);
141 }
142 
143 int
144 preen_subdev(char *name, struct dk_cinfo *dkiop, void *dp)
145 {
146 	char modname[255];
147 	void *dlhandle;
148 	int (*fptr)();
149 
150 	(void) sprintf(modname, "%s/%s%s.so.%d",
151 	    OBJECT_DIRECTORY, OBJECT_PREFIX, dkiop->dki_dname, OBJECT_VERSION);
152 	dlhandle = dlopen(modname, RTLD_LAZY);
153 	if (dlhandle == NULL) {
154 		if (debug)
155 			(void) fprintf(stderr, "preen_subdev: %s\n", dlerror());
156 		return (1);
157 	}
158 	fptr = (int (*)())dlsym(dlhandle, BUILD_NAME);
159 	if (fptr == NULL) {
160 		if (debug)
161 			(void) fprintf(stderr, "preen_subdev: %s\n", dlerror());
162 		return (1);
163 	}
164 	(*fptr)(name, dkiop, dp);
165 	return (0);
166 }
167 
168 /*
169  * select a device from the "unchecked" list, and add it to the
170  * active list.
171  */
172 int
173 preen_getdev(char *devnm)
174 {
175 	struct rawdev *rdp;
176 	struct onedev *dp;
177 
178 	if (unchecked == NULL)
179 		return (0);
180 
181 	rdp = get_runnable(&unchecked);
182 
183 	if (rdp) {
184 		for (dp = rdp->alldevs; dp; dp = dp->nxtdev) {
185 			makebusy(dp);
186 		}
187 		rdp->nxtrd = active;
188 		active = rdp;
189 		(void) strcpy(devnm, rdp->devname);
190 		return (1);
191 	} else {
192 		return (2);
193 	}
194 }
195 
196 int
197 preen_releasedev(char *name)
198 {
199 	struct rawdev *dp, *ldp;
200 
201 	for (ldp = NULL, dp = active; dp != NULL; ldp = dp, dp = dp->nxtrd) {
202 		if (strcmp(dp->devname, name) == 0)
203 			break;
204 	}
205 
206 	if (dp == NULL)
207 		return (-1);
208 	if (ldp != NULL) {
209 		ldp->nxtrd = dp->nxtrd;
210 	} else {
211 		active = dp->nxtrd;
212 	}
213 
214 	notbusy(dp);
215 	/*
216 	 * free(dp->devname);
217 	 * free(dp);
218 	 */
219 	return (0);
220 }
221 
222 static
223 struct rawdev *
224 get_runnable(struct rawdev **devlist)
225 {
226 	struct rawdev *last, *rdp;
227 	struct onedev *devp;
228 	struct driver *drvp;
229 	int rc = 1;
230 
231 	for (last = NULL, rdp = *devlist; rdp; last = rdp, rdp = rdp->nxtrd) {
232 		for (devp = rdp->alldevs; devp != NULL; devp = devp->nxtdev) {
233 			drvp = &dlist[devp->drvid];
234 			rc = (*drvp->choosefunc)(devp->mapsize, devp->unitmap,
235 			    drvp->mapsize, drvp->busymap);
236 			if (rc != 0)
237 				break;
238 		}
239 		if (rc == 0)
240 			break;
241 	}
242 
243 	/*
244 	 * remove from list...
245 	 */
246 	if (rdp) {
247 		if (last) {
248 			last->nxtrd = rdp->nxtrd;
249 		} else {
250 			*devlist = rdp->nxtrd;
251 		}
252 	}
253 
254 	return (rdp);
255 }
256 
257 /*
258  * add the given driver/unit reference to the `rawdev' structure identified
259  * by `cookie'
260  * If a new `driver' structure needs to be created, associate the given
261  * choosing function and driver private data with it.
262  */
263 void
264 preen_addunit(
265 	void    *cookie,
266 	char	*dname,		/* driver name */
267 	int	(*cf)(),	/* candidate choosing function */
268 	void	*datap,		/* driver private data */
269 	uint_t	unit)		/* unit number */
270 {
271 	int drvid;
272 	struct driver *dp;
273 	struct onedev *devp;
274 	struct rawdev *rdp = (struct rawdev *)cookie;
275 
276 	/*
277 	 * locate the driver struct
278 	 */
279 	dp = NULL;
280 	for (drvid = 0; drvid < ndrivers; drvid++) {
281 		if (strcmp(dlist[drvid].name, dname) == 0) {
282 			dp = &dlist[drvid];
283 			break;
284 		}
285 	}
286 
287 	if (dp == NULL) {
288 		/*
289 		 * driver struct doesn't exist yet -- create one
290 		 */
291 		if (cf == NULL)
292 			cf = chooseone;
293 		drvid = alloc_driver(dname, cf, datap);
294 		dp = &dlist[drvid];
295 	}
296 
297 	for (devp = rdp->alldevs; devp != NULL; devp = devp->nxtdev) {
298 		/*
299 		 * see if this device already references the given driver
300 		 */
301 		if (devp->drvid == drvid)
302 			break;
303 	}
304 
305 	if (devp == NULL) {
306 		/*
307 		 * allocate a new `struct onedev' and chain it in
308 		 * rdp->alldevs...
309 		 */
310 		devp = alloc_dev(drvid);
311 		devp->nxtdev = rdp->alldevs;
312 		rdp->alldevs = devp;
313 	}
314 
315 	/*
316 	 * add `unit' to the unitmap in devp
317 	 */
318 	addunit(devp, unit);
319 }
320 
321 static
322 int
323 alloc_driver(char *name, int (*cf)(), void *datap)
324 {
325 	struct driver *dp;
326 	extern char *strdup();
327 
328 	if (ndrivers == ndalloc) {
329 		dlist = ndalloc ?
330 		    (struct driver *)
331 		    realloc(dlist, sizeof (struct driver) * DRIVER_ALLOC) :
332 		    (struct driver *)
333 		    malloc(sizeof (struct driver) * DRIVER_ALLOC);
334 		if (dlist == NULL) {
335 			(void) fprintf(stderr, "out of memory in preenlib\n");
336 			exit(1);
337 		}
338 		ndalloc += DRIVER_ALLOC;
339 	}
340 
341 	dp = &dlist[ndrivers];
342 	dp->name = strdup(name);
343 	if (dp->name == NULL) {
344 		(void) fprintf(stderr, "out of memory in preenlib\n");
345 		exit(1);
346 	}
347 	dp->choosefunc = cf;
348 	dp->data = datap;
349 	dp->mapsize = 0;
350 	dp->busymap = NULL;
351 	return (ndrivers++);
352 }
353 
354 static
355 struct onedev *
356 alloc_dev(int did)
357 {
358 	struct onedev *devp;
359 
360 	devp = (struct onedev *)malloc(sizeof (struct onedev));
361 	if (devp == NULL) {
362 		(void) fprintf(stderr, "out of memory in preenlib\n");
363 		exit(1);
364 	}
365 	devp->drvid = did;
366 	devp->mapsize = 0;
367 	devp->unitmap = NULL;
368 	devp->nxtdev = NULL;
369 	return (devp);
370 }
371 
372 static
373 void
374 addunit(struct onedev *devp, uint_t unit)
375 {
376 	uint_t newsize;
377 
378 	newsize = howmany(unit+1, WORDSIZE);
379 	if (devp->mapsize < newsize) {
380 		devp->unitmap = devp->mapsize ?
381 		    (uint_t *)realloc(devp->unitmap,
382 		    newsize * sizeof (uint_t)) :
383 		    (uint_t *)malloc(newsize * sizeof (uint_t));
384 		if (devp->unitmap == NULL) {
385 			(void) fprintf(stderr, "out of memory in preenlib\n");
386 			exit(1);
387 		}
388 		(void) memset((char *)&devp->unitmap[devp->mapsize], 0,
389 		    (uint_t)((newsize - devp->mapsize) * sizeof (uint_t)));
390 		devp->mapsize = newsize;
391 	}
392 	devp->unitmap[unit / WORDSIZE] |= (1 << (unit % WORDSIZE));
393 }
394 
395 static int
396 chooseone(int devmapsize, ulong_t *devmap, int drvmapsize, ulong_t *drvmap)
397 {
398 	int i;
399 
400 	for (i = 0; i < min(devmapsize, drvmapsize); i++) {
401 		if (devmap[i] & drvmap[i])
402 			return (1);
403 	}
404 	return (0);
405 }
406 
407 /*
408  * mark the given driver/unit pair as busy.  This is called from
409  * preen_getdev.
410  */
411 static
412 void
413 makebusy(struct onedev *dev)
414 {
415 	struct driver *drvp = &dlist[dev->drvid];
416 	int newsize = dev->mapsize;
417 	int i;
418 
419 	if (drvp->mapsize < newsize) {
420 		drvp->busymap = drvp->mapsize ?
421 		    (uint_t *)realloc(drvp->busymap,
422 		    newsize * sizeof (uint_t)) :
423 		    (uint_t *)malloc(newsize * sizeof (uint_t));
424 		if (drvp->busymap == NULL) {
425 			(void) fprintf(stderr, "out of memory in preenlib\n");
426 			exit(1);
427 		}
428 		(void) memset((char *)&drvp->busymap[drvp->mapsize], 0,
429 		    (uint_t)((newsize - drvp->mapsize) * sizeof (uint_t)));
430 		drvp->mapsize = newsize;
431 	}
432 
433 	for (i = 0; i < newsize; i++)
434 		drvp->busymap[i] |= dev->unitmap[i];
435 }
436 
437 /*
438  * make each device in the given `rawdev' un-busy.
439  * Called from preen_releasedev
440  */
441 static
442 void
443 notbusy(struct rawdev *rd)
444 {
445 	struct onedev *devp;
446 	struct driver *drvp;
447 	int i;
448 
449 	for (devp = rd->alldevs; devp; devp = devp->nxtdev) {
450 		drvp = &dlist[devp->drvid];
451 		for (i = 0; i < devp->mapsize; i++)
452 			drvp->busymap[i] &= ~(devp->unitmap[i]);
453 	}
454 }
455