1 /* $NetBSD: dksubr.c,v 1.118 2025/02/18 17:09:34 mlelstv Exp $ */
2
3 /*-
4 * Copyright (c) 1996, 1997, 1998, 1999, 2002, 2008 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Jason R. Thorpe and Roland C. Dowdeswell.
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 #include <sys/cdefs.h>
33 __KERNEL_RCSID(0, "$NetBSD: dksubr.c,v 1.118 2025/02/18 17:09:34 mlelstv Exp $");
34
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/stat.h>
38 #include <sys/proc.h>
39 #include <sys/ioctl.h>
40 #include <sys/device.h>
41 #include <sys/disk.h>
42 #include <sys/disklabel.h>
43 #include <sys/buf.h>
44 #include <sys/bufq.h>
45 #include <sys/vnode.h>
46 #include <sys/fcntl.h>
47 #include <sys/namei.h>
48 #include <sys/module.h>
49 #include <sys/syslog.h>
50
51 #include <dev/dkvar.h>
52 #include <miscfs/specfs/specdev.h> /* for v_rdev */
53
54 int dkdebug = 0;
55
56 #ifdef DEBUG
57 #define DKDB_FOLLOW 0x1
58 #define DKDB_INIT 0x2
59 #define DKDB_VNODE 0x4
60 #define DKDB_DUMP 0x8
61
62 #define IFDEBUG(x,y) if (dkdebug & (x)) y
63 #define DPRINTF(x,y) IFDEBUG(x, printf y)
64 #define DPRINTF_FOLLOW(y) DPRINTF(DKDB_FOLLOW, y)
65 #else
66 #define IFDEBUG(x,y)
67 #define DPRINTF(x,y)
68 #define DPRINTF_FOLLOW(y)
69 #endif
70
71 #define DKF_READYFORDUMP (DKF_INITED|DKF_TAKEDUMP)
72
73 static int dk_subr_modcmd(modcmd_t, void *);
74
75 #define DKLABELDEV(dev) \
76 (MAKEDISKDEV(major((dev)), DISKUNIT((dev)), RAW_PART))
77
78 static void dk_makedisklabel(struct dk_softc *);
79 static int dk_translate(struct dk_softc *, struct buf *);
80
81 void
dk_init(struct dk_softc * dksc,device_t dev,int dtype)82 dk_init(struct dk_softc *dksc, device_t dev, int dtype)
83 {
84
85 memset(dksc, 0x0, sizeof(*dksc));
86 dksc->sc_dtype = dtype;
87 dksc->sc_dev = dev;
88
89 strlcpy(dksc->sc_xname, device_xname(dev), DK_XNAME_SIZE);
90 dksc->sc_dkdev.dk_name = dksc->sc_xname;
91 }
92
93 void
dk_attach(struct dk_softc * dksc)94 dk_attach(struct dk_softc *dksc)
95 {
96 KASSERT(dksc->sc_dev != NULL);
97
98 mutex_init(&dksc->sc_iolock, MUTEX_DEFAULT, IPL_VM);
99 dksc->sc_flags |= DKF_READYFORDUMP;
100 #ifdef DIAGNOSTIC
101 dksc->sc_flags |= DKF_WARNLABEL | DKF_LABELSANITY;
102 #endif
103
104 if ((dksc->sc_flags & DKF_NO_RND) == 0) {
105 /* Attach the device into the rnd source list. */
106 rnd_attach_source(&dksc->sc_rnd_source, dksc->sc_xname,
107 RND_TYPE_DISK, RND_FLAG_DEFAULT);
108 }
109 }
110
111 void
dk_detach(struct dk_softc * dksc)112 dk_detach(struct dk_softc *dksc)
113 {
114 if ((dksc->sc_flags & DKF_NO_RND) == 0) {
115 /* Unhook the entropy source. */
116 rnd_detach_source(&dksc->sc_rnd_source);
117 }
118
119 dksc->sc_flags &= ~DKF_READYFORDUMP;
120 mutex_destroy(&dksc->sc_iolock);
121 }
122
123 /* ARGSUSED */
124 int
dk_open(struct dk_softc * dksc,dev_t dev,int flags,int fmt,struct lwp * l)125 dk_open(struct dk_softc *dksc, dev_t dev,
126 int flags, int fmt, struct lwp *l)
127 {
128 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
129 struct disklabel *lp = dksc->sc_dkdev.dk_label;
130 int part = DISKPART(dev);
131 int pmask = 1 << part;
132 int ret = 0;
133 struct disk *dk = &dksc->sc_dkdev;
134
135 DPRINTF_FOLLOW(("%s(%s, %p, 0x%"PRIx64", 0x%x)\n", __func__,
136 dksc->sc_xname, dksc, dev, flags));
137
138 mutex_enter(&dk->dk_openlock);
139
140 /*
141 * If there are wedges, and this is not RAW_PART, then we
142 * need to fail.
143 */
144 if (dk->dk_nwedges != 0 && part != RAW_PART) {
145 ret = EBUSY;
146 goto done;
147 }
148
149 /* If no dkdriver attached, bail */
150 if (dkd == NULL) {
151 ret = ENXIO;
152 goto done;
153 }
154
155 /*
156 * initialize driver for the first opener
157 */
158 if (dk->dk_openmask == 0 && dkd->d_firstopen != NULL) {
159 ret = (*dkd->d_firstopen)(dksc->sc_dev, dev, flags, fmt);
160 if (ret)
161 goto done;
162 }
163
164 /*
165 * If we're init'ed and there are no other open partitions then
166 * update the in-core disklabel.
167 */
168 if ((dksc->sc_flags & DKF_INITED)) {
169 if ((dksc->sc_flags & DKF_VLABEL) == 0) {
170 dksc->sc_flags |= DKF_VLABEL;
171 dk_getdisklabel(dksc, dev);
172 }
173 }
174
175 /* Fail if we can't find the partition. */
176 if (part != RAW_PART &&
177 ((dksc->sc_flags & DKF_VLABEL) == 0 ||
178 part >= lp->d_npartitions ||
179 lp->d_partitions[part].p_fstype == FS_UNUSED)) {
180 ret = ENXIO;
181 goto done;
182 }
183
184 /* Mark our unit as open. */
185 switch (fmt) {
186 case S_IFCHR:
187 dk->dk_copenmask |= pmask;
188 break;
189 case S_IFBLK:
190 dk->dk_bopenmask |= pmask;
191 break;
192 }
193
194 dk->dk_openmask = dk->dk_copenmask | dk->dk_bopenmask;
195
196 done:
197 mutex_exit(&dk->dk_openlock);
198 return ret;
199 }
200
201 /* ARGSUSED */
202 int
dk_close(struct dk_softc * dksc,dev_t dev,int flags,int fmt,struct lwp * l)203 dk_close(struct dk_softc *dksc, dev_t dev,
204 int flags, int fmt, struct lwp *l)
205 {
206 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
207 int part = DISKPART(dev);
208 int pmask = 1 << part;
209 struct disk *dk = &dksc->sc_dkdev;
210
211 DPRINTF_FOLLOW(("%s(%s, %p, 0x%"PRIx64", 0x%x)\n", __func__,
212 dksc->sc_xname, dksc, dev, flags));
213
214 mutex_enter(&dk->dk_openlock);
215
216 switch (fmt) {
217 case S_IFCHR:
218 dk->dk_copenmask &= ~pmask;
219 break;
220 case S_IFBLK:
221 dk->dk_bopenmask &= ~pmask;
222 break;
223 }
224 dk->dk_openmask = dk->dk_copenmask | dk->dk_bopenmask;
225
226 if (dk->dk_openmask == 0) {
227 if (dkd->d_lastclose != NULL)
228 (*dkd->d_lastclose)(dksc->sc_dev);
229 if ((dksc->sc_flags & DKF_KLABEL) == 0)
230 dksc->sc_flags &= ~DKF_VLABEL;
231 }
232
233 mutex_exit(&dk->dk_openlock);
234 return 0;
235 }
236
237 static int
dk_translate(struct dk_softc * dksc,struct buf * bp)238 dk_translate(struct dk_softc *dksc, struct buf *bp)
239 {
240 int part;
241 int wlabel;
242 daddr_t blkno;
243 struct disklabel *lp;
244 struct disk *dk;
245 uint64_t numsecs;
246 unsigned secsize;
247
248 lp = dksc->sc_dkdev.dk_label;
249 dk = &dksc->sc_dkdev;
250
251 part = DISKPART(bp->b_dev);
252 numsecs = dk->dk_geom.dg_secperunit;
253 secsize = dk->dk_geom.dg_secsize;
254
255 /*
256 * The transfer must be a whole number of blocks and the offset must
257 * not be negative.
258 */
259 if ((bp->b_bcount % secsize) != 0 || bp->b_blkno < 0) {
260 bp->b_error = EINVAL;
261 goto done;
262 }
263
264 /* If there is nothing to do, then we are done */
265 if (bp->b_bcount == 0)
266 goto done;
267
268 wlabel = dksc->sc_flags & (DKF_WLABEL|DKF_LABELLING);
269 if (part == RAW_PART) {
270 uint64_t numblocks = btodb(numsecs * secsize);
271 if (bounds_check_with_mediasize(bp, DEV_BSIZE, numblocks) <= 0)
272 goto done;
273 } else {
274 if (bounds_check_with_label(&dksc->sc_dkdev, bp, wlabel) <= 0)
275 goto done;
276 }
277
278 /*
279 * Convert the block number to absolute and put it in terms
280 * of the device's logical block size.
281 */
282 if (secsize >= DEV_BSIZE)
283 blkno = bp->b_blkno / (secsize / DEV_BSIZE);
284 else
285 blkno = bp->b_blkno * (DEV_BSIZE / secsize);
286
287 if (part != RAW_PART)
288 blkno += lp->d_partitions[DISKPART(bp->b_dev)].p_offset;
289 bp->b_rawblkno = blkno;
290
291 return -1;
292
293 done:
294 bp->b_resid = bp->b_bcount;
295 return bp->b_error;
296 }
297
298 static int
dk_strategy1(struct dk_softc * dksc,struct buf * bp)299 dk_strategy1(struct dk_softc *dksc, struct buf *bp)
300 {
301 int error;
302
303 DPRINTF_FOLLOW(("%s(%s, %p, %p)\n", __func__,
304 dksc->sc_xname, dksc, bp));
305
306 if (!(dksc->sc_flags & DKF_INITED)) {
307 DPRINTF_FOLLOW(("%s: not inited\n", __func__));
308 bp->b_error = ENXIO;
309 bp->b_resid = bp->b_bcount;
310 biodone(bp);
311 return 1;
312 }
313
314 error = dk_translate(dksc, bp);
315 if (error >= 0) {
316 biodone(bp);
317 return 1;
318 }
319
320 return 0;
321 }
322
323 void
dk_strategy(struct dk_softc * dksc,struct buf * bp)324 dk_strategy(struct dk_softc *dksc, struct buf *bp)
325 {
326 int error;
327
328 error = dk_strategy1(dksc, bp);
329 if (error)
330 return;
331
332 /*
333 * Queue buffer and start unit
334 */
335 dk_start(dksc, bp);
336 }
337
338 int
dk_strategy_defer(struct dk_softc * dksc,struct buf * bp)339 dk_strategy_defer(struct dk_softc *dksc, struct buf *bp)
340 {
341 int error;
342
343 error = dk_strategy1(dksc, bp);
344 if (error)
345 return error;
346
347 /*
348 * Queue buffer only
349 */
350 mutex_enter(&dksc->sc_iolock);
351 disk_wait(&dksc->sc_dkdev);
352 bufq_put(dksc->sc_bufq, bp);
353 mutex_exit(&dksc->sc_iolock);
354
355 return 0;
356 }
357
358 int
dk_strategy_pending(struct dk_softc * dksc)359 dk_strategy_pending(struct dk_softc *dksc)
360 {
361 struct buf *bp;
362
363 if (!(dksc->sc_flags & DKF_INITED)) {
364 DPRINTF_FOLLOW(("%s: not inited\n", __func__));
365 return 0;
366 }
367
368 mutex_enter(&dksc->sc_iolock);
369 bp = bufq_peek(dksc->sc_bufq);
370 mutex_exit(&dksc->sc_iolock);
371
372 return bp != NULL;
373 }
374
375 void
dk_start(struct dk_softc * dksc,struct buf * bp)376 dk_start(struct dk_softc *dksc, struct buf *bp)
377 {
378 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
379 int error;
380
381 if (!(dksc->sc_flags & DKF_INITED)) {
382 DPRINTF_FOLLOW(("%s: not inited\n", __func__));
383 return;
384 }
385
386 mutex_enter(&dksc->sc_iolock);
387
388 if (bp != NULL) {
389 bp->b_ci = curcpu();
390 disk_wait(&dksc->sc_dkdev);
391 bufq_put(dksc->sc_bufq, bp);
392 }
393
394 /*
395 * If another thread is running the queue, increment
396 * busy counter to 2 so that the queue is retried,
397 * because the driver may now accept additional
398 * requests.
399 */
400 if (dksc->sc_busy < 2)
401 dksc->sc_busy++;
402 if (dksc->sc_busy > 1)
403 goto done;
404
405 /*
406 * Peeking at the buffer queue and committing the operation
407 * only after success isn't atomic.
408 *
409 * So when a diskstart fails, the buffer is saved
410 * and tried again before the next buffer is fetched.
411 * dk_drain() handles flushing of a saved buffer.
412 *
413 * This keeps order of I/O operations, unlike bufq_put.
414 */
415
416 while (dksc->sc_busy > 0) {
417
418 bp = dksc->sc_deferred;
419 dksc->sc_deferred = NULL;
420
421 if (bp == NULL)
422 bp = bufq_get(dksc->sc_bufq);
423
424 while (bp != NULL) {
425
426 disk_busy(&dksc->sc_dkdev);
427 mutex_exit(&dksc->sc_iolock);
428 error = dkd->d_diskstart(dksc->sc_dev, bp);
429 mutex_enter(&dksc->sc_iolock);
430 if (error == EAGAIN || error == ENOMEM) {
431 /*
432 * Not a disk error. Retry later.
433 */
434 KASSERT(dksc->sc_deferred == NULL);
435 dksc->sc_deferred = bp;
436 disk_unbusy(&dksc->sc_dkdev, 0, (bp->b_flags & B_READ));
437 disk_wait(&dksc->sc_dkdev);
438 break;
439 }
440
441 if (error != 0) {
442 bp->b_error = error;
443 bp->b_resid = bp->b_bcount;
444 mutex_exit(&dksc->sc_iolock);
445 dk_done(dksc, bp);
446 mutex_enter(&dksc->sc_iolock);
447 }
448
449 bp = bufq_get(dksc->sc_bufq);
450 }
451
452 dksc->sc_busy--;
453 }
454 done:
455 mutex_exit(&dksc->sc_iolock);
456 }
457
458 void
dk_done(struct dk_softc * dksc,struct buf * bp)459 dk_done(struct dk_softc *dksc, struct buf *bp)
460 {
461 struct disk *dk = &dksc->sc_dkdev;
462
463 if (bp->b_error != 0) {
464 struct cfdriver *cd = device_cfdriver(dksc->sc_dev);
465
466 diskerr(bp, cd->cd_name, "error", LOG_PRINTF, 0,
467 dk->dk_label);
468 printf("\n");
469 }
470
471 mutex_enter(&dksc->sc_iolock);
472 disk_unbusy(dk, bp->b_bcount - bp->b_resid, (bp->b_flags & B_READ));
473 mutex_exit(&dksc->sc_iolock);
474
475 if ((dksc->sc_flags & DKF_NO_RND) == 0)
476 rnd_add_uint32(&dksc->sc_rnd_source, bp->b_rawblkno);
477
478 biodone(bp);
479 }
480
481 void
dk_drain(struct dk_softc * dksc)482 dk_drain(struct dk_softc *dksc)
483 {
484 struct buf *bp;
485
486 mutex_enter(&dksc->sc_iolock);
487 bp = dksc->sc_deferred;
488 dksc->sc_deferred = NULL;
489 if (bp != NULL) {
490 bp->b_error = EIO;
491 bp->b_resid = bp->b_bcount;
492 biodone(bp);
493 }
494 bufq_drain(dksc->sc_bufq);
495 mutex_exit(&dksc->sc_iolock);
496 }
497
498 int
dk_discard(struct dk_softc * dksc,dev_t dev,off_t pos,off_t len)499 dk_discard(struct dk_softc *dksc, dev_t dev, off_t pos, off_t len)
500 {
501 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
502 unsigned secsize = dksc->sc_dkdev.dk_geom.dg_secsize;
503 struct buf tmp, *bp = &tmp;
504 int maxsz;
505 int error = 0;
506
507 KASSERT(len >= 0);
508
509 DPRINTF_FOLLOW(("%s(%s, %p, 0x%"PRIx64", %jd, %jd)\n", __func__,
510 dksc->sc_xname, dksc, dev, (intmax_t)pos, (intmax_t)len));
511
512 if (!(dksc->sc_flags & DKF_INITED)) {
513 DPRINTF_FOLLOW(("%s: not inited\n", __func__));
514 return ENXIO;
515 }
516
517 if (secsize == 0 || (pos % secsize) != 0 || (len % secsize) != 0)
518 return EINVAL;
519
520 /* largest value that b_bcount can store */
521 maxsz = rounddown(INT_MAX, secsize);
522
523 while (len > 0) {
524 /* enough data to please the bounds checking code */
525 bp->b_error = 0;
526 bp->b_dev = dev;
527 bp->b_blkno = (daddr_t)(pos / secsize);
528 bp->b_bcount = lmin(len, maxsz);
529 bp->b_flags = B_WRITE;
530
531 error = dk_translate(dksc, bp);
532 if (error >= 0)
533 break;
534
535 error = dkd->d_discard(dksc->sc_dev,
536 (off_t)bp->b_rawblkno * secsize,
537 (off_t)bp->b_bcount);
538 if (error)
539 break;
540
541 pos += bp->b_bcount;
542 len -= bp->b_bcount;
543 }
544
545 return error;
546 }
547
548 int
dk_size(struct dk_softc * dksc,dev_t dev)549 dk_size(struct dk_softc *dksc, dev_t dev)
550 {
551 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
552 struct disklabel *lp;
553 int is_open;
554 int part;
555 int size;
556
557 if ((dksc->sc_flags & DKF_INITED) == 0)
558 return -1;
559
560 part = DISKPART(dev);
561 is_open = dksc->sc_dkdev.dk_openmask & (1 << part);
562
563 if (!is_open && dkd->d_open(dev, 0, S_IFBLK, curlwp))
564 return -1;
565
566 lp = dksc->sc_dkdev.dk_label;
567 if (lp->d_partitions[part].p_fstype != FS_SWAP)
568 size = -1;
569 else
570 size = lp->d_partitions[part].p_size *
571 (lp->d_secsize / DEV_BSIZE);
572
573 if (!is_open && dkd->d_close(dev, 0, S_IFBLK, curlwp))
574 return -1;
575
576 return size;
577 }
578
579 int
dk_ioctl(struct dk_softc * dksc,dev_t dev,u_long cmd,void * data,int flag,struct lwp * l)580 dk_ioctl(struct dk_softc *dksc, dev_t dev,
581 u_long cmd, void *data, int flag, struct lwp *l)
582 {
583 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
584 struct disklabel *lp;
585 struct disk *dk = &dksc->sc_dkdev;
586 #ifdef __HAVE_OLD_DISKLABEL
587 struct disklabel newlabel;
588 #endif
589 int error;
590
591 DPRINTF_FOLLOW(("%s(%s, %p, 0x%"PRIx64", 0x%lx)\n", __func__,
592 dksc->sc_xname, dksc, dev, cmd));
593
594 /* ensure that the pseudo disk is open for writes for these commands */
595 switch (cmd) {
596 case DIOCSDINFO:
597 case DIOCWDINFO:
598 #ifdef __HAVE_OLD_DISKLABEL
599 case ODIOCSDINFO:
600 case ODIOCWDINFO:
601 #endif
602 case DIOCKLABEL:
603 case DIOCWLABEL:
604 case DIOCAWEDGE:
605 case DIOCDWEDGE:
606 case DIOCSSTRATEGY:
607 if ((flag & FWRITE) == 0)
608 return EBADF;
609 }
610
611 /* ensure that the pseudo-disk is initialized for these */
612 switch (cmd) {
613 case DIOCGDINFO:
614 case DIOCSDINFO:
615 case DIOCWDINFO:
616 case DIOCGPARTINFO:
617 case DIOCKLABEL:
618 case DIOCWLABEL:
619 case DIOCGDEFLABEL:
620 case DIOCAWEDGE:
621 case DIOCDWEDGE:
622 case DIOCLWEDGES:
623 case DIOCMWEDGES:
624 case DIOCRMWEDGES:
625 case DIOCCACHESYNC:
626 #ifdef __HAVE_OLD_DISKLABEL
627 case ODIOCGDINFO:
628 case ODIOCSDINFO:
629 case ODIOCWDINFO:
630 case ODIOCGDEFLABEL:
631 #endif
632 if ((dksc->sc_flags & DKF_INITED) == 0)
633 return ENXIO;
634 }
635
636 error = disk_ioctl(dk, dev, cmd, data, flag, l);
637 if (error != EPASSTHROUGH)
638 return error;
639 else
640 error = 0;
641
642 switch (cmd) {
643 case DIOCWDINFO:
644 case DIOCSDINFO:
645 #ifdef __HAVE_OLD_DISKLABEL
646 case ODIOCWDINFO:
647 case ODIOCSDINFO:
648 #endif
649 #ifdef __HAVE_OLD_DISKLABEL
650 if (cmd == ODIOCSDINFO || cmd == ODIOCWDINFO) {
651 memset(&newlabel, 0, sizeof newlabel);
652 memcpy(&newlabel, data, sizeof (struct olddisklabel));
653 lp = &newlabel;
654 } else
655 #endif
656 lp = (struct disklabel *)data;
657
658 mutex_enter(&dk->dk_openlock);
659 dksc->sc_flags |= DKF_LABELLING;
660
661 error = setdisklabel(dksc->sc_dkdev.dk_label,
662 lp, 0, dksc->sc_dkdev.dk_cpulabel);
663 if (error == 0) {
664 if (cmd == DIOCWDINFO
665 #ifdef __HAVE_OLD_DISKLABEL
666 || cmd == ODIOCWDINFO
667 #endif
668 )
669 error = writedisklabel(DKLABELDEV(dev),
670 dkd->d_strategy, dksc->sc_dkdev.dk_label,
671 dksc->sc_dkdev.dk_cpulabel);
672 }
673
674 dksc->sc_flags &= ~DKF_LABELLING;
675 mutex_exit(&dk->dk_openlock);
676 break;
677
678 case DIOCKLABEL:
679 if (*(int *)data != 0)
680 dksc->sc_flags |= DKF_KLABEL;
681 else
682 dksc->sc_flags &= ~DKF_KLABEL;
683 break;
684
685 case DIOCWLABEL:
686 if (*(int *)data != 0)
687 dksc->sc_flags |= DKF_WLABEL;
688 else
689 dksc->sc_flags &= ~DKF_WLABEL;
690 break;
691
692 case DIOCGDEFLABEL:
693 dk_getdefaultlabel(dksc, (struct disklabel *)data);
694 break;
695
696 #ifdef __HAVE_OLD_DISKLABEL
697 case ODIOCGDEFLABEL:
698 dk_getdefaultlabel(dksc, &newlabel);
699 if (newlabel.d_npartitions > OLDMAXPARTITIONS)
700 return ENOTTY;
701 memcpy(data, &newlabel, sizeof (struct olddisklabel));
702 break;
703 #endif
704
705 case DIOCGSTRATEGY:
706 {
707 struct disk_strategy *dks = (void *)data;
708
709 mutex_enter(&dksc->sc_iolock);
710 if (dksc->sc_bufq != NULL)
711 strlcpy(dks->dks_name,
712 bufq_getstrategyname(dksc->sc_bufq),
713 sizeof(dks->dks_name));
714 else
715 error = EINVAL;
716 mutex_exit(&dksc->sc_iolock);
717 dks->dks_paramlen = 0;
718 break;
719 }
720
721 case DIOCSSTRATEGY:
722 {
723 struct disk_strategy *dks = (void *)data;
724 struct bufq_state *new;
725 struct bufq_state *old;
726
727 if (dks->dks_param != NULL) {
728 return EINVAL;
729 }
730 dks->dks_name[sizeof(dks->dks_name) - 1] = 0; /* ensure term */
731 error = bufq_alloc(&new, dks->dks_name,
732 BUFQ_EXACT|BUFQ_SORT_RAWBLOCK);
733 if (error) {
734 return error;
735 }
736 mutex_enter(&dksc->sc_iolock);
737 old = dksc->sc_bufq;
738 if (old)
739 bufq_move(new, old);
740 dksc->sc_bufq = new;
741 mutex_exit(&dksc->sc_iolock);
742 if (old)
743 bufq_free(old);
744 break;
745 }
746
747 default:
748 error = ENOTTY;
749 }
750
751 return error;
752 }
753
754 /*
755 * dk_dump dumps all of physical memory into the partition specified.
756 * This requires substantially more framework than {s,w}ddump, and hence
757 * is probably much more fragile.
758 *
759 */
760
761 #define DKFF_READYFORDUMP(x) (((x) & DKF_READYFORDUMP) == DKF_READYFORDUMP)
762 static volatile int dk_dumping = 0;
763
764 /* ARGSUSED */
765 int
dk_dump(struct dk_softc * dksc,dev_t dev,daddr_t blkno,void * vav,size_t size,int flags)766 dk_dump(struct dk_softc *dksc, dev_t dev,
767 daddr_t blkno, void *vav, size_t size, int flags)
768 {
769 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
770 struct disk_geom *dg = &dksc->sc_dkdev.dk_geom;
771 char *va = vav;
772 struct disklabel *lp;
773 struct partition *p;
774 int part, towrt, maxblkcnt, nblk;
775 int maxxfer, rv = 0;
776
777 /*
778 * ensure that we consider this device to be safe for dumping,
779 * and that the device is configured.
780 */
781 if (!DKFF_READYFORDUMP(dksc->sc_flags)) {
782 DPRINTF(DKDB_DUMP, ("%s: bad dump flags 0x%x\n", __func__,
783 dksc->sc_flags));
784 return ENXIO;
785 }
786
787 /* ensure that we are not already dumping */
788 if (dk_dumping)
789 return EFAULT;
790 if ((flags & DK_DUMP_RECURSIVE) == 0)
791 dk_dumping = 1;
792
793 if (dkd->d_dumpblocks == NULL) {
794 DPRINTF(DKDB_DUMP, ("%s: no dumpblocks\n", __func__));
795 return ENXIO;
796 }
797
798 /* device specific max transfer size */
799 maxxfer = MAXPHYS;
800 if (dkd->d_iosize != NULL)
801 (*dkd->d_iosize)(dksc->sc_dev, &maxxfer);
802
803 /* Convert to disk sectors. Request must be a multiple of size. */
804 part = DISKPART(dev);
805 lp = dksc->sc_dkdev.dk_label;
806 if ((size % lp->d_secsize) != 0) {
807 DPRINTF(DKDB_DUMP, ("%s: odd size %zu\n", __func__, size));
808 return EFAULT;
809 }
810 towrt = size / lp->d_secsize;
811 blkno = dbtob(blkno) / lp->d_secsize; /* blkno in secsize units */
812
813 p = &lp->d_partitions[part];
814 if (part == RAW_PART) {
815 if (p->p_fstype != FS_UNUSED) {
816 DPRINTF(DKDB_DUMP, ("%s: bad fstype %d\n", __func__,
817 p->p_fstype));
818 return ENXIO;
819 }
820 /* Check whether dump goes to a wedge */
821 if (dksc->sc_dkdev.dk_nwedges == 0) {
822 DPRINTF(DKDB_DUMP, ("%s: dump to raw\n", __func__));
823 return ENXIO;
824 }
825 /* Check transfer bounds against media size */
826 if (blkno < 0 || (blkno + towrt) > dg->dg_secperunit) {
827 DPRINTF(DKDB_DUMP, ("%s: out of bounds blkno=%jd, towrt=%d, "
828 "nsects=%jd\n", __func__, (intmax_t)blkno, towrt, dg->dg_secperunit));
829 return EINVAL;
830 }
831 } else {
832 int nsects, sectoff;
833
834 if (p->p_fstype != FS_SWAP && p->p_fstype != FS_RAID) {
835 DPRINTF(DKDB_DUMP, ("%s: bad fstype %d\n", __func__,
836 p->p_fstype));
837 return ENXIO;
838 }
839 nsects = p->p_size;
840 sectoff = p->p_offset;
841
842 /* Check transfer bounds against partition size. */
843 if ((blkno < 0) || ((blkno + towrt) > nsects)) {
844 DPRINTF(DKDB_DUMP, ("%s: out of bounds blkno=%jd, towrt=%d, "
845 "nsects=%d\n", __func__, (intmax_t)blkno, towrt, nsects));
846 return EINVAL;
847 }
848
849 /* Offset block number to start of partition. */
850 blkno += sectoff;
851 }
852
853 /* Start dumping and return when done. */
854 maxblkcnt = howmany(maxxfer, lp->d_secsize);
855 while (towrt > 0) {
856 nblk = uimin(maxblkcnt, towrt);
857
858 if ((rv = (*dkd->d_dumpblocks)(dksc->sc_dev, va, blkno, nblk))
859 != 0) {
860 DPRINTF(DKDB_DUMP, ("%s: dumpblocks %d\n", __func__,
861 rv));
862 return rv;
863 }
864
865 towrt -= nblk;
866 blkno += nblk;
867 va += nblk * lp->d_secsize;
868 }
869
870 if ((flags & DK_DUMP_RECURSIVE) == 0)
871 dk_dumping = 0;
872
873 return 0;
874 }
875
876 /* ARGSUSED */
877 void
dk_getdefaultlabel(struct dk_softc * dksc,struct disklabel * lp)878 dk_getdefaultlabel(struct dk_softc *dksc, struct disklabel *lp)
879 {
880 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
881 struct disk_geom *dg = &dksc->sc_dkdev.dk_geom;
882
883 memset(lp, 0, sizeof(*lp));
884
885 if (dg->dg_secperunit > UINT32_MAX)
886 lp->d_secperunit = UINT32_MAX;
887 else
888 lp->d_secperunit = dg->dg_secperunit;
889 lp->d_secsize = dg->dg_secsize;
890 lp->d_nsectors = dg->dg_nsectors;
891 lp->d_ntracks = dg->dg_ntracks;
892 lp->d_ncylinders = dg->dg_ncylinders;
893 lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
894
895 strlcpy(lp->d_typename, dksc->sc_xname, sizeof(lp->d_typename));
896 lp->d_type = dksc->sc_dtype;
897 strlcpy(lp->d_packname, "fictitious", sizeof(lp->d_packname));
898 lp->d_rpm = 3600;
899 lp->d_interleave = 1;
900 lp->d_flags = 0;
901
902 lp->d_partitions[RAW_PART].p_offset = 0;
903 lp->d_partitions[RAW_PART].p_size = lp->d_secperunit;
904 lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED;
905 lp->d_npartitions = RAW_PART + 1;
906
907 lp->d_magic = DISKMAGIC;
908 lp->d_magic2 = DISKMAGIC;
909
910 if (dkd->d_label)
911 dkd->d_label(dksc->sc_dev, lp);
912
913 lp->d_checksum = dkcksum(lp);
914 }
915
916 /* ARGSUSED */
917 void
dk_getdisklabel(struct dk_softc * dksc,dev_t dev)918 dk_getdisklabel(struct dk_softc *dksc, dev_t dev)
919 {
920 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
921 struct disklabel *lp = dksc->sc_dkdev.dk_label;
922 struct cpu_disklabel *clp = dksc->sc_dkdev.dk_cpulabel;
923 struct disk_geom *dg = &dksc->sc_dkdev.dk_geom;
924 struct partition *pp;
925 int i, lpratio, dgratio;
926 const char *errstring;
927
928 memset(clp, 0x0, sizeof(*clp));
929 dk_getdefaultlabel(dksc, lp);
930 errstring = readdisklabel(DKLABELDEV(dev), dkd->d_strategy,
931 dksc->sc_dkdev.dk_label, dksc->sc_dkdev.dk_cpulabel);
932 if (errstring) {
933 dk_makedisklabel(dksc);
934 if (dksc->sc_flags & DKF_WARNLABEL)
935 printf("%s: %s\n", dksc->sc_xname, errstring);
936 return;
937 }
938
939 if ((dksc->sc_flags & DKF_LABELSANITY) == 0)
940 return;
941
942 /* Convert sector counts to multiple of DEV_BSIZE for comparison */
943 lpratio = dgratio = 1;
944 if (lp->d_secsize > DEV_BSIZE)
945 lpratio = lp->d_secsize / DEV_BSIZE;
946 if (dg->dg_secsize > DEV_BSIZE)
947 dgratio = dg->dg_secsize / DEV_BSIZE;
948
949 /* Sanity check */
950 if ((uint64_t)lp->d_secperunit * lpratio > dg->dg_secperunit * dgratio)
951 printf("WARNING: %s: "
952 "total unit size in disklabel (%" PRIu64 ") "
953 "!= the size of %s (%" PRIu64 ")\n", dksc->sc_xname,
954 (uint64_t)lp->d_secperunit * lpratio, dksc->sc_xname,
955 dg->dg_secperunit * dgratio);
956 else if (lp->d_secperunit < UINT32_MAX &&
957 (uint64_t)lp->d_secperunit * lpratio < dg->dg_secperunit * dgratio)
958 printf("%s: %" PRIu64 " trailing sectors not covered"
959 " by disklabel\n", dksc->sc_xname,
960 (dg->dg_secperunit * dgratio)
961 - (lp->d_secperunit * lpratio));
962
963 for (i=0; i < lp->d_npartitions; i++) {
964 uint64_t pend;
965
966 pp = &lp->d_partitions[i];
967 pend = pp->p_offset + pp->p_size;
968 if (pend * lpratio > dg->dg_secperunit * dgratio)
969 printf("WARNING: %s: end of partition `%c' exceeds "
970 "the size of %s (%" PRIu64 ")\n", dksc->sc_xname,
971 'a' + i, dksc->sc_xname,
972 dg->dg_secperunit * dgratio);
973 }
974 }
975
976 /*
977 * Heuristic to conjure a disklabel if reading a disklabel failed.
978 *
979 * This is to allow the raw partition to be used for a filesystem
980 * without caring about the write protected label sector.
981 *
982 * If the driver provides it's own callback, use that instead.
983 */
984 /* ARGSUSED */
985 static void
dk_makedisklabel(struct dk_softc * dksc)986 dk_makedisklabel(struct dk_softc *dksc)
987 {
988 const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
989 struct disklabel *lp = dksc->sc_dkdev.dk_label;
990
991 strlcpy(lp->d_packname, "default label", sizeof(lp->d_packname));
992
993 if (dkd->d_label)
994 dkd->d_label(dksc->sc_dev, lp);
995 else
996 lp->d_partitions[RAW_PART].p_fstype = FS_BSDFFS;
997
998 lp->d_checksum = dkcksum(lp);
999 }
1000
1001 MODULE(MODULE_CLASS_MISC, dk_subr, NULL);
1002
1003 static int
dk_subr_modcmd(modcmd_t cmd,void * arg)1004 dk_subr_modcmd(modcmd_t cmd, void *arg)
1005 {
1006 switch (cmd) {
1007 case MODULE_CMD_INIT:
1008 case MODULE_CMD_FINI:
1009 return 0;
1010 case MODULE_CMD_STAT:
1011 case MODULE_CMD_AUTOUNLOAD:
1012 default:
1013 return ENOTTY;
1014 }
1015 }
1016