subr_disk.c revision 1.85.2.1
1 /* $NetBSD: subr_disk.c,v 1.85.2.1 2007/07/15 13:27:43 ad Exp $ */ 2 3 /*- 4 * Copyright (c) 1996, 1997, 1999, 2000 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 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the NetBSD 22 * Foundation, Inc. and its contributors. 23 * 4. Neither the name of The NetBSD Foundation nor the names of its 24 * contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 * POSSIBILITY OF SUCH DAMAGE. 38 */ 39 40 /* 41 * Copyright (c) 1982, 1986, 1988, 1993 42 * The Regents of the University of California. All rights reserved. 43 * (c) UNIX System Laboratories, Inc. 44 * All or some portions of this file are derived from material licensed 45 * to the University of California by American Telephone and Telegraph 46 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 47 * the permission of UNIX System Laboratories, Inc. 48 * 49 * Redistribution and use in source and binary forms, with or without 50 * modification, are permitted provided that the following conditions 51 * are met: 52 * 1. Redistributions of source code must retain the above copyright 53 * notice, this list of conditions and the following disclaimer. 54 * 2. Redistributions in binary form must reproduce the above copyright 55 * notice, this list of conditions and the following disclaimer in the 56 * documentation and/or other materials provided with the distribution. 57 * 3. Neither the name of the University nor the names of its contributors 58 * may be used to endorse or promote products derived from this software 59 * without specific prior written permission. 60 * 61 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 62 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 63 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 64 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 65 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 66 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 67 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 68 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 69 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 70 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 71 * SUCH DAMAGE. 72 * 73 * @(#)ufs_disksubr.c 8.5 (Berkeley) 1/21/94 74 */ 75 76 #include <sys/cdefs.h> 77 __KERNEL_RCSID(0, "$NetBSD: subr_disk.c,v 1.85.2.1 2007/07/15 13:27:43 ad Exp $"); 78 79 #include <sys/param.h> 80 #include <sys/kernel.h> 81 #include <sys/malloc.h> 82 #include <sys/buf.h> 83 #include <sys/syslog.h> 84 #include <sys/disklabel.h> 85 #include <sys/disk.h> 86 #include <sys/sysctl.h> 87 #include <lib/libkern/libkern.h> 88 89 /* 90 * Compute checksum for disk label. 91 */ 92 u_int 93 dkcksum(struct disklabel *lp) 94 { 95 return dkcksum_sized(lp, lp->d_npartitions); 96 } 97 98 u_int 99 dkcksum_sized(struct disklabel *lp, size_t npartitions) 100 { 101 u_short *start, *end; 102 u_short sum = 0; 103 104 start = (u_short *)lp; 105 end = (u_short *)&lp->d_partitions[npartitions]; 106 while (start < end) 107 sum ^= *start++; 108 return (sum); 109 } 110 111 /* 112 * Disk error is the preface to plaintive error messages 113 * about failing disk transfers. It prints messages of the form 114 115 hp0g: hard error reading fsbn 12345 of 12344-12347 (hp0 bn %d cn %d tn %d sn %d) 116 117 * if the offset of the error in the transfer and a disk label 118 * are both available. blkdone should be -1 if the position of the error 119 * is unknown; the disklabel pointer may be null from drivers that have not 120 * been converted to use them. The message is printed with printf 121 * if pri is LOG_PRINTF, otherwise it uses log at the specified priority. 122 * The message should be completed (with at least a newline) with printf 123 * or addlog, respectively. There is no trailing space. 124 */ 125 #ifndef PRIdaddr 126 #define PRIdaddr PRId64 127 #endif 128 void 129 diskerr(const struct buf *bp, const char *dname, const char *what, int pri, 130 int blkdone, const struct disklabel *lp) 131 { 132 int unit = DISKUNIT(bp->b_dev), part = DISKPART(bp->b_dev); 133 void (*pr)(const char *, ...); 134 char partname = 'a' + part; 135 daddr_t sn; 136 137 if (/*CONSTCOND*/0) 138 /* Compiler will error this is the format is wrong... */ 139 printf("%" PRIdaddr, bp->b_blkno); 140 141 if (pri != LOG_PRINTF) { 142 static const char fmt[] = ""; 143 log(pri, fmt); 144 pr = addlog; 145 } else 146 pr = printf; 147 (*pr)("%s%d%c: %s %sing fsbn ", dname, unit, partname, what, 148 bp->b_flags & B_READ ? "read" : "writ"); 149 sn = bp->b_blkno; 150 if (bp->b_bcount <= DEV_BSIZE) 151 (*pr)("%" PRIdaddr, sn); 152 else { 153 if (blkdone >= 0) { 154 sn += blkdone; 155 (*pr)("%" PRIdaddr " of ", sn); 156 } 157 (*pr)("%" PRIdaddr "-%" PRIdaddr "", bp->b_blkno, 158 bp->b_blkno + (bp->b_bcount - 1) / DEV_BSIZE); 159 } 160 if (lp && (blkdone >= 0 || bp->b_bcount <= lp->d_secsize)) { 161 sn += lp->d_partitions[part].p_offset; 162 (*pr)(" (%s%d bn %" PRIdaddr "; cn %" PRIdaddr "", 163 dname, unit, sn, sn / lp->d_secpercyl); 164 sn %= lp->d_secpercyl; 165 (*pr)(" tn %" PRIdaddr " sn %" PRIdaddr ")", 166 sn / lp->d_nsectors, sn % lp->d_nsectors); 167 } 168 } 169 170 /* 171 * Searches the iostatlist for the disk corresponding to the 172 * name provided. 173 */ 174 struct disk * 175 disk_find(const char *name) 176 { 177 struct io_stats *stat; 178 179 stat = iostat_find(name); 180 181 if ((stat != NULL) && (stat->io_type == IOSTAT_DISK)) 182 return stat->io_parent; 183 184 return (NULL); 185 } 186 187 static void 188 disk_init0(struct disk *diskp) 189 { 190 191 /* 192 * Initialize the wedge-related locks and other fields. 193 */ 194 lockinit(&diskp->dk_rawlock, PRIBIO, "dkrawlk", 0, 0); 195 lockinit(&diskp->dk_openlock, PRIBIO, "dkoplk", 0, 0); 196 LIST_INIT(&diskp->dk_wedges); 197 diskp->dk_nwedges = 0; 198 diskp->dk_labelsector = LABELSECTOR; 199 disk_blocksize(diskp, DEV_BSIZE); 200 } 201 202 static void 203 disk_attach0(struct disk *diskp) 204 { 205 206 /* 207 * Allocate and initialize the disklabel structures. Note that 208 * it's not safe to sleep here, since we're probably going to be 209 * called during autoconfiguration. 210 */ 211 diskp->dk_label = malloc(sizeof(struct disklabel), M_DEVBUF, M_NOWAIT); 212 diskp->dk_cpulabel = malloc(sizeof(struct cpu_disklabel), M_DEVBUF, 213 M_NOWAIT); 214 if ((diskp->dk_label == NULL) || (diskp->dk_cpulabel == NULL)) 215 panic("disk_attach: can't allocate storage for disklabel"); 216 217 memset(diskp->dk_label, 0, sizeof(struct disklabel)); 218 memset(diskp->dk_cpulabel, 0, sizeof(struct cpu_disklabel)); 219 220 /* 221 * Set up the stats collection. 222 */ 223 diskp->dk_stats = iostat_alloc(IOSTAT_DISK, diskp, diskp->dk_name); 224 } 225 226 static void 227 disk_detach0(struct disk *diskp) 228 { 229 230 /* 231 * Remove from the drivelist. 232 */ 233 iostat_free(diskp->dk_stats); 234 235 /* 236 * Release the disk-info dictionary. 237 */ 238 if (diskp->dk_info) { 239 prop_object_release(diskp->dk_info); 240 diskp->dk_info = NULL; 241 } 242 243 /* 244 * Free the space used by the disklabel structures. 245 */ 246 free(diskp->dk_label, M_DEVBUF); 247 free(diskp->dk_cpulabel, M_DEVBUF); 248 } 249 250 /* 251 * Attach a disk. 252 */ 253 void 254 disk_attach(struct disk *diskp) 255 { 256 257 disk_init0(diskp); 258 disk_attach0(diskp); 259 } 260 261 /* 262 * Detach a disk. 263 */ 264 void 265 disk_detach(struct disk *diskp) 266 { 267 268 (void) lockmgr(&diskp->dk_openlock, LK_DRAIN, NULL); 269 (void) lockmgr(&diskp->dk_rawlock, LK_DRAIN, NULL); 270 disk_detach0(diskp); 271 } 272 273 /* 274 * Initialize a pseudo disk. 275 */ 276 void 277 pseudo_disk_init(struct disk *diskp) 278 { 279 280 disk_init0(diskp); 281 } 282 283 /* 284 * Attach a pseudo disk. 285 */ 286 void 287 pseudo_disk_attach(struct disk *diskp) 288 { 289 290 disk_attach0(diskp); 291 } 292 293 /* 294 * Detach a pseudo disk. 295 */ 296 void 297 pseudo_disk_detach(struct disk *diskp) 298 { 299 300 disk_detach0(diskp); 301 } 302 303 /* 304 * Mark the disk as busy for metrics collection. 305 */ 306 void 307 disk_busy(struct disk *diskp) 308 { 309 310 iostat_busy(diskp->dk_stats); 311 } 312 313 /* 314 * Finished disk operations, gather metrics. 315 */ 316 void 317 disk_unbusy(struct disk *diskp, long bcount, int read) 318 { 319 320 iostat_unbusy(diskp->dk_stats, bcount, read); 321 } 322 323 /* 324 * Set the physical blocksize of a disk, in bytes. 325 * Only necessary if blocksize != DEV_BSIZE. 326 */ 327 void 328 disk_blocksize(struct disk *diskp, int blocksize) 329 { 330 331 diskp->dk_blkshift = DK_BSIZE2BLKSHIFT(blocksize); 332 diskp->dk_byteshift = DK_BSIZE2BYTESHIFT(blocksize); 333 } 334 335 /* 336 * Bounds checking against the media size, used for the raw partition. 337 * The sector size passed in should currently always be DEV_BSIZE, 338 * and the media size the size of the device in DEV_BSIZE sectors. 339 */ 340 int 341 bounds_check_with_mediasize(struct buf *bp, int secsize, uint64_t mediasize) 342 { 343 int64_t sz; 344 345 sz = howmany(bp->b_bcount, secsize); 346 347 if (bp->b_blkno + sz > mediasize) { 348 sz = mediasize - bp->b_blkno; 349 if (sz == 0) { 350 /* If exactly at end of disk, return EOF. */ 351 bp->b_resid = bp->b_bcount; 352 goto done; 353 } 354 if (sz < 0) { 355 /* If past end of disk, return EINVAL. */ 356 bp->b_error = EINVAL; 357 goto bad; 358 } 359 /* Otherwise, truncate request. */ 360 bp->b_bcount = sz << DEV_BSHIFT; 361 } 362 363 return 1; 364 365 bad: 366 bp->b_flags |= B_ERROR; 367 done: 368 return 0; 369 } 370 371 /* 372 * Determine the size of the transfer, and make sure it is 373 * within the boundaries of the partition. Adjust transfer 374 * if needed, and signal errors or early completion. 375 */ 376 int 377 bounds_check_with_label(struct disk *dk, struct buf *bp, int wlabel) 378 { 379 struct disklabel *lp = dk->dk_label; 380 struct partition *p = lp->d_partitions + DISKPART(bp->b_dev); 381 uint64_t p_size, p_offset, labelsector; 382 int64_t sz; 383 384 /* Protect against division by zero. XXX: Should never happen?!?! */ 385 if (lp->d_secpercyl == 0) { 386 bp->b_error = EINVAL; 387 goto bad; 388 } 389 390 p_size = p->p_size << dk->dk_blkshift; 391 p_offset = p->p_offset << dk->dk_blkshift; 392 #if RAW_PART == 3 393 labelsector = lp->d_partitions[2].p_offset; 394 #else 395 labelsector = lp->d_partitions[RAW_PART].p_offset; 396 #endif 397 labelsector = (labelsector + dk->dk_labelsector) << dk->dk_blkshift; 398 399 sz = howmany(bp->b_bcount, DEV_BSIZE); 400 if ((bp->b_blkno + sz) > p_size) { 401 sz = p_size - bp->b_blkno; 402 if (sz == 0) { 403 /* If exactly at end of disk, return EOF. */ 404 bp->b_resid = bp->b_bcount; 405 return (0); 406 } 407 if (sz < 0) { 408 /* If past end of disk, return EINVAL. */ 409 bp->b_error = EINVAL; 410 goto bad; 411 } 412 /* Otherwise, truncate request. */ 413 bp->b_bcount = sz << DEV_BSHIFT; 414 } 415 416 /* Overwriting disk label? */ 417 if (bp->b_blkno + p_offset <= labelsector && 418 bp->b_blkno + p_offset + sz > labelsector && 419 (bp->b_flags & B_READ) == 0 && !wlabel) { 420 bp->b_error = EROFS; 421 goto bad; 422 } 423 424 /* calculate cylinder for disksort to order transfers with */ 425 bp->b_cylinder = (bp->b_blkno + p->p_offset) / 426 (lp->d_secsize / DEV_BSIZE) / lp->d_secpercyl; 427 return (1); 428 429 bad: 430 bp->b_flags |= B_ERROR; 431 return (-1); 432 } 433 434 int 435 disk_read_sectors(void (*strat)(struct buf *), const struct disklabel *lp, 436 struct buf *bp, unsigned int sector, int count) 437 { 438 bp->b_blkno = sector; 439 bp->b_bcount = count * lp->d_secsize; 440 bp->b_flags = (bp->b_flags & ~(B_WRITE | B_DONE)) | B_READ; 441 bp->b_cylinder = sector / lp->d_secpercyl; 442 (*strat)(bp); 443 return biowait(bp); 444 } 445 446 const char * 447 convertdisklabel(struct disklabel *lp, void (*strat)(struct buf *), 448 struct buf *bp, uint32_t secperunit) 449 { 450 struct partition rp, *altp, *p; 451 int geom_ok; 452 453 memset(&rp, 0, sizeof(rp)); 454 rp.p_size = secperunit; 455 rp.p_fstype = FS_UNUSED; 456 457 /* If we can seek to d_secperunit - 1, believe the disk geometry. */ 458 if (secperunit != 0 && 459 disk_read_sectors(strat, lp, bp, secperunit - 1, 1) == 0) 460 geom_ok = 1; 461 else 462 geom_ok = 0; 463 464 #if 0 465 printf("%s: secperunit (%" PRIu32 ") %s\n", __func__, 466 secperunit, geom_ok ? "ok" : "not ok"); 467 #endif 468 469 p = &lp->d_partitions[RAW_PART]; 470 if (RAW_PART == 'c' - 'a') 471 altp = &lp->d_partitions['d' - 'a']; 472 else 473 altp = &lp->d_partitions['c' - 'a']; 474 475 if (lp->d_npartitions > RAW_PART && p->p_offset == 0 && p->p_size != 0) 476 ; /* already a raw partition */ 477 else if (lp->d_npartitions > MAX('c', 'd') - 'a' && 478 altp->p_offset == 0 && altp->p_size != 0) { 479 /* alternate partition ('c' or 'd') is suitable for raw slot, 480 * swap with 'd' or 'c'. 481 */ 482 rp = *p; 483 *p = *altp; 484 *altp = rp; 485 } else if (lp->d_npartitions <= RAW_PART && 486 lp->d_npartitions > 'c' - 'a') { 487 /* No raw partition is present, but the alternate is present. 488 * Copy alternate to raw partition. 489 */ 490 lp->d_npartitions = RAW_PART + 1; 491 *p = *altp; 492 } else if (!geom_ok) 493 return "no raw partition and disk reports bad geometry"; 494 else if (lp->d_npartitions <= RAW_PART) { 495 memset(&lp->d_partitions[lp->d_npartitions], 0, 496 sizeof(struct partition) * (RAW_PART - lp->d_npartitions)); 497 *p = rp; 498 lp->d_npartitions = RAW_PART + 1; 499 } else if (lp->d_npartitions < MAXPARTITIONS) { 500 memmove(p + 1, p, 501 sizeof(struct partition) * (lp->d_npartitions - RAW_PART)); 502 *p = rp; 503 lp->d_npartitions++; 504 } else 505 return "no raw partition and partition table is full"; 506 return NULL; 507 } 508 509 /* 510 * disk_ioctl -- 511 * Generic disk ioctl handling. 512 */ 513 int 514 disk_ioctl(struct disk *diskp, u_long cmd, void *data, int flag, 515 struct lwp *l) 516 { 517 int error; 518 519 switch (cmd) { 520 case DIOCGDISKINFO: 521 { 522 struct plistref *pref = (struct plistref *) data; 523 524 if (diskp->dk_info == NULL) 525 error = ENOTSUP; 526 else 527 error = prop_dictionary_copyout_ioctl(pref, cmd, 528 diskp->dk_info); 529 break; 530 } 531 532 default: 533 error = EPASSTHROUGH; 534 } 535 536 return (error); 537 } 538
Indexes created Thu Sep 25 16:09:42 GMT 2025