sd.c revision 1.174 1 1.174 drochner /* $NetBSD: sd.c,v 1.174 2001/05/06 18:30:56 drochner Exp $ */
2 1.33 cgd
3 1.134 mycroft /*-
4 1.134 mycroft * Copyright (c) 1998 The NetBSD Foundation, Inc.
5 1.134 mycroft * All rights reserved.
6 1.134 mycroft *
7 1.134 mycroft * This code is derived from software contributed to The NetBSD Foundation
8 1.134 mycroft * by Charles M. Hannum.
9 1.25 mycroft *
10 1.25 mycroft * Redistribution and use in source and binary forms, with or without
11 1.25 mycroft * modification, are permitted provided that the following conditions
12 1.25 mycroft * are met:
13 1.25 mycroft * 1. Redistributions of source code must retain the above copyright
14 1.25 mycroft * notice, this list of conditions and the following disclaimer.
15 1.25 mycroft * 2. Redistributions in binary form must reproduce the above copyright
16 1.25 mycroft * notice, this list of conditions and the following disclaimer in the
17 1.25 mycroft * documentation and/or other materials provided with the distribution.
18 1.25 mycroft * 3. All advertising materials mentioning features or use of this software
19 1.25 mycroft * must display the following acknowledgement:
20 1.134 mycroft * This product includes software developed by the NetBSD
21 1.134 mycroft * Foundation, Inc. and its contributors.
22 1.134 mycroft * 4. Neither the name of The NetBSD Foundation nor the names of its
23 1.134 mycroft * contributors may be used to endorse or promote products derived
24 1.134 mycroft * from this software without specific prior written permission.
25 1.25 mycroft *
26 1.134 mycroft * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
27 1.134 mycroft * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
28 1.134 mycroft * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 1.134 mycroft * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
30 1.134 mycroft * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 1.134 mycroft * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 1.134 mycroft * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33 1.134 mycroft * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34 1.134 mycroft * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 1.134 mycroft * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 1.134 mycroft * POSSIBILITY OF SUCH DAMAGE.
37 1.25 mycroft */
38 1.25 mycroft
39 1.75 mycroft /*
40 1.25 mycroft * Originally written by Julian Elischer (julian (at) dialix.oz.au)
41 1.8 deraadt * for TRW Financial Systems for use under the MACH(2.5) operating system.
42 1.1 cgd *
43 1.1 cgd * TRW Financial Systems, in accordance with their agreement with Carnegie
44 1.1 cgd * Mellon University, makes this software available to CMU to distribute
45 1.1 cgd * or use in any manner that they see fit as long as this message is kept with
46 1.1 cgd * the software. For this reason TFS also grants any other persons or
47 1.1 cgd * organisations permission to use or modify this software.
48 1.1 cgd *
49 1.1 cgd * TFS supplies this software to be publicly redistributed
50 1.1 cgd * on the understanding that TFS is not responsible for the correct
51 1.1 cgd * functioning of this software in any circumstances.
52 1.9 cgd *
53 1.25 mycroft * Ported to run under 386BSD by Julian Elischer (julian (at) dialix.oz.au) Sept 1992
54 1.1 cgd */
55 1.1 cgd
56 1.128 mjacob #include "opt_scsi.h"
57 1.121 explorer #include "rnd.h"
58 1.121 explorer
59 1.19 mycroft #include <sys/types.h>
60 1.19 mycroft #include <sys/param.h>
61 1.19 mycroft #include <sys/systm.h>
62 1.54 mycroft #include <sys/kernel.h>
63 1.19 mycroft #include <sys/file.h>
64 1.19 mycroft #include <sys/stat.h>
65 1.19 mycroft #include <sys/ioctl.h>
66 1.140 bouyer #include <sys/scsiio.h>
67 1.19 mycroft #include <sys/buf.h>
68 1.19 mycroft #include <sys/uio.h>
69 1.19 mycroft #include <sys/malloc.h>
70 1.19 mycroft #include <sys/errno.h>
71 1.25 mycroft #include <sys/device.h>
72 1.19 mycroft #include <sys/disklabel.h>
73 1.25 mycroft #include <sys/disk.h>
74 1.87 christos #include <sys/proc.h>
75 1.95 christos #include <sys/conf.h>
76 1.147 thorpej #include <sys/vnode.h>
77 1.121 explorer #if NRND > 0
78 1.120 explorer #include <sys/rnd.h>
79 1.121 explorer #endif
80 1.19 mycroft
81 1.116 bouyer #include <dev/scsipi/scsipi_all.h>
82 1.116 bouyer #include <dev/scsipi/scsi_all.h>
83 1.124 cgd #include <dev/scsipi/scsipi_disk.h>
84 1.116 bouyer #include <dev/scsipi/scsi_disk.h>
85 1.116 bouyer #include <dev/scsipi/scsiconf.h>
86 1.124 cgd #include <dev/scsipi/sdvar.h>
87 1.124 cgd
88 1.124 cgd #include "sd.h" /* NSD_SCSIBUS and NSD_ATAPIBUS come from here */
89 1.1 cgd
90 1.36 cgd #define SDUNIT(dev) DISKUNIT(dev)
91 1.36 cgd #define SDPART(dev) DISKPART(dev)
92 1.148 enami #define SDMINOR(unit, part) DISKMINOR(unit, part)
93 1.36 cgd #define MAKESDDEV(maj, unit, part) MAKEDISKDEV(maj, unit, part)
94 1.36 cgd
95 1.36 cgd #define SDLABELDEV(dev) (MAKESDDEV(major(dev), SDUNIT(dev), RAW_PART))
96 1.1 cgd
97 1.87 christos int sdlock __P((struct sd_softc *));
98 1.87 christos void sdunlock __P((struct sd_softc *));
99 1.87 christos void sdminphys __P((struct buf *));
100 1.119 thorpej void sdgetdefaultlabel __P((struct sd_softc *, struct disklabel *));
101 1.87 christos void sdgetdisklabel __P((struct sd_softc *));
102 1.171 bouyer void sdstart __P((struct scsipi_periph *));
103 1.116 bouyer void sddone __P((struct scsipi_xfer *));
104 1.132 thorpej void sd_shutdown __P((void *));
105 1.87 christos int sd_reassign_blocks __P((struct sd_softc *, u_long));
106 1.127 mjacob int sd_interpret_sense __P((struct scsipi_xfer *));
107 1.89 thorpej
108 1.123 thorpej extern struct cfdriver sd_cd;
109 1.25 mycroft
110 1.25 mycroft struct dkdriver sddkdriver = { sdstrategy };
111 1.25 mycroft
112 1.171 bouyer const struct scsipi_periphsw sd_switch = {
113 1.127 mjacob sd_interpret_sense, /* check our error handler first */
114 1.25 mycroft sdstart, /* have a queue, served by this */
115 1.25 mycroft NULL, /* have no async handler */
116 1.84 thorpej sddone, /* deal with stats at interrupt time */
117 1.25 mycroft };
118 1.1 cgd
119 1.3 deraadt /*
120 1.171 bouyer * Attach routine common to atapi & scsi.
121 1.3 deraadt */
122 1.25 mycroft void
123 1.171 bouyer sdattach(parent, sd, periph, ops)
124 1.124 cgd struct device *parent;
125 1.124 cgd struct sd_softc *sd;
126 1.171 bouyer struct scsipi_periph *periph;
127 1.124 cgd const struct sd_ops *ops;
128 1.1 cgd {
129 1.124 cgd int error, result;
130 1.25 mycroft struct disk_parms *dp = &sd->params;
131 1.145 lukem char pbuf[9];
132 1.25 mycroft
133 1.171 bouyer SC_DEBUG(periph, SCSIPI_DB2, ("sdattach: "));
134 1.25 mycroft
135 1.155 thorpej BUFQ_INIT(&sd->buf_queue);
136 1.155 thorpej
137 1.25 mycroft /*
138 1.25 mycroft * Store information needed to contact our base driver
139 1.25 mycroft */
140 1.171 bouyer sd->sc_periph = periph;
141 1.124 cgd sd->sc_ops = ops;
142 1.171 bouyer
143 1.171 bouyer periph->periph_dev = &sd->sc_dev;
144 1.171 bouyer periph->periph_switch = &sd_switch;
145 1.171 bouyer
146 1.171 bouyer /*
147 1.171 bouyer * Increase our openings to the maximum-per-periph
148 1.171 bouyer * supported by the adapter. This will either be
149 1.171 bouyer * clamped down or grown by the adapter if necessary.
150 1.171 bouyer */
151 1.171 bouyer periph->periph_openings =
152 1.171 bouyer SCSIPI_CHAN_MAX_PERIPH(periph->periph_channel);
153 1.171 bouyer periph->periph_flags |= PERIPH_GROW_OPENINGS;
154 1.3 deraadt
155 1.81 thorpej /*
156 1.84 thorpej * Initialize and attach the disk structure.
157 1.81 thorpej */
158 1.84 thorpej sd->sc_dk.dk_driver = &sddkdriver;
159 1.84 thorpej sd->sc_dk.dk_name = sd->sc_dev.dv_xname;
160 1.84 thorpej disk_attach(&sd->sc_dk);
161 1.94 mycroft
162 1.160 thorpej #ifdef __BROKEN_DK_ESTABLISH
163 1.94 mycroft dk_establish(&sd->sc_dk, &sd->sc_dev); /* XXX */
164 1.94 mycroft #endif
165 1.81 thorpej
166 1.3 deraadt /*
167 1.165 soren * Use the subdriver to request information regarding the drive.
168 1.3 deraadt */
169 1.104 christos printf("\n");
170 1.105 matthias
171 1.171 bouyer error = scsipi_start(periph, SSS_START,
172 1.149 thorpej XS_CTL_DISCOVERY | XS_CTL_IGNORE_ILLEGAL_REQUEST |
173 1.149 thorpej XS_CTL_IGNORE_MEDIA_CHANGE | XS_CTL_SILENT);
174 1.105 matthias
175 1.124 cgd if (error)
176 1.124 cgd result = SDGP_RESULT_OFFLINE;
177 1.51 mycroft else
178 1.124 cgd result = (*sd->sc_ops->sdo_get_parms)(sd, &sd->params,
179 1.149 thorpej XS_CTL_DISCOVERY);
180 1.124 cgd printf("%s: ", sd->sc_dev.dv_xname);
181 1.124 cgd switch (result) {
182 1.124 cgd case SDGP_RESULT_OK:
183 1.145 lukem format_bytes(pbuf, sizeof(pbuf),
184 1.145 lukem (u_int64_t)dp->disksize * dp->blksize);
185 1.145 lukem printf(
186 1.145 lukem "%s, %ld cyl, %ld head, %ld sec, %ld bytes/sect x %ld sectors",
187 1.145 lukem pbuf, dp->cyls, dp->heads, dp->sectors, dp->blksize,
188 1.145 lukem dp->disksize);
189 1.124 cgd break;
190 1.124 cgd
191 1.124 cgd case SDGP_RESULT_OFFLINE:
192 1.124 cgd printf("drive offline");
193 1.124 cgd break;
194 1.124 cgd
195 1.124 cgd case SDGP_RESULT_UNFORMATTED:
196 1.124 cgd printf("unformatted media");
197 1.124 cgd break;
198 1.124 cgd
199 1.124 cgd #ifdef DIAGNOSTIC
200 1.124 cgd default:
201 1.124 cgd panic("sdattach: unknown result from get_parms");
202 1.124 cgd break;
203 1.124 cgd #endif
204 1.124 cgd }
205 1.124 cgd printf("\n");
206 1.120 explorer
207 1.132 thorpej /*
208 1.132 thorpej * Establish a shutdown hook so that we can ensure that
209 1.132 thorpej * our data has actually made it onto the platter at
210 1.132 thorpej * shutdown time. Note that this relies on the fact
211 1.132 thorpej * that the shutdown hook code puts us at the head of
212 1.132 thorpej * the list (thus guaranteeing that our hook runs before
213 1.132 thorpej * our ancestors').
214 1.132 thorpej */
215 1.132 thorpej if ((sd->sc_sdhook =
216 1.132 thorpej shutdownhook_establish(sd_shutdown, sd)) == NULL)
217 1.132 thorpej printf("%s: WARNING: unable to establish shutdown hook\n",
218 1.132 thorpej sd->sc_dev.dv_xname);
219 1.132 thorpej
220 1.121 explorer #if NRND > 0
221 1.120 explorer /*
222 1.120 explorer * attach the device into the random source list
223 1.120 explorer */
224 1.144 explorer rnd_attach_source(&sd->rnd_source, sd->sc_dev.dv_xname,
225 1.144 explorer RND_TYPE_DISK, 0);
226 1.121 explorer #endif
227 1.1 cgd }
228 1.1 cgd
229 1.147 thorpej int
230 1.147 thorpej sdactivate(self, act)
231 1.147 thorpej struct device *self;
232 1.147 thorpej enum devact act;
233 1.147 thorpej {
234 1.147 thorpej int rv = 0;
235 1.147 thorpej
236 1.147 thorpej switch (act) {
237 1.147 thorpej case DVACT_ACTIVATE:
238 1.147 thorpej rv = EOPNOTSUPP;
239 1.147 thorpej break;
240 1.147 thorpej
241 1.147 thorpej case DVACT_DEACTIVATE:
242 1.147 thorpej /*
243 1.147 thorpej * Nothing to do; we key off the device's DVF_ACTIVE.
244 1.147 thorpej */
245 1.147 thorpej break;
246 1.147 thorpej }
247 1.147 thorpej return (rv);
248 1.147 thorpej }
249 1.147 thorpej
250 1.147 thorpej int
251 1.147 thorpej sddetach(self, flags)
252 1.147 thorpej struct device *self;
253 1.147 thorpej int flags;
254 1.147 thorpej {
255 1.147 thorpej struct sd_softc *sd = (struct sd_softc *) self;
256 1.147 thorpej struct buf *bp;
257 1.174 drochner int s, bmaj, cmaj, i, mn;
258 1.147 thorpej
259 1.147 thorpej /* locate the major number */
260 1.147 thorpej for (bmaj = 0; bmaj <= nblkdev; bmaj++)
261 1.147 thorpej if (bdevsw[bmaj].d_open == sdopen)
262 1.147 thorpej break;
263 1.147 thorpej for (cmaj = 0; cmaj <= nchrdev; cmaj++)
264 1.147 thorpej if (cdevsw[cmaj].d_open == sdopen)
265 1.147 thorpej break;
266 1.147 thorpej
267 1.147 thorpej s = splbio();
268 1.147 thorpej
269 1.147 thorpej /* Kill off any queued buffers. */
270 1.155 thorpej while ((bp = BUFQ_FIRST(&sd->buf_queue)) != NULL) {
271 1.155 thorpej BUFQ_REMOVE(&sd->buf_queue, bp);
272 1.147 thorpej bp->b_error = EIO;
273 1.147 thorpej bp->b_flags |= B_ERROR;
274 1.147 thorpej bp->b_resid = bp->b_bcount;
275 1.147 thorpej biodone(bp);
276 1.147 thorpej }
277 1.147 thorpej
278 1.147 thorpej /* Kill off any pending commands. */
279 1.171 bouyer scsipi_kill_pending(sd->sc_periph);
280 1.147 thorpej
281 1.147 thorpej splx(s);
282 1.147 thorpej
283 1.158 soren /* Nuke the vnodes for any open instances */
284 1.174 drochner for (i = 0; i < MAXPARTITIONS; i++) {
285 1.174 drochner mn = SDMINOR(self->dv_unit, i);
286 1.174 drochner vdevgone(bmaj, mn, mn, VBLK);
287 1.174 drochner vdevgone(cmaj, mn, mn, VCHR);
288 1.174 drochner }
289 1.147 thorpej
290 1.147 thorpej /* Detach from the disk list. */
291 1.147 thorpej disk_detach(&sd->sc_dk);
292 1.147 thorpej
293 1.147 thorpej /* Get rid of the shutdown hook. */
294 1.147 thorpej shutdownhook_disestablish(sd->sc_sdhook);
295 1.147 thorpej
296 1.147 thorpej #if NRND > 0
297 1.147 thorpej /* Unhook the entropy source. */
298 1.147 thorpej rnd_detach_source(&sd->rnd_source);
299 1.147 thorpej #endif
300 1.147 thorpej
301 1.147 thorpej return (0);
302 1.147 thorpej }
303 1.147 thorpej
304 1.65 mycroft /*
305 1.65 mycroft * Wait interruptibly for an exclusive lock.
306 1.65 mycroft *
307 1.65 mycroft * XXX
308 1.65 mycroft * Several drivers do this; it should be abstracted and made MP-safe.
309 1.65 mycroft */
310 1.61 mycroft int
311 1.65 mycroft sdlock(sd)
312 1.61 mycroft struct sd_softc *sd;
313 1.61 mycroft {
314 1.61 mycroft int error;
315 1.61 mycroft
316 1.61 mycroft while ((sd->flags & SDF_LOCKED) != 0) {
317 1.61 mycroft sd->flags |= SDF_WANTED;
318 1.61 mycroft if ((error = tsleep(sd, PRIBIO | PCATCH, "sdlck", 0)) != 0)
319 1.118 enami return (error);
320 1.61 mycroft }
321 1.65 mycroft sd->flags |= SDF_LOCKED;
322 1.118 enami return (0);
323 1.61 mycroft }
324 1.61 mycroft
325 1.65 mycroft /*
326 1.65 mycroft * Unlock and wake up any waiters.
327 1.65 mycroft */
328 1.61 mycroft void
329 1.61 mycroft sdunlock(sd)
330 1.61 mycroft struct sd_softc *sd;
331 1.61 mycroft {
332 1.61 mycroft
333 1.61 mycroft sd->flags &= ~SDF_LOCKED;
334 1.61 mycroft if ((sd->flags & SDF_WANTED) != 0) {
335 1.61 mycroft sd->flags &= ~SDF_WANTED;
336 1.61 mycroft wakeup(sd);
337 1.61 mycroft }
338 1.61 mycroft }
339 1.61 mycroft
340 1.3 deraadt /*
341 1.25 mycroft * open the device. Make sure the partition info is a up-to-date as can be.
342 1.3 deraadt */
343 1.3 deraadt int
344 1.87 christos sdopen(dev, flag, fmt, p)
345 1.25 mycroft dev_t dev;
346 1.37 mycroft int flag, fmt;
347 1.87 christos struct proc *p;
348 1.1 cgd {
349 1.51 mycroft struct sd_softc *sd;
350 1.171 bouyer struct scsipi_periph *periph;
351 1.171 bouyer struct scsipi_adapter *adapt;
352 1.65 mycroft int unit, part;
353 1.65 mycroft int error;
354 1.1 cgd
355 1.25 mycroft unit = SDUNIT(dev);
356 1.89 thorpej if (unit >= sd_cd.cd_ndevs)
357 1.118 enami return (ENXIO);
358 1.89 thorpej sd = sd_cd.cd_devs[unit];
359 1.112 pk if (sd == NULL)
360 1.118 enami return (ENXIO);
361 1.3 deraadt
362 1.147 thorpej if ((sd->sc_dev.dv_flags & DVF_ACTIVE) == 0)
363 1.147 thorpej return (ENODEV);
364 1.147 thorpej
365 1.171 bouyer periph = sd->sc_periph;
366 1.171 bouyer adapt = periph->periph_channel->chan_adapter;
367 1.140 bouyer part = SDPART(dev);
368 1.25 mycroft
369 1.171 bouyer SC_DEBUG(periph, SCSIPI_DB1,
370 1.98 christos ("sdopen: dev=0x%x (unit %d (of %d), partition %d)\n", dev, unit,
371 1.140 bouyer sd_cd.cd_ndevs, part));
372 1.3 deraadt
373 1.137 thorpej /*
374 1.137 thorpej * If this is the first open of this device, add a reference
375 1.137 thorpej * to the adapter.
376 1.137 thorpej */
377 1.137 thorpej if (sd->sc_dk.dk_openmask == 0 &&
378 1.171 bouyer (error = scsipi_adapter_addref(adapt)) != 0)
379 1.137 thorpej return (error);
380 1.137 thorpej
381 1.87 christos if ((error = sdlock(sd)) != 0)
382 1.137 thorpej goto bad4;
383 1.45 mycroft
384 1.171 bouyer if ((periph->periph_flags & PERIPH_OPEN) != 0) {
385 1.47 mycroft /*
386 1.47 mycroft * If any partition is open, but the disk has been invalidated,
387 1.140 bouyer * disallow further opens of non-raw partition
388 1.47 mycroft */
389 1.171 bouyer if ((periph->periph_flags & PERIPH_MEDIA_LOADED) == 0 &&
390 1.141 bouyer (part != RAW_PART || fmt != S_IFCHR)) {
391 1.66 mycroft error = EIO;
392 1.66 mycroft goto bad3;
393 1.66 mycroft }
394 1.47 mycroft } else {
395 1.55 mycroft /* Check that it is still responding and ok. */
396 1.171 bouyer error = scsipi_test_unit_ready(periph,
397 1.149 thorpej XS_CTL_IGNORE_ILLEGAL_REQUEST | XS_CTL_IGNORE_MEDIA_CHANGE |
398 1.149 thorpej XS_CTL_IGNORE_NOT_READY);
399 1.87 christos if (error)
400 1.57 mycroft goto bad3;
401 1.57 mycroft
402 1.140 bouyer /*
403 1.140 bouyer * Start the pack spinning if necessary. Always allow the
404 1.140 bouyer * raw parition to be opened, for raw IOCTLs. Data transfers
405 1.140 bouyer * will check for SDEV_MEDIA_LOADED.
406 1.140 bouyer */
407 1.171 bouyer error = scsipi_start(periph, SSS_START,
408 1.149 thorpej XS_CTL_IGNORE_ILLEGAL_REQUEST |
409 1.149 thorpej XS_CTL_IGNORE_MEDIA_CHANGE | XS_CTL_SILENT);
410 1.140 bouyer if (error) {
411 1.141 bouyer if (part != RAW_PART || fmt != S_IFCHR)
412 1.140 bouyer goto bad3;
413 1.140 bouyer else
414 1.140 bouyer goto out;
415 1.140 bouyer }
416 1.57 mycroft
417 1.171 bouyer periph->periph_flags |= PERIPH_OPEN;
418 1.48 mycroft
419 1.171 bouyer if (periph->periph_flags & PERIPH_REMOVABLE) {
420 1.170 explorer /* Lock the pack in. */
421 1.171 bouyer error = scsipi_prevent(periph, PR_PREVENT,
422 1.171 bouyer XS_CTL_IGNORE_ILLEGAL_REQUEST |
423 1.171 bouyer XS_CTL_IGNORE_MEDIA_CHANGE);
424 1.170 explorer if (error)
425 1.170 explorer goto bad;
426 1.170 explorer }
427 1.54 mycroft
428 1.171 bouyer if ((periph->periph_flags & PERIPH_MEDIA_LOADED) == 0) {
429 1.171 bouyer periph->periph_flags |= PERIPH_MEDIA_LOADED;
430 1.3 deraadt
431 1.124 cgd /*
432 1.124 cgd * Load the physical device parameters.
433 1.124 cgd *
434 1.124 cgd * Note that if media is present but unformatted,
435 1.124 cgd * we allow the open (so that it can be formatted!).
436 1.124 cgd * The drive should refuse real I/O, if the media is
437 1.124 cgd * unformatted.
438 1.124 cgd */
439 1.124 cgd if ((*sd->sc_ops->sdo_get_parms)(sd, &sd->params,
440 1.124 cgd 0) == SDGP_RESULT_OFFLINE) {
441 1.45 mycroft error = ENXIO;
442 1.45 mycroft goto bad2;
443 1.45 mycroft }
444 1.171 bouyer SC_DEBUG(periph, SCSIPI_DB3, ("Params loaded "));
445 1.45 mycroft
446 1.45 mycroft /* Load the partition info if not already loaded. */
447 1.45 mycroft sdgetdisklabel(sd);
448 1.171 bouyer SC_DEBUG(periph, SCSIPI_DB3, ("Disklabel loaded "));
449 1.45 mycroft }
450 1.65 mycroft }
451 1.25 mycroft
452 1.47 mycroft /* Check that the partition exists. */
453 1.37 mycroft if (part != RAW_PART &&
454 1.84 thorpej (part >= sd->sc_dk.dk_label->d_npartitions ||
455 1.84 thorpej sd->sc_dk.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) {
456 1.25 mycroft error = ENXIO;
457 1.25 mycroft goto bad;
458 1.1 cgd }
459 1.3 deraadt
460 1.140 bouyer out: /* Insure only one open at a time. */
461 1.37 mycroft switch (fmt) {
462 1.37 mycroft case S_IFCHR:
463 1.40 mycroft sd->sc_dk.dk_copenmask |= (1 << part);
464 1.37 mycroft break;
465 1.37 mycroft case S_IFBLK:
466 1.40 mycroft sd->sc_dk.dk_bopenmask |= (1 << part);
467 1.37 mycroft break;
468 1.1 cgd }
469 1.118 enami sd->sc_dk.dk_openmask =
470 1.118 enami sd->sc_dk.dk_copenmask | sd->sc_dk.dk_bopenmask;
471 1.37 mycroft
472 1.171 bouyer SC_DEBUG(periph, SCSIPI_DB3, ("open complete\n"));
473 1.65 mycroft sdunlock(sd);
474 1.118 enami return (0);
475 1.1 cgd
476 1.45 mycroft bad2:
477 1.171 bouyer periph->periph_flags &= ~PERIPH_MEDIA_LOADED;
478 1.45 mycroft
479 1.25 mycroft bad:
480 1.40 mycroft if (sd->sc_dk.dk_openmask == 0) {
481 1.171 bouyer scsipi_prevent(periph, PR_ALLOW,
482 1.149 thorpej XS_CTL_IGNORE_ILLEGAL_REQUEST | XS_CTL_IGNORE_MEDIA_CHANGE);
483 1.171 bouyer periph->periph_flags &= ~PERIPH_OPEN;
484 1.65 mycroft }
485 1.45 mycroft
486 1.57 mycroft bad3:
487 1.65 mycroft sdunlock(sd);
488 1.137 thorpej bad4:
489 1.137 thorpej if (sd->sc_dk.dk_openmask == 0)
490 1.171 bouyer scsipi_adapter_delref(adapt);
491 1.118 enami return (error);
492 1.1 cgd }
493 1.1 cgd
494 1.3 deraadt /*
495 1.25 mycroft * close the device.. only called if we are the LAST occurence of an open
496 1.25 mycroft * device. Convenient now but usually a pain.
497 1.3 deraadt */
498 1.87 christos int
499 1.87 christos sdclose(dev, flag, fmt, p)
500 1.25 mycroft dev_t dev;
501 1.37 mycroft int flag, fmt;
502 1.87 christos struct proc *p;
503 1.1 cgd {
504 1.89 thorpej struct sd_softc *sd = sd_cd.cd_devs[SDUNIT(dev)];
505 1.171 bouyer struct scsipi_periph *periph = sd->sc_periph;
506 1.171 bouyer struct scsipi_adapter *adapt = periph->periph_channel->chan_adapter;
507 1.37 mycroft int part = SDPART(dev);
508 1.65 mycroft int error;
509 1.65 mycroft
510 1.87 christos if ((error = sdlock(sd)) != 0)
511 1.118 enami return (error);
512 1.37 mycroft
513 1.37 mycroft switch (fmt) {
514 1.37 mycroft case S_IFCHR:
515 1.40 mycroft sd->sc_dk.dk_copenmask &= ~(1 << part);
516 1.37 mycroft break;
517 1.37 mycroft case S_IFBLK:
518 1.40 mycroft sd->sc_dk.dk_bopenmask &= ~(1 << part);
519 1.37 mycroft break;
520 1.37 mycroft }
521 1.118 enami sd->sc_dk.dk_openmask =
522 1.118 enami sd->sc_dk.dk_copenmask | sd->sc_dk.dk_bopenmask;
523 1.25 mycroft
524 1.40 mycroft if (sd->sc_dk.dk_openmask == 0) {
525 1.132 thorpej /*
526 1.132 thorpej * If the disk cache needs flushing, and the disk supports
527 1.132 thorpej * it, do it now.
528 1.132 thorpej */
529 1.132 thorpej if ((sd->flags & SDF_DIRTY) != 0 &&
530 1.146 hannken sd->sc_ops->sdo_flush != NULL) {
531 1.146 hannken if ((*sd->sc_ops->sdo_flush)(sd, 0)) {
532 1.146 hannken printf("%s: cache synchronization failed\n",
533 1.146 hannken sd->sc_dev.dv_xname);
534 1.146 hannken sd->flags &= ~SDF_FLUSHING;
535 1.146 hannken } else
536 1.146 hannken sd->flags &= ~(SDF_FLUSHING|SDF_DIRTY);
537 1.146 hannken }
538 1.132 thorpej
539 1.171 bouyer if (! (periph->periph_flags & PERIPH_KEEP_LABEL))
540 1.171 bouyer periph->periph_flags &= ~PERIPH_MEDIA_LOADED;
541 1.171 bouyer
542 1.171 bouyer scsipi_wait_drain(periph);
543 1.47 mycroft
544 1.171 bouyer if (periph->periph_flags & PERIPH_REMOVABLE) {
545 1.171 bouyer scsipi_prevent(periph, PR_ALLOW,
546 1.171 bouyer XS_CTL_IGNORE_ILLEGAL_REQUEST |
547 1.171 bouyer XS_CTL_IGNORE_NOT_READY);
548 1.170 explorer }
549 1.171 bouyer periph->periph_flags &= ~PERIPH_OPEN;
550 1.170 explorer
551 1.171 bouyer scsipi_wait_drain(periph);
552 1.138 thorpej
553 1.171 bouyer scsipi_adapter_delref(adapt);
554 1.1 cgd }
555 1.47 mycroft
556 1.65 mycroft sdunlock(sd);
557 1.118 enami return (0);
558 1.1 cgd }
559 1.1 cgd
560 1.3 deraadt /*
561 1.25 mycroft * Actually translate the requested transfer into one the physical driver
562 1.25 mycroft * can understand. The transfer is described by a buf and will include
563 1.3 deraadt * only one physical transfer.
564 1.3 deraadt */
565 1.75 mycroft void
566 1.25 mycroft sdstrategy(bp)
567 1.25 mycroft struct buf *bp;
568 1.1 cgd {
569 1.89 thorpej struct sd_softc *sd = sd_cd.cd_devs[SDUNIT(bp->b_dev)];
570 1.171 bouyer struct scsipi_periph *periph = sd->sc_periph;
571 1.157 thorpej struct disklabel *lp;
572 1.157 thorpej daddr_t blkno;
573 1.77 mycroft int s;
574 1.166 chs boolean_t sector_aligned;
575 1.1 cgd
576 1.171 bouyer SC_DEBUG(sd->sc_periph, SCSIPI_DB2, ("sdstrategy "));
577 1.171 bouyer SC_DEBUG(sd->sc_periph, SCSIPI_DB1,
578 1.97 christos ("%ld bytes @ blk %d\n", bp->b_bcount, bp->b_blkno));
579 1.80 mycroft /*
580 1.140 bouyer * If the device has been made invalid, error out
581 1.80 mycroft */
582 1.171 bouyer if ((periph->periph_flags & PERIPH_MEDIA_LOADED) == 0 ||
583 1.147 thorpej (sd->sc_dev.dv_flags & DVF_ACTIVE) == 0) {
584 1.171 bouyer if (periph->periph_flags & PERIPH_OPEN)
585 1.141 bouyer bp->b_error = EIO;
586 1.141 bouyer else
587 1.141 bouyer bp->b_error = ENODEV;
588 1.80 mycroft goto bad;
589 1.80 mycroft }
590 1.157 thorpej
591 1.157 thorpej lp = sd->sc_dk.dk_label;
592 1.157 thorpej
593 1.25 mycroft /*
594 1.143 bouyer * The transfer must be a whole number of blocks, offset must not be
595 1.143 bouyer * negative.
596 1.25 mycroft */
597 1.166 chs if (lp->d_secsize == DEV_BSIZE) {
598 1.166 chs sector_aligned = (bp->b_bcount & (DEV_BSIZE - 1)) == 0;
599 1.166 chs } else {
600 1.166 chs sector_aligned = (bp->b_bcount % lp->d_secsize) == 0;
601 1.166 chs }
602 1.166 chs if (!sector_aligned || bp->b_blkno < 0) {
603 1.140 bouyer bp->b_error = EINVAL;
604 1.1 cgd goto bad;
605 1.1 cgd }
606 1.25 mycroft /*
607 1.25 mycroft * If it's a null transfer, return immediatly
608 1.25 mycroft */
609 1.1 cgd if (bp->b_bcount == 0)
610 1.1 cgd goto done;
611 1.52 mycroft
612 1.3 deraadt /*
613 1.52 mycroft * Do bounds checking, adjust transfer. if error, process.
614 1.52 mycroft * If end of partition, just return.
615 1.3 deraadt */
616 1.68 mycroft if (SDPART(bp->b_dev) != RAW_PART &&
617 1.157 thorpej bounds_check_with_label(bp, lp,
618 1.61 mycroft (sd->flags & (SDF_WLABEL|SDF_LABELLING)) != 0) <= 0)
619 1.52 mycroft goto done;
620 1.37 mycroft
621 1.157 thorpej /*
622 1.157 thorpej * Now convert the block number to absolute and put it in
623 1.157 thorpej * terms of the device's logical block size.
624 1.157 thorpej */
625 1.166 chs if (lp->d_secsize == DEV_BSIZE)
626 1.166 chs blkno = bp->b_blkno;
627 1.166 chs else if (lp->d_secsize > DEV_BSIZE)
628 1.157 thorpej blkno = bp->b_blkno / (lp->d_secsize / DEV_BSIZE);
629 1.157 thorpej else
630 1.157 thorpej blkno = bp->b_blkno * (DEV_BSIZE / lp->d_secsize);
631 1.171 bouyer
632 1.157 thorpej if (SDPART(bp->b_dev) != RAW_PART)
633 1.157 thorpej blkno += lp->d_partitions[SDPART(bp->b_dev)].p_offset;
634 1.171 bouyer
635 1.157 thorpej bp->b_rawblkno = blkno;
636 1.157 thorpej
637 1.77 mycroft s = splbio();
638 1.1 cgd
639 1.25 mycroft /*
640 1.171 bouyer * Place it in the queue of disk activities for this disk.
641 1.171 bouyer *
642 1.171 bouyer * XXX Only do disksort() if the current operating mode does not
643 1.171 bouyer * XXX include tagged queueing.
644 1.25 mycroft */
645 1.155 thorpej disksort_blkno(&sd->buf_queue, bp);
646 1.1 cgd
647 1.3 deraadt /*
648 1.3 deraadt * Tell the device to get going on the transfer if it's
649 1.3 deraadt * not doing anything, otherwise just wait for completion
650 1.3 deraadt */
651 1.171 bouyer sdstart(sd->sc_periph);
652 1.1 cgd
653 1.77 mycroft splx(s);
654 1.1 cgd return;
655 1.25 mycroft
656 1.1 cgd bad:
657 1.1 cgd bp->b_flags |= B_ERROR;
658 1.1 cgd done:
659 1.25 mycroft /*
660 1.25 mycroft * Correctly set the buf to indicate a completed xfer
661 1.25 mycroft */
662 1.25 mycroft bp->b_resid = bp->b_bcount;
663 1.1 cgd biodone(bp);
664 1.1 cgd }
665 1.1 cgd
666 1.3 deraadt /*
667 1.3 deraadt * sdstart looks to see if there is a buf waiting for the device
668 1.3 deraadt * and that the device is not already busy. If both are true,
669 1.25 mycroft * It dequeues the buf and creates a scsi command to perform the
670 1.116 bouyer * transfer in the buf. The transfer request will call scsipi_done
671 1.3 deraadt * on completion, which will in turn call this routine again
672 1.3 deraadt * so that the next queued transfer is performed.
673 1.3 deraadt * The bufs are queued by the strategy routine (sdstrategy)
674 1.25 mycroft *
675 1.3 deraadt * This routine is also called after other non-queued requests
676 1.3 deraadt * have been made of the scsi driver, to ensure that the queue
677 1.3 deraadt * continues to be drained.
678 1.25 mycroft *
679 1.3 deraadt * must be called at the correct (highish) spl level
680 1.116 bouyer * sdstart() is called at splbio from sdstrategy and scsipi_done
681 1.3 deraadt */
682 1.87 christos void
683 1.171 bouyer sdstart(periph)
684 1.171 bouyer struct scsipi_periph *periph;
685 1.3 deraadt {
686 1.171 bouyer struct sd_softc *sd = (void *)periph->periph_dev;
687 1.118 enami struct disklabel *lp = sd->sc_dk.dk_label;
688 1.25 mycroft struct buf *bp = 0;
689 1.116 bouyer struct scsipi_rw_big cmd_big;
690 1.124 cgd #if NSD_SCSIBUS > 0
691 1.81 thorpej struct scsi_rw cmd_small;
692 1.124 cgd #endif
693 1.116 bouyer struct scsipi_generic *cmdp;
694 1.171 bouyer int nblks, cmdlen, error, flags;
695 1.3 deraadt
696 1.171 bouyer SC_DEBUG(periph, SCSIPI_DB2, ("sdstart "));
697 1.3 deraadt /*
698 1.25 mycroft * Check if the device has room for another command
699 1.3 deraadt */
700 1.171 bouyer while (periph->periph_active < periph->periph_openings) {
701 1.25 mycroft /*
702 1.75 mycroft * there is excess capacity, but a special waits
703 1.25 mycroft * It'll need the adapter as soon as we clear out of the
704 1.25 mycroft * way and let it run (user level wait).
705 1.25 mycroft */
706 1.171 bouyer if (periph->periph_flags & PERIPH_WAITING) {
707 1.171 bouyer periph->periph_flags &= ~PERIPH_WAITING;
708 1.171 bouyer wakeup((caddr_t)periph);
709 1.25 mycroft return;
710 1.25 mycroft }
711 1.1 cgd
712 1.25 mycroft /*
713 1.25 mycroft * See if there is a buf with work for us to do..
714 1.25 mycroft */
715 1.155 thorpej if ((bp = BUFQ_FIRST(&sd->buf_queue)) == NULL)
716 1.25 mycroft return;
717 1.155 thorpej BUFQ_REMOVE(&sd->buf_queue, bp);
718 1.3 deraadt
719 1.25 mycroft /*
720 1.25 mycroft * If the device has become invalid, abort all the
721 1.25 mycroft * reads and writes until all files have been closed and
722 1.51 mycroft * re-opened
723 1.25 mycroft */
724 1.171 bouyer if ((periph->periph_flags & PERIPH_MEDIA_LOADED) == 0) {
725 1.32 chopps bp->b_error = EIO;
726 1.32 chopps bp->b_flags |= B_ERROR;
727 1.109 thorpej bp->b_resid = bp->b_bcount;
728 1.32 chopps biodone(bp);
729 1.32 chopps continue;
730 1.25 mycroft }
731 1.1 cgd
732 1.25 mycroft /*
733 1.157 thorpej * We have a buf, now we should make a command.
734 1.25 mycroft */
735 1.157 thorpej
736 1.166 chs if (lp->d_secsize == DEV_BSIZE)
737 1.166 chs nblks = bp->b_bcount >> DEV_BSHIFT;
738 1.166 chs else
739 1.166 chs nblks = howmany(bp->b_bcount, lp->d_secsize);
740 1.3 deraadt
741 1.124 cgd #if NSD_SCSIBUS > 0
742 1.25 mycroft /*
743 1.81 thorpej * Fill out the scsi command. If the transfer will
744 1.81 thorpej * fit in a "small" cdb, use it.
745 1.25 mycroft */
746 1.157 thorpej if (((bp->b_rawblkno & 0x1fffff) == bp->b_rawblkno) &&
747 1.171 bouyer ((nblks & 0xff) == nblks) &&
748 1.171 bouyer !(periph->periph_quirks & PQUIRK_ONLYBIG) &&
749 1.171 bouyer scsipi_periph_bustype(periph) == SCSIPI_BUSTYPE_SCSI) {
750 1.81 thorpej /*
751 1.81 thorpej * We can fit in a small cdb.
752 1.81 thorpej */
753 1.81 thorpej bzero(&cmd_small, sizeof(cmd_small));
754 1.81 thorpej cmd_small.opcode = (bp->b_flags & B_READ) ?
755 1.116 bouyer SCSI_READ_COMMAND : SCSI_WRITE_COMMAND;
756 1.157 thorpej _lto3b(bp->b_rawblkno, cmd_small.addr);
757 1.81 thorpej cmd_small.length = nblks & 0xff;
758 1.81 thorpej cmdlen = sizeof(cmd_small);
759 1.116 bouyer cmdp = (struct scsipi_generic *)&cmd_small;
760 1.124 cgd } else
761 1.124 cgd #endif
762 1.124 cgd {
763 1.81 thorpej /*
764 1.81 thorpej * Need a large cdb.
765 1.81 thorpej */
766 1.81 thorpej bzero(&cmd_big, sizeof(cmd_big));
767 1.81 thorpej cmd_big.opcode = (bp->b_flags & B_READ) ?
768 1.81 thorpej READ_BIG : WRITE_BIG;
769 1.157 thorpej _lto4b(bp->b_rawblkno, cmd_big.addr);
770 1.91 mycroft _lto2b(nblks, cmd_big.length);
771 1.81 thorpej cmdlen = sizeof(cmd_big);
772 1.116 bouyer cmdp = (struct scsipi_generic *)&cmd_big;
773 1.81 thorpej }
774 1.1 cgd
775 1.84 thorpej /* Instrumentation. */
776 1.84 thorpej disk_busy(&sd->sc_dk);
777 1.84 thorpej
778 1.25 mycroft /*
779 1.132 thorpej * Mark the disk dirty so that the cache will be
780 1.132 thorpej * flushed on close.
781 1.132 thorpej */
782 1.135 thorpej if ((bp->b_flags & B_READ) == 0)
783 1.135 thorpej sd->flags |= SDF_DIRTY;
784 1.132 thorpej
785 1.132 thorpej /*
786 1.171 bouyer * Figure out what flags to use.
787 1.171 bouyer */
788 1.171 bouyer flags = XS_CTL_NOSLEEP|XS_CTL_ASYNC;
789 1.171 bouyer if (bp->b_flags & B_READ)
790 1.172 thorpej flags |= XS_CTL_DATA_IN;
791 1.173 tsutsui else
792 1.173 tsutsui flags |= XS_CTL_DATA_OUT;
793 1.172 thorpej if (bp->b_flags & B_ORDERED)
794 1.172 thorpej flags |= XS_CTL_ORDERED_TAG;
795 1.171 bouyer else
796 1.172 thorpej flags |= XS_CTL_SIMPLE_TAG;
797 1.171 bouyer
798 1.171 bouyer /*
799 1.25 mycroft * Call the routine that chats with the adapter.
800 1.25 mycroft * Note: we cannot sleep as we may be an interrupt
801 1.25 mycroft */
802 1.171 bouyer error = scsipi_command(periph, cmdp, cmdlen,
803 1.81 thorpej (u_char *)bp->b_data, bp->b_bcount,
804 1.171 bouyer SDRETRIES, 60000, bp, flags);
805 1.129 thorpej if (error) {
806 1.130 thorpej disk_unbusy(&sd->sc_dk, 0);
807 1.104 christos printf("%s: not queued, error %d\n",
808 1.99 thorpej sd->sc_dev.dv_xname, error);
809 1.129 thorpej }
810 1.25 mycroft }
811 1.72 mycroft }
812 1.72 mycroft
813 1.111 mycroft void
814 1.111 mycroft sddone(xs)
815 1.116 bouyer struct scsipi_xfer *xs;
816 1.84 thorpej {
817 1.171 bouyer struct sd_softc *sd = (void *)xs->xs_periph->periph_dev;
818 1.84 thorpej
819 1.132 thorpej if (sd->flags & SDF_FLUSHING) {
820 1.132 thorpej /* Flush completed, no longer dirty. */
821 1.132 thorpej sd->flags &= ~(SDF_FLUSHING|SDF_DIRTY);
822 1.132 thorpej }
823 1.132 thorpej
824 1.120 explorer if (xs->bp != NULL) {
825 1.111 mycroft disk_unbusy(&sd->sc_dk, xs->bp->b_bcount - xs->bp->b_resid);
826 1.121 explorer #if NRND > 0
827 1.157 thorpej rnd_add_uint32(&sd->rnd_source, xs->bp->b_rawblkno);
828 1.121 explorer #endif
829 1.120 explorer }
830 1.84 thorpej }
831 1.84 thorpej
832 1.81 thorpej void
833 1.81 thorpej sdminphys(bp)
834 1.81 thorpej struct buf *bp;
835 1.81 thorpej {
836 1.89 thorpej struct sd_softc *sd = sd_cd.cd_devs[SDUNIT(bp->b_dev)];
837 1.81 thorpej long max;
838 1.81 thorpej
839 1.81 thorpej /*
840 1.81 thorpej * If the device is ancient, we want to make sure that
841 1.81 thorpej * the transfer fits into a 6-byte cdb.
842 1.82 thorpej *
843 1.82 thorpej * XXX Note that the SCSI-I spec says that 256-block transfers
844 1.82 thorpej * are allowed in a 6-byte read/write, and are specified
845 1.82 thorpej * by settng the "length" to 0. However, we're conservative
846 1.82 thorpej * here, allowing only 255-block transfers in case an
847 1.82 thorpej * ancient device gets confused by length == 0. A length of 0
848 1.82 thorpej * in a 10-byte read/write actually means 0 blocks.
849 1.81 thorpej */
850 1.167 augustss if ((sd->flags & SDF_ANCIENT) &&
851 1.171 bouyer ((sd->sc_periph->periph_flags &
852 1.171 bouyer (PERIPH_REMOVABLE | PERIPH_MEDIA_LOADED)) != PERIPH_REMOVABLE)) {
853 1.84 thorpej max = sd->sc_dk.dk_label->d_secsize * 0xff;
854 1.81 thorpej
855 1.81 thorpej if (bp->b_bcount > max)
856 1.81 thorpej bp->b_bcount = max;
857 1.81 thorpej }
858 1.81 thorpej
859 1.171 bouyer (*sd->sc_periph->periph_channel->chan_adapter->adapt_minphys)(bp);
860 1.81 thorpej }
861 1.81 thorpej
862 1.72 mycroft int
863 1.87 christos sdread(dev, uio, ioflag)
864 1.72 mycroft dev_t dev;
865 1.72 mycroft struct uio *uio;
866 1.87 christos int ioflag;
867 1.72 mycroft {
868 1.72 mycroft
869 1.81 thorpej return (physio(sdstrategy, NULL, dev, B_READ, sdminphys, uio));
870 1.72 mycroft }
871 1.72 mycroft
872 1.72 mycroft int
873 1.87 christos sdwrite(dev, uio, ioflag)
874 1.72 mycroft dev_t dev;
875 1.72 mycroft struct uio *uio;
876 1.87 christos int ioflag;
877 1.72 mycroft {
878 1.72 mycroft
879 1.81 thorpej return (physio(sdstrategy, NULL, dev, B_WRITE, sdminphys, uio));
880 1.1 cgd }
881 1.3 deraadt
882 1.3 deraadt /*
883 1.3 deraadt * Perform special action on behalf of the user
884 1.3 deraadt * Knows about the internals of this device
885 1.3 deraadt */
886 1.75 mycroft int
887 1.51 mycroft sdioctl(dev, cmd, addr, flag, p)
888 1.25 mycroft dev_t dev;
889 1.43 cgd u_long cmd;
890 1.25 mycroft caddr_t addr;
891 1.25 mycroft int flag;
892 1.51 mycroft struct proc *p;
893 1.1 cgd {
894 1.89 thorpej struct sd_softc *sd = sd_cd.cd_devs[SDUNIT(dev)];
895 1.171 bouyer struct scsipi_periph *periph = sd->sc_periph;
896 1.142 bouyer int part = SDPART(dev);
897 1.45 mycroft int error;
898 1.168 fvdl #ifdef __HAVE_OLD_DISKLABEL
899 1.168 fvdl struct disklabel newlabel;
900 1.168 fvdl #endif
901 1.1 cgd
902 1.171 bouyer SC_DEBUG(sd->sc_periph, SCSIPI_DB2, ("sdioctl 0x%lx ", cmd));
903 1.147 thorpej
904 1.25 mycroft /*
905 1.140 bouyer * If the device is not valid, some IOCTLs can still be
906 1.140 bouyer * handled on the raw partition. Check this here.
907 1.25 mycroft */
908 1.171 bouyer if ((periph->periph_flags & PERIPH_MEDIA_LOADED) == 0) {
909 1.140 bouyer switch (cmd) {
910 1.154 leo case DIOCKLABEL:
911 1.140 bouyer case DIOCWLABEL:
912 1.140 bouyer case DIOCLOCK:
913 1.140 bouyer case DIOCEJECT:
914 1.142 bouyer case ODIOCEJECT:
915 1.140 bouyer case SCIOCIDENTIFY:
916 1.140 bouyer case OSCIOCIDENTIFY:
917 1.140 bouyer case SCIOCCOMMAND:
918 1.140 bouyer case SCIOCDEBUG:
919 1.142 bouyer if (part == RAW_PART)
920 1.140 bouyer break;
921 1.140 bouyer /* FALLTHROUGH */
922 1.140 bouyer default:
923 1.171 bouyer if ((periph->periph_flags & PERIPH_OPEN) == 0)
924 1.141 bouyer return (ENODEV);
925 1.141 bouyer else
926 1.141 bouyer return (EIO);
927 1.140 bouyer }
928 1.140 bouyer }
929 1.45 mycroft
930 1.25 mycroft switch (cmd) {
931 1.1 cgd case DIOCGDINFO:
932 1.84 thorpej *(struct disklabel *)addr = *(sd->sc_dk.dk_label);
933 1.118 enami return (0);
934 1.25 mycroft
935 1.168 fvdl #ifdef __HAVE_OLD_DISKLABEL
936 1.168 fvdl case ODIOCGDINFO:
937 1.168 fvdl newlabel = *(sd->sc_dk.dk_label);
938 1.168 fvdl if (newlabel.d_npartitions > OLDMAXPARTITIONS)
939 1.169 fvdl return ENOTTY;
940 1.168 fvdl memcpy(addr, &newlabel, sizeof (struct olddisklabel));
941 1.168 fvdl return (0);
942 1.168 fvdl #endif
943 1.168 fvdl
944 1.3 deraadt case DIOCGPART:
945 1.84 thorpej ((struct partinfo *)addr)->disklab = sd->sc_dk.dk_label;
946 1.37 mycroft ((struct partinfo *)addr)->part =
947 1.142 bouyer &sd->sc_dk.dk_label->d_partitions[part];
948 1.118 enami return (0);
949 1.25 mycroft
950 1.61 mycroft case DIOCWDINFO:
951 1.3 deraadt case DIOCSDINFO:
952 1.168 fvdl #ifdef __HAVE_OLD_DISKLABEL
953 1.168 fvdl case ODIOCWDINFO:
954 1.168 fvdl case ODIOCSDINFO:
955 1.168 fvdl #endif
956 1.168 fvdl {
957 1.168 fvdl struct disklabel *lp;
958 1.168 fvdl
959 1.168 fvdl #ifdef __HAVE_OLD_DISKLABEL
960 1.168 fvdl if (cmd == ODIOCSDINFO || cmd == ODIOCWDINFO) {
961 1.168 fvdl memset(&newlabel, 0, sizeof newlabel);
962 1.168 fvdl memcpy(&newlabel, addr, sizeof (struct olddisklabel));
963 1.168 fvdl lp = &newlabel;
964 1.168 fvdl } else
965 1.168 fvdl #endif
966 1.168 fvdl lp = (struct disklabel *)addr;
967 1.168 fvdl
968 1.3 deraadt if ((flag & FWRITE) == 0)
969 1.118 enami return (EBADF);
970 1.61 mycroft
971 1.87 christos if ((error = sdlock(sd)) != 0)
972 1.118 enami return (error);
973 1.65 mycroft sd->flags |= SDF_LABELLING;
974 1.61 mycroft
975 1.84 thorpej error = setdisklabel(sd->sc_dk.dk_label,
976 1.168 fvdl lp, /*sd->sc_dk.dk_openmask : */0,
977 1.84 thorpej sd->sc_dk.dk_cpulabel);
978 1.62 mycroft if (error == 0) {
979 1.168 fvdl if (cmd == DIOCWDINFO
980 1.168 fvdl #ifdef __HAVE_OLD_DISKLABEL
981 1.168 fvdl || cmd == ODIOCWDINFO
982 1.168 fvdl #endif
983 1.168 fvdl )
984 1.62 mycroft error = writedisklabel(SDLABELDEV(dev),
985 1.84 thorpej sdstrategy, sd->sc_dk.dk_label,
986 1.84 thorpej sd->sc_dk.dk_cpulabel);
987 1.62 mycroft }
988 1.61 mycroft
989 1.61 mycroft sd->flags &= ~SDF_LABELLING;
990 1.61 mycroft sdunlock(sd);
991 1.118 enami return (error);
992 1.168 fvdl }
993 1.154 leo
994 1.154 leo case DIOCKLABEL:
995 1.154 leo if (*(int *)addr)
996 1.171 bouyer periph->periph_flags |= PERIPH_KEEP_LABEL;
997 1.154 leo else
998 1.171 bouyer periph->periph_flags &= ~PERIPH_KEEP_LABEL;
999 1.154 leo return (0);
1000 1.25 mycroft
1001 1.3 deraadt case DIOCWLABEL:
1002 1.3 deraadt if ((flag & FWRITE) == 0)
1003 1.118 enami return (EBADF);
1004 1.37 mycroft if (*(int *)addr)
1005 1.37 mycroft sd->flags |= SDF_WLABEL;
1006 1.37 mycroft else
1007 1.37 mycroft sd->flags &= ~SDF_WLABEL;
1008 1.118 enami return (0);
1009 1.86 thorpej
1010 1.86 thorpej case DIOCLOCK:
1011 1.171 bouyer return (scsipi_prevent(periph,
1012 1.118 enami (*(int *)addr) ? PR_PREVENT : PR_ALLOW, 0));
1013 1.142 bouyer
1014 1.86 thorpej case DIOCEJECT:
1015 1.171 bouyer if ((periph->periph_flags & PERIPH_REMOVABLE) == 0)
1016 1.142 bouyer return (ENOTTY);
1017 1.142 bouyer if (*(int *)addr == 0) {
1018 1.142 bouyer /*
1019 1.142 bouyer * Don't force eject: check that we are the only
1020 1.142 bouyer * partition open. If so, unlock it.
1021 1.142 bouyer */
1022 1.142 bouyer if ((sd->sc_dk.dk_openmask & ~(1 << part)) == 0 &&
1023 1.142 bouyer sd->sc_dk.dk_bopenmask + sd->sc_dk.dk_copenmask ==
1024 1.142 bouyer sd->sc_dk.dk_openmask) {
1025 1.171 bouyer error = scsipi_prevent(periph, PR_ALLOW,
1026 1.149 thorpej XS_CTL_IGNORE_NOT_READY);
1027 1.142 bouyer if (error)
1028 1.142 bouyer return (error);
1029 1.142 bouyer } else {
1030 1.142 bouyer return (EBUSY);
1031 1.142 bouyer }
1032 1.142 bouyer }
1033 1.142 bouyer /* FALLTHROUGH */
1034 1.142 bouyer case ODIOCEJECT:
1035 1.171 bouyer return ((periph->periph_flags & PERIPH_REMOVABLE) == 0 ?
1036 1.171 bouyer ENOTTY : scsipi_start(periph, SSS_STOP|SSS_LOEJ, 0));
1037 1.25 mycroft
1038 1.119 thorpej case DIOCGDEFLABEL:
1039 1.119 thorpej sdgetdefaultlabel(sd, (struct disklabel *)addr);
1040 1.119 thorpej return (0);
1041 1.168 fvdl
1042 1.168 fvdl #ifdef __HAVE_OLD_DISKLABEL
1043 1.168 fvdl case ODIOCGDEFLABEL:
1044 1.168 fvdl sdgetdefaultlabel(sd, &newlabel);
1045 1.168 fvdl if (newlabel.d_npartitions > OLDMAXPARTITIONS)
1046 1.169 fvdl return ENOTTY;
1047 1.168 fvdl memcpy(addr, &newlabel, sizeof (struct olddisklabel));
1048 1.168 fvdl return (0);
1049 1.168 fvdl #endif
1050 1.119 thorpej
1051 1.1 cgd default:
1052 1.142 bouyer if (part != RAW_PART)
1053 1.118 enami return (ENOTTY);
1054 1.171 bouyer return (scsipi_do_ioctl(periph, dev, cmd, addr, flag, p));
1055 1.25 mycroft }
1056 1.45 mycroft
1057 1.25 mycroft #ifdef DIAGNOSTIC
1058 1.25 mycroft panic("sdioctl: impossible");
1059 1.25 mycroft #endif
1060 1.1 cgd }
1061 1.1 cgd
1062 1.75 mycroft void
1063 1.119 thorpej sdgetdefaultlabel(sd, lp)
1064 1.51 mycroft struct sd_softc *sd;
1065 1.119 thorpej struct disklabel *lp;
1066 1.1 cgd {
1067 1.1 cgd
1068 1.74 mycroft bzero(lp, sizeof(struct disklabel));
1069 1.25 mycroft
1070 1.74 mycroft lp->d_secsize = sd->params.blksize;
1071 1.74 mycroft lp->d_ntracks = sd->params.heads;
1072 1.74 mycroft lp->d_nsectors = sd->params.sectors;
1073 1.74 mycroft lp->d_ncylinders = sd->params.cyls;
1074 1.74 mycroft lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
1075 1.1 cgd
1076 1.171 bouyer switch (scsipi_periph_bustype(sd->sc_periph)) {
1077 1.131 drochner #if NSD_SCSIBUS > 0
1078 1.171 bouyer case SCSIPI_BUSTYPE_SCSI:
1079 1.131 drochner lp->d_type = DTYPE_SCSI;
1080 1.131 drochner break;
1081 1.131 drochner #endif
1082 1.131 drochner #if NSD_ATAPIBUS > 0
1083 1.171 bouyer case SCSIPI_BUSTYPE_ATAPI:
1084 1.131 drochner lp->d_type = DTYPE_ATAPI;
1085 1.131 drochner break;
1086 1.131 drochner #endif
1087 1.131 drochner }
1088 1.131 drochner strncpy(lp->d_typename, sd->name, 16);
1089 1.74 mycroft strncpy(lp->d_packname, "fictitious", 16);
1090 1.74 mycroft lp->d_secperunit = sd->params.disksize;
1091 1.124 cgd lp->d_rpm = sd->params.rot_rate;
1092 1.74 mycroft lp->d_interleave = 1;
1093 1.74 mycroft lp->d_flags = 0;
1094 1.74 mycroft
1095 1.74 mycroft lp->d_partitions[RAW_PART].p_offset = 0;
1096 1.74 mycroft lp->d_partitions[RAW_PART].p_size =
1097 1.74 mycroft lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);
1098 1.74 mycroft lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED;
1099 1.74 mycroft lp->d_npartitions = RAW_PART + 1;
1100 1.74 mycroft
1101 1.74 mycroft lp->d_magic = DISKMAGIC;
1102 1.74 mycroft lp->d_magic2 = DISKMAGIC;
1103 1.74 mycroft lp->d_checksum = dkcksum(lp);
1104 1.119 thorpej }
1105 1.119 thorpej
1106 1.119 thorpej
1107 1.119 thorpej /*
1108 1.119 thorpej * Load the label information on the named device
1109 1.119 thorpej */
1110 1.119 thorpej void
1111 1.119 thorpej sdgetdisklabel(sd)
1112 1.119 thorpej struct sd_softc *sd;
1113 1.119 thorpej {
1114 1.119 thorpej struct disklabel *lp = sd->sc_dk.dk_label;
1115 1.119 thorpej char *errstring;
1116 1.119 thorpej
1117 1.119 thorpej bzero(sd->sc_dk.dk_cpulabel, sizeof(struct cpu_disklabel));
1118 1.119 thorpej
1119 1.119 thorpej sdgetdefaultlabel(sd, lp);
1120 1.119 thorpej
1121 1.119 thorpej if (lp->d_secpercyl == 0) {
1122 1.119 thorpej lp->d_secpercyl = 100;
1123 1.119 thorpej /* as long as it's not 0 - readdisklabel divides by it (?) */
1124 1.119 thorpej }
1125 1.45 mycroft
1126 1.25 mycroft /*
1127 1.25 mycroft * Call the generic disklabel extraction routine
1128 1.25 mycroft */
1129 1.87 christos errstring = readdisklabel(MAKESDDEV(0, sd->sc_dev.dv_unit, RAW_PART),
1130 1.118 enami sdstrategy, lp, sd->sc_dk.dk_cpulabel);
1131 1.87 christos if (errstring) {
1132 1.104 christos printf("%s: %s\n", sd->sc_dev.dv_xname, errstring);
1133 1.45 mycroft return;
1134 1.1 cgd }
1135 1.132 thorpej }
1136 1.132 thorpej
1137 1.132 thorpej void
1138 1.132 thorpej sd_shutdown(arg)
1139 1.132 thorpej void *arg;
1140 1.132 thorpej {
1141 1.132 thorpej struct sd_softc *sd = arg;
1142 1.132 thorpej
1143 1.132 thorpej /*
1144 1.132 thorpej * If the disk cache needs to be flushed, and the disk supports
1145 1.132 thorpej * it, flush it. We're cold at this point, so we poll for
1146 1.132 thorpej * completion.
1147 1.132 thorpej */
1148 1.146 hannken if ((sd->flags & SDF_DIRTY) != 0 && sd->sc_ops->sdo_flush != NULL) {
1149 1.149 thorpej if ((*sd->sc_ops->sdo_flush)(sd, XS_CTL_NOSLEEP|XS_CTL_POLL)) {
1150 1.146 hannken printf("%s: cache synchronization failed\n",
1151 1.146 hannken sd->sc_dev.dv_xname);
1152 1.146 hannken sd->flags &= ~SDF_FLUSHING;
1153 1.146 hannken } else
1154 1.146 hannken sd->flags &= ~(SDF_FLUSHING|SDF_DIRTY);
1155 1.146 hannken }
1156 1.1 cgd }
1157 1.1 cgd
1158 1.3 deraadt /*
1159 1.3 deraadt * Tell the device to map out a defective block
1160 1.3 deraadt */
1161 1.75 mycroft int
1162 1.91 mycroft sd_reassign_blocks(sd, blkno)
1163 1.51 mycroft struct sd_softc *sd;
1164 1.91 mycroft u_long blkno;
1165 1.1 cgd {
1166 1.116 bouyer struct scsi_reassign_blocks scsipi_cmd;
1167 1.3 deraadt struct scsi_reassign_blocks_data rbdata;
1168 1.1 cgd
1169 1.116 bouyer bzero(&scsipi_cmd, sizeof(scsipi_cmd));
1170 1.1 cgd bzero(&rbdata, sizeof(rbdata));
1171 1.116 bouyer scsipi_cmd.opcode = SCSI_REASSIGN_BLOCKS;
1172 1.1 cgd
1173 1.91 mycroft _lto2b(sizeof(rbdata.defect_descriptor[0]), rbdata.length);
1174 1.91 mycroft _lto4b(blkno, rbdata.defect_descriptor[0].dlbaddr);
1175 1.1 cgd
1176 1.171 bouyer return (scsipi_command(sd->sc_periph,
1177 1.118 enami (struct scsipi_generic *)&scsipi_cmd, sizeof(scsipi_cmd),
1178 1.118 enami (u_char *)&rbdata, sizeof(rbdata), SDRETRIES, 5000, NULL,
1179 1.163 enami XS_CTL_DATA_OUT | XS_CTL_DATA_ONSTACK));
1180 1.1 cgd }
1181 1.127 mjacob
1182 1.127 mjacob /*
1183 1.127 mjacob * Check Errors
1184 1.127 mjacob */
1185 1.127 mjacob int
1186 1.127 mjacob sd_interpret_sense(xs)
1187 1.127 mjacob struct scsipi_xfer *xs;
1188 1.127 mjacob {
1189 1.171 bouyer struct scsipi_periph *periph = xs->xs_periph;
1190 1.127 mjacob struct scsipi_sense_data *sense = &xs->sense.scsi_sense;
1191 1.171 bouyer struct sd_softc *sd = (void *)periph->periph_dev;
1192 1.171 bouyer int s, error, retval = EJUSTRETURN;
1193 1.171 bouyer
1194 1.171 bouyer /*
1195 1.171 bouyer * If the periph is already recovering, just do the normal
1196 1.171 bouyer * error processing.
1197 1.171 bouyer */
1198 1.171 bouyer if (periph->periph_flags & PERIPH_RECOVERING)
1199 1.171 bouyer return (retval);
1200 1.127 mjacob
1201 1.127 mjacob /*
1202 1.127 mjacob * If the device is not open yet, let the generic code handle it.
1203 1.127 mjacob */
1204 1.171 bouyer if ((periph->periph_flags & PERIPH_MEDIA_LOADED) == 0)
1205 1.127 mjacob return (retval);
1206 1.127 mjacob
1207 1.127 mjacob /*
1208 1.127 mjacob * If it isn't a extended or extended/deferred error, let
1209 1.127 mjacob * the generic code handle it.
1210 1.127 mjacob */
1211 1.127 mjacob if ((sense->error_code & SSD_ERRCODE) != 0x70 &&
1212 1.171 bouyer (sense->error_code & SSD_ERRCODE) != 0x71)
1213 1.127 mjacob return (retval);
1214 1.127 mjacob
1215 1.127 mjacob if ((sense->flags & SSD_KEY) == SKEY_NOT_READY &&
1216 1.127 mjacob sense->add_sense_code == 0x4) {
1217 1.127 mjacob if (sense->add_sense_code_qual == 0x01) {
1218 1.127 mjacob /*
1219 1.171 bouyer * Unit In The Process Of Becoming Ready.
1220 1.127 mjacob */
1221 1.171 bouyer printf("%s: waiting for pack to spin up...\n",
1222 1.171 bouyer sd->sc_dev.dv_xname);
1223 1.171 bouyer scsipi_periph_freeze(periph, 1);
1224 1.171 bouyer callout_reset(&periph->periph_callout,
1225 1.171 bouyer 5 * hz, scsipi_periph_timed_thaw, periph);
1226 1.171 bouyer retval = ERESTART;
1227 1.127 mjacob } else if ((sense->add_sense_code_qual == 0x2) &&
1228 1.171 bouyer (periph->periph_quirks & PQUIRK_NOSTARTUNIT) == 0) {
1229 1.171 bouyer printf("%s: pack is stopped, restarting...\n",
1230 1.171 bouyer sd->sc_dev.dv_xname);
1231 1.171 bouyer s = splbio();
1232 1.171 bouyer periph->periph_flags |= PERIPH_RECOVERING;
1233 1.171 bouyer splx(s);
1234 1.171 bouyer error = scsipi_start(periph, SSS_START,
1235 1.171 bouyer XS_CTL_URGENT|XS_CTL_HEAD_TAG|
1236 1.171 bouyer XS_CTL_THAW_PERIPH|XS_CTL_FREEZE_PERIPH);
1237 1.171 bouyer if (error) {
1238 1.171 bouyer printf("%s: unable to restart pack\n",
1239 1.145 lukem sd->sc_dev.dv_xname);
1240 1.171 bouyer retval = error;
1241 1.171 bouyer } else
1242 1.171 bouyer retval = ERESTART;
1243 1.171 bouyer s = splbio();
1244 1.171 bouyer periph->periph_flags &= ~PERIPH_RECOVERING;
1245 1.171 bouyer splx(s);
1246 1.127 mjacob }
1247 1.127 mjacob }
1248 1.127 mjacob return (retval);
1249 1.127 mjacob }
1250 1.127 mjacob
1251 1.1 cgd
1252 1.3 deraadt int
1253 1.45 mycroft sdsize(dev)
1254 1.45 mycroft dev_t dev;
1255 1.1 cgd {
1256 1.51 mycroft struct sd_softc *sd;
1257 1.112 pk int part, unit, omask;
1258 1.45 mycroft int size;
1259 1.1 cgd
1260 1.112 pk unit = SDUNIT(dev);
1261 1.112 pk if (unit >= sd_cd.cd_ndevs)
1262 1.112 pk return (-1);
1263 1.112 pk sd = sd_cd.cd_devs[unit];
1264 1.112 pk if (sd == NULL)
1265 1.112 pk return (-1);
1266 1.112 pk
1267 1.147 thorpej if ((sd->sc_dev.dv_flags & DVF_ACTIVE) == 0)
1268 1.147 thorpej return (-1);
1269 1.147 thorpej
1270 1.45 mycroft part = SDPART(dev);
1271 1.112 pk omask = sd->sc_dk.dk_openmask & (1 << part);
1272 1.112 pk
1273 1.112 pk if (omask == 0 && sdopen(dev, 0, S_IFBLK, NULL) != 0)
1274 1.112 pk return (-1);
1275 1.171 bouyer if ((sd->sc_periph->periph_flags & PERIPH_MEDIA_LOADED) == 0)
1276 1.140 bouyer size = -1;
1277 1.140 bouyer else if (sd->sc_dk.dk_label->d_partitions[part].p_fstype != FS_SWAP)
1278 1.45 mycroft size = -1;
1279 1.45 mycroft else
1280 1.113 thorpej size = sd->sc_dk.dk_label->d_partitions[part].p_size *
1281 1.113 thorpej (sd->sc_dk.dk_label->d_secsize / DEV_BSIZE);
1282 1.112 pk if (omask == 0 && sdclose(dev, 0, S_IFBLK, NULL) != 0)
1283 1.112 pk return (-1);
1284 1.112 pk return (size);
1285 1.3 deraadt }
1286 1.3 deraadt
1287 1.71 cgd /* #define SD_DUMP_NOT_TRUSTED if you just want to watch */
1288 1.116 bouyer static struct scsipi_xfer sx;
1289 1.71 cgd static int sddoingadump;
1290 1.3 deraadt
1291 1.3 deraadt /*
1292 1.25 mycroft * dump all of physical memory into the partition specified, starting
1293 1.25 mycroft * at offset 'dumplo' into the partition.
1294 1.3 deraadt */
1295 1.3 deraadt int
1296 1.71 cgd sddump(dev, blkno, va, size)
1297 1.71 cgd dev_t dev;
1298 1.71 cgd daddr_t blkno;
1299 1.71 cgd caddr_t va;
1300 1.71 cgd size_t size;
1301 1.71 cgd {
1302 1.71 cgd struct sd_softc *sd; /* disk unit to do the I/O */
1303 1.71 cgd struct disklabel *lp; /* disk's disklabel */
1304 1.71 cgd int unit, part;
1305 1.71 cgd int sectorsize; /* size of a disk sector */
1306 1.71 cgd int nsects; /* number of sectors in partition */
1307 1.71 cgd int sectoff; /* sector offset of partition */
1308 1.71 cgd int totwrt; /* total number of sectors left to write */
1309 1.71 cgd int nwrt; /* current number of sectors to write */
1310 1.116 bouyer struct scsipi_rw_big cmd; /* write command */
1311 1.116 bouyer struct scsipi_xfer *xs; /* ... convenience */
1312 1.171 bouyer struct scsipi_periph *periph = sd->sc_periph;
1313 1.171 bouyer struct scsipi_channel *chan = periph->periph_channel;
1314 1.171 bouyer
1315 1.171 bouyer if ((sd->sc_dev.dv_flags & DVF_ACTIVE) == 0)
1316 1.171 bouyer return (ENODEV);
1317 1.147 thorpej
1318 1.71 cgd /* Check if recursive dump; if so, punt. */
1319 1.71 cgd if (sddoingadump)
1320 1.118 enami return (EFAULT);
1321 1.71 cgd
1322 1.71 cgd /* Mark as active early. */
1323 1.71 cgd sddoingadump = 1;
1324 1.1 cgd
1325 1.71 cgd unit = SDUNIT(dev); /* Decompose unit & partition. */
1326 1.71 cgd part = SDPART(dev);
1327 1.1 cgd
1328 1.71 cgd /* Check for acceptable drive number. */
1329 1.89 thorpej if (unit >= sd_cd.cd_ndevs || (sd = sd_cd.cd_devs[unit]) == NULL)
1330 1.118 enami return (ENXIO);
1331 1.152 bouyer
1332 1.152 bouyer if ((sd->sc_dev.dv_flags & DVF_ACTIVE) == 0)
1333 1.152 bouyer return (ENODEV);
1334 1.3 deraadt
1335 1.71 cgd /* Make sure it was initialized. */
1336 1.171 bouyer if ((periph->periph_flags & PERIPH_MEDIA_LOADED) != 0)
1337 1.118 enami return (ENXIO);
1338 1.25 mycroft
1339 1.71 cgd /* Convert to disk sectors. Request must be a multiple of size. */
1340 1.84 thorpej lp = sd->sc_dk.dk_label;
1341 1.71 cgd sectorsize = lp->d_secsize;
1342 1.71 cgd if ((size % sectorsize) != 0)
1343 1.118 enami return (EFAULT);
1344 1.71 cgd totwrt = size / sectorsize;
1345 1.71 cgd blkno = dbtob(blkno) / sectorsize; /* blkno in DEV_BSIZE units */
1346 1.25 mycroft
1347 1.71 cgd nsects = lp->d_partitions[part].p_size;
1348 1.71 cgd sectoff = lp->d_partitions[part].p_offset;
1349 1.25 mycroft
1350 1.71 cgd /* Check transfer bounds against partition size. */
1351 1.71 cgd if ((blkno < 0) || ((blkno + totwrt) > nsects))
1352 1.118 enami return (EINVAL);
1353 1.25 mycroft
1354 1.71 cgd /* Offset block number to start of partition. */
1355 1.71 cgd blkno += sectoff;
1356 1.71 cgd
1357 1.71 cgd xs = &sx;
1358 1.3 deraadt
1359 1.71 cgd while (totwrt > 0) {
1360 1.71 cgd nwrt = totwrt; /* XXX */
1361 1.71 cgd #ifndef SD_DUMP_NOT_TRUSTED
1362 1.25 mycroft /*
1363 1.25 mycroft * Fill out the scsi command
1364 1.25 mycroft */
1365 1.25 mycroft bzero(&cmd, sizeof(cmd));
1366 1.51 mycroft cmd.opcode = WRITE_BIG;
1367 1.91 mycroft _lto4b(blkno, cmd.addr);
1368 1.91 mycroft _lto2b(nwrt, cmd.length);
1369 1.25 mycroft /*
1370 1.116 bouyer * Fill out the scsipi_xfer structure
1371 1.25 mycroft * Note: we cannot sleep as we may be an interrupt
1372 1.122 thorpej * don't use scsipi_command() as it may want to wait
1373 1.122 thorpej * for an xs.
1374 1.25 mycroft */
1375 1.25 mycroft bzero(xs, sizeof(sx));
1376 1.149 thorpej xs->xs_control |= XS_CTL_NOSLEEP | XS_CTL_POLL |
1377 1.149 thorpej XS_CTL_DATA_OUT;
1378 1.149 thorpej xs->xs_status = 0;
1379 1.171 bouyer xs->xs_periph = periph;
1380 1.171 bouyer xs->xs_retries = SDRETRIES;
1381 1.25 mycroft xs->timeout = 10000; /* 10000 millisecs for a disk ! */
1382 1.116 bouyer xs->cmd = (struct scsipi_generic *)&cmd;
1383 1.25 mycroft xs->cmdlen = sizeof(cmd);
1384 1.71 cgd xs->resid = nwrt * sectorsize;
1385 1.25 mycroft xs->error = XS_NOERROR;
1386 1.25 mycroft xs->bp = 0;
1387 1.71 cgd xs->data = va;
1388 1.71 cgd xs->datalen = nwrt * sectorsize;
1389 1.1 cgd
1390 1.25 mycroft /*
1391 1.25 mycroft * Pass all this info to the scsi driver.
1392 1.25 mycroft */
1393 1.171 bouyer scsipi_adapter_request(chan, ADAPTER_REQ_RUN_XFER, xs);
1394 1.171 bouyer if ((xs->xs_status & XS_STS_DONE) == 0 ||
1395 1.171 bouyer xs->error != XS_NOERROR)
1396 1.171 bouyer return (EIO);
1397 1.71 cgd #else /* SD_DUMP_NOT_TRUSTED */
1398 1.71 cgd /* Let's just talk about this first... */
1399 1.104 christos printf("sd%d: dump addr 0x%x, blk %d\n", unit, va, blkno);
1400 1.71 cgd delay(500 * 1000); /* half a second */
1401 1.71 cgd #endif /* SD_DUMP_NOT_TRUSTED */
1402 1.25 mycroft
1403 1.25 mycroft /* update block count */
1404 1.71 cgd totwrt -= nwrt;
1405 1.71 cgd blkno += nwrt;
1406 1.71 cgd va += sectorsize * nwrt;
1407 1.25 mycroft }
1408 1.71 cgd sddoingadump = 0;
1409 1.118 enami return (0);
1410 1.1 cgd }
1411