subr_disk.c revision 1.93.8.1
1/* $NetBSD: subr_disk.c,v 1.93.8.1 2009/03/03 18:32:56 skrll 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 * 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.93.8.1 2009/03/03 18:32:56 skrll 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/syslog.h> 77#include <sys/disklabel.h> 78#include <sys/disk.h> 79#include <sys/sysctl.h> 80#include <lib/libkern/libkern.h> 81 82/* 83 * Compute checksum for disk label. 84 */ 85u_int 86dkcksum(struct disklabel *lp) 87{ 88 return dkcksum_sized(lp, lp->d_npartitions); 89} 90 91u_int 92dkcksum_sized(struct disklabel *lp, size_t npartitions) 93{ 94 u_short *start, *end; 95 u_short sum = 0; 96 97 start = (u_short *)lp; 98 end = (u_short *)&lp->d_partitions[npartitions]; 99 while (start < end) 100 sum ^= *start++; 101 return (sum); 102} 103 104/* 105 * Disk error is the preface to plaintive error messages 106 * about failing disk transfers. It prints messages of the form 107 108hp0g: hard error reading fsbn 12345 of 12344-12347 (hp0 bn %d cn %d tn %d sn %d) 109 110 * if the offset of the error in the transfer and a disk label 111 * are both available. blkdone should be -1 if the position of the error 112 * is unknown; the disklabel pointer may be null from drivers that have not 113 * been converted to use them. The message is printed with printf 114 * if pri is LOG_PRINTF, otherwise it uses log at the specified priority. 115 * The message should be completed (with at least a newline) with printf 116 * or addlog, respectively. There is no trailing space. 117 */ 118#ifndef PRIdaddr 119#define PRIdaddr PRId64 120#endif 121void 122diskerr(const struct buf *bp, const char *dname, const char *what, int pri, 123 int blkdone, const struct disklabel *lp) 124{ 125 int unit = DISKUNIT(bp->b_dev), part = DISKPART(bp->b_dev); 126 void (*pr)(const char *, ...); 127 char partname = 'a' + part; 128 daddr_t sn; 129 130 if (/*CONSTCOND*/0) 131 /* Compiler will error this is the format is wrong... */ 132 printf("%" PRIdaddr, bp->b_blkno); 133 134 if (pri != LOG_PRINTF) { 135 static const char fmt[] = ""; 136 log(pri, fmt); 137 pr = addlog; 138 } else 139 pr = printf; 140 (*pr)("%s%d%c: %s %sing fsbn ", dname, unit, partname, what, 141 bp->b_flags & B_READ ? "read" : "writ"); 142 sn = bp->b_blkno; 143 if (bp->b_bcount <= DEV_BSIZE) 144 (*pr)("%" PRIdaddr, sn); 145 else { 146 if (blkdone >= 0) { 147 sn += blkdone; 148 (*pr)("%" PRIdaddr " of ", sn); 149 } 150 (*pr)("%" PRIdaddr "-%" PRIdaddr "", bp->b_blkno, 151 bp->b_blkno + (bp->b_bcount - 1) / DEV_BSIZE); 152 } 153 if (lp && (blkdone >= 0 || bp->b_bcount <= lp->d_secsize)) { 154 sn += lp->d_partitions[part].p_offset; 155 (*pr)(" (%s%d bn %" PRIdaddr "; cn %" PRIdaddr "", 156 dname, unit, sn, sn / lp->d_secpercyl); 157 sn %= lp->d_secpercyl; 158 (*pr)(" tn %" PRIdaddr " sn %" PRIdaddr ")", 159 sn / lp->d_nsectors, sn % lp->d_nsectors); 160 } 161} 162 163/* 164 * Searches the iostatlist for the disk corresponding to the 165 * name provided. 166 */ 167struct disk * 168disk_find(const char *name) 169{ 170 struct io_stats *stat; 171 172 stat = iostat_find(name); 173 174 if ((stat != NULL) && (stat->io_type == IOSTAT_DISK)) 175 return stat->io_parent; 176 177 return (NULL); 178} 179 180void 181disk_init(struct disk *diskp, const char *name, const struct dkdriver *driver) 182{ 183 184 /* 185 * Initialize the wedge-related locks and other fields. 186 */ 187 mutex_init(&diskp->dk_rawlock, MUTEX_DEFAULT, IPL_NONE); 188 mutex_init(&diskp->dk_openlock, MUTEX_DEFAULT, IPL_NONE); 189 LIST_INIT(&diskp->dk_wedges); 190 diskp->dk_nwedges = 0; 191 diskp->dk_labelsector = LABELSECTOR; 192 disk_blocksize(diskp, DEV_BSIZE); 193 diskp->dk_name = name; 194 diskp->dk_driver = driver; 195} 196 197/* 198 * Attach a disk. 199 */ 200void 201disk_attach(struct disk *diskp) 202{ 203 204 /* 205 * Allocate and initialize the disklabel structures. 206 */ 207 diskp->dk_label = kmem_zalloc(sizeof(struct disklabel), KM_SLEEP); 208 diskp->dk_cpulabel = kmem_zalloc(sizeof(struct cpu_disklabel), 209 KM_SLEEP); 210 if ((diskp->dk_label == NULL) || (diskp->dk_cpulabel == NULL)) 211 panic("disk_attach: can't allocate storage for disklabel"); 212 213 /* 214 * Set up the stats collection. 215 */ 216 diskp->dk_stats = iostat_alloc(IOSTAT_DISK, diskp, diskp->dk_name); 217} 218 219/* 220 * Detach a disk. 221 */ 222void 223disk_detach(struct disk *diskp) 224{ 225 226 /* 227 * Remove from the drivelist. 228 */ 229 iostat_free(diskp->dk_stats); 230 231 /* 232 * Release the disk-info dictionary. 233 */ 234 if (diskp->dk_info) { 235 prop_object_release(diskp->dk_info); 236 diskp->dk_info = NULL; 237 } 238 239 /* 240 * Free the space used by the disklabel structures. 241 */ 242 kmem_free(diskp->dk_label, sizeof(*diskp->dk_label)); 243 kmem_free(diskp->dk_cpulabel, sizeof(*diskp->dk_cpulabel)); 244} 245 246void 247disk_destroy(struct disk *diskp) 248{ 249 250 mutex_destroy(&diskp->dk_openlock); 251 mutex_destroy(&diskp->dk_rawlock); 252} 253 254/* 255 * Mark the disk as busy for metrics collection. 256 */ 257void 258disk_busy(struct disk *diskp) 259{ 260 261 iostat_busy(diskp->dk_stats); 262} 263 264/* 265 * Finished disk operations, gather metrics. 266 */ 267void 268disk_unbusy(struct disk *diskp, long bcount, int read) 269{ 270 271 iostat_unbusy(diskp->dk_stats, bcount, read); 272} 273 274/* 275 * Set the physical blocksize of a disk, in bytes. 276 * Only necessary if blocksize != DEV_BSIZE. 277 */ 278void 279disk_blocksize(struct disk *diskp, int blocksize) 280{ 281 282 diskp->dk_blkshift = DK_BSIZE2BLKSHIFT(blocksize); 283 diskp->dk_byteshift = DK_BSIZE2BYTESHIFT(blocksize); 284} 285 286/* 287 * Bounds checking against the media size, used for the raw partition. 288 * The sector size passed in should currently always be DEV_BSIZE, 289 * and the media size the size of the device in DEV_BSIZE sectors. 290 */ 291int 292bounds_check_with_mediasize(struct buf *bp, int secsize, uint64_t mediasize) 293{ 294 int64_t sz; 295 296 sz = howmany(bp->b_bcount, secsize); 297 298 if (bp->b_blkno + sz > mediasize) { 299 sz = mediasize - bp->b_blkno; 300 if (sz == 0) { 301 /* If exactly at end of disk, return EOF. */ 302 bp->b_resid = bp->b_bcount; 303 return 0; 304 } 305 if (sz < 0) { 306 /* If past end of disk, return EINVAL. */ 307 bp->b_error = EINVAL; 308 return 0; 309 } 310 /* Otherwise, truncate request. */ 311 bp->b_bcount = sz << DEV_BSHIFT; 312 } 313 314 return 1; 315} 316 317/* 318 * Determine the size of the transfer, and make sure it is 319 * within the boundaries of the partition. Adjust transfer 320 * if needed, and signal errors or early completion. 321 */ 322int 323bounds_check_with_label(struct disk *dk, struct buf *bp, int wlabel) 324{ 325 struct disklabel *lp = dk->dk_label; 326 struct partition *p = lp->d_partitions + DISKPART(bp->b_dev); 327 uint64_t p_size, p_offset, labelsector; 328 int64_t sz; 329 330 /* Protect against division by zero. XXX: Should never happen?!?! */ 331 if (lp->d_secpercyl == 0) { 332 bp->b_error = EINVAL; 333 return -1; 334 } 335 336 p_size = p->p_size << dk->dk_blkshift; 337 p_offset = p->p_offset << dk->dk_blkshift; 338#if RAW_PART == 3 339 labelsector = lp->d_partitions[2].p_offset; 340#else 341 labelsector = lp->d_partitions[RAW_PART].p_offset; 342#endif 343 labelsector = (labelsector + dk->dk_labelsector) << dk->dk_blkshift; 344 345 sz = howmany(bp->b_bcount, DEV_BSIZE); 346 if ((bp->b_blkno + sz) > p_size) { 347 sz = p_size - bp->b_blkno; 348 if (sz == 0) { 349 /* If exactly at end of disk, return EOF. */ 350 bp->b_resid = bp->b_bcount; 351 return 0; 352 } 353 if (sz < 0) { 354 /* If past end of disk, return EINVAL. */ 355 bp->b_error = EINVAL; 356 return -1; 357 } 358 /* Otherwise, truncate request. */ 359 bp->b_bcount = sz << DEV_BSHIFT; 360 } 361 362 /* Overwriting disk label? */ 363 if (bp->b_blkno + p_offset <= labelsector && 364 bp->b_blkno + p_offset + sz > labelsector && 365 (bp->b_flags & B_READ) == 0 && !wlabel) { 366 bp->b_error = EROFS; 367 return -1; 368 } 369 370 /* calculate cylinder for disksort to order transfers with */ 371 bp->b_cylinder = (bp->b_blkno + p->p_offset) / 372 (lp->d_secsize / DEV_BSIZE) / lp->d_secpercyl; 373 return 1; 374} 375 376int 377disk_read_sectors(void (*strat)(struct buf *), const struct disklabel *lp, 378 struct buf *bp, unsigned int sector, int count) 379{ 380 bp->b_blkno = sector; 381 bp->b_bcount = count * lp->d_secsize; 382 bp->b_flags = (bp->b_flags & ~B_WRITE) | B_READ; 383 bp->b_oflags &= ~BO_DONE; 384 bp->b_cylinder = sector / lp->d_secpercyl; 385 (*strat)(bp); 386 return biowait(bp); 387} 388 389const char * 390convertdisklabel(struct disklabel *lp, void (*strat)(struct buf *), 391 struct buf *bp, uint32_t secperunit) 392{ 393 struct partition rp, *altp, *p; 394 int geom_ok; 395 396 memset(&rp, 0, sizeof(rp)); 397 rp.p_size = secperunit; 398 rp.p_fstype = FS_UNUSED; 399 400 /* If we can seek to d_secperunit - 1, believe the disk geometry. */ 401 if (secperunit != 0 && 402 disk_read_sectors(strat, lp, bp, secperunit - 1, 1) == 0) 403 geom_ok = 1; 404 else 405 geom_ok = 0; 406 407#if 0 408 printf("%s: secperunit (%" PRIu32 ") %s\n", __func__, 409 secperunit, geom_ok ? "ok" : "not ok"); 410#endif 411 412 p = &lp->d_partitions[RAW_PART]; 413 if (RAW_PART == 'c' - 'a') 414 altp = &lp->d_partitions['d' - 'a']; 415 else 416 altp = &lp->d_partitions['c' - 'a']; 417 418 if (lp->d_npartitions > RAW_PART && p->p_offset == 0 && p->p_size != 0) 419 ; /* already a raw partition */ 420 else if (lp->d_npartitions > MAX('c', 'd') - 'a' && 421 altp->p_offset == 0 && altp->p_size != 0) { 422 /* alternate partition ('c' or 'd') is suitable for raw slot, 423 * swap with 'd' or 'c'. 424 */ 425 rp = *p; 426 *p = *altp; 427 *altp = rp; 428 } else if (lp->d_npartitions <= RAW_PART && 429 lp->d_npartitions > 'c' - 'a') { 430 /* No raw partition is present, but the alternate is present. 431 * Copy alternate to raw partition. 432 */ 433 lp->d_npartitions = RAW_PART + 1; 434 *p = *altp; 435 } else if (!geom_ok) 436 return "no raw partition and disk reports bad geometry"; 437 else if (lp->d_npartitions <= RAW_PART) { 438 memset(&lp->d_partitions[lp->d_npartitions], 0, 439 sizeof(struct partition) * (RAW_PART - lp->d_npartitions)); 440 *p = rp; 441 lp->d_npartitions = RAW_PART + 1; 442 } else if (lp->d_npartitions < MAXPARTITIONS) { 443 memmove(p + 1, p, 444 sizeof(struct partition) * (lp->d_npartitions - RAW_PART)); 445 *p = rp; 446 lp->d_npartitions++; 447 } else 448 return "no raw partition and partition table is full"; 449 return NULL; 450} 451 452/* 453 * disk_ioctl -- 454 * Generic disk ioctl handling. 455 */ 456int 457disk_ioctl(struct disk *diskp, u_long cmd, void *data, int flag, 458 struct lwp *l) 459{ 460 int error; 461 462 switch (cmd) { 463 case DIOCGDISKINFO: 464 { 465 struct plistref *pref = (struct plistref *) data; 466 467 if (diskp->dk_info == NULL) 468 error = ENOTSUP; 469 else 470 error = prop_dictionary_copyout_ioctl(pref, cmd, 471 diskp->dk_info); 472 break; 473 } 474 475 default: 476 error = EPASSTHROUGH; 477 } 478 479 return (error); 480} 481