Change the kernel dev_t, representing a pointer to a specinfo structure,
[dragonfly.git] / sys / kern / subr_diskslice.c
1 /*-
2  * Copyright (c) 1994 Bruce D. Evans.
3  * All rights reserved.
4  *
5  * Copyright (c) 1990 The Regents of the University of California.
6  * All rights reserved.
7  *
8  * This code is derived from software contributed to Berkeley by
9  * William Jolitz.
10  *
11  * Copyright (c) 1982, 1986, 1988 Regents of the University of California.
12  * All rights reserved.
13  *
14  * Redistribution and use in source and binary forms, with or without
15  * modification, are permitted provided that the following conditions
16  * are met:
17  * 1. Redistributions of source code must retain the above copyright
18  *    notice, this list of conditions and the following disclaimer.
19  * 2. Redistributions in binary form must reproduce the above copyright
20  *    notice, this list of conditions and the following disclaimer in the
21  *    documentation and/or other materials provided with the distribution.
22  * 3. All advertising materials mentioning features or use of this software
23  *    must display the following acknowledgement:
24  *      This product includes software developed by the University of
25  *      California, Berkeley and its contributors.
26  * 4. Neither the name of the University nor the names of its contributors
27  *    may be used to endorse or promote products derived from this software
28  *    without specific prior written permission.
29  *
30  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
31  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
32  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
33  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
34  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
35  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
36  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
37  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
38  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
39  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
40  * SUCH DAMAGE.
41  *
42  *      from: @(#)wd.c  7.2 (Berkeley) 5/9/91
43  *      from: wd.c,v 1.55 1994/10/22 01:57:12 phk Exp $
44  *      from: @(#)ufs_disksubr.c        7.16 (Berkeley) 5/4/91
45  *      from: ufs_disksubr.c,v 1.8 1994/06/07 01:21:39 phk Exp $
46  * $FreeBSD: src/sys/kern/subr_diskslice.c,v 1.82.2.6 2001/07/24 09:49:41 dd Exp $
47  * $DragonFly: src/sys/kern/subr_diskslice.c,v 1.24 2006/09/10 01:26:39 dillon Exp $
48  */
49
50 #include <sys/param.h>
51 #include <sys/systm.h>
52 #include <sys/buf.h>
53 #include <sys/conf.h>
54 #include <sys/disklabel.h>
55 #include <sys/diskslice.h>
56 #include <sys/diskmbr.h>
57 #include <sys/fcntl.h>
58 #include <sys/malloc.h>
59 #include <sys/stat.h>
60 #include <sys/syslog.h>
61 #include <sys/proc.h>
62 #include <sys/vnode.h>
63 #include <sys/device.h>
64 #include <sys/thread2.h>
65
66 #include <vfs/ufs/dinode.h>     /* XXX used only for fs.h */
67 #include <vfs/ufs/fs.h>         /* XXX used only to get BBSIZE/SBSIZE */
68
69 #define TRACE(str)      do { if (ds_debug) printf str; } while (0)
70
71 typedef u_char  bool_t;
72
73 static volatile bool_t ds_debug;
74
75 static struct disklabel *clone_label (struct disklabel *lp);
76 static void dsiodone (struct bio *bio);
77 static char *fixlabel (char *sname, struct diskslice *sp,
78                            struct disklabel *lp, int writeflag);
79 static void free_ds_label (struct diskslices *ssp, int slice);
80 static void partition_info (char *sname, int part, struct partition *pp);
81 static void slice_info (char *sname, struct diskslice *sp);
82 static void set_ds_label (struct diskslices *ssp, int slice,
83                               struct disklabel *lp);
84 static void set_ds_wlabel (struct diskslices *ssp, int slice, int wlabel);
85
86 /*
87  * Duplicate a label for the whole disk, and initialize defaults in the
88  * copy for fields that are not already initialized.  The caller only
89  * needs to initialize d_secsize and d_secperunit, and zero the fields
90  * that are to be defaulted.
91  */
92 static struct disklabel *
93 clone_label(struct disklabel *lp)
94 {
95         struct disklabel *lp1;
96
97         lp1 = kmalloc(sizeof *lp1, M_DEVBUF, M_WAITOK);
98         *lp1 = *lp;
99         lp = NULL;
100         if (lp1->d_typename[0] == '\0')
101                 strncpy(lp1->d_typename, "amnesiac", sizeof(lp1->d_typename));
102         if (lp1->d_packname[0] == '\0')
103                 strncpy(lp1->d_packname, "fictitious", sizeof(lp1->d_packname));
104         if (lp1->d_nsectors == 0)
105                 lp1->d_nsectors = 32;
106         if (lp1->d_ntracks == 0)
107                 lp1->d_ntracks = 64;
108         lp1->d_secpercyl = lp1->d_nsectors * lp1->d_ntracks;
109         lp1->d_ncylinders = lp1->d_secperunit / lp1->d_secpercyl;
110         if (lp1->d_rpm == 0)
111                 lp1->d_rpm = 3600;
112         if (lp1->d_interleave == 0)
113                 lp1->d_interleave = 1;
114         if (lp1->d_npartitions < RAW_PART + 1)
115                 lp1->d_npartitions = MAXPARTITIONS;
116         if (lp1->d_bbsize == 0)
117                 lp1->d_bbsize = BBSIZE;
118         if (lp1->d_sbsize == 0)
119                 lp1->d_sbsize = SBSIZE;
120         lp1->d_partitions[RAW_PART].p_size = lp1->d_secperunit;
121         lp1->d_magic = DISKMAGIC;
122         lp1->d_magic2 = DISKMAGIC;
123         lp1->d_checksum = dkcksum(lp1);
124         return (lp1);
125 }
126
127 /*
128  * Determine the size of the transfer, and make sure it is
129  * within the boundaries of the partition. Adjust transfer
130  * if needed, and signal errors or early completion.
131  *
132  * XXX TODO:
133  *      o Split buffers that are too big for the device.
134  *      o Check for overflow.
135  *      o Finish cleaning this up.
136  *
137  * This function returns 1 on success, 0 if transfer equates
138  * to EOF (end of disk) or -1 on failure.  The appropriate 
139  * 'errno' value is also set in bp->b_error and bp->b_flags
140  * is marked with B_ERROR.
141  */
142 struct bio *
143 dscheck(cdev_t dev, struct bio *bio, struct diskslices *ssp)
144 {
145         struct buf *bp = bio->bio_buf;
146         struct bio *nbio;
147         u_long  endsecno;
148         daddr_t labelsect;
149         struct disklabel *lp;
150         char *msg;
151         long nsec;
152         struct partition *pp;
153         daddr_t secno;
154         daddr_t slicerel_secno;
155         struct diskslice *sp;
156         int shift;
157         int mask;
158
159         if (bio->bio_offset < 0) {
160                 printf("dscheck(%s): negative bio_offset %lld\n", 
161                     devtoname(dev), bio->bio_offset);
162                 goto bad;
163         }
164         sp = &ssp->dss_slices[dkslice(dev)];
165         lp = sp->ds_label;
166
167         if (ssp->dss_secmult == 1) {
168                 shift = DEV_BSHIFT;
169                 goto doshift;
170         } else if (ssp->dss_secshift != -1) {
171                 shift = DEV_BSHIFT + ssp->dss_secshift;
172 doshift:
173                 mask = (1 << shift) - 1;
174                 if ((int)bp->b_bcount & mask)
175                         goto bad_bcount;
176                 if ((int)bio->bio_offset & mask)
177                         goto bad_blkno;
178                 secno = (daddr_t)(bio->bio_offset >> shift);
179                 nsec = bp->b_bcount >> shift;
180         } else {
181                 if (bp->b_bcount % ssp->dss_secsize)
182                         goto bad_bcount;
183                 if (bio->bio_offset % ssp->dss_secsize)
184                         goto bad_blkno;
185                 secno = (daddr_t)(bio->bio_offset / ssp->dss_secsize);
186                 nsec = bp->b_bcount / ssp->dss_secsize;
187         }
188         if (lp == NULL) {
189                 labelsect = -LABELSECTOR - 1;
190                 endsecno = sp->ds_size;
191                 slicerel_secno = secno;
192         } else {
193                 labelsect = lp->d_partitions[LABEL_PART].p_offset;
194                 if (labelsect != 0)
195                         Debugger("labelsect != 0 in dscheck()");
196                 pp = &lp->d_partitions[dkpart(dev)];
197                 endsecno = pp->p_size;
198                 slicerel_secno = pp->p_offset + secno;
199         }
200
201         /* overwriting disk label ? */
202         /* XXX should also protect bootstrap in first 8K */
203         if (slicerel_secno <= LABELSECTOR + labelsect &&
204 #if LABELSECTOR != 0
205             slicerel_secno + nsec > LABELSECTOR + labelsect &&
206 #endif
207             bp->b_cmd != BUF_CMD_READ && sp->ds_wlabel == 0) {
208                 bp->b_error = EROFS;
209                 goto error;
210         }
211
212 #if defined(DOSBBSECTOR) && defined(notyet)
213         /* overwriting master boot record? */
214         if (slicerel_secno <= DOSBBSECTOR && bp->b_cmd != BUF_CMD_READ &&
215             sp->ds_wlabel == 0) {
216                 bp->b_error = EROFS;
217                 goto error;
218         }
219 #endif
220
221         /*
222          * EOF handling
223          */
224         if (secno + nsec > endsecno) {
225                 /*
226                  * Return an error if beyond the end of the disk, or
227                  * if B_BNOCLIP is set.  Tell the system that we do not
228                  * need to keep the buffer around.
229                  */
230                 if (secno > endsecno || (bp->b_flags & B_BNOCLIP))
231                         goto bad;
232
233                 /*
234                  * If exactly at end of disk, return an EOF.  Throw away
235                  * the buffer contents, if any, by setting B_INVAL.
236                  */
237                 if (secno == endsecno) {
238                         bp->b_resid = bp->b_bcount;
239                         bp->b_flags |= B_INVAL;
240                         goto done;
241                 }
242
243                 /*
244                  * Else truncate
245                  */
246                 nsec = endsecno - secno;
247                 bp->b_bcount = nsec * ssp->dss_secsize;
248         }
249
250         nbio = push_bio(bio);
251         nbio->bio_offset = (off_t)(sp->ds_offset + slicerel_secno) * 
252                            ssp->dss_secsize;
253
254         /*
255          * Snoop on label accesses if the slice offset is nonzero.  Fudge
256          * offsets in the label to keep the in-core label coherent with
257          * the on-disk one.
258          */
259         if (slicerel_secno <= LABELSECTOR + labelsect
260 #if LABELSECTOR != 0
261             && slicerel_secno + nsec > LABELSECTOR + labelsect
262 #endif
263             && sp->ds_offset != 0) {
264                 nbio->bio_done = dsiodone;
265                 nbio->bio_caller_info1.ptr = sp;
266                 nbio->bio_caller_info2.offset = (off_t)(LABELSECTOR + labelsect -
267                                          slicerel_secno) * ssp->dss_secsize;
268                 if (bp->b_cmd != BUF_CMD_READ) {
269                         /*
270                          * XXX even disklabel(8) writes directly so we need
271                          * to adjust writes.  Perhaps we should drop support
272                          * for DIOCWLABEL (always write protect labels) and
273                          * require the use of DIOCWDINFO.
274                          *
275                          * XXX probably need to copy the data to avoid even
276                          * temporarily corrupting the in-core copy.
277                          */
278                         /* XXX need name here. */
279                         msg = fixlabel(
280                                 NULL, sp,
281                                (struct disklabel *)
282                                (bp->b_data + (int)nbio->bio_caller_info2.offset),
283                                TRUE);
284                         if (msg != NULL) {
285                                 printf("dscheck(%s): %s\n", 
286                                     devtoname(dev), msg);
287                                 bp->b_error = EROFS;
288                                 pop_bio(nbio);
289                                 goto error;
290                         }
291                 }
292         }
293         return (nbio);
294
295 bad_bcount:
296         printf(
297         "dscheck(%s): b_bcount %d is not on a sector boundary (ssize %d)\n",
298             devtoname(dev), bp->b_bcount, ssp->dss_secsize);
299         goto bad;
300
301 bad_blkno:
302         printf(
303         "dscheck(%s): bio_offset %lld is not on a sector boundary (ssize %d)\n",
304             devtoname(dev), bio->bio_offset, ssp->dss_secsize);
305 bad:
306         bp->b_error = EINVAL;
307         /* fall through */
308 error:
309         /*
310          * Terminate the I/O with a ranging error.  Since the buffer is
311          * either illegal or beyond the file EOF, mark it B_INVAL as well.
312          */
313         bp->b_resid = bp->b_bcount;
314         bp->b_flags |= B_ERROR | B_INVAL;
315 done:
316         /*
317          * Caller must biodone() the originally passed bio if NULL is
318          * returned.
319          */
320         return (NULL);
321 }
322
323 void
324 dsclose(cdev_t dev, int mode, struct diskslices *ssp)
325 {
326         u_char mask;
327         struct diskslice *sp;
328
329         sp = &ssp->dss_slices[dkslice(dev)];
330         mask = 1 << dkpart(dev);
331         sp->ds_openmask &= ~mask;
332 }
333
334 void
335 dsgone(struct diskslices **sspp)
336 {
337         int slice;
338         struct diskslice *sp;
339         struct diskslices *ssp;
340
341         for (slice = 0, ssp = *sspp; slice < ssp->dss_nslices; slice++) {
342                 sp = &ssp->dss_slices[slice];
343                 free_ds_label(ssp, slice);
344         }
345         kfree(ssp, M_DEVBUF);
346         *sspp = NULL;
347 }
348
349 /*
350  * For the "write" commands (DIOCSDINFO and DIOCWDINFO), this
351  * is subject to the same restriction as dsopen().
352  */
353 int
354 dsioctl(cdev_t dev, u_long cmd, caddr_t data, 
355         int flags, struct diskslices **sspp)
356 {
357         int error;
358         struct disklabel *lp;
359         int old_wlabel;
360         u_char openmask;
361         int part;
362         int slice;
363         struct diskslice *sp;
364         struct diskslices *ssp;
365         struct partition *pp;
366
367         slice = dkslice(dev);
368         ssp = *sspp;
369         sp = &ssp->dss_slices[slice];
370         lp = sp->ds_label;
371         switch (cmd) {
372
373         case DIOCGDVIRGIN:
374                 lp = (struct disklabel *)data;
375                 if (ssp->dss_slices[WHOLE_DISK_SLICE].ds_label) {
376                         *lp = *ssp->dss_slices[WHOLE_DISK_SLICE].ds_label;
377                 } else {
378                         bzero(lp, sizeof(struct disklabel));
379                 }
380
381                 lp->d_magic = DISKMAGIC;
382                 lp->d_magic2 = DISKMAGIC;
383                 pp = &lp->d_partitions[RAW_PART];
384                 pp->p_offset = 0;
385                 pp->p_size = sp->ds_size;
386
387                 lp->d_npartitions = MAXPARTITIONS;
388                 if (lp->d_interleave == 0)
389                         lp->d_interleave = 1;
390                 if (lp->d_rpm == 0)
391                         lp->d_rpm = 3600;
392                 if (lp->d_nsectors == 0)
393                         lp->d_nsectors = 32;
394                 if (lp->d_ntracks == 0)
395                         lp->d_ntracks = 64;
396
397                 lp->d_bbsize = BBSIZE;
398                 lp->d_sbsize = SBSIZE;
399                 lp->d_secpercyl = lp->d_nsectors * lp->d_ntracks;
400                 lp->d_ncylinders = sp->ds_size / lp->d_secpercyl;
401                 lp->d_secperunit = sp->ds_size;
402                 lp->d_checksum = 0;
403                 lp->d_checksum = dkcksum(lp);
404                 return (0);
405
406         case DIOCGDINFO:
407                 if (lp == NULL)
408                         return (EINVAL);
409                 *(struct disklabel *)data = *lp;
410                 return (0);
411
412 #ifdef notyet
413         case DIOCGDINFOP:
414                 if (lp == NULL)
415                         return (EINVAL);
416                 *(struct disklabel **)data = lp;
417                 return (0);
418 #endif
419
420         case DIOCGPART:
421                 if (lp == NULL)
422                         return (EINVAL);
423                 ((struct partinfo *)data)->disklab = lp;
424                 ((struct partinfo *)data)->part
425                         = &lp->d_partitions[dkpart(dev)];
426                 return (0);
427
428         case DIOCGSLICEINFO:
429                 bcopy(ssp, data, (char *)&ssp->dss_slices[ssp->dss_nslices] -
430                                  (char *)ssp);
431                 return (0);
432
433         case DIOCSDINFO:
434                 if (slice == WHOLE_DISK_SLICE)
435                         return (ENODEV);
436                 if (!(flags & FWRITE))
437                         return (EBADF);
438                 lp = kmalloc(sizeof *lp, M_DEVBUF, M_WAITOK);
439                 if (sp->ds_label == NULL)
440                         bzero(lp, sizeof *lp);
441                 else
442                         bcopy(sp->ds_label, lp, sizeof *lp);
443                 if (sp->ds_label == NULL)
444                         openmask = 0;
445                 else {
446                         openmask = sp->ds_openmask;
447                         if (slice == COMPATIBILITY_SLICE)
448                                 openmask |= ssp->dss_slices[
449                                     ssp->dss_first_bsd_slice].ds_openmask;
450                         else if (slice == ssp->dss_first_bsd_slice)
451                                 openmask |= ssp->dss_slices[
452                                     COMPATIBILITY_SLICE].ds_openmask;
453                 }
454                 error = setdisklabel(lp, (struct disklabel *)data,
455                                      (u_long)openmask);
456                 /* XXX why doesn't setdisklabel() check this? */
457                 if (error == 0 && lp->d_partitions[RAW_PART].p_offset != 0)
458                         error = EXDEV;
459                 if (error == 0) {
460                         if (lp->d_secperunit > sp->ds_size)
461                                 error = ENOSPC;
462                         for (part = 0; part < lp->d_npartitions; part++)
463                                 if (lp->d_partitions[part].p_size > sp->ds_size)
464                                         error = ENOSPC;
465                 }
466                 if (error != 0) {
467                         kfree(lp, M_DEVBUF);
468                         return (error);
469                 }
470                 free_ds_label(ssp, slice);
471                 set_ds_label(ssp, slice, lp);
472                 return (0);
473
474         case DIOCSYNCSLICEINFO:
475                 if (slice != WHOLE_DISK_SLICE || dkpart(dev) != RAW_PART)
476                         return (EINVAL);
477                 if (!*(int *)data)
478                         for (slice = 0; slice < ssp->dss_nslices; slice++) {
479                                 openmask = ssp->dss_slices[slice].ds_openmask;
480                                 if (openmask
481                                     && (slice != WHOLE_DISK_SLICE
482                                         || openmask & ~(1 << RAW_PART)))
483                                         return (EBUSY);
484                         }
485
486                 /*
487                  * Temporarily forget the current slices struct and read
488                  * the current one.
489                  * XXX should wait for current accesses on this disk to
490                  * complete, then lock out future accesses and opens.
491                  */
492                 *sspp = NULL;
493                 lp = kmalloc(sizeof *lp, M_DEVBUF, M_WAITOK);
494                 *lp = *ssp->dss_slices[WHOLE_DISK_SLICE].ds_label;
495                 error = dsopen(dev, S_IFCHR, ssp->dss_oflags, sspp, lp);
496                 if (error != 0) {
497                         kfree(lp, M_DEVBUF);
498                         *sspp = ssp;
499                         return (error);
500                 }
501
502                 /*
503                  * Reopen everything.  This is a no-op except in the "force"
504                  * case and when the raw bdev and cdev are both open.  Abort
505                  * if anything fails.
506                  */
507                 for (slice = 0; slice < ssp->dss_nslices; slice++) {
508                         for (openmask = ssp->dss_slices[slice].ds_openmask,
509                              part = 0; openmask; openmask >>= 1, part++) {
510                                 if (!(openmask & 1))
511                                         continue;
512                                 error = dsopen(dkmodslice(dkmodpart(dev, part),
513                                                           slice),
514                                                S_IFCHR, ssp->dss_oflags, sspp,
515                                                lp);
516                                 if (error != 0) {
517                                         kfree(lp, M_DEVBUF);
518                                         *sspp = ssp;
519                                         return (EBUSY);
520                                 }
521                         }
522                 }
523
524                 kfree(lp, M_DEVBUF);
525                 dsgone(&ssp);
526                 return (0);
527
528         case DIOCWDINFO:
529                 error = dsioctl(dev, DIOCSDINFO, data, flags, &ssp);
530                 if (error != 0)
531                         return (error);
532                 /*
533                  * XXX this used to hack on dk_openpart to fake opening
534                  * partition 0 in case that is used instead of dkpart(dev).
535                  */
536                 old_wlabel = sp->ds_wlabel;
537                 set_ds_wlabel(ssp, slice, TRUE);
538                 error = writedisklabel(dev, sp->ds_label);
539                 /* XXX should invalidate in-core label if write failed. */
540                 set_ds_wlabel(ssp, slice, old_wlabel);
541                 return (error);
542
543         case DIOCWLABEL:
544                 if (slice == WHOLE_DISK_SLICE)
545                         return (ENODEV);
546                 if (!(flags & FWRITE))
547                         return (EBADF);
548                 set_ds_wlabel(ssp, slice, *(int *)data != 0);
549                 return (0);
550
551         default:
552                 return (ENOIOCTL);
553         }
554 }
555
556 /*
557  * Chain the bio_done.  b_cmd remains valid through such chaining.
558  */
559 static void
560 dsiodone(struct bio *bio)
561 {
562         struct buf *bp = bio->bio_buf;
563         char *msg;
564
565         if (bp->b_cmd != BUF_CMD_READ
566             || (!(bp->b_flags & B_ERROR) && bp->b_error == 0)) {
567                 msg = fixlabel(NULL, bio->bio_caller_info1.ptr,
568                                (struct disklabel *)
569                                (bp->b_data + (int)bio->bio_caller_info2.offset),
570                                FALSE);
571                 if (msg != NULL)
572                         printf("%s\n", msg);
573         }
574         biodone(bio->bio_prev);
575 }
576
577 int
578 dsisopen(struct diskslices *ssp)
579 {
580         int slice;
581
582         if (ssp == NULL)
583                 return (0);
584         for (slice = 0; slice < ssp->dss_nslices; slice++) {
585                 if (ssp->dss_slices[slice].ds_openmask)
586                         return (1);
587         }
588         return (0);
589 }
590
591 /*
592  * Allocate a slices "struct" and initialize it to contain only an empty
593  * compatibility slice (pointing to itself), a whole disk slice (covering
594  * the disk as described by the label), and (nslices - BASE_SLICES) empty
595  * slices beginning at BASE_SLICE.
596  */
597 struct diskslices *
598 dsmakeslicestruct(int nslices, struct disklabel *lp)
599 {
600         struct diskslice *sp;
601         struct diskslices *ssp;
602
603         ssp = kmalloc(offsetof(struct diskslices, dss_slices) +
604                      nslices * sizeof *sp, M_DEVBUF, M_WAITOK);
605         ssp->dss_first_bsd_slice = COMPATIBILITY_SLICE;
606         ssp->dss_nslices = nslices;
607         ssp->dss_oflags = 0;
608         ssp->dss_secmult = lp->d_secsize / DEV_BSIZE;
609         if (ssp->dss_secmult & (ssp->dss_secmult - 1))
610                 ssp->dss_secshift = -1;
611         else
612                 ssp->dss_secshift = ffs(ssp->dss_secmult) - 1;
613         ssp->dss_secsize = lp->d_secsize;
614         sp = &ssp->dss_slices[0];
615         bzero(sp, nslices * sizeof *sp);
616         sp[WHOLE_DISK_SLICE].ds_size = lp->d_secperunit;
617         return (ssp);
618 }
619
620 char *
621 dsname(cdev_t dev, int unit, int slice, int part, char *partname)
622 {
623         static char name[32];
624         const char *dname;
625
626         dname = dev_dname(dev);
627         if (strlen(dname) > 16)
628                 dname = "nametoolong";
629         snprintf(name, sizeof(name), "%s%d", dname, unit);
630         partname[0] = '\0';
631         if (slice != WHOLE_DISK_SLICE || part != RAW_PART) {
632                 partname[0] = 'a' + part;
633                 partname[1] = '\0';
634                 if (slice != COMPATIBILITY_SLICE) {
635                         snprintf(name + strlen(name),
636                             sizeof(name) - strlen(name), "s%d", slice - 1);
637                 }
638         }
639         return (name);
640 }
641
642 /*
643  * This should only be called when the unit is inactive and the strategy
644  * routine should not allow it to become active unless we call it.  Our
645  * strategy routine must be special to allow activity.
646  */
647 int
648 dsopen(cdev_t dev, int mode, u_int flags, 
649         struct diskslices **sspp, struct disklabel *lp)
650 {
651         cdev_t dev1;
652         int error;
653         struct disklabel *lp1;
654         char *msg;
655         u_char mask;
656         bool_t need_init;
657         int part;
658         char partname[2];
659         int slice;
660         char *sname;
661         struct diskslice *sp;
662         struct diskslices *ssp;
663         int unit;
664
665         dev->si_bsize_phys = lp->d_secsize;
666
667         unit = dkunit(dev);
668         if (lp->d_secsize % DEV_BSIZE) {
669                 printf("%s: invalid sector size %lu\n", devtoname(dev),
670                     (u_long)lp->d_secsize);
671                 return (EINVAL);
672         }
673
674         /*
675          * Do not attempt to read the slice table or disk label when
676          * accessing the raw disk.
677          */
678         if (dkslice(dev) == WHOLE_DISK_SLICE && dkpart(dev) == RAW_PART) {
679                 flags |= DSO_ONESLICE | DSO_NOLABELS;
680         }
681
682         /*
683          * XXX reinitialize the slice table unless there is an open device
684          * on the unit.  This should only be done if the media has changed.
685          */
686         ssp = *sspp;
687         need_init = !dsisopen(ssp);
688         if (ssp != NULL && need_init)
689                 dsgone(sspp);
690         if (need_init) {
691                 /*
692                  * Allocate a minimal slices "struct".  This will become
693                  * the final slices "struct" if we don't want real slices
694                  * or if we can't find any real slices.
695                  */
696                 *sspp = dsmakeslicestruct(BASE_SLICE, lp);
697
698                 if (!(flags & DSO_ONESLICE)) {
699                         TRACE(("dsinit\n"));
700                         error = dsinit(dev, lp, sspp);
701                         if (error != 0) {
702                                 dsgone(sspp);
703                                 return (error);
704                         }
705                 }
706                 ssp = *sspp;
707                 ssp->dss_oflags = flags;
708
709                 /*
710                  * If there are no real slices, then make the compatiblity
711                  * slice cover the whole disk.
712                  */
713                 if (ssp->dss_nslices == BASE_SLICE)
714                         ssp->dss_slices[COMPATIBILITY_SLICE].ds_size
715                                 = lp->d_secperunit;
716
717                 /* Point the compatibility slice at the BSD slice, if any. */
718                 for (slice = BASE_SLICE; slice < ssp->dss_nslices; slice++) {
719                         sp = &ssp->dss_slices[slice];
720                         if (sp->ds_type == DOSPTYP_386BSD /* XXX */) {
721                                 ssp->dss_first_bsd_slice = slice;
722                                 ssp->dss_slices[COMPATIBILITY_SLICE].ds_offset
723                                         = sp->ds_offset;
724                                 ssp->dss_slices[COMPATIBILITY_SLICE].ds_size
725                                         = sp->ds_size;
726                                 ssp->dss_slices[COMPATIBILITY_SLICE].ds_type
727                                         = sp->ds_type;
728                                 break;
729                         }
730                 }
731
732                 ssp->dss_slices[WHOLE_DISK_SLICE].ds_label = clone_label(lp);
733                 ssp->dss_slices[WHOLE_DISK_SLICE].ds_wlabel = TRUE;
734         }
735
736         /*
737          * Initialize secondary info for all slices.  It is needed for more
738          * than the current slice in the DEVFS case.  XXX DEVFS is no more.
739          */
740         for (slice = 0; slice < ssp->dss_nslices; slice++) {
741                 sp = &ssp->dss_slices[slice];
742                 if (sp->ds_label != NULL)
743                         continue;
744                 dev1 = dkmodslice(dkmodpart(dev, RAW_PART), slice);
745                 sname = dsname(dev, unit, slice, RAW_PART, partname);
746                 /*
747                  * XXX this should probably only be done for the need_init
748                  * case, but there may be a problem with DIOCSYNCSLICEINFO.
749                  */
750                 set_ds_wlabel(ssp, slice, TRUE);        /* XXX invert */
751                 lp1 = clone_label(lp);
752                 TRACE(("readdisklabel\n"));
753                 if (flags & DSO_NOLABELS)
754                         msg = NULL;
755                 else {
756                         msg = readdisklabel(dev1, lp1);
757
758                         /*
759                          * readdisklabel() returns NULL for success, and an
760                          * error string for failure.
761                          *
762                          * If there isn't a label on the disk, and if the
763                          * DSO_COMPATLABEL is set, we want to use the
764                          * faked-up label provided by the caller.
765                          *
766                          * So we set msg to NULL to indicate that there is
767                          * no failure (since we have a faked-up label),
768                          * free lp1, and then clone it again from lp.
769                          * (In case readdisklabel() modified lp1.)
770                          */
771                         if (msg != NULL && (flags & DSO_COMPATLABEL)) {
772                                 msg = NULL;
773                                 kfree(lp1, M_DEVBUF);
774                                 lp1 = clone_label(lp);
775                         }
776                 }
777                 if (msg == NULL)
778                         msg = fixlabel(sname, sp, lp1, FALSE);
779                 if (msg == NULL && lp1->d_secsize != ssp->dss_secsize)
780                         msg = "inconsistent sector size";
781                 if (msg != NULL) {
782                         if (sp->ds_type == DOSPTYP_386BSD /* XXX */)
783                                 log(LOG_WARNING, "%s: cannot find label (%s)\n",
784                                     sname, msg);
785                         kfree(lp1, M_DEVBUF);
786                         continue;
787                 }
788                 if (lp1->d_flags & D_BADSECT) {
789                         log(LOG_ERR, "%s: bad sector table not supported\n",
790                             sname);
791                         kfree(lp1, M_DEVBUF);
792                         continue;
793                 }
794                 set_ds_label(ssp, slice, lp1);
795                 set_ds_wlabel(ssp, slice, FALSE);
796         }
797
798         slice = dkslice(dev);
799         if (slice >= ssp->dss_nslices)
800                 return (ENXIO);
801         sp = &ssp->dss_slices[slice];
802         part = dkpart(dev);
803         if (part != RAW_PART
804             && (sp->ds_label == NULL || part >= sp->ds_label->d_npartitions))
805                 return (EINVAL);        /* XXX needs translation */
806         mask = 1 << part;
807         sp->ds_openmask |= mask;
808         return (0);
809 }
810
811 int
812 dssize(cdev_t dev, struct diskslices **sspp)
813 {
814         struct disklabel *lp;
815         int part;
816         int slice;
817         struct diskslices *ssp;
818
819         slice = dkslice(dev);
820         part = dkpart(dev);
821         ssp = *sspp;
822         if (ssp == NULL || slice >= ssp->dss_nslices
823             || !(ssp->dss_slices[slice].ds_openmask & (1 << part))) {
824                 if (dev_dopen(dev, FREAD, S_IFCHR, proc0.p_ucred) != 0)
825                         return (-1);
826                 dev_dclose(dev, FREAD, S_IFCHR);
827                 ssp = *sspp;
828         }
829         lp = ssp->dss_slices[slice].ds_label;
830         if (lp == NULL)
831                 return (-1);
832         return ((int)lp->d_partitions[part].p_size);
833 }
834
835 static void
836 free_ds_label(struct diskslices *ssp, int slice)
837 {
838         struct disklabel *lp;
839         struct diskslice *sp;
840
841         sp = &ssp->dss_slices[slice];
842         lp = sp->ds_label;
843         if (lp == NULL)
844                 return;
845         kfree(lp, M_DEVBUF);
846         set_ds_label(ssp, slice, (struct disklabel *)NULL);
847 }
848
849 static char *
850 fixlabel(char *sname, struct diskslice *sp, struct disklabel *lp, int writeflag)
851 {
852         u_long end;
853         u_long offset;
854         int part;
855         struct partition *pp;
856         u_long start;
857         bool_t warned;
858
859         /* These errors "can't happen" so don't bother reporting details. */
860         if (lp->d_magic != DISKMAGIC || lp->d_magic2 != DISKMAGIC)
861                 return ("fixlabel: invalid magic");
862         if (dkcksum(lp) != 0)
863                 return ("fixlabel: invalid checksum");
864
865         pp = &lp->d_partitions[RAW_PART];
866         if (writeflag) {
867                 start = 0;
868                 offset = sp->ds_offset;
869         } else {
870                 start = sp->ds_offset;
871                 offset = -sp->ds_offset;
872         }
873         if (pp->p_offset != start) {
874                 if (sname != NULL) {
875                         printf(
876 "%s: rejecting BSD label: raw partition offset != slice offset\n",
877                                sname);
878                         slice_info(sname, sp);
879                         partition_info(sname, RAW_PART, pp);
880                 }
881                 return ("fixlabel: raw partition offset != slice offset");
882         }
883         if (pp->p_size != sp->ds_size) {
884                 if (sname != NULL) {
885                         printf("%s: raw partition size != slice size\n", sname);
886                         slice_info(sname, sp);
887                         partition_info(sname, RAW_PART, pp);
888                 }
889                 if (pp->p_size > sp->ds_size) {
890                         if (sname == NULL)
891                                 return ("fixlabel: raw partition size > slice size");
892                         printf("%s: truncating raw partition\n", sname);
893                         pp->p_size = sp->ds_size;
894                 }
895         }
896         end = start + sp->ds_size;
897         if (start > end)
898                 return ("fixlabel: slice wraps");
899         if (lp->d_secpercyl <= 0)
900                 return ("fixlabel: d_secpercyl <= 0");
901         pp -= RAW_PART;
902         warned = FALSE;
903         for (part = 0; part < lp->d_npartitions; part++, pp++) {
904                 if (pp->p_offset != 0 || pp->p_size != 0) {
905                         if (pp->p_offset < start
906                             || pp->p_offset + pp->p_size > end
907                             || pp->p_offset + pp->p_size < pp->p_offset) {
908                                 if (sname != NULL) {
909                                         printf(
910 "%s: rejecting partition in BSD label: it isn't entirely within the slice\n",
911                                                sname);
912                                         if (!warned) {
913                                                 slice_info(sname, sp);
914                                                 warned = TRUE;
915                                         }
916                                         partition_info(sname, part, pp);
917                                 }
918                                 /* XXX else silently discard junk. */
919                                 bzero(pp, sizeof *pp);
920                         } else
921                                 pp->p_offset += offset;
922                 }
923         }
924         lp->d_ncylinders = sp->ds_size / lp->d_secpercyl;
925         lp->d_secperunit = sp->ds_size;
926         lp->d_checksum = 0;
927         lp->d_checksum = dkcksum(lp);
928         return (NULL);
929 }
930
931 static void
932 partition_info(char *sname, int part, struct partition *pp)
933 {
934         printf("%s%c: start %lu, end %lu, size %lu\n", sname, 'a' + part,
935                (u_long)pp->p_offset, (u_long)(pp->p_offset + pp->p_size - 1),
936                (u_long)pp->p_size);
937 }
938
939 static void
940 slice_info(char *sname, struct diskslice *sp)
941 {
942         printf("%s: start %lu, end %lu, size %lu\n", sname,
943                sp->ds_offset, sp->ds_offset + sp->ds_size - 1, sp->ds_size);
944 }
945
946 static void
947 set_ds_label(struct diskslices *ssp, int slice, struct disklabel *lp)
948 {
949         ssp->dss_slices[slice].ds_label = lp;
950         if (slice == COMPATIBILITY_SLICE)
951                 ssp->dss_slices[ssp->dss_first_bsd_slice].ds_label = lp;
952         else if (slice == ssp->dss_first_bsd_slice)
953                 ssp->dss_slices[COMPATIBILITY_SLICE].ds_label = lp;
954 }
955
956 static void
957 set_ds_wlabel(struct diskslices *ssp, int slice, int wlabel)
958 {
959         ssp->dss_slices[slice].ds_wlabel = wlabel;
960         if (slice == COMPATIBILITY_SLICE)
961                 ssp->dss_slices[ssp->dss_first_bsd_slice].ds_wlabel = wlabel;
962         else if (slice == ssp->dss_first_bsd_slice)
963                 ssp->dss_slices[COMPATIBILITY_SLICE].ds_wlabel = wlabel;
964 }