1 /* $NetBSD: subr_disk.c,v 1.138 2025/04/13 14:00:59 jakllsch Exp $ */
2
3 /*-
4 * Copyright (c) 1996, 1997, 1999, 2000, 2009 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 of the Numerical Aerospace Simulation Facility,
9 * NASA Ames Research Center.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 /*
34 * Copyright (c) 1982, 1986, 1988, 1993
35 * The Regents of the University of California. All rights reserved.
36 * (c) UNIX System Laboratories, Inc.
37 * All or some portions of this file are derived from material licensed
38 * to the University of California by American Telephone and Telegraph
39 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
40 * the permission of UNIX System Laboratories, Inc.
41 *
42 * Redistribution and use in source and binary forms, with or without
43 * modification, are permitted provided that the following conditions
44 * are met:
45 * 1. Redistributions of source code must retain the above copyright
46 * notice, this list of conditions and the following disclaimer.
47 * 2. Redistributions in binary form must reproduce the above copyright
48 * notice, this list of conditions and the following disclaimer in the
49 * documentation and/or other materials provided with the distribution.
50 * 3. Neither the name of the University nor the names of its contributors
51 * may be used to endorse or promote products derived from this software
52 * without specific prior written permission.
53 *
54 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
55 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
56 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
57 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
58 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
59 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
60 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
61 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
62 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
63 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
64 * SUCH DAMAGE.
65 *
66 * @(#)ufs_disksubr.c 8.5 (Berkeley) 1/21/94
67 */
68
69 #include <sys/cdefs.h>
70 __KERNEL_RCSID(0, "$NetBSD: subr_disk.c,v 1.138 2025/04/13 14:00:59 jakllsch Exp $");
71
72 #include <sys/param.h>
73 #include <sys/kernel.h>
74 #include <sys/kmem.h>
75 #include <sys/buf.h>
76 #include <sys/fcntl.h>
77 #include <sys/syslog.h>
78 #include <sys/disklabel.h>
79 #include <sys/disk.h>
80 #include <sys/sysctl.h>
81 #include <lib/libkern/libkern.h>
82
83 /*
84 * Disk error is the preface to plaintive error messages
85 * about failing disk transfers. It prints messages of the form
86
87 hp0g: hard error reading fsbn 12345 of 12344-12347 (hp0 bn %d cn %d tn %d sn %d)
88
89 * if the offset of the error in the transfer and a disk label
90 * are both available. blkdone should be -1 if the position of the error
91 * is unknown; the disklabel pointer may be null from drivers that have not
92 * been converted to use them. The message is printed with printf
93 * if pri is LOG_PRINTF, otherwise it uses log at the specified priority.
94 * The message should be completed (with at least a newline) with printf
95 * or addlog, respectively. There is no trailing space.
96 */
97 #ifndef PRIdaddr
98 #define PRIdaddr PRId64
99 #endif
100 void
diskerr(const struct buf * bp,const char * dname,const char * what,int pri,int blkdone,const struct disklabel * lp)101 diskerr(const struct buf *bp, const char *dname, const char *what, int pri,
102 int blkdone, const struct disklabel *lp)
103 {
104 int unit = DISKUNIT(bp->b_dev), part = DISKPART(bp->b_dev);
105 void (*pr)(const char *, ...) __printflike(1, 2);
106 char partname = 'a' + part;
107 daddr_t sn;
108
109 if (/*CONSTCOND*/0)
110 /* Compiler will error this if the format is wrong... */
111 printf("%" PRIdaddr, bp->b_blkno);
112
113 if (pri != LOG_PRINTF) {
114 static const char fmt[] = "";
115 log(pri, fmt);
116 pr = addlog;
117 } else
118 pr = printf;
119 (*pr)("%s%d%c: %s %sing fsbn ", dname, unit, partname, what,
120 bp->b_flags & B_READ ? "read" : "writ");
121 sn = bp->b_blkno;
122 if (bp->b_bcount <= DEV_BSIZE)
123 (*pr)("%" PRIdaddr, sn);
124 else {
125 if (blkdone >= 0) {
126 sn += blkdone;
127 (*pr)("%" PRIdaddr " of ", sn);
128 }
129 (*pr)("%" PRIdaddr "-%" PRIdaddr "", bp->b_blkno,
130 bp->b_blkno + (bp->b_bcount - 1) / DEV_BSIZE);
131 }
132 if (lp && (blkdone >= 0 || bp->b_bcount <= lp->d_secsize)) {
133 sn += lp->d_partitions[part].p_offset;
134 (*pr)(" (%s%d bn %" PRIdaddr "; cn %" PRIdaddr "",
135 dname, unit, sn, sn / lp->d_secpercyl);
136 sn %= lp->d_secpercyl;
137 (*pr)(" tn %" PRIdaddr " sn %" PRIdaddr ")",
138 sn / lp->d_nsectors, sn % lp->d_nsectors);
139 }
140 }
141
142 /*
143 * Searches the iostatlist for the disk corresponding to the
144 * name provided.
145 */
146 struct disk *
disk_find(const char * name)147 disk_find(const char *name)
148 {
149 struct io_stats *stat;
150
151 stat = iostat_find(name);
152
153 if ((stat != NULL) && (stat->io_type == IOSTAT_DISK))
154 return stat->io_parent;
155
156 return (NULL);
157 }
158
159 void
disk_init(struct disk * diskp,const char * name,const struct dkdriver * driver)160 disk_init(struct disk *diskp, const char *name, const struct dkdriver *driver)
161 {
162 u_int blocksize = DEV_BSIZE;
163
164 /*
165 * Initialize the wedge-related locks and other fields.
166 */
167 mutex_init(&diskp->dk_rawlock, MUTEX_DEFAULT, IPL_NONE);
168 mutex_init(&diskp->dk_openlock, MUTEX_DEFAULT, IPL_NONE);
169 LIST_INIT(&diskp->dk_wedges);
170 diskp->dk_nwedges = 0;
171 diskp->dk_labelsector = LABELSECTOR;
172 diskp->dk_blkshift = DK_BSIZE2BLKSHIFT(blocksize);
173 diskp->dk_byteshift = DK_BSIZE2BYTESHIFT(blocksize);
174 diskp->dk_name = name;
175 diskp->dk_driver = driver;
176 }
177
178 /*
179 * Rename a disk.
180 */
181 void
disk_rename(struct disk * diskp,const char * name)182 disk_rename(struct disk *diskp, const char *name)
183 {
184
185 diskp->dk_name = name;
186 iostat_rename(diskp->dk_stats, diskp->dk_name);
187 }
188
189 /*
190 * Attach a disk.
191 */
192 void
disk_attach(struct disk * diskp)193 disk_attach(struct disk *diskp)
194 {
195
196 /*
197 * Allocate and initialize the disklabel structures.
198 */
199 diskp->dk_label = kmem_zalloc(sizeof(struct disklabel), KM_SLEEP);
200 diskp->dk_cpulabel = kmem_zalloc(sizeof(struct cpu_disklabel),
201 KM_SLEEP);
202
203 /*
204 * Set up the stats collection.
205 */
206 diskp->dk_stats = iostat_alloc(IOSTAT_DISK, diskp, diskp->dk_name);
207 }
208
209 int
disk_begindetach(struct disk * dk,int (* lastclose)(device_t),device_t self,int flags)210 disk_begindetach(struct disk *dk, int (*lastclose)(device_t),
211 device_t self, int flags)
212 {
213 int rc;
214
215 rc = 0;
216 mutex_enter(&dk->dk_openlock);
217 if (dk->dk_openmask == 0)
218 ; /* nothing to do */
219 else if ((flags & DETACH_FORCE) == 0)
220 rc = EBUSY;
221 else if (lastclose != NULL)
222 rc = (*lastclose)(self);
223 mutex_exit(&dk->dk_openlock);
224
225 return rc;
226 }
227
228 /*
229 * Detach a disk.
230 */
231 void
disk_detach(struct disk * diskp)232 disk_detach(struct disk *diskp)
233 {
234
235 /*
236 * Remove from the drivelist.
237 */
238 iostat_free(diskp->dk_stats);
239
240 /*
241 * Release the disk-info dictionary.
242 */
243 if (diskp->dk_info) {
244 prop_object_release(diskp->dk_info);
245 diskp->dk_info = NULL;
246 }
247
248 /*
249 * Free the space used by the disklabel structures.
250 */
251 kmem_free(diskp->dk_label, sizeof(*diskp->dk_label));
252 kmem_free(diskp->dk_cpulabel, sizeof(*diskp->dk_cpulabel));
253 }
254
255 void
disk_destroy(struct disk * diskp)256 disk_destroy(struct disk *diskp)
257 {
258
259 mutex_destroy(&diskp->dk_openlock);
260 mutex_destroy(&diskp->dk_rawlock);
261 }
262
263 /*
264 * Mark the disk as having work queued for metrics collection.
265 */
266 void
disk_wait(struct disk * diskp)267 disk_wait(struct disk *diskp)
268 {
269
270 iostat_wait(diskp->dk_stats);
271 }
272
273 /*
274 * Mark the disk as busy for metrics collection.
275 */
276 void
disk_busy(struct disk * diskp)277 disk_busy(struct disk *diskp)
278 {
279
280 iostat_busy(diskp->dk_stats);
281 }
282
283 /*
284 * Finished disk operations, gather metrics.
285 */
286 void
disk_unbusy(struct disk * diskp,long bcount,int read)287 disk_unbusy(struct disk *diskp, long bcount, int read)
288 {
289
290 iostat_unbusy(diskp->dk_stats, bcount, read);
291 }
292
293 /*
294 * Return true if disk has an I/O operation in flight.
295 */
296 bool
disk_isbusy(struct disk * diskp)297 disk_isbusy(struct disk *diskp)
298 {
299
300 return iostat_isbusy(diskp->dk_stats);
301 }
302
303 /*
304 * Bounds checking against the media size, used for the raw partition.
305 * secsize, mediasize and b_blkno must all be the same units.
306 * Possibly this has to be DEV_BSIZE (512).
307 */
308 int
bounds_check_with_mediasize(struct buf * bp,int secsize,uint64_t mediasize)309 bounds_check_with_mediasize(struct buf *bp, int secsize, uint64_t mediasize)
310 {
311 int64_t sz;
312
313 if (bp->b_blkno < 0) {
314 /* Reject negative offsets immediately. */
315 bp->b_error = EINVAL;
316 return 0;
317 }
318
319 sz = howmany((int64_t)bp->b_bcount, secsize);
320
321 /*
322 * bp->b_bcount is a 32-bit value, and we rejected a negative
323 * bp->b_blkno already, so "bp->b_blkno + sz" cannot overflow.
324 */
325
326 if (bp->b_blkno + sz > mediasize) {
327 sz = mediasize - bp->b_blkno;
328 if (sz == 0) {
329 /* If exactly at end of disk, return EOF. */
330 bp->b_resid = bp->b_bcount;
331 return 0;
332 }
333 if (sz < 0) {
334 /* If past end of disk, return EINVAL. */
335 bp->b_error = EINVAL;
336 return 0;
337 }
338 /* Otherwise, truncate request. */
339 bp->b_bcount = sz * secsize;
340 }
341
342 return 1;
343 }
344
345 /*
346 * Determine the size of the transfer, and make sure it is
347 * within the boundaries of the partition. Adjust transfer
348 * if needed, and signal errors or early completion.
349 */
350 int
bounds_check_with_label(struct disk * dk,struct buf * bp,int wlabel)351 bounds_check_with_label(struct disk *dk, struct buf *bp, int wlabel)
352 {
353 struct disklabel *lp = dk->dk_label;
354 struct partition *p = lp->d_partitions + DISKPART(bp->b_dev);
355 uint64_t p_size, p_offset, labelsector;
356 int64_t sz;
357
358 if (bp->b_blkno < 0) {
359 /* Reject negative offsets immediately. */
360 bp->b_error = EINVAL;
361 return -1;
362 }
363
364 /* Protect against division by zero. XXX: Should never happen?!?! */
365 if ((lp->d_secsize / DEV_BSIZE) == 0 || lp->d_secpercyl == 0) {
366 bp->b_error = EINVAL;
367 return -1;
368 }
369
370 p_size = (uint64_t)p->p_size << dk->dk_blkshift;
371 p_offset = (uint64_t)p->p_offset << dk->dk_blkshift;
372 #if RAW_PART == 3
373 labelsector = lp->d_partitions[2].p_offset;
374 #else
375 labelsector = lp->d_partitions[RAW_PART].p_offset;
376 #endif
377 labelsector = (labelsector + dk->dk_labelsector) << dk->dk_blkshift;
378
379 sz = howmany((int64_t)bp->b_bcount, DEV_BSIZE);
380
381 /*
382 * bp->b_bcount is a 32-bit value, and we rejected a negative
383 * bp->b_blkno already, so "bp->b_blkno + sz" cannot overflow.
384 */
385
386 if (bp->b_blkno + sz > p_size) {
387 sz = p_size - bp->b_blkno;
388 if (sz == 0) {
389 /* If exactly at end of disk, return EOF. */
390 bp->b_resid = bp->b_bcount;
391 return 0;
392 }
393 if (sz < 0) {
394 /* If past end of disk, return EINVAL. */
395 bp->b_error = EINVAL;
396 return -1;
397 }
398 /* Otherwise, truncate request. */
399 bp->b_bcount = sz << DEV_BSHIFT;
400 }
401
402 /* Overwriting disk label? */
403 if (bp->b_blkno + p_offset <= labelsector &&
404 bp->b_blkno + p_offset + sz > labelsector &&
405 (bp->b_flags & B_READ) == 0 && !wlabel) {
406 bp->b_error = EROFS;
407 return -1;
408 }
409
410 /* calculate cylinder for disksort to order transfers with */
411 bp->b_cylinder = (bp->b_blkno + p->p_offset) /
412 (lp->d_secsize / DEV_BSIZE) / lp->d_secpercyl;
413 return 1;
414 }
415
416 int
disk_read_sectors(void (* strat)(struct buf *),const struct disklabel * lp,struct buf * bp,unsigned int sector,int count)417 disk_read_sectors(void (*strat)(struct buf *), const struct disklabel *lp,
418 struct buf *bp, unsigned int sector, int count)
419 {
420
421 if ((lp->d_secsize / DEV_BSIZE) == 0 || lp->d_secpercyl == 0)
422 return EINVAL;
423
424 bp->b_blkno = btodb((off_t)sector * lp->d_secsize);
425 bp->b_bcount = count * lp->d_secsize;
426 bp->b_flags = (bp->b_flags & ~B_WRITE) | B_READ;
427 bp->b_oflags &= ~BO_DONE;
428 bp->b_cylinder = sector / lp->d_secpercyl;
429 (*strat)(bp);
430 return biowait(bp);
431 }
432
433 const char *
convertdisklabel(struct disklabel * lp,void (* strat)(struct buf *),struct buf * bp,uint32_t secperunit)434 convertdisklabel(struct disklabel *lp, void (*strat)(struct buf *),
435 struct buf *bp, uint32_t secperunit)
436 {
437 struct partition rp, *altp, *p;
438 int geom_ok;
439 const char *str;
440
441 memset(&rp, 0, sizeof(rp));
442 rp.p_size = secperunit;
443 rp.p_fstype = FS_UNUSED;
444
445 /* If we can seek to d_secperunit - 1, believe the disk geometry. */
446 if (secperunit != 0 &&
447 disk_read_sectors(strat, lp, bp, secperunit - 1, 1) == 0)
448 geom_ok = 1;
449 else
450 geom_ok = 0;
451
452 #if 0
453 printf("%s: secperunit (%" PRIu32 ") %s\n", __func__,
454 secperunit, geom_ok ? "ok" : "not ok");
455 #endif
456
457 p = &lp->d_partitions[RAW_PART];
458 if (RAW_PART == 'c' - 'a')
459 altp = &lp->d_partitions['d' - 'a'];
460 else
461 altp = &lp->d_partitions['c' - 'a'];
462
463 if (lp->d_npartitions > RAW_PART && p->p_offset == 0 && p->p_size != 0)
464 return NULL; /* already a raw partition */
465 else if (lp->d_npartitions > MAX('c', 'd') - 'a' &&
466 altp->p_offset == 0 && altp->p_size != 0) {
467 /* alternate partition ('c' or 'd') is suitable for raw slot,
468 * swap with 'd' or 'c'.
469 */
470 rp = *p;
471 *p = *altp;
472 *altp = rp;
473 return NULL;
474 } else if (lp->d_npartitions <= RAW_PART &&
475 lp->d_npartitions > 'c' - 'a') {
476 /* No raw partition is present, but the alternate is present.
477 * Copy alternate to raw partition.
478 */
479 lp->d_npartitions = RAW_PART + 1;
480 *p = *altp;
481 return NULL;
482 } else if (!geom_ok)
483 str = "no raw partition and disk reports bad geometry";
484 else if (lp->d_npartitions <= RAW_PART) {
485 memset(&lp->d_partitions[lp->d_npartitions], 0,
486 sizeof(struct partition) * (RAW_PART - lp->d_npartitions));
487 *p = rp;
488 lp->d_npartitions = RAW_PART + 1;
489 return NULL;
490 } else if (lp->d_npartitions < MAXPARTITIONS) {
491 memmove(p + 1, p,
492 sizeof(struct partition) * (lp->d_npartitions - RAW_PART));
493 *p = rp;
494 lp->d_npartitions++;
495 return NULL;
496 } else
497 str = "no raw partition and partition table is full";
498 #ifdef DIAGNOSTIC
499 printf("Bad partition: %s\n", str);
500 printf("type = %u, subtype = %u, typename = %s\n",
501 lp->d_type, lp->d_subtype, lp->d_typename);
502 printf("secsize = %u, nsectors = %u, ntracks = %u\n",
503 lp->d_secsize, lp->d_nsectors, lp->d_ntracks);
504 printf("ncylinders = %u, secpercyl = %u, secperunit = %u\n",
505 lp->d_ncylinders, lp->d_secpercyl, lp->d_secperunit);
506 printf("npartitions = %u\n", lp->d_npartitions);
507
508 for (size_t i = 0; i < MIN(lp->d_npartitions, MAXPARTITIONS); i++) {
509 p = &lp->d_partitions[i];
510 printf("\t%c: offset = %u size = %u fstype = %u\n",
511 (char)(i + 'a'), p->p_offset, p->p_size, p->p_fstype);
512 }
513 #endif
514 return str;
515 }
516
517 /*
518 * disk_ioctl --
519 * Generic disk ioctl handling.
520 */
521 int
disk_ioctl(struct disk * dk,dev_t dev,u_long cmd,void * data,int flag,struct lwp * l)522 disk_ioctl(struct disk *dk, dev_t dev, u_long cmd, void *data, int flag,
523 struct lwp *l)
524 {
525 struct dkwedge_info *dkw;
526 struct partinfo *pi;
527 struct partition *dp;
528 #ifdef __HAVE_OLD_DISKLABEL
529 struct disklabel newlabel;
530 #endif
531
532 switch (cmd) {
533 case DIOCGDISKINFO: {
534 prop_dictionary_t disk_info;
535 int error;
536
537 mutex_enter(&dk->dk_openlock);
538 if ((disk_info = dk->dk_info) == NULL) {
539 error = ENOTSUP;
540 } else {
541 prop_object_retain(disk_info);
542 error = 0;
543 }
544 mutex_exit(&dk->dk_openlock);
545 if (error)
546 return error;
547
548 error = prop_dictionary_copyout_ioctl(data, cmd, disk_info);
549 prop_object_release(disk_info);
550 return error;
551 }
552 case DIOCGSECTORSIZE:
553 *(u_int *)data = dk->dk_geom.dg_secsize;
554 return 0;
555
556 case DIOCGMEDIASIZE:
557 *(off_t *)data = (off_t)dk->dk_geom.dg_secsize *
558 dk->dk_geom.dg_secperunit;
559 return 0;
560 default:
561 break;
562 }
563
564 if (dev == NODEV)
565 return EPASSTHROUGH;
566
567 /* The following should be moved to dk_ioctl */
568 switch (cmd) {
569 case DIOCGDINFO:
570 if (dk->dk_label == NULL)
571 return EBUSY;
572 memcpy(data, dk->dk_label, sizeof (*dk->dk_label));
573 return 0;
574
575 #ifdef __HAVE_OLD_DISKLABEL
576 case ODIOCGDINFO:
577 if (dk->dk_label == NULL)
578 return EBUSY;
579 memcpy(&newlabel, dk->dk_label, sizeof(newlabel));
580 if (newlabel.d_npartitions > OLDMAXPARTITIONS)
581 return ENOTTY;
582 memcpy(data, &newlabel, sizeof(struct olddisklabel));
583 return 0;
584 #endif
585
586 case DIOCGPARTINFO:
587 pi = data;
588 memset(pi, 0, sizeof(*pi));
589 pi->pi_secsize = dk->dk_geom.dg_secsize;
590 pi->pi_bsize = MAX(BLKDEV_IOSIZE, pi->pi_secsize);
591
592 if (DISKPART(dev) == RAW_PART) {
593 pi->pi_size = dk->dk_geom.dg_secperunit;
594 return 0;
595 }
596
597 if (dk->dk_label == NULL)
598 return EBUSY;
599
600 dp = &dk->dk_label->d_partitions[DISKPART(dev)];
601 pi->pi_offset = dp->p_offset;
602 pi->pi_size = dp->p_size;
603
604 pi->pi_fstype = dp->p_fstype;
605 pi->pi_frag = dp->p_frag;
606 pi->pi_fsize = dp->p_fsize;
607 pi->pi_cpg = dp->p_cpg;
608
609 /*
610 * dholland 20130616: XXX this logic should not be
611 * here. It is here because the old buffer cache
612 * demands that all accesses to the same blocks need
613 * to be the same size; but it only works for FFS and
614 * nowadays I think it'll fail silently if the size
615 * info in the disklabel is wrong. (Or missing.) The
616 * buffer cache needs to be smarter; or failing that
617 * we need a reliable way here to get the right block
618 * size; or a reliable way to guarantee that (a) the
619 * fs is not mounted when we get here and (b) any
620 * buffers generated here will get purged when the fs
621 * does get mounted.
622 */
623 if (dp->p_fstype == FS_BSDFFS &&
624 dp->p_frag != 0 && dp->p_fsize != 0)
625 pi->pi_bsize = dp->p_frag * dp->p_fsize;
626 return 0;
627
628 case DIOCAWEDGE:
629 if ((flag & FWRITE) == 0)
630 return EBADF;
631
632 dkw = data;
633 strlcpy(dkw->dkw_parent, dk->dk_name, sizeof(dkw->dkw_parent));
634 return dkwedge_add(dkw);
635
636 case DIOCDWEDGE:
637 if ((flag & FWRITE) == 0)
638 return EBADF;
639
640 dkw = data;
641 strlcpy(dkw->dkw_parent, dk->dk_name, sizeof(dkw->dkw_parent));
642 return dkwedge_del(dkw);
643
644 case DIOCLWEDGES:
645 return dkwedge_list(dk, data, l);
646
647 case DIOCMWEDGES:
648 if ((flag & FWRITE) == 0)
649 return EBADF;
650
651 dkwedge_discover(dk);
652 return 0;
653
654 case DIOCRMWEDGES:
655 if ((flag & FWRITE) == 0)
656 return EBADF;
657
658 dkwedge_delidle(dk);
659 return 0;
660
661 case DIOCGSECTORALIGN: {
662 struct disk_sectoralign * const dsa = data;
663 const int part = DISKPART(dev);
664
665 dsa->dsa_alignment = MAX(1u, dk->dk_geom.dg_physsecsize /
666 dk->dk_geom.dg_secsize);
667 dsa->dsa_firstaligned = dk->dk_geom.dg_alignedsec;
668
669 if (part != RAW_PART) {
670 struct disklabel * const lp = dk->dk_label;
671 daddr_t offset = lp->d_partitions[part].p_offset;
672 uint32_t r = offset % dsa->dsa_alignment;
673
674 if (r <= dsa->dsa_firstaligned)
675 dsa->dsa_firstaligned -= r;
676 else
677 dsa->dsa_firstaligned += dsa->dsa_alignment - r;
678 }
679 dsa->dsa_firstaligned %= dsa->dsa_alignment;
680 return 0;
681 }
682
683 default:
684 return EPASSTHROUGH;
685 }
686 }
687
688 /*
689 * disk_set_info --
690 * Canonicalize dk->dk_geom and set some parameters.
691 *
692 * If disk_set_info can happen concurrently with disk_ioctl in a
693 * driver, the driver must serialize calls to disk_set_info with
694 * dk_openlock.
695 */
696 void
disk_set_info(device_t dev,struct disk * dk,const char * type)697 disk_set_info(device_t dev, struct disk *dk, const char *type)
698 {
699 struct disk_geom *dg = &dk->dk_geom;
700
701 if (dg->dg_secsize == 0) {
702 #ifdef DIAGNOSTIC
703 printf("%s: fixing 0 sector size\n", dk->dk_name);
704 #endif
705 dg->dg_secsize = DEV_BSIZE;
706 }
707
708 dk->dk_blkshift = DK_BSIZE2BLKSHIFT(dg->dg_secsize);
709 dk->dk_byteshift = DK_BSIZE2BYTESHIFT(dg->dg_secsize);
710
711 if (dg->dg_secperunit == 0) {
712 #ifdef DIAGNOSTIC
713 if (dg->dg_ncylinders == 0) {
714 printf("%s: secperunit and ncylinders are zero\n",
715 dk->dk_name);
716 }
717 if (dg->dg_nsectors == 0 || dg->dg_ntracks == 0) {
718 printf("%s: secperunit and (sectors or tracks) "
719 "are zero\n", dk->dk_name);
720 }
721 #endif
722 dg->dg_secperunit = (int64_t) dg->dg_nsectors *
723 dg->dg_ntracks * dg->dg_ncylinders;
724 }
725
726 if (dg->dg_ncylinders == 0) {
727 if (dg->dg_ntracks && dg->dg_nsectors)
728 dg->dg_ncylinders = dg->dg_secperunit /
729 (dg->dg_ntracks * dg->dg_nsectors);
730 }
731
732 prop_dictionary_t disk_info, odisk_info, geom;
733
734 disk_info = prop_dictionary_create();
735 geom = prop_dictionary_create();
736
737 prop_dictionary_set_uint64(geom, "sectors-per-unit",
738 dg->dg_secperunit);
739
740 prop_dictionary_set_uint32(geom, "sector-size", dg->dg_secsize);
741
742 if (dg->dg_nsectors)
743 prop_dictionary_set_uint16(geom, "sectors-per-track",
744 dg->dg_nsectors);
745
746 if (dg->dg_ntracks)
747 prop_dictionary_set_uint16(geom, "tracks-per-cylinder",
748 dg->dg_ntracks);
749
750 if (dg->dg_ncylinders)
751 prop_dictionary_set_uint64(geom, "cylinders-per-unit",
752 dg->dg_ncylinders);
753
754 if (dg->dg_physsecsize) {
755 prop_dictionary_set_uint32(geom, "physical-sector-size",
756 dg->dg_physsecsize);
757 prop_dictionary_set_uint32(geom, "aligned-sector",
758 dg->dg_alignedsec);
759 }
760
761 prop_dictionary_set(disk_info, "geometry", geom);
762
763 if (type)
764 prop_dictionary_set_string_nocopy(disk_info, "type", type);
765
766 prop_object_release(geom);
767
768 odisk_info = dk->dk_info;
769 dk->dk_info = disk_info;
770
771 if (dev)
772 prop_dictionary_set(device_properties(dev), "disk-info",
773 disk_info);
774
775 /*
776 * Don't release disk_info here; we keep a reference to it.
777 * disk_detach() will release it when we go away.
778 */
779 if (odisk_info)
780 prop_object_release(odisk_info);
781 }
782
783 int
disklabel_dev_unit(dev_t dev)784 disklabel_dev_unit(dev_t dev)
785 {
786
787 return DISKUNIT(dev);
788 }
789