xref: /netbsd-src/sys/dev/ld.c (revision 6cd39ddb8550f6fa1bff3fed32053d7f19fd0453)
1 /*	$NetBSD: ld.c,v 1.93 2015/08/28 17:41:49 mlelstv Exp $	*/
2 
3 /*-
4  * Copyright (c) 1998, 2000 The NetBSD Foundation, Inc.
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to The NetBSD Foundation
8  * by Andrew Doran and Charles M. Hannum.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29  * POSSIBILITY OF SUCH DAMAGE.
30  */
31 
32 /*
33  * Disk driver for use by RAID controllers.
34  */
35 
36 #include <sys/cdefs.h>
37 __KERNEL_RCSID(0, "$NetBSD: ld.c,v 1.93 2015/08/28 17:41:49 mlelstv Exp $");
38 
39 #include <sys/param.h>
40 #include <sys/systm.h>
41 #include <sys/kernel.h>
42 #include <sys/device.h>
43 #include <sys/queue.h>
44 #include <sys/proc.h>
45 #include <sys/buf.h>
46 #include <sys/bufq.h>
47 #include <sys/endian.h>
48 #include <sys/disklabel.h>
49 #include <sys/disk.h>
50 #include <sys/dkio.h>
51 #include <sys/stat.h>
52 #include <sys/conf.h>
53 #include <sys/fcntl.h>
54 #include <sys/vnode.h>
55 #include <sys/syslog.h>
56 #include <sys/mutex.h>
57 
58 #include <dev/ldvar.h>
59 
60 #include <prop/proplib.h>
61 
62 static void	ldminphys(struct buf *bp);
63 static bool	ld_suspend(device_t, const pmf_qual_t *);
64 static bool	ld_shutdown(device_t, int);
65 static int	ld_diskstart(device_t, struct buf *bp);
66 static void	ld_iosize(device_t, int *);
67 static int	ld_dumpblocks(device_t, void *, daddr_t, int);
68 static void	ld_fake_geometry(struct ld_softc *);
69 static void	ld_set_geometry(struct ld_softc *);
70 static void	ld_config_interrupts (device_t);
71 static int	ld_lastclose(device_t);
72 static int	ld_discard(device_t, off_t, off_t);
73 
74 extern struct	cfdriver ld_cd;
75 
76 static dev_type_open(ldopen);
77 static dev_type_close(ldclose);
78 static dev_type_read(ldread);
79 static dev_type_write(ldwrite);
80 static dev_type_ioctl(ldioctl);
81 static dev_type_strategy(ldstrategy);
82 static dev_type_dump(lddump);
83 static dev_type_size(ldsize);
84 static dev_type_discard(lddiscard);
85 
86 const struct bdevsw ld_bdevsw = {
87 	.d_open = ldopen,
88 	.d_close = ldclose,
89 	.d_strategy = ldstrategy,
90 	.d_ioctl = ldioctl,
91 	.d_dump = lddump,
92 	.d_psize = ldsize,
93 	.d_discard = lddiscard,
94 	.d_flag = D_DISK | D_MPSAFE
95 };
96 
97 const struct cdevsw ld_cdevsw = {
98 	.d_open = ldopen,
99 	.d_close = ldclose,
100 	.d_read = ldread,
101 	.d_write = ldwrite,
102 	.d_ioctl = ldioctl,
103 	.d_stop = nostop,
104 	.d_tty = notty,
105 	.d_poll = nopoll,
106 	.d_mmap = nommap,
107 	.d_kqfilter = nokqfilter,
108 	.d_discard = lddiscard,
109 	.d_flag = D_DISK | D_MPSAFE
110 };
111 
112 static struct	dkdriver lddkdriver = {
113 	.d_open = ldopen,
114 	.d_close = ldclose,
115 	.d_strategy = ldstrategy,
116 	.d_iosize = ld_iosize,
117 	.d_minphys  = ldminphys,
118 	.d_diskstart = ld_diskstart,
119 	.d_dumpblocks = ld_dumpblocks,
120 	.d_lastclose = ld_lastclose,
121 	.d_discard = ld_discard
122 };
123 
124 void
125 ldattach(struct ld_softc *sc)
126 {
127 	device_t self = sc->sc_dv;
128 	struct dk_softc *dksc = &sc->sc_dksc;
129 
130 	mutex_init(&sc->sc_mutex, MUTEX_DEFAULT, IPL_VM);
131 	cv_init(&sc->sc_drain, "lddrain");
132 
133 	if ((sc->sc_flags & LDF_ENABLED) == 0) {
134 		return;
135 	}
136 
137 	/* Initialise dk and disk structure. */
138 	dk_init(dksc, self, DKTYPE_LD);
139 	disk_init(&dksc->sc_dkdev, dksc->sc_xname, &lddkdriver);
140 
141 	if (sc->sc_maxxfer > MAXPHYS)
142 		sc->sc_maxxfer = MAXPHYS;
143 
144 	/* Build synthetic geometry if necessary. */
145 	if (sc->sc_nheads == 0 || sc->sc_nsectors == 0 ||
146 	    sc->sc_ncylinders == 0)
147 	    ld_fake_geometry(sc);
148 
149 	sc->sc_disksize512 = sc->sc_secperunit * sc->sc_secsize / DEV_BSIZE;
150 
151 	/* Attach dk and disk subsystems */
152 	dk_attach(dksc);
153 	disk_attach(&dksc->sc_dkdev);
154 	ld_set_geometry(sc);
155 
156 	bufq_alloc(&dksc->sc_bufq, BUFQ_DISK_DEFAULT_STRAT, BUFQ_SORT_RAWBLOCK);
157 
158 	/* Register with PMF */
159 	if (!pmf_device_register1(dksc->sc_dev, ld_suspend, NULL, ld_shutdown))
160 		aprint_error_dev(dksc->sc_dev,
161 		    "couldn't establish power handler\n");
162 
163 	/* Discover wedges on this disk. */
164 	config_interrupts(sc->sc_dv, ld_config_interrupts);
165 }
166 
167 int
168 ldadjqparam(struct ld_softc *sc, int xmax)
169 {
170 
171 	mutex_enter(&sc->sc_mutex);
172 	sc->sc_maxqueuecnt = xmax;
173 	mutex_exit(&sc->sc_mutex);
174 
175 	return (0);
176 }
177 
178 int
179 ldbegindetach(struct ld_softc *sc, int flags)
180 {
181 	struct dk_softc *dksc = &sc->sc_dksc;
182 	int rv = 0;
183 
184 	if ((sc->sc_flags & LDF_ENABLED) == 0)
185 		return (0);
186 
187 	rv = disk_begindetach(&dksc->sc_dkdev, ld_lastclose, dksc->sc_dev, flags);
188 
189 	if (rv != 0)
190 		return rv;
191 
192 	mutex_enter(&sc->sc_mutex);
193 	sc->sc_maxqueuecnt = 0;
194 
195 	while (sc->sc_queuecnt > 0) {
196 		sc->sc_flags |= LDF_DRAIN;
197 		cv_wait(&sc->sc_drain, &sc->sc_mutex);
198 	}
199 	mutex_exit(&sc->sc_mutex);
200 
201 	return (rv);
202 }
203 
204 void
205 ldenddetach(struct ld_softc *sc)
206 {
207 	struct dk_softc *dksc = &sc->sc_dksc;
208 	int bmaj, cmaj, i, mn;
209 
210 	if ((sc->sc_flags & LDF_ENABLED) == 0)
211 		return;
212 
213 	mutex_enter(&sc->sc_mutex);
214 
215 	/* Wait for commands queued with the hardware to complete. */
216 	if (sc->sc_queuecnt != 0) {
217 		if (cv_timedwait(&sc->sc_drain, &sc->sc_mutex, 30 * hz))
218 			printf("%s: not drained\n", dksc->sc_xname);
219 	}
220 	mutex_exit(&sc->sc_mutex);
221 
222 	/* Kill off any queued buffers. */
223 	dk_drain(dksc);
224 	bufq_free(dksc->sc_bufq);
225 
226 	/* Locate the major numbers. */
227 	bmaj = bdevsw_lookup_major(&ld_bdevsw);
228 	cmaj = cdevsw_lookup_major(&ld_cdevsw);
229 
230 	/* Nuke the vnodes for any open instances. */
231 	for (i = 0; i < MAXPARTITIONS; i++) {
232 		mn = DISKMINOR(device_unit(dksc->sc_dev), i);
233 		vdevgone(bmaj, mn, mn, VBLK);
234 		vdevgone(cmaj, mn, mn, VCHR);
235 	}
236 
237 	/* Delete all of our wedges. */
238 	dkwedge_delall(&dksc->sc_dkdev);
239 
240 	/* Detach from the disk list. */
241 	disk_detach(&dksc->sc_dkdev);
242 	disk_destroy(&dksc->sc_dkdev);
243 
244 	dk_detach(dksc);
245 
246 	/* Deregister with PMF */
247 	pmf_device_deregister(dksc->sc_dev);
248 
249 	/*
250 	 * XXX We can't really flush the cache here, beceause the
251 	 * XXX device may already be non-existent from the controller's
252 	 * XXX perspective.
253 	 */
254 #if 0
255 	/* Flush the device's cache. */
256 	if (sc->sc_flush != NULL)
257 		if ((*sc->sc_flush)(sc, 0) != 0)
258 			device_printf(dksc->sc_dev, "unable to flush cache\n");
259 #endif
260 	cv_destroy(&sc->sc_drain);
261 	mutex_destroy(&sc->sc_mutex);
262 }
263 
264 /* ARGSUSED */
265 static bool
266 ld_suspend(device_t dev, const pmf_qual_t *qual)
267 {
268 	return ld_shutdown(dev, 0);
269 }
270 
271 /* ARGSUSED */
272 static bool
273 ld_shutdown(device_t dev, int flags)
274 {
275 	struct ld_softc *sc = device_private(dev);
276 	struct dk_softc *dksc = &sc->sc_dksc;
277 
278 	if (sc->sc_flush != NULL && (*sc->sc_flush)(sc, LDFL_POLL) != 0) {
279 		device_printf(dksc->sc_dev, "unable to flush cache\n");
280 		return false;
281 	}
282 
283 	return true;
284 }
285 
286 /* ARGSUSED */
287 static int
288 ldopen(dev_t dev, int flags, int fmt, struct lwp *l)
289 {
290 	struct ld_softc *sc;
291 	struct dk_softc *dksc;
292 	int unit;
293 
294 	unit = DISKUNIT(dev);
295 	if ((sc = device_lookup_private(&ld_cd, unit)) == NULL)
296 		return (ENXIO);
297 	dksc = &sc->sc_dksc;
298 
299 	return dk_open(dksc, dev, flags, fmt, l);
300 }
301 
302 static int
303 ld_lastclose(device_t self)
304 {
305 	struct ld_softc *sc = device_private(self);
306 
307 	if (sc->sc_flush != NULL && (*sc->sc_flush)(sc, 0) != 0)
308 		device_printf(self, "unable to flush cache\n");
309 
310 	return 0;
311 }
312 
313 /* ARGSUSED */
314 static int
315 ldclose(dev_t dev, int flags, int fmt, struct lwp *l)
316 {
317 	struct ld_softc *sc;
318 	struct dk_softc *dksc;
319 	int unit;
320 
321 	unit = DISKUNIT(dev);
322 	sc = device_lookup_private(&ld_cd, unit);
323 	dksc = &sc->sc_dksc;
324 
325 	return dk_close(dksc, dev, flags, fmt, l);
326 }
327 
328 /* ARGSUSED */
329 static int
330 ldread(dev_t dev, struct uio *uio, int ioflag)
331 {
332 
333 	return (physio(ldstrategy, NULL, dev, B_READ, ldminphys, uio));
334 }
335 
336 /* ARGSUSED */
337 static int
338 ldwrite(dev_t dev, struct uio *uio, int ioflag)
339 {
340 
341 	return (physio(ldstrategy, NULL, dev, B_WRITE, ldminphys, uio));
342 }
343 
344 /* ARGSUSED */
345 static int
346 ldioctl(dev_t dev, u_long cmd, void *addr, int32_t flag, struct lwp *l)
347 {
348 	struct ld_softc *sc;
349 	struct dk_softc *dksc;
350 	int unit, error;
351 
352 	unit = DISKUNIT(dev);
353 	sc = device_lookup_private(&ld_cd, unit);
354 	dksc = &sc->sc_dksc;
355 
356 	error = disk_ioctl(&dksc->sc_dkdev, dev, cmd, addr, flag, l);
357 	if (error != EPASSTHROUGH)
358 		return (error);
359 
360 	error = dk_ioctl(dksc, dev, cmd, addr, flag, l);
361 	if (error != EPASSTHROUGH)
362 		return (error);
363 
364 	error = 0;
365 
366 	switch (cmd) {
367 	case DIOCCACHESYNC:
368 		/*
369 		 * XXX Do we really need to care about having a writable
370 		 * file descriptor here?
371 		 */
372 		if ((flag & FWRITE) == 0)
373 			error = EBADF;
374 		else if (sc->sc_flush)
375 			error = (*sc->sc_flush)(sc, 0);
376 		else
377 			error = 0;	/* XXX Error out instead? */
378 		break;
379 	default:
380 		error = ENOTTY;
381 		break;
382 	}
383 
384 	return (error);
385 }
386 
387 static void
388 ldstrategy(struct buf *bp)
389 {
390 	struct ld_softc *sc;
391 	struct dk_softc *dksc;
392 	int unit;
393 
394 	unit = DISKUNIT(bp->b_dev);
395 	sc = device_lookup_private(&ld_cd, unit);
396 	dksc = &sc->sc_dksc;
397 
398 	return dk_strategy(dksc, bp);
399 }
400 
401 static int
402 ld_diskstart(device_t dev, struct buf *bp)
403 {
404 	struct ld_softc *sc = device_private(dev);
405 	int error;
406 
407 	if (sc->sc_queuecnt >= sc->sc_maxqueuecnt)
408 		return EAGAIN;
409 
410 	mutex_enter(&sc->sc_mutex);
411 
412 	if (sc->sc_queuecnt >= sc->sc_maxqueuecnt)
413 		error = EAGAIN;
414 	else {
415 		error = (*sc->sc_start)(sc, bp);
416 		if (error == 0)
417 			sc->sc_queuecnt++;
418 	}
419 
420 	mutex_exit(&sc->sc_mutex);
421 
422 	return error;
423 }
424 
425 void
426 lddone(struct ld_softc *sc, struct buf *bp)
427 {
428 	struct dk_softc *dksc = &sc->sc_dksc;
429 
430 	dk_done(dksc, bp);
431 
432 	mutex_enter(&sc->sc_mutex);
433 	if (--sc->sc_queuecnt <= sc->sc_maxqueuecnt) {
434 		if ((sc->sc_flags & LDF_DRAIN) != 0) {
435 			sc->sc_flags &= ~LDF_DRAIN;
436 			cv_broadcast(&sc->sc_drain);
437 		}
438 		mutex_exit(&sc->sc_mutex);
439 		dk_start(dksc, NULL);
440 	} else
441 		mutex_exit(&sc->sc_mutex);
442 }
443 
444 static int
445 ldsize(dev_t dev)
446 {
447 	struct ld_softc *sc;
448 	struct dk_softc *dksc;
449 	int unit;
450 
451 	unit = DISKUNIT(dev);
452 	if ((sc = device_lookup_private(&ld_cd, unit)) == NULL)
453 		return (ENODEV);
454 	dksc = &sc->sc_dksc;
455 
456 	if ((sc->sc_flags & LDF_ENABLED) == 0)
457 		return (ENODEV);
458 
459 	return dk_size(dksc, dev);
460 }
461 
462 /*
463  * Take a dump.
464  */
465 static int
466 lddump(dev_t dev, daddr_t blkno, void *va, size_t size)
467 {
468 	struct ld_softc *sc;
469 	struct dk_softc *dksc;
470 	int unit;
471 
472 	unit = DISKUNIT(dev);
473 	if ((sc = device_lookup_private(&ld_cd, unit)) == NULL)
474 		return (ENXIO);
475 	dksc = &sc->sc_dksc;
476 
477 	if ((sc->sc_flags & LDF_ENABLED) == 0)
478 		return (ENODEV);
479 
480 	return dk_dump(dksc, dev, blkno, va, size);
481 }
482 
483 static int
484 ld_dumpblocks(device_t dev, void *va, daddr_t blkno, int nblk)
485 {
486 	struct ld_softc *sc = device_private(dev);
487 
488 	if (sc->sc_dump == NULL)
489 		return (ENODEV);
490 
491 	return (*sc->sc_dump)(sc, va, blkno, nblk);
492 }
493 
494 /*
495  * Adjust the size of a transfer.
496  */
497 static void
498 ldminphys(struct buf *bp)
499 {
500 	int unit;
501 	struct ld_softc *sc;
502 
503 	unit = DISKUNIT(bp->b_dev);
504 	sc = device_lookup_private(&ld_cd, unit);
505 
506 	ld_iosize(sc->sc_dv, &bp->b_bcount);
507 	minphys(bp);
508 }
509 
510 static void
511 ld_iosize(device_t d, int *countp)
512 {
513 	struct ld_softc *sc = device_private(d);
514 
515 	if (*countp > sc->sc_maxxfer)
516 		*countp = sc->sc_maxxfer;
517 }
518 
519 static void
520 ld_fake_geometry(struct ld_softc *sc)
521 {
522 	uint64_t ncyl;
523 
524 	if (sc->sc_secperunit <= 528 * 2048)		/* 528MB */
525 		sc->sc_nheads = 16;
526 	else if (sc->sc_secperunit <= 1024 * 2048)	/* 1GB */
527 		sc->sc_nheads = 32;
528 	else if (sc->sc_secperunit <= 21504 * 2048)	/* 21GB */
529 		sc->sc_nheads = 64;
530 	else if (sc->sc_secperunit <= 43008 * 2048)	/* 42GB */
531 		sc->sc_nheads = 128;
532 	else
533 		sc->sc_nheads = 255;
534 
535 	sc->sc_nsectors = 63;
536 	sc->sc_ncylinders = INT_MAX;
537 	ncyl = sc->sc_secperunit /
538 	    (sc->sc_nheads * sc->sc_nsectors);
539 	if (ncyl < INT_MAX)
540 		sc->sc_ncylinders = (int)ncyl;
541 }
542 
543 static void
544 ld_set_geometry(struct ld_softc *sc)
545 {
546 	struct dk_softc *dksc = &sc->sc_dksc;
547 	struct disk_geom *dg = &dksc->sc_dkdev.dk_geom;
548 	char tbuf[9];
549 
550 	format_bytes(tbuf, sizeof(tbuf), sc->sc_secperunit *
551 	    sc->sc_secsize);
552 	aprint_normal_dev(dksc->sc_dev, "%s, %d cyl, %d head, %d sec, "
553 	    "%d bytes/sect x %"PRIu64" sectors\n",
554 	    tbuf, sc->sc_ncylinders, sc->sc_nheads,
555 	    sc->sc_nsectors, sc->sc_secsize, sc->sc_secperunit);
556 
557 	memset(dg, 0, sizeof(*dg));
558 	dg->dg_secperunit = sc->sc_secperunit;
559 	dg->dg_secsize = sc->sc_secsize;
560 	dg->dg_nsectors = sc->sc_nsectors;
561 	dg->dg_ntracks = sc->sc_nheads;
562 	dg->dg_ncylinders = sc->sc_ncylinders;
563 
564 	disk_set_info(dksc->sc_dev, &dksc->sc_dkdev, NULL);
565 }
566 
567 static void
568 ld_config_interrupts(device_t d)
569 {
570 	struct ld_softc *sc = device_private(d);
571 	struct dk_softc *dksc = &sc->sc_dksc;
572 
573 	dkwedge_discover(&dksc->sc_dkdev);
574 }
575 
576 static int
577 ld_discard(device_t dev, off_t pos, off_t len)
578 {
579 	struct ld_softc *sc = device_private(dev);
580 
581 	if (sc->sc_discard == NULL)
582 		return (ENODEV);
583 
584 	return (*sc->sc_discard)(sc, pos, len);
585 }
586 
587 static int
588 lddiscard(dev_t dev, off_t pos, off_t len)
589 {
590 	struct ld_softc *sc;
591 	struct dk_softc *dksc;
592 	int unit;
593 
594 	unit = DISKUNIT(dev);
595 	sc = device_lookup_private(&ld_cd, unit);
596 	dksc = &sc->sc_dksc;
597 
598 	return dk_discard(dksc, dev, pos, len);
599 }
600