Merge from vendor branch DIFFUTILS:
[dragonfly.git] / sys / kern / subr_disk.c
1 /*
2  * ----------------------------------------------------------------------------
3  * "THE BEER-WARE LICENSE" (Revision 42):
4  * <phk@FreeBSD.ORG> wrote this file.  As long as you retain this notice you
5  * can do whatever you want with this stuff. If we meet some day, and you think
6  * this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
7  * ----------------------------------------------------------------------------
8  *
9  * Copyright (c) 1982, 1986, 1988, 1993
10  *      The Regents of the University of California.  All rights reserved.
11  * (c) UNIX System Laboratories, Inc.
12  * All or some portions of this file are derived from material licensed
13  * to the University of California by American Telephone and Telegraph
14  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
15  * the permission of UNIX System Laboratories, Inc.
16  *
17  * Redistribution and use in source and binary forms, with or without
18  * modification, are permitted provided that the following conditions
19  * are met:
20  * 1. Redistributions of source code must retain the above copyright
21  *    notice, this list of conditions and the following disclaimer.
22  * 2. Redistributions in binary form must reproduce the above copyright
23  *    notice, this list of conditions and the following disclaimer in the
24  *    documentation and/or other materials provided with the distribution.
25  * 3. All advertising materials mentioning features or use of this software
26  *    must display the following acknowledgement:
27  *      This product includes software developed by the University of
28  *      California, Berkeley and its contributors.
29  * 4. Neither the name of the University nor the names of its contributors
30  *    may be used to endorse or promote products derived from this software
31  *    without specific prior written permission.
32  *
33  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
34  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
35  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
36  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
37  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
38  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
39  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
40  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
41  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
42  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
43  * SUCH DAMAGE.
44  *
45  *      @(#)ufs_disksubr.c      8.5 (Berkeley) 1/21/94
46  * $FreeBSD: src/sys/kern/subr_disk.c,v 1.20.2.6 2001/10/05 07:14:57 peter Exp $
47  * $FreeBSD: src/sys/ufs/ufs/ufs_disksubr.c,v 1.44.2.3 2001/03/05 05:42:19 obrien Exp $
48  * $DragonFly: src/sys/kern/subr_disk.c,v 1.8 2004/02/18 06:59:15 dillon Exp $
49  */
50
51 #include <sys/param.h>
52 #include <sys/systm.h>
53 #include <sys/kernel.h>
54 #include <sys/proc.h>
55 #include <sys/sysctl.h>
56 #include <sys/buf.h>
57 #include <sys/conf.h>
58 #include <sys/disklabel.h>
59 #include <sys/diskslice.h>
60 #include <sys/disk.h>
61 #include <sys/malloc.h>
62 #include <sys/sysctl.h>
63 #include <machine/md_var.h>
64 #include <sys/ctype.h>
65 #include <sys/syslog.h>
66 #include <sys/device.h>
67 #include <sys/msgport.h>
68 #include <sys/msgport2.h>
69 #include <sys/buf2.h>
70
71 static MALLOC_DEFINE(M_DISK, "disk", "disk data");
72
73 static d_strategy_t diskstrategy;
74 static d_open_t diskopen;
75 static d_close_t diskclose; 
76 static d_ioctl_t diskioctl;
77 static d_psize_t diskpsize;
78 static int disk_putport(lwkt_port_t port, lwkt_msg_t msg);
79
80 static LIST_HEAD(, disk) disklist = LIST_HEAD_INITIALIZER(&disklist);
81
82 static void
83 inherit_raw(dev_t pdev, dev_t dev)
84 {
85         dev->si_disk = pdev->si_disk;
86         dev->si_drv1 = pdev->si_drv1;
87         dev->si_drv2 = pdev->si_drv2;
88         dev->si_iosize_max = pdev->si_iosize_max;
89         dev->si_bsize_phys = pdev->si_bsize_phys;
90         dev->si_bsize_best = pdev->si_bsize_best;
91 }
92
93 /*
94  * Create a slice and unit managed disk.  The underlying raw disk device
95  * is specified by cdevsw.  We create the device as a managed device by
96  * first creating it normally then overriding the message port with our
97  * own frontend (which will be responsible for assigning pblkno).
98  */
99 dev_t
100 disk_create(int unit, struct disk *dp, int flags, struct cdevsw *cdevsw)
101 {
102         dev_t dev;
103
104         bzero(dp, sizeof(*dp));
105         lwkt_initport(&dp->d_port, NULL);       /* intercept port */
106         dp->d_port.mp_putport = disk_putport;
107
108         dev = makedev(cdevsw->d_maj, 0);        /* base device */
109         dev->si_disk = dp;
110                                                 /* forwarding port */
111         dp->d_fwdport = cdevsw_add_override(cdevsw, &dp->d_port);
112
113         if (bootverbose)
114                 printf("Creating DISK %s%d\n", cdevsw->d_name, unit);
115
116         /*
117          * The whole disk placemarker holds the disk structure.
118          */
119         dev = make_dev(cdevsw, dkmakeminor(unit, WHOLE_DISK_SLICE, RAW_PART),
120             UID_ROOT, GID_OPERATOR, 0640, "%s%d", cdevsw->d_name, unit);
121         dev->si_disk = dp;
122         dp->d_dev = dev;
123         dp->d_dsflags = flags;
124         LIST_INSERT_HEAD(&disklist, dp, d_list);
125         return (dev);
126 }
127
128 void
129 disk_destroy(struct disk *disk)
130 {
131         dev_t dev = disk->d_dev;
132
133         LIST_REMOVE(disk, d_list);
134         bzero(disk, sizeof(*disk));
135         dev->si_disk = NULL;
136         destroy_dev(dev);
137         /* YYY remove cdevsw entries? */
138         return;
139 }
140
141 int
142 disk_dumpcheck(dev_t dev, u_int *count, u_int *blkno, u_int *secsize)
143 {
144         struct disk *dp;
145         struct disklabel *dl;
146         u_int boff;
147
148         dp = dev->si_disk;
149         if (!dp)
150                 return (ENXIO);
151         if (!dp->d_slice)
152                 return (ENXIO);
153         dl = dsgetlabel(dev, dp->d_slice);
154         if (!dl)
155                 return (ENXIO);
156         *count = Maxmem * (PAGE_SIZE / dl->d_secsize);
157         if (dumplo <= LABELSECTOR || 
158             (dumplo + *count > dl->d_partitions[dkpart(dev)].p_size))
159                 return (EINVAL);
160         boff = dl->d_partitions[dkpart(dev)].p_offset +
161             dp->d_slice->dss_slices[dkslice(dev)].ds_offset;
162         *blkno = boff + dumplo;
163         *secsize = dl->d_secsize;
164         return (0);
165         
166 }
167
168 void 
169 disk_invalidate (struct disk *disk)
170 {
171         if (disk->d_slice)
172                 dsgone(&disk->d_slice);
173 }
174
175 struct disk *
176 disk_enumerate(struct disk *disk)
177 {
178         if (!disk)
179                 return (LIST_FIRST(&disklist));
180         else
181                 return (LIST_NEXT(disk, d_list));
182 }
183
184 static int
185 sysctl_disks(SYSCTL_HANDLER_ARGS)
186 {
187         struct disk *disk;
188         int error, first;
189
190         disk = NULL;
191         first = 1;
192
193         while ((disk = disk_enumerate(disk))) {
194                 if (!first) {
195                         error = SYSCTL_OUT(req, " ", 1);
196                         if (error)
197                                 return error;
198                 } else {
199                         first = 0;
200                 }
201                 error = SYSCTL_OUT(req, disk->d_dev->si_name, strlen(disk->d_dev->si_name));
202                 if (error)
203                         return error;
204         }
205         error = SYSCTL_OUT(req, "", 1);
206         return error;
207 }
208  
209 SYSCTL_PROC(_kern, OID_AUTO, disks, CTLTYPE_STRING | CTLFLAG_RD, 0, NULL, 
210     sysctl_disks, "A", "names of available disks");
211
212 /*
213  * The port intercept functions
214  */
215 static
216 int
217 disk_putport(lwkt_port_t port, lwkt_msg_t lmsg)
218 {
219         struct disk *disk = (struct disk *)port;
220         cdevallmsg_t msg = (cdevallmsg_t)lmsg;
221         int error;
222
223         switch(msg->am_lmsg.ms_cmd) {
224         case CDEV_CMD_OPEN:
225                 error = diskopen(
226                             msg->am_open.msg.dev,
227                             msg->am_open.oflags,
228                             msg->am_open.devtype,
229                             msg->am_open.td);
230                 break;
231         case CDEV_CMD_CLOSE:
232                 error = diskclose(
233                             msg->am_close.msg.dev,
234                             msg->am_close.fflag,
235                             msg->am_close.devtype,
236                             msg->am_close.td);
237                 break;
238         case CDEV_CMD_IOCTL:
239                 error = diskioctl(
240                             msg->am_ioctl.msg.dev,
241                             msg->am_ioctl.cmd,
242                             msg->am_ioctl.data,
243                             msg->am_ioctl.fflag,
244                             msg->am_ioctl.td);
245                 break;
246         case CDEV_CMD_STRATEGY:
247                 diskstrategy(msg->am_strategy.bp);
248                 error = 0;
249                 break;
250         case CDEV_CMD_PSIZE:
251                 msg->am_psize.result = diskpsize(msg->am_psize.msg.dev);
252                 error = 0;      /* XXX */
253                 break;
254         default:
255                 error = lwkt_forwardmsg(disk->d_fwdport, &msg->am_lmsg);
256                 break;
257         }
258         return(error);
259 }
260
261 static int
262 diskopen(dev_t dev, int oflags, int devtype, struct thread *td)
263 {
264         dev_t pdev;
265         struct disk *dp;
266         int error;
267
268         error = 0;
269         pdev = dkmodpart(dkmodslice(dev, WHOLE_DISK_SLICE), RAW_PART);
270
271         dp = pdev->si_disk;
272         if (dp == NULL)
273                 return (ENXIO);
274
275         while (dp->d_flags & DISKFLAG_LOCK) {
276                 dp->d_flags |= DISKFLAG_WANTED;
277                 error = tsleep(dp, PCATCH, "diskopen", hz);
278                 if (error)
279                         return (error);
280         }
281         dp->d_flags |= DISKFLAG_LOCK;
282
283         if (!dsisopen(dp->d_slice)) {
284                 if (!pdev->si_iosize_max)
285                         pdev->si_iosize_max = dev->si_iosize_max;
286                 error = dev_port_dopen(dp->d_fwdport, pdev, oflags, devtype, td);
287         }
288
289         /* Inherit properties from the whole/raw dev_t */
290         inherit_raw(pdev, dev);
291
292         if (error)
293                 goto out;
294         
295         error = dsopen(dev, devtype, dp->d_dsflags, &dp->d_slice, &dp->d_label);
296
297         if (!dsisopen(dp->d_slice)) 
298                 dev_port_dclose(dp->d_fwdport, pdev, oflags, devtype, td);
299 out:    
300         dp->d_flags &= ~DISKFLAG_LOCK;
301         if (dp->d_flags & DISKFLAG_WANTED) {
302                 dp->d_flags &= ~DISKFLAG_WANTED;
303                 wakeup(dp);
304         }
305         
306         return(error);
307 }
308
309 static int
310 diskclose(dev_t dev, int fflag, int devtype, struct thread *td)
311 {
312         struct disk *dp;
313         int error;
314         dev_t pdev;
315
316         error = 0;
317         pdev = dkmodpart(dkmodslice(dev, WHOLE_DISK_SLICE), RAW_PART);
318         dp = pdev->si_disk;
319         if (!dp)
320                 return (ENXIO);
321         dsclose(dev, devtype, dp->d_slice);
322         if (!dsisopen(dp->d_slice))
323                 error = dev_port_dclose(dp->d_fwdport, pdev, fflag, devtype, td);
324         return (error);
325 }
326
327 static void
328 diskstrategy(struct buf *bp)
329 {
330         dev_t pdev;
331         struct disk *dp;
332
333         pdev = dkmodpart(dkmodslice(bp->b_dev, WHOLE_DISK_SLICE), RAW_PART);
334         dp = pdev->si_disk;
335         if (dp != bp->b_dev->si_disk)
336                 inherit_raw(pdev, bp->b_dev);
337
338         if (!dp) {
339                 bp->b_error = ENXIO;
340                 bp->b_flags |= B_ERROR;
341                 biodone(bp);
342                 return;
343         }
344
345         if (dscheck(bp, dp->d_slice) <= 0) {
346                 biodone(bp);
347                 return;
348         }
349         dev_port_dstrategy(dp->d_fwdport, dp->d_dev, bp);
350 }
351
352 /*
353  * note: when forwarding the ioctl we use the original device rather then
354  * the whole disk slice.
355  */
356 static int
357 diskioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
358 {
359         struct disk *dp;
360         int error;
361         dev_t pdev;
362
363         pdev = dkmodpart(dkmodslice(dev, WHOLE_DISK_SLICE), RAW_PART);
364         dp = pdev->si_disk;
365         if (!dp)
366                 return (ENXIO);
367         error = dsioctl(dev, cmd, data, fflag, &dp->d_slice);
368         if (error == ENOIOCTL)
369                 error = dev_port_dioctl(dp->d_fwdport, dev, cmd, data, fflag, td);
370         return (error);
371 }
372
373 static int
374 diskpsize(dev_t dev)
375 {
376         struct disk *dp;
377         dev_t pdev;
378
379         pdev = dkmodpart(dkmodslice(dev, WHOLE_DISK_SLICE), RAW_PART);
380         dp = pdev->si_disk;
381         if (!dp)
382                 return (-1);
383         if (dp != dev->si_disk) {
384                 dev->si_drv1 = pdev->si_drv1;
385                 dev->si_drv2 = pdev->si_drv2;
386                 /* XXX: don't set bp->b_dev->si_disk (?) */
387         }
388         return (dssize(dev, &dp->d_slice));
389 }
390
391 SYSCTL_DECL(_debug_sizeof);
392
393 SYSCTL_INT(_debug_sizeof, OID_AUTO, disklabel, CTLFLAG_RD, 
394     0, sizeof(struct disklabel), "sizeof(struct disklabel)");
395
396 SYSCTL_INT(_debug_sizeof, OID_AUTO, diskslices, CTLFLAG_RD, 
397     0, sizeof(struct diskslices), "sizeof(struct diskslices)");
398
399 SYSCTL_INT(_debug_sizeof, OID_AUTO, disk, CTLFLAG_RD, 
400     0, sizeof(struct disk), "sizeof(struct disk)");
401
402
403 /*
404  * Seek sort for disks.
405  *
406  * The buf_queue keep two queues, sorted in ascending block order.  The first
407  * queue holds those requests which are positioned after the current block
408  * (in the first request); the second, which starts at queue->switch_point,
409  * holds requests which came in after their block number was passed.  Thus
410  * we implement a one way scan, retracting after reaching the end of the drive
411  * to the first request on the second queue, at which time it becomes the
412  * first queue.
413  *
414  * A one-way scan is natural because of the way UNIX read-ahead blocks are
415  * allocated.
416  */
417 void
418 bufqdisksort(bufq, bp)
419         struct buf_queue_head *bufq;
420         struct buf *bp;
421 {
422         struct buf *bq;
423         struct buf *bn;
424         struct buf *be;
425         
426         be = TAILQ_LAST(&bufq->queue, buf_queue);
427         /*
428          * If the queue is empty or we are an
429          * ordered transaction, then it's easy.
430          */
431         if ((bq = bufq_first(bufq)) == NULL
432          || (bp->b_flags & B_ORDERED) != 0) {
433                 bufq_insert_tail(bufq, bp);
434                 return;
435         } else if (bufq->insert_point != NULL) {
436
437                 /*
438                  * A certain portion of the list is
439                  * "locked" to preserve ordering, so
440                  * we can only insert after the insert
441                  * point.
442                  */
443                 bq = bufq->insert_point;
444         } else {
445
446                 /*
447                  * If we lie before the last removed (currently active)
448                  * request, and are not inserting ourselves into the
449                  * "locked" portion of the list, then we must add ourselves
450                  * to the second request list.
451                  */
452                 if (bp->b_pblkno < bufq->last_pblkno) {
453
454                         bq = bufq->switch_point;
455                         /*
456                          * If we are starting a new secondary list,
457                          * then it's easy.
458                          */
459                         if (bq == NULL) {
460                                 bufq->switch_point = bp;
461                                 bufq_insert_tail(bufq, bp);
462                                 return;
463                         }
464                         /*
465                          * If we lie ahead of the current switch point,
466                          * insert us before the switch point and move
467                          * the switch point.
468                          */
469                         if (bp->b_pblkno < bq->b_pblkno) {
470                                 bufq->switch_point = bp;
471                                 TAILQ_INSERT_BEFORE(bq, bp, b_act);
472                                 return;
473                         }
474                 } else {
475                         if (bufq->switch_point != NULL)
476                                 be = TAILQ_PREV(bufq->switch_point,
477                                                 buf_queue, b_act);
478                         /*
479                          * If we lie between last_pblkno and bq,
480                          * insert before bq.
481                          */
482                         if (bp->b_pblkno < bq->b_pblkno) {
483                                 TAILQ_INSERT_BEFORE(bq, bp, b_act);
484                                 return;
485                         }
486                 }
487         }
488
489         /*
490          * Request is at/after our current position in the list.
491          * Optimize for sequential I/O by seeing if we go at the tail.
492          */
493         if (bp->b_pblkno > be->b_pblkno) {
494                 TAILQ_INSERT_AFTER(&bufq->queue, be, bp, b_act);
495                 return;
496         }
497
498         /* Otherwise, insertion sort */
499         while ((bn = TAILQ_NEXT(bq, b_act)) != NULL) {
500                 
501                 /*
502                  * We want to go after the current request if it is the end
503                  * of the first request list, or if the next request is a
504                  * larger cylinder than our request.
505                  */
506                 if (bn == bufq->switch_point
507                  || bp->b_pblkno < bn->b_pblkno)
508                         break;
509                 bq = bn;
510         }
511         TAILQ_INSERT_AFTER(&bufq->queue, bq, bp, b_act);
512 }
513
514
515 /*
516  * Attempt to read a disk label from a device using the indicated strategy
517  * routine.  The label must be partly set up before this: secpercyl, secsize
518  * and anything required in the strategy routine (e.g., dummy bounds for the
519  * partition containing the label) must be filled in before calling us.
520  * Returns NULL on success and an error string on failure.
521  */
522 char *
523 readdisklabel(dev, lp)
524         dev_t dev;
525         struct disklabel *lp;
526 {
527         struct buf *bp;
528         struct disklabel *dlp;
529         char *msg = NULL;
530
531         bp = geteblk((int)lp->d_secsize);
532         bp->b_dev = dev;
533         bp->b_blkno = LABELSECTOR * ((int)lp->d_secsize/DEV_BSIZE);
534         bp->b_bcount = lp->d_secsize;
535         bp->b_flags &= ~B_INVAL;
536         bp->b_flags |= B_READ;
537         BUF_STRATEGY(bp, 1);
538         if (biowait(bp))
539                 msg = "I/O error";
540         else for (dlp = (struct disklabel *)bp->b_data;
541             dlp <= (struct disklabel *)((char *)bp->b_data +
542             lp->d_secsize - sizeof(*dlp));
543             dlp = (struct disklabel *)((char *)dlp + sizeof(long))) {
544                 if (dlp->d_magic != DISKMAGIC || dlp->d_magic2 != DISKMAGIC) {
545                         if (msg == NULL)
546                                 msg = "no disk label";
547                 } else if (dlp->d_npartitions > MAXPARTITIONS ||
548                            dkcksum(dlp) != 0)
549                         msg = "disk label corrupted";
550                 else {
551                         *lp = *dlp;
552                         msg = NULL;
553                         break;
554                 }
555         }
556         bp->b_flags |= B_INVAL | B_AGE;
557         brelse(bp);
558         return (msg);
559 }
560
561 /*
562  * Check new disk label for sensibility before setting it.
563  */
564 int
565 setdisklabel(olp, nlp, openmask)
566         struct disklabel *olp, *nlp;
567         u_long openmask;
568 {
569         int i;
570         struct partition *opp, *npp;
571
572         /*
573          * Check it is actually a disklabel we are looking at.
574          */
575         if (nlp->d_magic != DISKMAGIC || nlp->d_magic2 != DISKMAGIC ||
576             dkcksum(nlp) != 0)
577                 return (EINVAL);
578         /*
579          * For each partition that we think is open,
580          */
581         while ((i = ffs((long)openmask)) != 0) {
582                 i--;
583                 /*
584                  * Check it is not changing....
585                  */
586                 openmask &= ~(1 << i);
587                 if (nlp->d_npartitions <= i)
588                         return (EBUSY);
589                 opp = &olp->d_partitions[i];
590                 npp = &nlp->d_partitions[i];
591                 if (npp->p_offset != opp->p_offset || npp->p_size < opp->p_size)
592                         return (EBUSY);
593                 /*
594                  * Copy internally-set partition information
595                  * if new label doesn't include it.             XXX
596                  * (If we are using it then we had better stay the same type)
597                  * This is possibly dubious, as someone else noted (XXX)
598                  */
599                 if (npp->p_fstype == FS_UNUSED && opp->p_fstype != FS_UNUSED) {
600                         npp->p_fstype = opp->p_fstype;
601                         npp->p_fsize = opp->p_fsize;
602                         npp->p_frag = opp->p_frag;
603                         npp->p_cpg = opp->p_cpg;
604                 }
605         }
606         nlp->d_checksum = 0;
607         nlp->d_checksum = dkcksum(nlp);
608         *olp = *nlp;
609         return (0);
610 }
611
612 /*
613  * Write disk label back to device after modification.
614  */
615 int
616 writedisklabel(dev, lp)
617         dev_t dev;
618         struct disklabel *lp;
619 {
620         struct buf *bp;
621         struct disklabel *dlp;
622         int error = 0;
623
624         if (lp->d_partitions[RAW_PART].p_offset != 0)
625                 return (EXDEV);                 /* not quite right */
626         bp = geteblk((int)lp->d_secsize);
627         bp->b_dev = dkmodpart(dev, RAW_PART);
628         bp->b_blkno = LABELSECTOR * ((int)lp->d_secsize/DEV_BSIZE);
629         bp->b_bcount = lp->d_secsize;
630 #if 1
631         /*
632          * We read the label first to see if it's there,
633          * in which case we will put ours at the same offset into the block..
634          * (I think this is stupid [Julian])
635          * Note that you can't write a label out over a corrupted label!
636          * (also stupid.. how do you write the first one? by raw writes?)
637          */
638         bp->b_flags &= ~B_INVAL;
639         bp->b_flags |= B_READ;
640         BUF_STRATEGY(bp, 1);
641         error = biowait(bp);
642         if (error)
643                 goto done;
644         for (dlp = (struct disklabel *)bp->b_data;
645             dlp <= (struct disklabel *)
646               ((char *)bp->b_data + lp->d_secsize - sizeof(*dlp));
647             dlp = (struct disklabel *)((char *)dlp + sizeof(long))) {
648                 if (dlp->d_magic == DISKMAGIC && dlp->d_magic2 == DISKMAGIC &&
649                     dkcksum(dlp) == 0) {
650                         *dlp = *lp;
651                         bp->b_flags &= ~(B_DONE | B_READ);
652                         bp->b_flags |= B_WRITE;
653 #ifdef __alpha__
654                         alpha_fix_srm_checksum(bp);
655 #endif
656                         BUF_STRATEGY(bp, 1);
657                         error = biowait(bp);
658                         goto done;
659                 }
660         }
661         error = ESRCH;
662 done:
663 #else
664         bzero(bp->b_data, lp->d_secsize);
665         dlp = (struct disklabel *)bp->b_data;
666         *dlp = *lp;
667         bp->b_flags &= ~B_INVAL;
668         bp->b_flags |= B_WRITE;
669         BUF_STRATEGY(bp, 1);
670         error = biowait(bp);
671 #endif
672         bp->b_flags |= B_INVAL | B_AGE;
673         brelse(bp);
674         return (error);
675 }
676
677 /*
678  * Disk error is the preface to plaintive error messages
679  * about failing disk transfers.  It prints messages of the form
680
681 hp0g: hard error reading fsbn 12345 of 12344-12347 (hp0 bn %d cn %d tn %d sn %d)
682
683  * if the offset of the error in the transfer and a disk label
684  * are both available.  blkdone should be -1 if the position of the error
685  * is unknown; the disklabel pointer may be null from drivers that have not
686  * been converted to use them.  The message is printed with printf
687  * if pri is LOG_PRINTF, otherwise it uses log at the specified priority.
688  * The message should be completed (with at least a newline) with printf
689  * or addlog, respectively.  There is no trailing space.
690  */
691 void
692 diskerr(bp, what, pri, blkdone, lp)
693         struct buf *bp;
694         char *what;
695         int pri, blkdone;
696         struct disklabel *lp;
697 {
698         int unit = dkunit(bp->b_dev);
699         int slice = dkslice(bp->b_dev);
700         int part = dkpart(bp->b_dev);
701         char partname[2];
702         char *sname;
703         daddr_t sn;
704
705         sname = dsname(bp->b_dev, unit, slice, part, partname);
706         printf("%s%s: %s %sing fsbn ", sname, partname, what,
707               bp->b_flags & B_READ ? "read" : "writ");
708         sn = bp->b_blkno;
709         if (bp->b_bcount <= DEV_BSIZE)
710                 printf("%ld", (long)sn);
711         else {
712                 if (blkdone >= 0) {
713                         sn += blkdone;
714                         printf("%ld of ", (long)sn);
715                 }
716                 printf("%ld-%ld", (long)bp->b_blkno,
717                     (long)(bp->b_blkno + (bp->b_bcount - 1) / DEV_BSIZE));
718         }
719         if (lp && (blkdone >= 0 || bp->b_bcount <= lp->d_secsize)) {
720 #ifdef tahoe
721                 sn *= DEV_BSIZE / lp->d_secsize;                /* XXX */
722 #endif
723                 sn += lp->d_partitions[part].p_offset;
724                 /*
725                  * XXX should add slice offset and not print the slice,
726                  * but we don't know the slice pointer.
727                  * XXX should print bp->b_pblkno so that this will work
728                  * independent of slices, labels and bad sector remapping,
729                  * but some drivers don't set bp->b_pblkno.
730                  */
731                 printf(" (%s bn %ld; cn %ld", sname, (long)sn,
732                     (long)(sn / lp->d_secpercyl));
733                 sn %= (long)lp->d_secpercyl;
734                 printf(" tn %ld sn %ld)", (long)(sn / lp->d_nsectors),
735                     (long)(sn % lp->d_nsectors));
736         }
737 }