[apple/xnu.git] / bsd / kern / subr_disk.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
/*
 * Copyright (c) 1982, 1986, 1988, 1993
 *	The Regents of the University of California.  All rights reserved.
 * (c) UNIX System Laboratories, Inc.
 * All or some portions of this file are derived from material licensed
 * to the University of California by American Telephone and Telegraph
 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
 * the permission of UNIX System Laboratories, Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	@(#)ufs_disksubr.c	8.5 (Berkeley) 1/21/94
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/disklabel.h>
#include <sys/syslog.h>

/*
 * Seek sort for disks.  We depend on the driver which calls us using b_resid
 * as the current cylinder number.
 *
 * The argument ap structure holds a b_actf activity chain pointer on which we
 * keep two queues, sorted in ascending cylinder order.  The first queue holds
 * those requests which are positioned after the current cylinder (in the first
 * request); the second holds requests which came in after their cylinder number
 * was passed.  Thus we implement a one way scan, retracting after reaching the
 * end of the drive to the first request on the second queue, at which time it
 * becomes the first queue.
 *
 * A one-way scan is natural because of the way UNIX read-ahead blocks are
 * allocated.
 */

/*
 * For portability with historic industry practice, the
 * cylinder number has to be maintained in the `b_resid'
 * field.
 */
#define	b_cylinder	b_resid

void
disksort(ap, bp)
	register struct buf *ap, *bp;
{
	register struct buf *bq;

	/* If the queue is empty, then it's easy. */
	if (ap->b_actf == NULL) {
		bp->b_actf = NULL;
		ap->b_actf = bp;
		return;
	}

	/*
	 * If we lie after the first (currently active) request, then we
	 * must locate the second request list and add ourselves to it.
	 */
	bq = ap->b_actf;
	if (bp->b_cylinder < bq->b_cylinder) {
		while (bq->b_actf) {
			/*
			 * Check for an ``inversion'' in the normally ascending
			 * cylinder numbers, indicating the start of the second
			 * request list.
			 */
			if (bq->b_actf->b_cylinder < bq->b_cylinder) {
				/*
				 * Search the second request list for the first
				 * request at a larger cylinder number.  We go
				 * before that; if there is no such request, we
				 * go at end.
				 */
				do {
					if (bp->b_cylinder <
					    bq->b_actf->b_cylinder)
						goto insert;
					if (bp->b_cylinder ==
					    bq->b_actf->b_cylinder &&
					    bp->b_blkno < bq->b_actf->b_blkno)
						goto insert;
					bq = bq->b_actf;
				} while (bq->b_actf);
				goto insert;		/* after last */
			}
			bq = bq->b_actf;
		}
		/*
		 * No inversions... we will go after the last, and
		 * be the first request in the second request list.
		 */
		goto insert;
	}
	/*
	 * Request is at/after the current request...
	 * sort in the first request list.
	 */
	while (bq->b_actf) {
		/*
		 * We want to go after the current request if there is an
		 * inversion after it (i.e. it is the end of the first
		 * request list), or if the next request is a larger cylinder
		 * than our request.
		 */
		if (bq->b_actf->b_cylinder < bq->b_cylinder ||
		    bp->b_cylinder < bq->b_actf->b_cylinder ||
		    (bp->b_cylinder == bq->b_actf->b_cylinder &&
		    bp->b_blkno < bq->b_actf->b_blkno))
			goto insert;
		bq = bq->b_actf;
	}
	/*
	 * Neither a second list nor a larger request... we go at the end of
	 * the first list, which is the same as the end of the whole schebang.
	 */
insert:	bp->b_actf = bq->b_actf;
	bq->b_actf = bp;
}

/* encoding of disk minor numbers, should be elsewhere... */
#define dkunit(dev)		(minor(dev) >> 3)
#define dkpart(dev)		(minor(dev) & 07)
#define dkminor(unit, part)	(((unit) << 3) | (part))

/*
 * Compute checksum for disk label.
 */
u_int
dkcksum(lp)
	register struct disklabel *lp;
{
	register u_short *start, *end;
	register u_short sum = 0;

	start = (u_short *)lp;
	end = (u_short *)&lp->d_partitions[lp->d_npartitions];
	while (start < end)
		sum ^= *start++;
	return (sum);
}

/*
 * Disk error is the preface to plaintive error messages
 * about failing disk transfers.  It prints messages of the form

hp0g: hard error reading fsbn 12345 of 12344-12347 (hp0 bn %d cn %d tn %d sn %d)

 * if the offset of the error in the transfer and a disk label
 * are both available.  blkdone should be -1 if the position of the error
 * is unknown; the disklabel pointer may be null from drivers that have not
 * been converted to use them.  The message is printed with printf
 * if pri is LOG_PRINTF, otherwise it uses log at the specified priority.
 * The message should be completed (with at least a newline) with printf
 * or addlog, respectively.  There is no trailing space.
 */
void
diskerr(bp, dname, what, pri, blkdone, lp)
	register struct buf *bp;
	char *dname, *what;
	int pri, blkdone;
	register struct disklabel *lp;
{
	int unit = dkunit(bp->b_dev), part = dkpart(bp->b_dev);
	register void (*pr) __P((const char *, ...));
	char partname = 'a' + part;
	int sn;

	if (pri != LOG_PRINTF) {
		log(pri, "");
		pr = addlog;
	} else
		pr = printf;
	(*pr)("%s%d%c: %s %sing fsbn ", dname, unit, partname, what,
	    bp->b_flags & B_READ ? "read" : "writ");
	sn = bp->b_blkno;
	if (bp->b_bcount <= DEV_BSIZE)
		(*pr)("%d", sn);
	else {
		if (blkdone >= 0) {
			sn += blkdone;
			(*pr)("%d of ", sn);
		}
		(*pr)("%d-%d", bp->b_blkno,
		    bp->b_blkno + (bp->b_bcount - 1) / DEV_BSIZE);
	}
	if (lp && (blkdone >= 0 || bp->b_bcount <= lp->d_secsize)) {
#ifdef tahoe
		sn *= DEV_BSIZE / lp->d_secsize;		/* XXX */
#endif
		sn += lp->d_partitions[part].p_offset;
		(*pr)(" (%s%d bn %d; cn %d", dname, unit, sn,
		    sn / lp->d_secpercyl);
		sn %= lp->d_secpercyl;
		(*pr)(" tn %d sn %d)", sn / lp->d_nsectors, sn % lp->d_nsectors);
	}
}
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
	23	/*
	24	* Copyright (c) 1982, 1986, 1988, 1993
	25	* The Regents of the University of California. All rights reserved.
	26	* (c) UNIX System Laboratories, Inc.
	27	* All or some portions of this file are derived from material licensed
	28	* to the University of California by American Telephone and Telegraph
	29	* Co. or Unix System Laboratories, Inc. and are reproduced herein with
	30	* the permission of UNIX System Laboratories, Inc.
	31	*
	32	* Redistribution and use in source and binary forms, with or without
	33	* modification, are permitted provided that the following conditions
	34	* are met:
	35	* 1. Redistributions of source code must retain the above copyright
	36	* notice, this list of conditions and the following disclaimer.
	37	* 2. Redistributions in binary form must reproduce the above copyright
	38	* notice, this list of conditions and the following disclaimer in the
	39	* documentation and/or other materials provided with the distribution.
	40	* 3. All advertising materials mentioning features or use of this software
	41	* must display the following acknowledgement:
	42	* This product includes software developed by the University of
	43	* California, Berkeley and its contributors.
	44	* 4. Neither the name of the University nor the names of its contributors
	45	* may be used to endorse or promote products derived from this software
	46	* without specific prior written permission.
	47	*
	48	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	49	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	50	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	51	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	52	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	53	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	54	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	55	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	56	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	57	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	58	* SUCH DAMAGE.
	59	*
	60	* @(#)ufs_disksubr.c 8.5 (Berkeley) 1/21/94
	61	*/
	62
	63	#include <sys/param.h>
	64	#include <sys/systm.h>
65	#include <sys/buf.h>
66	#include <sys/disklabel.h>
67	#include <sys/syslog.h>
68
69	/*
70	* Seek sort for disks. We depend on the driver which calls us using b_resid
71	* as the current cylinder number.
72	*
73	* The argument ap structure holds a b_actf activity chain pointer on which we
74	* keep two queues, sorted in ascending cylinder order. The first queue holds
75	* those requests which are positioned after the current cylinder (in the first
76	* request); the second holds requests which came in after their cylinder number
77	* was passed. Thus we implement a one way scan, retracting after reaching the
78	* end of the drive to the first request on the second queue, at which time it
79	* becomes the first queue.
80	*
81	* A one-way scan is natural because of the way UNIX read-ahead blocks are
82	* allocated.
83	*/
84
85	/*
86	* For portability with historic industry practice, the
87	* cylinder number has to be maintained in the `b_resid'
88	* field.
89	*/
90	#define b_cylinder b_resid
91
92	void
93	disksort(ap, bp)
94	register struct buf ap, bp;
95	{
96	register struct buf *bq;
97
98	/* If the queue is empty, then it's easy. */
99	if (ap->b_actf == NULL) {
100	bp->b_actf = NULL;
101	ap->b_actf = bp;
102	return;
103	}
104
105	/*
106	* If we lie after the first (currently active) request, then we
107	* must locate the second request list and add ourselves to it.
108	*/
109	bq = ap->b_actf;
110	if (bp->b_cylinder < bq->b_cylinder) {
111	while (bq->b_actf) {
112	/*
113	* Check for an ``inversion'' in the normally ascending
114	* cylinder numbers, indicating the start of the second
115	* request list.
116	*/
117	if (bq->b_actf->b_cylinder < bq->b_cylinder) {
118	/*
119	* Search the second request list for the first
120	* request at a larger cylinder number. We go
121	* before that; if there is no such request, we
122	* go at end.
123	*/
124	do {
125	if (bp->b_cylinder <
126	bq->b_actf->b_cylinder)
127	goto insert;
128	if (bp->b_cylinder ==
129	bq->b_actf->b_cylinder &&
130	bp->b_blkno < bq->b_actf->b_blkno)
131	goto insert;
132	bq = bq->b_actf;
133	} while (bq->b_actf);
134	goto insert; /* after last */
135	}
136	bq = bq->b_actf;
137	}
138	/*
139	* No inversions... we will go after the last, and
140	* be the first request in the second request list.
141	*/
142	goto insert;
143	}
144	/*
145	* Request is at/after the current request...
146	* sort in the first request list.
147	*/
148	while (bq->b_actf) {
149	/*
150	* We want to go after the current request if there is an
151	* inversion after it (i.e. it is the end of the first
152	* request list), or if the next request is a larger cylinder
153	* than our request.
154	*/
155	if (bq->b_actf->b_cylinder < bq->b_cylinder \|\|
156	bp->b_cylinder < bq->b_actf->b_cylinder \|\|
157	(bp->b_cylinder == bq->b_actf->b_cylinder &&
158	bp->b_blkno < bq->b_actf->b_blkno))
159	goto insert;
160	bq = bq->b_actf;
161	}
162	/*
163	* Neither a second list nor a larger request... we go at the end of
164	* the first list, which is the same as the end of the whole schebang.
165	*/
166	insert: bp->b_actf = bq->b_actf;
167	bq->b_actf = bp;
168	}
169
170	/* encoding of disk minor numbers, should be elsewhere... */
171	#define dkunit(dev) (minor(dev) >> 3)
172	#define dkpart(dev) (minor(dev) & 07)
173	#define dkminor(unit, part) (((unit) << 3) \| (part))
174
175	/*
176	* Compute checksum for disk label.
177	*/
178	u_int
179	dkcksum(lp)
180	register struct disklabel *lp;
181	{
182	register u_short start, end;
183	register u_short sum = 0;
184
185	start = (u_short *)lp;
186	end = (u_short *)&lp->d_partitions[lp->d_npartitions];
187	while (start < end)
188	sum ^= *start++;
189	return (sum);
190	}
191
192	/*
193	* Disk error is the preface to plaintive error messages
194	* about failing disk transfers. It prints messages of the form
195
196	hp0g: hard error reading fsbn 12345 of 12344-12347 (hp0 bn %d cn %d tn %d sn %d)
197
198	* if the offset of the error in the transfer and a disk label
199	* are both available. blkdone should be -1 if the position of the error
200	* is unknown; the disklabel pointer may be null from drivers that have not
201	* been converted to use them. The message is printed with printf
202	* if pri is LOG_PRINTF, otherwise it uses log at the specified priority.
203	* The message should be completed (with at least a newline) with printf
204	* or addlog, respectively. There is no trailing space.
205	*/
206	void
207	diskerr(bp, dname, what, pri, blkdone, lp)
208	register struct buf *bp;
209	char dname, what;
210	int pri, blkdone;
211	register struct disklabel *lp;
212	{
213	int unit = dkunit(bp->b_dev), part = dkpart(bp->b_dev);
214	register void (pr) __P((const char , ...));
215	char partname = 'a' + part;
216	int sn;
217
218	if (pri != LOG_PRINTF) {
219	log(pri, "");
220	pr = addlog;
221	} else
222	pr = printf;
223	(*pr)("%s%d%c: %s %sing fsbn ", dname, unit, partname, what,
224	bp->b_flags & B_READ ? "read" : "writ");
225	sn = bp->b_blkno;
226	if (bp->b_bcount <= DEV_BSIZE)
227	(*pr)("%d", sn);
228	else {
229	if (blkdone >= 0) {
230	sn += blkdone;
231	(*pr)("%d of ", sn);
232	}
233	(*pr)("%d-%d", bp->b_blkno,
234	bp->b_blkno + (bp->b_bcount - 1) / DEV_BSIZE);
235	}
236	if (lp && (blkdone >= 0 \|\| bp->b_bcount <= lp->d_secsize)) {
237	#ifdef tahoe
238	sn = DEV_BSIZE / lp->d_secsize; / XXX */
239	#endif
240	sn += lp->d_partitions[part].p_offset;
241	(*pr)(" (%s%d bn %d; cn %d", dname, unit, sn,
242	sn / lp->d_secpercyl);
243	sn %= lp->d_secpercyl;
244	(*pr)(" tn %d sn %d)", sn / lp->d_nsectors, sn % lp->d_nsectors);
245	}
246	}