d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
1c85e6a35d
freebsd-nq/sys/kern/subr_diskslice.c

998 lines
26 KiB
C
Raw Normal View History

subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
/*-
* Copyright (c) 1994 Bruce D. Evans.
* All rights reserved.
*
* Copyright (c) 1990 The Regents of the University of California.
* All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* William Jolitz.
*
* Copyright (c) 1982, 1986, 1988 Regents of the University of California.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* from: @(#)wd.c 7.2 (Berkeley) 5/9/91
* from: wd.c,v 1.55 1994/10/22 01:57:12 phk Exp $
* from: @(#)ufs_disksubr.c 7.16 (Berkeley) 5/4/91
* from: ufs_disksubr.c,v 1.8 1994/06/07 01:21:39 phk Exp $
$Id$ -> $FreeBSD$
1999-08-28 01:08:13 +00:00
* $FreeBSD$
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
*/
#include <sys/param.h>
Divorce "dev_t" from the "major|minor" bitmap, which is now called udev_t in the kernel but still called dev_t in userland. Provide functions to manipulate both types: major() umajor() minor() uminor() makedev() umakedev() dev2udev() udev2dev() For now they're functions, they will become in-line functions after one of the next two steps in this process. Return major/minor/makedev to macro-hood for userland. Register a name in cdevsw[] for the "filedescriptor" driver. In the kernel the udev_t appears in places where we have the major/minor number combination, (ie: a potential device: we may not have the driver nor the device), like in inodes, vattr, cdevsw registration and so on, whereas the dev_t appears where we carry around a reference to a actual device. In the future the cdevsw and the aliased-from vnode will be hung directly from the dev_t, along with up to two softc pointers for the device driver and a few houskeeping bits. This will essentially replace the current "alias" check code (same buck, bigger bang). A little stunt has been provided to try to catch places where the wrong type is being used (dev_t vs udev_t), if you see something not working, #undef DEVT_FASCIST in kern/kern_conf.c and see if it makes a difference. If it does, please try to track it down (many hands make light work) or at least try to reproduce it as simply as possible, and describe how to do that. Without DEVT_FASCIST I belive this patch is a no-op. Stylistic/posixoid comments about the userland view of the <sys/*.h> files welcome now, from userland they now contain the end result. Next planned step: make all dev_t's refer to the same devsw[] which means convert BLK's to CHR's at the perimeter of the vnodes and other places where they enter the game (bootdev, mknod, sysctl).
1999-05-11 19:55:07 +00:00
#include <sys/systm.h>
Separate the struct bio related stuff out of <sys/buf.h> into <sys/bio.h>. <sys/bio.h> is now a prerequisite for <sys/buf.h> but it shall not be made a nested include according to bdes teachings on the subject of nested includes. Diskdrivers and similar stuff below specfs::strategy() should no longer need to include <sys/buf.> unless they need caching of data. Still a few bogus uses of struct buf to track down. Repocopy by: peter
2000-05-05 09:59:14 +00:00
#include <sys/bio.h>
Don't include <sys/conf.h> for the kernel in disk-related headers. It is needed for implementation details but very little of it is needed for the interface. Include it in the few places that didn't already include it. Include <sys/ioccom.h> in <sys/disklabel.h> (as already in <sys/diskslice.h>) so that all the disk-related headers are almost self-sufficient.
1996-09-20 17:39:44 +00:00
#include <sys/conf.h>
Move generic disk ioctls from <sys/disklabel.h> to <sys/disk.h>. Sponsored by: DARPA & NAI Labs
2002-04-08 09:20:07 +00:00
#include <sys/disk.h>
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
#include <sys/disklabel.h>
#include <sys/diskslice.h>
#include <sys/fcntl.h>
#include <sys/malloc.h>
#include <sys/stat.h>
Fixed overflow in the bounds checking in dscheck(). It assumed that daadr_t is no larger than a long, and some other relatively harmless things (*blush*). Overflow for subtracting a daddr_t from a u_long caused "truncation" of the i/o for attempts to access blocks beyond the end of the actually cause expansion of the i/o to a preposterous size.
2002-06-06 00:35:07 +00:00
#include <sys/stdint.h>
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
#include <sys/syslog.h>
This should fix PR 438. Apparently I never tested disklabel on the block device. v_numoutput wasn't incremented to match the b_iodone nesting. It's still fishy that vwakeup() clears B_WRITEINPROG before biodone() has finished; however, B_WRITEINPROG seems to be never used. Submitted by: Bruce Evans
1995-05-24 23:33:42 +00:00
#include <sys/vnode.h>
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
Don't warn about missing labels for non-BSD slices. Don't print debugging messages by default. Initialize the compatibility slice here and not in the machine-dependent code. Fix initialization of the label for the whole disk slice. Make it clear that write protection of labels doesn't apply when there is no label.
1995-03-04 11:42:27 +00:00
#define TRACE(str) do { if (ds_debug) printf str; } while (0)
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
typedef u_char bool_t;
Don't warn about missing labels for non-BSD slices. Don't print debugging messages by default. Initialize the compatibility slice here and not in the machine-dependent code. Fix initialization of the label for the whole disk slice. Make it clear that write protection of labels doesn't apply when there is no label.
1995-03-04 11:42:27 +00:00
static volatile bool_t ds_debug;
Remove __P.
2002-03-19 21:25:46 +00:00
static struct disklabel *clone_label(struct disklabel *lp);
static void dsiodone(struct bio *bp);
static char *fixlabel(char *sname, struct diskslice *sp,
struct disklabel *lp, int writeflag);
static void free_ds_label(struct diskslices *ssp, int slice);
static void partition_info(char *sname, int part, struct partition *pp);
static void slice_info(char *sname, struct diskslice *sp);
static void set_ds_label(struct diskslices *ssp, int slice,
struct disklabel *lp);
static void set_ds_labeldevs(dev_t dev, struct diskslices *ssp);
static void set_ds_wlabel(struct diskslices *ssp, int slice,
int wlabel);
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
Initialize more defaults for the in-core label for the whole disk. Callers only need to initialize d_secperunit now, but should initialize d_type (to reduce the IDE/SCSI confusion), d_typename (put the disk model in it) and geometry info (if it isn't completely ficticious). Callers will soon need to initialize d_secsize.
1998-07-20 14:35:27 +00:00
/*
* Duplicate a label for the whole disk, and initialize defaults in the
* copy for fields that are not already initialized. The caller only
* needs to initialize d_secsize and d_secperunit, and zero the fields
* that are to be defaulted.
*/
static struct disklabel *
clone_label(lp)
struct disklabel *lp;
{
struct disklabel *lp1;
lp1 = malloc(sizeof *lp1, M_DEVBUF, M_WAITOK);
*lp1 = *lp;
lp = NULL;
if (lp1->d_typename[0] == '\0')
strncpy(lp1->d_typename, "amnesiac", sizeof(lp1->d_typename));
if (lp1->d_packname[0] == '\0')
strncpy(lp1->d_packname, "fictitious", sizeof(lp1->d_packname));
if (lp1->d_nsectors == 0)
lp1->d_nsectors = 32;
if (lp1->d_ntracks == 0)
lp1->d_ntracks = 64;
lp1->d_secpercyl = lp1->d_nsectors * lp1->d_ntracks;
lp1->d_ncylinders = lp1->d_secperunit / lp1->d_secpercyl;
if (lp1->d_rpm == 0)
lp1->d_rpm = 3600;
if (lp1->d_interleave == 0)
lp1->d_interleave = 1;
if (lp1->d_npartitions < RAW_PART + 1)
lp1->d_npartitions = MAXPARTITIONS;
if (lp1->d_bbsize == 0)
lp1->d_bbsize = BBSIZE;
lp1->d_partitions[RAW_PART].p_size = lp1->d_secperunit;
lp1->d_magic = DISKMAGIC;
lp1->d_magic2 = DISKMAGIC;
lp1->d_checksum = dkcksum(lp1);
return (lp1);
}
Uninlined most of the bloated inline functions in <sys/disklabel.h>. Some of them need to become even larger to support devfs.
2002-01-17 18:33:18 +00:00
dev_t
dkmodpart(dev_t dev, int part)
{
return (makedev(major(dev), (minor(dev) & ~7) | part));
}
dev_t
dkmodslice(dev_t dev, int slice)
{
return (makedev(major(dev), (minor(dev) & ~0x1f0000) | (slice << 16)));
}
u_int
dkunit(dev_t dev)
{
return (((minor(dev) >> 16) & 0x1e0) | ((minor(dev) >> 3) & 0x1f));
}
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
/*
* Determine the size of the transfer, and make sure it is
* within the boundaries of the partition. Adjust transfer
* if needed, and signal errors or early completion.
*
* XXX TODO:
* o Split buffers that are too big for the device.
* o Check for overflow.
* o Finish cleaning this up.
*/
int
dscheck(bp, ssp)
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
struct bio *bp;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
struct diskslices *ssp;
{
This commit adds basic support for the UFS2 filesystem. The UFS2 filesystem expands the inode to 256 bytes to make space for 64-bit block pointers. It also adds a file-creation time field, an ability to use jumbo blocks per inode to allow extent like pointer density, and space for extended attributes (up to twice the filesystem block size worth of attributes, e.g., on a 16K filesystem, there is space for 32K of attributes). UFS2 fully supports and runs existing UFS1 filesystems. New filesystems built using newfs can be built in either UFS1 or UFS2 format using the -O option. In this commit UFS1 is the default format, so if you want to build UFS2 format filesystems, you must specify -O 2. This default will be changed to UFS2 when UFS2 proves itself to be stable. In this commit the boot code for reading UFS2 filesystems is not compiled (see /sys/boot/common/ufsread.c) as there is insufficient space in the boot block. Once the size of the boot block is increased, this code can be defined. Things to note: the definition of SBSIZE has changed to SBLOCKSIZE. The header file <ufs/ufs/dinode.h> must be included before <ufs/ffs/fs.h> so as to get the definitions of ufs2_daddr_t and ufs_lbn_t. Still TODO: Verify that the first level bootstraps work for all the architectures. Convert the utility ffsinfo to understand UFS2 and test growfs. Add support for the extended attribute storage. Update soft updates to ensure integrity of extended attribute storage. Switch the current extended attribute interfaces to use the extended attribute storage. Add the extent like functionality (framework is there, but is currently never used). Sponsored by: DARPA & NAI Labs. Reviewed by: Poul-Henning Kamp <phk@freebsd.org>
2002-06-21 06:18:05 +00:00
daddr_t blkno;
daddr_t endsecno;
daddr_t labelsect;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
struct disklabel *lp;
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
char *msg;
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
long nsec;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
struct partition *pp;
This commit adds basic support for the UFS2 filesystem. The UFS2 filesystem expands the inode to 256 bytes to make space for 64-bit block pointers. It also adds a file-creation time field, an ability to use jumbo blocks per inode to allow extent like pointer density, and space for extended attributes (up to twice the filesystem block size worth of attributes, e.g., on a 16K filesystem, there is space for 32K of attributes). UFS2 fully supports and runs existing UFS1 filesystems. New filesystems built using newfs can be built in either UFS1 or UFS2 format using the -O option. In this commit UFS1 is the default format, so if you want to build UFS2 format filesystems, you must specify -O 2. This default will be changed to UFS2 when UFS2 proves itself to be stable. In this commit the boot code for reading UFS2 filesystems is not compiled (see /sys/boot/common/ufsread.c) as there is insufficient space in the boot block. Once the size of the boot block is increased, this code can be defined. Things to note: the definition of SBSIZE has changed to SBLOCKSIZE. The header file <ufs/ufs/dinode.h> must be included before <ufs/ffs/fs.h> so as to get the definitions of ufs2_daddr_t and ufs_lbn_t. Still TODO: Verify that the first level bootstraps work for all the architectures. Convert the utility ffsinfo to understand UFS2 and test growfs. Add support for the extended attribute storage. Update soft updates to ensure integrity of extended attribute storage. Switch the current extended attribute interfaces to use the extended attribute storage. Add the extent like functionality (framework is there, but is currently never used). Sponsored by: DARPA & NAI Labs. Reviewed by: Poul-Henning Kamp <phk@freebsd.org>
2002-06-21 06:18:05 +00:00
daddr_t secno;
daddr_t slicerel_secno;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
struct diskslice *sp;
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
blkno = bp->bio_blkno;
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
if (blkno < 0) {
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
printf("dscheck(%s): negative bio_blkno %ld\n",
devtoname(bp->bio_dev), (long)blkno);
bp->bio_error = EINVAL;
It's bad if the blockno is negative.
1996-01-07 22:39:06 +00:00
goto bad;
Remove local TRUE & FALSE definitions. Fall into debugger on negative blk#.
1996-01-16 18:11:24 +00:00
}
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
sp = &ssp->dss_slices[dkslice(bp->bio_dev)];
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
lp = sp->ds_label;
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
if (ssp->dss_secmult == 1) {
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
if (bp->bio_bcount % (u_long)DEV_BSIZE)
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
goto bad_bcount;
secno = blkno;
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
nsec = bp->bio_bcount >> DEV_BSHIFT;
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
} else if (ssp->dss_secshift != -1) {
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
if (bp->bio_bcount & (ssp->dss_secsize - 1))
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
goto bad_bcount;
if (blkno & (ssp->dss_secmult - 1))
goto bad_blkno;
secno = blkno >> ssp->dss_secshift;
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
nsec = bp->bio_bcount >> (DEV_BSHIFT + ssp->dss_secshift);
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
} else {
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
if (bp->bio_bcount % ssp->dss_secsize)
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
goto bad_bcount;
if (blkno % ssp->dss_secmult)
goto bad_blkno;
secno = blkno / ssp->dss_secmult;
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
nsec = bp->bio_bcount / ssp->dss_secsize;
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
}
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
if (lp == NULL) {
labelsect = -LABELSECTOR - 1;
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
endsecno = sp->ds_size;
slicerel_secno = secno;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
} else {
labelsect = lp->d_partitions[LABEL_PART].p_offset;
Add compatibility cruft. Slice 0 is now for the first BSD slice. The first BSD slice is the first DOSpartition with id 0xa5 or the whole disk if their are no DOSpartitions (except the latter is not yet implemented). Existing partitions on it work the same as in 2.0 except the 'd' partition is no longer special and partitions are relative to the skice. Slice 1 is now for the whole disk and gets a read-only label describing the disk. Previously, slice 0 was for the whole disk and there was no label on it. Slices 2-31 are for DOSpartitions. Slice 0 is an alias for one of these if there is a BSD slice. Previously, slices 1-31 were for DOSpartitions. diskslice_machdep.c: Expand whole disk slice to include all DOSpartitions. More work is required for >1024 cylinders and to rewrite the label iff the driver is unsure about the geometry. subr_diskslice.c: New function dsisopen() to help handle media changes.
1995-02-16 15:19:19 +00:00
if (labelsect != 0) Debugger("labelsect != 0 in dscheck()");
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
pp = &lp->d_partitions[dkpart(bp->bio_dev)];
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
endsecno = pp->p_size;
slicerel_secno = pp->p_offset + secno;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
}
/* overwriting disk label ? */
/* XXX should also protect bootstrap in first 8K */
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
if (slicerel_secno <= LABELSECTOR + labelsect &&
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
#if LABELSECTOR != 0
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
slicerel_secno + nsec > LABELSECTOR + labelsect &&
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
#endif
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
(bp->bio_cmd == BIO_WRITE) && sp->ds_wlabel == 0) {
bp->bio_error = EROFS;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
goto bad;
}
#if defined(DOSBBSECTOR) && defined(notyet)
/* overwriting master boot record? */
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
if (slicerel_secno <= DOSBBSECTOR && (bp->bio_cmd == BIO_WRITE) &&
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
sp->ds_wlabel == 0) {
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
bp->bio_error = EROFS;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
goto bad;
}
#endif
/* beyond partition? */
Fixed overflow in the bounds checking in dscheck(). It assumed that daadr_t is no larger than a long, and some other relatively harmless things (*blush*). Overflow for subtracting a daddr_t from a u_long caused "truncation" of the i/o for attempts to access blocks beyond the end of the actually cause expansion of the i/o to a preposterous size.
2002-06-06 00:35:07 +00:00
if ((uintmax_t)secno + nsec > endsecno) {
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
/* if exactly at end of disk, return an EOF */
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
if (secno == endsecno) {
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
bp->bio_resid = bp->bio_bcount;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
return (0);
}
/* or truncate if part of it fits */
Fixed overflow in the bounds checking in dscheck(). It assumed that daadr_t is no larger than a long, and some other relatively harmless things (*blush*). Overflow for subtracting a daddr_t from a u_long caused "truncation" of the i/o for attempts to access blocks beyond the end of the actually cause expansion of the i/o to a preposterous size.
2002-06-06 00:35:07 +00:00
if (secno > endsecno) {
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
bp->bio_error = EINVAL;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
goto bad;
}
Fixed overflow in the bounds checking in dscheck(). It assumed that daadr_t is no larger than a long, and some other relatively harmless things (*blush*). Overflow for subtracting a daddr_t from a u_long caused "truncation" of the i/o for attempts to access blocks beyond the end of the actually cause expansion of the i/o to a preposterous size.
2002-06-06 00:35:07 +00:00
bp->bio_bcount = (endsecno - secno) * ssp->dss_secsize;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
}
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
bp->bio_pblkno = sp->ds_offset + slicerel_secno;
Keep absolute offsets in on-disk labels for backwards compatibility. This requires complications to adjust the offsets to relative when a block containing the label is read and back to absolute when such a block is written. The adjustment is not made on the whole disk slice. Don't allow setting the offset of partition C to nonzero in in-core labels. This will cause some (nonstandard) disktab entries to fail. They will need to be changed to have relative offsets (and no partitions outside of the slice). Don't write protect the (nonexistent) label on the whole disk slice. Writing labels and bootstraps should work right now (except if there is no DOSpartition table).
1995-02-18 22:10:44 +00:00
/*
* Snoop on label accesses if the slice offset is nonzero. Fudge
* offsets in the label to keep the in-core label coherent with
* the on-disk one.
*/
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
if (slicerel_secno <= LABELSECTOR + labelsect
Keep absolute offsets in on-disk labels for backwards compatibility. This requires complications to adjust the offsets to relative when a block containing the label is read and back to absolute when such a block is written. The adjustment is not made on the whole disk slice. Don't allow setting the offset of partition C to nonzero in in-core labels. This will cause some (nonstandard) disktab entries to fail. They will need to be changed to have relative offsets (and no partitions outside of the slice). Don't write protect the (nonexistent) label on the whole disk slice. Writing labels and bootstraps should work right now (except if there is no DOSpartition table).
1995-02-18 22:10:44 +00:00
#if LABELSECTOR != 0
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
&& slicerel_secno + nsec > LABELSECTOR + labelsect
Keep absolute offsets in on-disk labels for backwards compatibility. This requires complications to adjust the offsets to relative when a block containing the label is read and back to absolute when such a block is written. The adjustment is not made on the whole disk slice. Don't allow setting the offset of partition C to nonzero in in-core labels. This will cause some (nonstandard) disktab entries to fail. They will need to be changed to have relative offsets (and no partitions outside of the slice). Don't write protect the (nonexistent) label on the whole disk slice. Writing labels and bootstraps should work right now (except if there is no DOSpartition table).
1995-02-18 22:10:44 +00:00
#endif
&& sp->ds_offset != 0) {
struct iodone_chain *ic;
ic = malloc(sizeof *ic , M_DEVBUF, M_WAITOK);
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
ic->ic_prev_flags = bp->bio_flags;
ic->ic_prev_iodone = bp->bio_done;
ic->ic_prev_iodone_chain = bp->bio_done_chain;
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
ic->ic_args[0].ia_long = (LABELSECTOR + labelsect -
slicerel_secno) * ssp->dss_secsize;
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
ic->ic_args[1].ia_ptr = sp;
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
bp->bio_done = dsiodone;
bp->bio_done_chain = ic;
if (!(bp->bio_cmd == BIO_READ)) {
Keep absolute offsets in on-disk labels for backwards compatibility. This requires complications to adjust the offsets to relative when a block containing the label is read and back to absolute when such a block is written. The adjustment is not made on the whole disk slice. Don't allow setting the offset of partition C to nonzero in in-core labels. This will cause some (nonstandard) disktab entries to fail. They will need to be changed to have relative offsets (and no partitions outside of the slice). Don't write protect the (nonexistent) label on the whole disk slice. Writing labels and bootstraps should work right now (except if there is no DOSpartition table).
1995-02-18 22:10:44 +00:00
/*
* XXX even disklabel(8) writes directly so we need
* to adjust writes. Perhaps we should drop support
* for DIOCWLABEL (always write protect labels) and
* require the use of DIOCWDINFO.
*
* XXX probably need to copy the data to avoid even
* temporarily corrupting the in-core copy.
*/
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
/* XXX need name here. */
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
msg = fixlabel((char *)NULL, sp,
(struct disklabel *)
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
(bp->bio_data + ic->ic_args[0].ia_long),
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
TRUE);
if (msg != NULL) {
Include "dscheck" and device name in all messages from dscheck().
1999-08-31 18:36:15 +00:00
printf("dscheck(%s): %s\n",
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
devtoname(bp->bio_dev), msg);
bp->bio_error = EROFS;
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
goto bad;
}
Keep absolute offsets in on-disk labels for backwards compatibility. This requires complications to adjust the offsets to relative when a block containing the label is read and back to absolute when such a block is written. The adjustment is not made on the whole disk slice. Don't allow setting the offset of partition C to nonzero in in-core labels. This will cause some (nonstandard) disktab entries to fail. They will need to be changed to have relative offsets (and no partitions outside of the slice). Don't write protect the (nonexistent) label on the whole disk slice. Writing labels and bootstraps should work right now (except if there is no DOSpartition table).
1995-02-18 22:10:44 +00:00
}
}
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
return (1);
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
bad_bcount:
Use "multiple 4 char outdent until no wrap" rather than ANSI string concatenation to preserve K&R compatibility. Requested by: bde Terminology by: grog
1999-09-01 09:39:11 +00:00
printf(
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
"dscheck(%s): bio_bcount %ld is not on a sector boundary (ssize %d)\n",
devtoname(bp->bio_dev), bp->bio_bcount, ssp->dss_secsize);
bp->bio_error = EINVAL;
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
goto bad;
bad_blkno:
Use "multiple 4 char outdent until no wrap" rather than ANSI string concatenation to preserve K&R compatibility. Requested by: bde Terminology by: grog
1999-09-01 09:39:11 +00:00
printf(
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
"dscheck(%s): bio_blkno %ld is not on a sector boundary (ssize %d)\n",
devtoname(bp->bio_dev), (long)blkno, ssp->dss_secsize);
bp->bio_error = EINVAL;
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
goto bad;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
bad:
Complete the bio/buf divorce for all code below devfs::strategy Exceptions: Vinum untouched. This means that it cannot be compiled. Greg Lehey is on the case. CCD not converted yet, casts to struct buf (still safe) atapi-cd casts to struct buf to examine B_PHYS
2000-04-15 05:54:02 +00:00
bp->bio_resid = bp->bio_bcount;
bp->bio_flags |= BIO_ERROR;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
return (-1);
}
void
dsclose(dev, mode, ssp)
dev_t dev;
int mode;
struct diskslices *ssp;
{
u_char mask;
struct diskslice *sp;
sp = &ssp->dss_slices[dkslice(dev)];
mask = 1 << dkpart(dev);
Cleanup some more remaining bdev fluff.
2000-01-16 09:25:34 +00:00
sp->ds_openmask &= ~mask;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
}
Separate go-away code from dsinit() to produce dsgone(). Call correct_writedisklabel() instead of writedisklabel() (temporary compatibility hack). Remove kludge for allowing a label on slice 0.
1994-12-16 16:14:39 +00:00
void
dsgone(sspp)
struct diskslices **sspp;
{
int slice;
struct diskslice *sp;
struct diskslices *ssp;
for (slice = 0, ssp = *sspp; slice < ssp->dss_nslices; slice++) {
sp = &ssp->dss_slices[slice];
Fixed removal of devfs entries for the real slice corresponding to the compatibility slice. They were forgotten on last-close and then creating them on first-open failed. Devfs entries for slices other than the one containing the root file system are still invisible unless you open a non-devfs inode on the slice.
1996-04-19 19:22:29 +00:00
free_ds_label(ssp, slice);
Separate go-away code from dsinit() to produce dsgone(). Call correct_writedisklabel() instead of writedisklabel() (temporary compatibility hack). Remove kludge for allowing a label on slice 0.
1994-12-16 16:14:39 +00:00
}
Add compatibility cruft. Slice 0 is now for the first BSD slice. The first BSD slice is the first DOSpartition with id 0xa5 or the whole disk if their are no DOSpartitions (except the latter is not yet implemented). Existing partitions on it work the same as in 2.0 except the 'd' partition is no longer special and partitions are relative to the skice. Slice 1 is now for the whole disk and gets a read-only label describing the disk. Previously, slice 0 was for the whole disk and there was no label on it. Slices 2-31 are for DOSpartitions. Slice 0 is an alias for one of these if there is a BSD slice. Previously, slices 1-31 were for DOSpartitions. diskslice_machdep.c: Expand whole disk slice to include all DOSpartitions. More work is required for >1024 cylinders and to rewrite the label iff the driver is unsure about the geometry. subr_diskslice.c: New function dsisopen() to help handle media changes.
1995-02-16 15:19:19 +00:00
free(ssp, M_DEVBUF);
Separate go-away code from dsinit() to produce dsgone(). Call correct_writedisklabel() instead of writedisklabel() (temporary compatibility hack). Remove kludge for allowing a label on slice 0.
1994-12-16 16:14:39 +00:00
*sspp = NULL;
}
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
/*
Remove BAD144 support, it has already been disabled for some time.
1999-12-08 09:33:00 +00:00
* For the "write" commands (DIOCSDINFO and DIOCWDINFO), this
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
* is subject to the same restriction as dsopen().
*/
int
We don't need to pass the diskname argument all over the diskslice/label code, we can find the name from any convenient dev_t
1999-08-28 14:33:44 +00:00
dsioctl(dev, cmd, data, flags, sspp)
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
dev_t dev;
Protect all modifications to v_numoutput with splbio().
1998-08-13 08:09:08 +00:00
u_long cmd;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
caddr_t data;
int flags;
Change dsioctl() interface to allow DIOCSYNCSLICEINFO to update the caller's slice pointer and to print the device name in error messages. Finishing implementing DIOCSYNCSLICEINFO (except for locking).
1995-04-30 15:16:02 +00:00
struct diskslices **sspp;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
{
int error;
struct disklabel *lp;
int old_wlabel;
Reject attempts to set an in-core label which says that the "disk" or a partition is larger than the slice. Now `disklabel -Brw sdX auto' should fail properly on sliced disks without partition of type 165, e.g., on zip disks with the factory default formatting. Previously it set a bogus in-core label for the compatibility slice and used this to corrupt the MBR (the slice has offset 0 and size 0, but setting the label in effect corrupted its size to nonzero). `disklabel -Brw sdX auto' already failed properly on normally (not dangerously dedicated) sliced disks _with_ partition of type 165, because the compatibility slice has a nonzero offset so the MBR remained inaccessible when the size was corrupted. This bug only affected in-core labels. On-disk labels are checked carefully when they read and written.
1997-09-16 10:11:49 +00:00
u_char openmask;
int part;
Add compatibility cruft. Slice 0 is now for the first BSD slice. The first BSD slice is the first DOSpartition with id 0xa5 or the whole disk if their are no DOSpartitions (except the latter is not yet implemented). Existing partitions on it work the same as in 2.0 except the 'd' partition is no longer special and partitions are relative to the skice. Slice 1 is now for the whole disk and gets a read-only label describing the disk. Previously, slice 0 was for the whole disk and there was no label on it. Slices 2-31 are for DOSpartitions. Slice 0 is an alias for one of these if there is a BSD slice. Previously, slices 1-31 were for DOSpartitions. diskslice_machdep.c: Expand whole disk slice to include all DOSpartitions. More work is required for >1024 cylinders and to rewrite the label iff the driver is unsure about the geometry. subr_diskslice.c: New function dsisopen() to help handle media changes.
1995-02-16 15:19:19 +00:00
int slice;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
struct diskslice *sp;
Change dsioctl() interface to allow DIOCSYNCSLICEINFO to update the caller's slice pointer and to print the device name in error messages. Finishing implementing DIOCSYNCSLICEINFO (except for locking).
1995-04-30 15:16:02 +00:00
struct diskslices *ssp;
Add a new ioctl for doing virgin disklabels. Submitted by: dillon
2000-10-31 07:05:40 +00:00
struct partition *pp;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
Add compatibility cruft. Slice 0 is now for the first BSD slice. The first BSD slice is the first DOSpartition with id 0xa5 or the whole disk if their are no DOSpartitions (except the latter is not yet implemented). Existing partitions on it work the same as in 2.0 except the 'd' partition is no longer special and partitions are relative to the skice. Slice 1 is now for the whole disk and gets a read-only label describing the disk. Previously, slice 0 was for the whole disk and there was no label on it. Slices 2-31 are for DOSpartitions. Slice 0 is an alias for one of these if there is a BSD slice. Previously, slices 1-31 were for DOSpartitions. diskslice_machdep.c: Expand whole disk slice to include all DOSpartitions. More work is required for >1024 cylinders and to rewrite the label iff the driver is unsure about the geometry. subr_diskslice.c: New function dsisopen() to help handle media changes.
1995-02-16 15:19:19 +00:00
slice = dkslice(dev);
Change dsioctl() interface to allow DIOCSYNCSLICEINFO to update the caller's slice pointer and to print the device name in error messages. Finishing implementing DIOCSYNCSLICEINFO (except for locking).
1995-04-30 15:16:02 +00:00
ssp = *sspp;
Add compatibility cruft. Slice 0 is now for the first BSD slice. The first BSD slice is the first DOSpartition with id 0xa5 or the whole disk if their are no DOSpartitions (except the latter is not yet implemented). Existing partitions on it work the same as in 2.0 except the 'd' partition is no longer special and partitions are relative to the skice. Slice 1 is now for the whole disk and gets a read-only label describing the disk. Previously, slice 0 was for the whole disk and there was no label on it. Slices 2-31 are for DOSpartitions. Slice 0 is an alias for one of these if there is a BSD slice. Previously, slices 1-31 were for DOSpartitions. diskslice_machdep.c: Expand whole disk slice to include all DOSpartitions. More work is required for >1024 cylinders and to rewrite the label iff the driver is unsure about the geometry. subr_diskslice.c: New function dsisopen() to help handle media changes.
1995-02-16 15:19:19 +00:00
sp = &ssp->dss_slices[slice];
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
lp = sp->ds_label;
switch (cmd) {
Add a new ioctl for doing virgin disklabels. Submitted by: dillon
2000-10-31 07:05:40 +00:00
case DIOCGDVIRGIN:
lp = (struct disklabel *)data;
if (ssp->dss_slices[WHOLE_DISK_SLICE].ds_label) {
*lp = *ssp->dss_slices[WHOLE_DISK_SLICE].ds_label;
} else {
bzero(lp, sizeof(struct disklabel));
}
lp->d_magic = DISKMAGIC;
lp->d_magic2 = DISKMAGIC;
pp = &lp->d_partitions[RAW_PART];
pp->p_offset = 0;
pp->p_size = sp->ds_size;
lp->d_npartitions = MAXPARTITIONS;
if (lp->d_interleave == 0)
lp->d_interleave = 1;
if (lp->d_rpm == 0)
lp->d_rpm = 3600;
if (lp->d_nsectors == 0)
lp->d_nsectors = 32;
if (lp->d_ntracks == 0)
lp->d_ntracks = 64;
lp->d_bbsize = BBSIZE;
Retire the bogus uses of the disklabel field d_sbsize and begin to initialize it to zero so we don't have to have everbody and their aunt including FFS specific header files. Sponsored by: DARPA & NAI Labs.
2002-05-12 20:49:41 +00:00
lp->d_sbsize = 0;
Add a new ioctl for doing virgin disklabels. Submitted by: dillon
2000-10-31 07:05:40 +00:00
lp->d_secpercyl = lp->d_nsectors * lp->d_ntracks;
lp->d_ncylinders = sp->ds_size / lp->d_secpercyl;
lp->d_secperunit = sp->ds_size;
lp->d_checksum = 0;
lp->d_checksum = dkcksum(lp);
return (0);
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
case DIOCGDINFO:
if (lp == NULL)
return (EINVAL);
*(struct disklabel *)data = *lp;
return (0);
Implement the two "GEOM" ioctls DIOCGSECTORSIZE and DIOCGMEDIASIZE for the non-GEOM code as well. This simplifies the the kernel-dumping and disk-management tools as less compatibility cruft will be needed. Sponsored by: DARPA and NAI Labs.
2002-03-31 21:17:12 +00:00
case DIOCGSECTORSIZE:
if (lp == NULL)
return (EINVAL);
*(u_int *)data = lp->d_secsize;
return (0);
case DIOCGMEDIASIZE:
if (lp == NULL)
return (EINVAL);
*(off_t *)data = (off_t)lp->d_partitions[dkpart(dev)].p_size *
lp->d_secsize;
return (0);
Add ioctls DIOCGSLICEINFO and DIOCSYNCSLICEINFO. The latter isn't finished or tested.
1995-04-24 17:07:08 +00:00
case DIOCGSLICEINFO:
Don't attempt to copy the whole slices "struct" for DIOCGSLICEINFO. The slices "struct" isn't really a struct; we allocate only part of it in the fully dangerously dedicated case. Since the "struct" is malloced, the page beyond it may not be mapped, so attempts to copy it would crash. This problem became larger when the full struct was bloated from < 1K to > 3K by the addition of (mostly unused) DEVFS tokens some time before 2.2.0 was released.
1998-06-06 03:06:55 +00:00
bcopy(ssp, data, (char *)&ssp->dss_slices[ssp->dss_nslices] -
(char *)ssp);
Add ioctls DIOCGSLICEINFO and DIOCSYNCSLICEINFO. The latter isn't finished or tested.
1995-04-24 17:07:08 +00:00
return (0);
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
case DIOCSDINFO:
Add compatibility cruft. Slice 0 is now for the first BSD slice. The first BSD slice is the first DOSpartition with id 0xa5 or the whole disk if their are no DOSpartitions (except the latter is not yet implemented). Existing partitions on it work the same as in 2.0 except the 'd' partition is no longer special and partitions are relative to the skice. Slice 1 is now for the whole disk and gets a read-only label describing the disk. Previously, slice 0 was for the whole disk and there was no label on it. Slices 2-31 are for DOSpartitions. Slice 0 is an alias for one of these if there is a BSD slice. Previously, slices 1-31 were for DOSpartitions. diskslice_machdep.c: Expand whole disk slice to include all DOSpartitions. More work is required for >1024 cylinders and to rewrite the label iff the driver is unsure about the geometry. subr_diskslice.c: New function dsisopen() to help handle media changes.
1995-02-16 15:19:19 +00:00
if (slice == WHOLE_DISK_SLICE)
return (ENODEV);
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
if (!(flags & FWRITE))
return (EBADF);
lp = malloc(sizeof *lp, M_DEVBUF, M_WAITOK);
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
if (sp->ds_label == NULL)
bzero(lp, sizeof *lp);
else
bcopy(sp->ds_label, lp, sizeof *lp);
Fixed an aliasing bug. It was too easy to defeat the check for moving or shrinking an open partition (by changing the label for a compatibility slice while partitions on the corresponding real slice are open, or vice versa).
1998-02-15 05:41:31 +00:00
if (sp->ds_label == NULL)
openmask = 0;
else {
openmask = sp->ds_openmask;
if (slice == COMPATIBILITY_SLICE)
openmask |= ssp->dss_slices[
ssp->dss_first_bsd_slice].ds_openmask;
else if (slice == ssp->dss_first_bsd_slice)
openmask |= ssp->dss_slices[
COMPATIBILITY_SLICE].ds_openmask;
}
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
error = setdisklabel(lp, (struct disklabel *)data,
Fixed an aliasing bug. It was too easy to defeat the check for moving or shrinking an open partition (by changing the label for a compatibility slice while partitions on the corresponding real slice are open, or vice versa).
1998-02-15 05:41:31 +00:00
(u_long)openmask);
Keep absolute offsets in on-disk labels for backwards compatibility. This requires complications to adjust the offsets to relative when a block containing the label is read and back to absolute when such a block is written. The adjustment is not made on the whole disk slice. Don't allow setting the offset of partition C to nonzero in in-core labels. This will cause some (nonstandard) disktab entries to fail. They will need to be changed to have relative offsets (and no partitions outside of the slice). Don't write protect the (nonexistent) label on the whole disk slice. Writing labels and bootstraps should work right now (except if there is no DOSpartition table).
1995-02-18 22:10:44 +00:00
/* XXX why doesn't setdisklabel() check this? */
if (error == 0 && lp->d_partitions[RAW_PART].p_offset != 0)
Overload the correct errno for attempts to set an in-core label with a raw partition at a nonzero offset (EINVAL should have been EXDEV; DIOCSDINFO was broken, and DIOCWDINFO was broken because it depended on DIOCSDINFO). A zero offset for the raw partition should probably be enforced in setdisklabel(), and DIOCWDINFO should probably always be handled by first calling setdisklabel() so that writedisklabel() doesn't need to enforce it, but this has never been done; dsioctl() has a special check. Changes in this commit are limited to dsioctl() to preserve bug for bug compatibility in drivers that don't use the slice code (notably the ccd driver, which allows setting a bogus label in DIOCWDINFO and doesn't undo the setting when writedisklabel() fails).
1998-10-17 09:46:42 +00:00
error = EXDEV;
Reject attempts to set an in-core label which says that the "disk" or a partition is larger than the slice. Now `disklabel -Brw sdX auto' should fail properly on sliced disks without partition of type 165, e.g., on zip disks with the factory default formatting. Previously it set a bogus in-core label for the compatibility slice and used this to corrupt the MBR (the slice has offset 0 and size 0, but setting the label in effect corrupted its size to nonzero). `disklabel -Brw sdX auto' already failed properly on normally (not dangerously dedicated) sliced disks _with_ partition of type 165, because the compatibility slice has a nonzero offset so the MBR remained inaccessible when the size was corrupted. This bug only affected in-core labels. On-disk labels are checked carefully when they read and written.
1997-09-16 10:11:49 +00:00
if (error == 0) {
if (lp->d_secperunit > sp->ds_size)
error = ENOSPC;
for (part = 0; part < lp->d_npartitions; part++)
if (lp->d_partitions[part].p_size > sp->ds_size)
error = ENOSPC;
}
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
if (error != 0) {
free(lp, M_DEVBUF);
return (error);
}
Fixed removal of devfs entries for the real slice corresponding to the compatibility slice. They were forgotten on last-close and then creating them on first-open failed. Devfs entries for slices other than the one containing the root file system are still invisible unless you open a non-devfs inode on the slice.
1996-04-19 19:22:29 +00:00
free_ds_label(ssp, slice);
Add compatibility cruft. Slice 0 is now for the first BSD slice. The first BSD slice is the first DOSpartition with id 0xa5 or the whole disk if their are no DOSpartitions (except the latter is not yet implemented). Existing partitions on it work the same as in 2.0 except the 'd' partition is no longer special and partitions are relative to the skice. Slice 1 is now for the whole disk and gets a read-only label describing the disk. Previously, slice 0 was for the whole disk and there was no label on it. Slices 2-31 are for DOSpartitions. Slice 0 is an alias for one of these if there is a BSD slice. Previously, slices 1-31 were for DOSpartitions. diskslice_machdep.c: Expand whole disk slice to include all DOSpartitions. More work is required for >1024 cylinders and to rewrite the label iff the driver is unsure about the geometry. subr_diskslice.c: New function dsisopen() to help handle media changes.
1995-02-16 15:19:19 +00:00
set_ds_label(ssp, slice, lp);
We don't need to pass the diskname argument all over the diskslice/label code, we can find the name from any convenient dev_t
1999-08-28 14:33:44 +00:00
set_ds_labeldevs(dev, ssp);
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
return (0);
Add ioctls DIOCGSLICEINFO and DIOCSYNCSLICEINFO. The latter isn't finished or tested.
1995-04-24 17:07:08 +00:00
case DIOCSYNCSLICEINFO:
if (slice != WHOLE_DISK_SLICE || dkpart(dev) != RAW_PART)
return (EINVAL);
Change dsioctl() interface to allow DIOCSYNCSLICEINFO to update the caller's slice pointer and to print the device name in error messages. Finishing implementing DIOCSYNCSLICEINFO (except for locking).
1995-04-30 15:16:02 +00:00
if (!*(int *)data)
for (slice = 0; slice < ssp->dss_nslices; slice++) {
Cleaned up rev.1.39 - the shadowing variable should have just gone away.
1998-07-20 13:51:11 +00:00
openmask = ssp->dss_slices[slice].ds_openmask;
if (openmask
Change dsioctl() interface to allow DIOCSYNCSLICEINFO to update the caller's slice pointer and to print the device name in error messages. Finishing implementing DIOCSYNCSLICEINFO (except for locking).
1995-04-30 15:16:02 +00:00
&& (slice != WHOLE_DISK_SLICE
Cleaned up rev.1.39 - the shadowing variable should have just gone away.
1998-07-20 13:51:11 +00:00
|| openmask & ~(1 << RAW_PART)))
Change dsioctl() interface to allow DIOCSYNCSLICEINFO to update the caller's slice pointer and to print the device name in error messages. Finishing implementing DIOCSYNCSLICEINFO (except for locking).
1995-04-30 15:16:02 +00:00
return (EBUSY);
}
/*
* Temporarily forget the current slices struct and read
* the current one.
* XXX should wait for current accesses on this disk to
* complete, then lock out future accesses and opens.
*/
*sspp = NULL;
Add ioctls DIOCGSLICEINFO and DIOCSYNCSLICEINFO. The latter isn't finished or tested.
1995-04-24 17:07:08 +00:00
lp = malloc(sizeof *lp, M_DEVBUF, M_WAITOK);
*lp = *ssp->dss_slices[WHOLE_DISK_SLICE].ds_label;
Cleanup some more remaining bdev fluff.
2000-01-16 09:25:34 +00:00
error = dsopen(dev, S_IFCHR, ssp->dss_oflags, sspp, lp);
Change dsioctl() interface to allow DIOCSYNCSLICEINFO to update the caller's slice pointer and to print the device name in error messages. Finishing implementing DIOCSYNCSLICEINFO (except for locking).
1995-04-30 15:16:02 +00:00
if (error != 0) {
free(lp, M_DEVBUF);
*sspp = ssp;
return (error);
}
Fix reopening of open subdevices for DIOCSYNCSLICEINFO: Reopen the bdev for the raw partition and not the cdev if only the bdev was open. Don't use a bogus limit for the number of partitions to possibly reopen (bug found by Julian). Add function dssize() to help fix wdsize() and sdsize(). The slice layer knows more about (un)open partitions and partition sizes than the driver layer.
1995-05-08 16:24:08 +00:00
/*
* Reopen everything. This is a no-op except in the "force"
* case and when the raw bdev and cdev are both open. Abort
* if anything fails.
*/
Change dsioctl() interface to allow DIOCSYNCSLICEINFO to update the caller's slice pointer and to print the device name in error messages. Finishing implementing DIOCSYNCSLICEINFO (except for locking).
1995-04-30 15:16:02 +00:00
for (slice = 0; slice < ssp->dss_nslices; slice++) {
Cleanup some more remaining bdev fluff.
2000-01-16 09:25:34 +00:00
for (openmask = ssp->dss_slices[slice].ds_openmask,
Fix reopening of open subdevices for DIOCSYNCSLICEINFO: Reopen the bdev for the raw partition and not the cdev if only the bdev was open. Don't use a bogus limit for the number of partitions to possibly reopen (bug found by Julian). Add function dssize() to help fix wdsize() and sdsize(). The slice layer knows more about (un)open partitions and partition sizes than the driver layer.
1995-05-08 16:24:08 +00:00
part = 0; openmask; openmask >>= 1, part++) {
if (!(openmask & 1))
Change dsioctl() interface to allow DIOCSYNCSLICEINFO to update the caller's slice pointer and to print the device name in error messages. Finishing implementing DIOCSYNCSLICEINFO (except for locking).
1995-04-30 15:16:02 +00:00
continue;
Const poisoning from d_name. Fixed some style bugs in recent changes.
1999-09-13 14:12:23 +00:00
error = dsopen(dkmodslice(dkmodpart(dev, part),
Change dsioctl() interface to allow DIOCSYNCSLICEINFO to update the caller's slice pointer and to print the device name in error messages. Finishing implementing DIOCSYNCSLICEINFO (except for locking).
1995-04-30 15:16:02 +00:00
slice),
Added a flags arg to dsopen() and updated drivers. The DSO_ONESLICE and DSO_NOLABELS flags prevent searching for slices and labels respectively. Current drivers don't set these flags. When DSO_NOLABELS is set, the in-core label for the whole disk is cloned to create an in-core label for each slice. This gives the correct result (a good in-core label for the compatibility slice) if DSO_ONESLICE is set or only one slice is found, but usually gives broken labels otherwise, so DSO_ONESLICE should be set if DSO_NOLABELS is set.
1998-07-30 15:16:06 +00:00
S_IFCHR, ssp->dss_oflags, sspp,
Spring cleaning around strategy and disklabels/slices: Introduce BUF_STRATEGY(struct buf *, int flag) macro, and use it throughout. please see comment in sys/conf.h about the flag argument. Remove strategy argument from all the diskslice/label/bad144 implementations, it should be found from the dev_t. Remove bogus and unused strategy1 routines. Remove open/close arguments from dssize(). Pick them up from dev_t. Remove unused and unfinished setgeom support from diskslice/label/bad144 code.
1999-08-14 11:40:51 +00:00
lp);
Change dsioctl() interface to allow DIOCSYNCSLICEINFO to update the caller's slice pointer and to print the device name in error messages. Finishing implementing DIOCSYNCSLICEINFO (except for locking).
1995-04-30 15:16:02 +00:00
if (error != 0) {
free(lp, M_DEVBUF);
*sspp = ssp;
return (EBUSY);
}
}
}
Fix reopening of open subdevices for DIOCSYNCSLICEINFO: Reopen the bdev for the raw partition and not the cdev if only the bdev was open. Don't use a bogus limit for the number of partitions to possibly reopen (bug found by Julian). Add function dssize() to help fix wdsize() and sdsize(). The slice layer knows more about (un)open partitions and partition sizes than the driver layer.
1995-05-08 16:24:08 +00:00
Add ioctls DIOCGSLICEINFO and DIOCSYNCSLICEINFO. The latter isn't finished or tested.
1995-04-24 17:07:08 +00:00
free(lp, M_DEVBUF);
Change dsioctl() interface to allow DIOCSYNCSLICEINFO to update the caller's slice pointer and to print the device name in error messages. Finishing implementing DIOCSYNCSLICEINFO (except for locking).
1995-04-30 15:16:02 +00:00
dsgone(&ssp);
return (0);
Add ioctls DIOCGSLICEINFO and DIOCSYNCSLICEINFO. The latter isn't finished or tested.
1995-04-24 17:07:08 +00:00
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
case DIOCWDINFO:
We don't need to pass the diskname argument all over the diskslice/label code, we can find the name from any convenient dev_t
1999-08-28 14:33:44 +00:00
error = dsioctl(dev, DIOCSDINFO, data, flags, &ssp);
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
if (error != 0)
return (error);
/*
* XXX this used to hack on dk_openpart to fake opening
* partition 0 in case that is used instead of dkpart(dev).
*/
old_wlabel = sp->ds_wlabel;
Add compatibility cruft. Slice 0 is now for the first BSD slice. The first BSD slice is the first DOSpartition with id 0xa5 or the whole disk if their are no DOSpartitions (except the latter is not yet implemented). Existing partitions on it work the same as in 2.0 except the 'd' partition is no longer special and partitions are relative to the skice. Slice 1 is now for the whole disk and gets a read-only label describing the disk. Previously, slice 0 was for the whole disk and there was no label on it. Slices 2-31 are for DOSpartitions. Slice 0 is an alias for one of these if there is a BSD slice. Previously, slices 1-31 were for DOSpartitions. diskslice_machdep.c: Expand whole disk slice to include all DOSpartitions. More work is required for >1024 cylinders and to rewrite the label iff the driver is unsure about the geometry. subr_diskslice.c: New function dsisopen() to help handle media changes.
1995-02-16 15:19:19 +00:00
set_ds_wlabel(ssp, slice, TRUE);
Spring cleaning around strategy and disklabels/slices: Introduce BUF_STRATEGY(struct buf *, int flag) macro, and use it throughout. please see comment in sys/conf.h about the flag argument. Remove strategy argument from all the diskslice/label/bad144 implementations, it should be found from the dev_t. Remove bogus and unused strategy1 routines. Remove open/close arguments from dssize(). Pick them up from dev_t. Remove unused and unfinished setgeom support from diskslice/label/bad144 code.
1999-08-14 11:40:51 +00:00
error = writedisklabel(dev, sp->ds_label);
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
/* XXX should invalidate in-core label if write failed. */
Add compatibility cruft. Slice 0 is now for the first BSD slice. The first BSD slice is the first DOSpartition with id 0xa5 or the whole disk if their are no DOSpartitions (except the latter is not yet implemented). Existing partitions on it work the same as in 2.0 except the 'd' partition is no longer special and partitions are relative to the skice. Slice 1 is now for the whole disk and gets a read-only label describing the disk. Previously, slice 0 was for the whole disk and there was no label on it. Slices 2-31 are for DOSpartitions. Slice 0 is an alias for one of these if there is a BSD slice. Previously, slices 1-31 were for DOSpartitions. diskslice_machdep.c: Expand whole disk slice to include all DOSpartitions. More work is required for >1024 cylinders and to rewrite the label iff the driver is unsure about the geometry. subr_diskslice.c: New function dsisopen() to help handle media changes.
1995-02-16 15:19:19 +00:00
set_ds_wlabel(ssp, slice, old_wlabel);
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
return (error);
case DIOCWLABEL:
Hack the diskslice stuff so that it allows the alpha sysinstall to manipulate the disklabel. This is almost certainly not the right way to do it but I'm desperate.
1999-05-09 11:27:41 +00:00
#ifndef __alpha__
Add compatibility cruft. Slice 0 is now for the first BSD slice. The first BSD slice is the first DOSpartition with id 0xa5 or the whole disk if their are no DOSpartitions (except the latter is not yet implemented). Existing partitions on it work the same as in 2.0 except the 'd' partition is no longer special and partitions are relative to the skice. Slice 1 is now for the whole disk and gets a read-only label describing the disk. Previously, slice 0 was for the whole disk and there was no label on it. Slices 2-31 are for DOSpartitions. Slice 0 is an alias for one of these if there is a BSD slice. Previously, slices 1-31 were for DOSpartitions. diskslice_machdep.c: Expand whole disk slice to include all DOSpartitions. More work is required for >1024 cylinders and to rewrite the label iff the driver is unsure about the geometry. subr_diskslice.c: New function dsisopen() to help handle media changes.
1995-02-16 15:19:19 +00:00
if (slice == WHOLE_DISK_SLICE)
return (ENODEV);
Hack the diskslice stuff so that it allows the alpha sysinstall to manipulate the disklabel. This is almost certainly not the right way to do it but I'm desperate.
1999-05-09 11:27:41 +00:00
#endif
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
if (!(flags & FWRITE))
return (EBADF);
Add compatibility cruft. Slice 0 is now for the first BSD slice. The first BSD slice is the first DOSpartition with id 0xa5 or the whole disk if their are no DOSpartitions (except the latter is not yet implemented). Existing partitions on it work the same as in 2.0 except the 'd' partition is no longer special and partitions are relative to the skice. Slice 1 is now for the whole disk and gets a read-only label describing the disk. Previously, slice 0 was for the whole disk and there was no label on it. Slices 2-31 are for DOSpartitions. Slice 0 is an alias for one of these if there is a BSD slice. Previously, slices 1-31 were for DOSpartitions. diskslice_machdep.c: Expand whole disk slice to include all DOSpartitions. More work is required for >1024 cylinders and to rewrite the label iff the driver is unsure about the geometry. subr_diskslice.c: New function dsisopen() to help handle media changes.
1995-02-16 15:19:19 +00:00
set_ds_wlabel(ssp, slice, *(int *)data != 0);
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
return (0);
default:
Use ENOIOCTL instead of -1 (= ERESTART) for diskslice ioctls that are not handled at a particular level.
1997-12-06 14:27:56 +00:00
return (ENOIOCTL);
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
}
}
Keep absolute offsets in on-disk labels for backwards compatibility. This requires complications to adjust the offsets to relative when a block containing the label is read and back to absolute when such a block is written. The adjustment is not made on the whole disk slice. Don't allow setting the offset of partition C to nonzero in in-core labels. This will cause some (nonstandard) disktab entries to fail. They will need to be changed to have relative offsets (and no partitions outside of the slice). Don't write protect the (nonexistent) label on the whole disk slice. Writing labels and bootstraps should work right now (except if there is no DOSpartition table).
1995-02-18 22:10:44 +00:00
static void
dsiodone(bp)
Give struct bio it's own call back mechanism.
2000-05-01 13:36:25 +00:00
struct bio *bp;
Keep absolute offsets in on-disk labels for backwards compatibility. This requires complications to adjust the offsets to relative when a block containing the label is read and back to absolute when such a block is written. The adjustment is not made on the whole disk slice. Don't allow setting the offset of partition C to nonzero in in-core labels. This will cause some (nonstandard) disktab entries to fail. They will need to be changed to have relative offsets (and no partitions outside of the slice). Don't write protect the (nonexistent) label on the whole disk slice. Writing labels and bootstraps should work right now (except if there is no DOSpartition table).
1995-02-18 22:10:44 +00:00
{
struct iodone_chain *ic;
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
char *msg;
Keep absolute offsets in on-disk labels for backwards compatibility. This requires complications to adjust the offsets to relative when a block containing the label is read and back to absolute when such a block is written. The adjustment is not made on the whole disk slice. Don't allow setting the offset of partition C to nonzero in in-core labels. This will cause some (nonstandard) disktab entries to fail. They will need to be changed to have relative offsets (and no partitions outside of the slice). Don't write protect the (nonexistent) label on the whole disk slice. Writing labels and bootstraps should work right now (except if there is no DOSpartition table).
1995-02-18 22:10:44 +00:00
Give struct bio it's own call back mechanism.
2000-05-01 13:36:25 +00:00
ic = bp->bio_done_chain;
bp->bio_done = ic->ic_prev_iodone;
bp->bio_done_chain = ic->ic_prev_iodone_chain;
if (!(bp->bio_cmd == BIO_READ)
|| (!(bp->bio_flags & BIO_ERROR) && bp->bio_error == 0)) {
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
msg = fixlabel((char *)NULL, ic->ic_args[1].ia_ptr,
(struct disklabel *)
Give struct bio it's own call back mechanism.
2000-05-01 13:36:25 +00:00
(bp->bio_data + ic->ic_args[0].ia_long),
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
FALSE);
if (msg != NULL)
printf("%s\n", msg);
}
Keep absolute offsets in on-disk labels for backwards compatibility. This requires complications to adjust the offsets to relative when a block containing the label is read and back to absolute when such a block is written. The adjustment is not made on the whole disk slice. Don't allow setting the offset of partition C to nonzero in in-core labels. This will cause some (nonstandard) disktab entries to fail. They will need to be changed to have relative offsets (and no partitions outside of the slice). Don't write protect the (nonexistent) label on the whole disk slice. Writing labels and bootstraps should work right now (except if there is no DOSpartition table).
1995-02-18 22:10:44 +00:00
free(ic, M_DEVBUF);
Give struct bio it's own call back mechanism.
2000-05-01 13:36:25 +00:00
biodone(bp);
Keep absolute offsets in on-disk labels for backwards compatibility. This requires complications to adjust the offsets to relative when a block containing the label is read and back to absolute when such a block is written. The adjustment is not made on the whole disk slice. Don't allow setting the offset of partition C to nonzero in in-core labels. This will cause some (nonstandard) disktab entries to fail. They will need to be changed to have relative offsets (and no partitions outside of the slice). Don't write protect the (nonexistent) label on the whole disk slice. Writing labels and bootstraps should work right now (except if there is no DOSpartition table).
1995-02-18 22:10:44 +00:00
}
Add compatibility cruft. Slice 0 is now for the first BSD slice. The first BSD slice is the first DOSpartition with id 0xa5 or the whole disk if their are no DOSpartitions (except the latter is not yet implemented). Existing partitions on it work the same as in 2.0 except the 'd' partition is no longer special and partitions are relative to the skice. Slice 1 is now for the whole disk and gets a read-only label describing the disk. Previously, slice 0 was for the whole disk and there was no label on it. Slices 2-31 are for DOSpartitions. Slice 0 is an alias for one of these if there is a BSD slice. Previously, slices 1-31 were for DOSpartitions. diskslice_machdep.c: Expand whole disk slice to include all DOSpartitions. More work is required for >1024 cylinders and to rewrite the label iff the driver is unsure about the geometry. subr_diskslice.c: New function dsisopen() to help handle media changes.
1995-02-16 15:19:19 +00:00
int
dsisopen(ssp)
struct diskslices *ssp;
{
int slice;
if (ssp == NULL)
return (0);
for (slice = 0; slice < ssp->dss_nslices; slice++)
if (ssp->dss_slices[slice].ds_openmask)
return (1);
return (0);
}
Moved allocation of the slices struct to the right place. Initialize everything in it (the devsw pointers were not initialized early or at all for the !DEVFS case, but this was harmless on i386's).
1998-07-20 13:39:45 +00:00
/*
* Allocate a slices "struct" and initialize it to contain only an empty
* compatibility slice (pointing to itself), a whole disk slice (covering
* the disk as described by the label), and (nslices - BASE_SLICES) empty
* slices beginning at BASE_SLICE.
*/
struct diskslices *
dsmakeslicestruct(nslices, lp)
int nslices;
struct disklabel *lp;
{
struct diskslice *sp;
struct diskslices *ssp;
ssp = malloc(offsetof(struct diskslices, dss_slices) +
nslices * sizeof *sp, M_DEVBUF, M_WAITOK);
ssp->dss_first_bsd_slice = COMPATIBILITY_SLICE;
ssp->dss_nslices = nslices;
Added a flags arg to dsopen() and updated drivers. The DSO_ONESLICE and DSO_NOLABELS flags prevent searching for slices and labels respectively. Current drivers don't set these flags. When DSO_NOLABELS is set, the in-core label for the whole disk is cloned to create an in-core label for each slice. This gives the correct result (a good in-core label for the compatibility slice) if DSO_ONESLICE is set or only one slice is found, but usually gives broken labels otherwise, so DSO_ONESLICE should be set if DSO_NOLABELS is set.
1998-07-30 15:16:06 +00:00
ssp->dss_oflags = 0;
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
ssp->dss_secmult = lp->d_secsize / DEV_BSIZE;
if (ssp->dss_secmult & (ssp->dss_secmult - 1))
ssp->dss_secshift = -1;
else
ssp->dss_secshift = ffs(ssp->dss_secmult) - 1;
ssp->dss_secsize = lp->d_secsize;
Moved allocation of the slices struct to the right place. Initialize everything in it (the devsw pointers were not initialized early or at all for the !DEVFS case, but this was harmless on i386's).
1998-07-20 13:39:45 +00:00
sp = &ssp->dss_slices[0];
bzero(sp, nslices * sizeof *sp);
sp[WHOLE_DISK_SLICE].ds_size = lp->d_secperunit;
return (ssp);
}
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
char *
We don't need to pass the diskname argument all over the diskslice/label code, we can find the name from any convenient dev_t
1999-08-28 14:33:44 +00:00
dsname(dev, unit, slice, part, partname)
dev_t dev;
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
int unit;
int slice;
int part;
char *partname;
{
static char name[32];
Const poisoning from d_name. Fixed some style bugs in recent changes.
1999-09-13 14:12:23 +00:00
const char *dname;
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
We don't need to pass the diskname argument all over the diskslice/label code, we can find the name from any convenient dev_t
1999-08-28 14:33:44 +00:00
dname = devsw(dev)->d_name;
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
if (strlen(dname) > 16)
dname = "nametoolong";
Examine all occurrences of sprintf(), strcat(), and str[n]cpy() for possible buffer overflow problems. Replaced most sprintf()'s with snprintf(); for others cases, added terminating NUL bytes where appropriate, replaced constants like "16" with sizeof(), etc. These changes include several bug fixes, but most changes are for maintainability's sake. Any instance where it wasn't "immediately obvious" that a buffer overflow could not occur was made safer. Reviewed by: Bruce Evans <bde@zeta.org.au> Reviewed by: Matthew Dillon <dillon@apollo.backplane.com> Reviewed by: Mike Spengler <mks@networkcs.com>
1998-12-04 22:54:57 +00:00
snprintf(name, sizeof(name), "%s%d", dname, unit);
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
partname[0] = '\0';
if (slice != WHOLE_DISK_SLICE || part != RAW_PART) {
partname[0] = 'a' + part;
partname[1] = '\0';
if (slice != COMPATIBILITY_SLICE)
Examine all occurrences of sprintf(), strcat(), and str[n]cpy() for possible buffer overflow problems. Replaced most sprintf()'s with snprintf(); for others cases, added terminating NUL bytes where appropriate, replaced constants like "16" with sizeof(), etc. These changes include several bug fixes, but most changes are for maintainability's sake. Any instance where it wasn't "immediately obvious" that a buffer overflow could not occur was made safer. Reviewed by: Bruce Evans <bde@zeta.org.au> Reviewed by: Matthew Dillon <dillon@apollo.backplane.com> Reviewed by: Mike Spengler <mks@networkcs.com>
1998-12-04 22:54:57 +00:00
snprintf(name + strlen(name),
sizeof(name) - strlen(name), "s%d", slice - 1);
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
}
return (name);
}
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
/*
* This should only be called when the unit is inactive and the strategy
* routine should not allow it to become active unless we call it. Our
* strategy routine must be special to allow activity.
*/
int
We don't need to pass the diskname argument all over the diskslice/label code, we can find the name from any convenient dev_t
1999-08-28 14:33:44 +00:00
dsopen(dev, mode, flags, sspp, lp)
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
dev_t dev;
int mode;
Added a flags arg to dsopen() and updated drivers. The DSO_ONESLICE and DSO_NOLABELS flags prevent searching for slices and labels respectively. Current drivers don't set these flags. When DSO_NOLABELS is set, the in-core label for the whole disk is cloned to create an in-core label for each slice. This gives the correct result (a good in-core label for the compatibility slice) if DSO_ONESLICE is set or only one slice is found, but usually gives broken labels otherwise, so DSO_ONESLICE should be set if DSO_NOLABELS is set.
1998-07-30 15:16:06 +00:00
u_int flags;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
struct diskslices **sspp;
struct disklabel *lp;
{
Search for labels on all slices whenever any minor for a drive is opened. If DEVFS is configured, create devfs devices for previously invisible partitions on the slices. Fixed an old aliasing bug which caused E=17 errors from DEVFS for DIOCSDINFO when there were no real slices.
1996-10-29 13:15:30 +00:00
dev_t dev1;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
int error;
Don't warn about missing labels for non-BSD slices. Don't print debugging messages by default. Initialize the compatibility slice here and not in the machine-dependent code. Fix initialization of the label for the whole disk slice. Make it clear that write protection of labels doesn't apply when there is no label.
1995-03-04 11:42:27 +00:00
struct disklabel *lp1;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
char *msg;
u_char mask;
int part;
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
char partname[2];
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
int slice;
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
char *sname;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
struct diskslice *sp;
struct diskslices *ssp;
int unit;
initialize si_bsize_phys from what the drive told us.
1999-08-29 09:10:05 +00:00
dev->si_bsize_phys = lp->d_secsize;
Convert DEVFS hooks in (most) drivers to make_dev(). Diskslice/label code not yet handled. Vinum, i4b, alpha, pc98 not dealt with (left to respective Maintainers) Add the correct hook for devfs to kern_conf.c The net result of this excercise is that a lot less files depends on DEVFS, and devtoname() gets more sensible output in many cases. A few drivers had minor additional cleanups performed relating to cdevsw registration. A few drivers don't register a cdevsw{} anymore, but only use make_dev().
1999-08-23 20:59:21 +00:00
dsopen: Print a message if the unit has an invalid sector size. Reviewed-by: ken, bde
1999-06-21 03:48:16 +00:00
unit = dkunit(dev);
if (lp->d_secsize % DEV_BSIZE) {
We don't need to pass the diskname argument all over the diskslice/label code, we can find the name from any convenient dev_t
1999-08-28 14:33:44 +00:00
printf("%s: invalid sector size %lu\n", devtoname(dev),
dsopen: Print a message if the unit has an invalid sector size. Reviewed-by: ken, bde
1999-06-21 03:48:16 +00:00
(u_long)lp->d_secsize);
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
return (EINVAL);
dsopen: Print a message if the unit has an invalid sector size. Reviewed-by: ken, bde
1999-06-21 03:48:16 +00:00
}
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
Add compatibility cruft. Slice 0 is now for the first BSD slice. The first BSD slice is the first DOSpartition with id 0xa5 or the whole disk if their are no DOSpartitions (except the latter is not yet implemented). Existing partitions on it work the same as in 2.0 except the 'd' partition is no longer special and partitions are relative to the skice. Slice 1 is now for the whole disk and gets a read-only label describing the disk. Previously, slice 0 was for the whole disk and there was no label on it. Slices 2-31 are for DOSpartitions. Slice 0 is an alias for one of these if there is a BSD slice. Previously, slices 1-31 were for DOSpartitions. diskslice_machdep.c: Expand whole disk slice to include all DOSpartitions. More work is required for >1024 cylinders and to rewrite the label iff the driver is unsure about the geometry. subr_diskslice.c: New function dsisopen() to help handle media changes.
1995-02-16 15:19:19 +00:00
/*
* XXX reinitialize the slice table unless there is an open device
* on the unit. This should only be done if the media has changed.
*/
Discard junk from partition tables when reading the tables for applications the same as when initializing the in-core copies. Adjust checksums in labels after adjusting labels. This finishes fudging the on-disk label to make it coherent with the in-core label. Handle EIO during initialization better. Initialize the compatibility slice to the whole disk If there are no real slices. Don't warn about adjusting offsets in the label to make the 'c' partition start at 0. The 'c' offset is now always absolute on-disk and 0 in-core so an adjustment is usually required. Don't confuse LABEL_PART with RAW_PART so much. Check for partitions being within slices differently.
1995-02-21 08:38:24 +00:00
ssp = *sspp;
Create a general facility for making dev_t's depend on another dev_t. The dev_depends(dev_t, dev_t) function is for tying them to each other. When destroy_dev() is called on a dev_t, all dev_t's depending on it will also be destroyed (depth first order). Rewrite the make_dev_alias() to use this dependency facility. kern/subr_disk.c: Make the disk mini-layer use dependencies to make sure all relevant dev_t's are removed when the disk disappears. Make the disk mini-layer precreate some magic sub devices which the disk/slice/label code expects to be there. kern/subr_disklabel.c: Remove some now unneeded variables. kern/subr_diskmbr.c: Remove some ancient, commented out code. kern/subr_diskslice.c: Minor cleanup. Use name from dev_t instead of dsname()
2001-05-26 08:27:58 +00:00
if (!dsisopen(ssp)) {
if (ssp != NULL)
dsgone(sspp);
Moved allocation of the slices struct to the right place. Initialize everything in it (the devsw pointers were not initialized early or at all for the !DEVFS case, but this was harmless on i386's).
1998-07-20 13:39:45 +00:00
/*
* Allocate a minimal slices "struct". This will become
* the final slices "struct" if we don't want real slices
* or if we can't find any real slices.
*/
*sspp = dsmakeslicestruct(BASE_SLICE, lp);
Added a flags arg to dsopen() and updated drivers. The DSO_ONESLICE and DSO_NOLABELS flags prevent searching for slices and labels respectively. Current drivers don't set these flags. When DSO_NOLABELS is set, the in-core label for the whole disk is cloned to create an in-core label for each slice. This gives the correct result (a good in-core label for the compatibility slice) if DSO_ONESLICE is set or only one slice is found, but usually gives broken labels otherwise, so DSO_ONESLICE should be set if DSO_NOLABELS is set.
1998-07-30 15:16:06 +00:00
if (!(flags & DSO_ONESLICE)) {
TRACE(("dsinit\n"));
We don't need to pass the diskname argument all over the diskslice/label code, we can find the name from any convenient dev_t
1999-08-28 14:33:44 +00:00
error = dsinit(dev, lp, sspp);
Added a flags arg to dsopen() and updated drivers. The DSO_ONESLICE and DSO_NOLABELS flags prevent searching for slices and labels respectively. Current drivers don't set these flags. When DSO_NOLABELS is set, the in-core label for the whole disk is cloned to create an in-core label for each slice. This gives the correct result (a good in-core label for the compatibility slice) if DSO_ONESLICE is set or only one slice is found, but usually gives broken labels otherwise, so DSO_ONESLICE should be set if DSO_NOLABELS is set.
1998-07-30 15:16:06 +00:00
if (error != 0) {
dsgone(sspp);
return (error);
}
Discard junk from partition tables when reading the tables for applications the same as when initializing the in-core copies. Adjust checksums in labels after adjusting labels. This finishes fudging the on-disk label to make it coherent with the in-core label. Handle EIO during initialization better. Initialize the compatibility slice to the whole disk If there are no real slices. Don't warn about adjusting offsets in the label to make the 'c' partition start at 0. The 'c' offset is now always absolute on-disk and 0 in-core so an adjustment is usually required. Don't confuse LABEL_PART with RAW_PART so much. Check for partitions being within slices differently.
1995-02-21 08:38:24 +00:00
}
ssp = *sspp;
Added a flags arg to dsopen() and updated drivers. The DSO_ONESLICE and DSO_NOLABELS flags prevent searching for slices and labels respectively. Current drivers don't set these flags. When DSO_NOLABELS is set, the in-core label for the whole disk is cloned to create an in-core label for each slice. This gives the correct result (a good in-core label for the compatibility slice) if DSO_ONESLICE is set or only one slice is found, but usually gives broken labels otherwise, so DSO_ONESLICE should be set if DSO_NOLABELS is set.
1998-07-30 15:16:06 +00:00
ssp->dss_oflags = flags;
Don't warn about missing labels for non-BSD slices. Don't print debugging messages by default. Initialize the compatibility slice here and not in the machine-dependent code. Fix initialization of the label for the whole disk slice. Make it clear that write protection of labels doesn't apply when there is no label.
1995-03-04 11:42:27 +00:00
/*
* If there are no real slices, then make the compatiblity
* slice cover the whole disk.
*/
Discard junk from partition tables when reading the tables for applications the same as when initializing the in-core copies. Adjust checksums in labels after adjusting labels. This finishes fudging the on-disk label to make it coherent with the in-core label. Handle EIO during initialization better. Initialize the compatibility slice to the whole disk If there are no real slices. Don't warn about adjusting offsets in the label to make the 'c' partition start at 0. The 'c' offset is now always absolute on-disk and 0 in-core so an adjustment is usually required. Don't confuse LABEL_PART with RAW_PART so much. Check for partitions being within slices differently.
1995-02-21 08:38:24 +00:00
if (ssp->dss_nslices == BASE_SLICE)
ssp->dss_slices[COMPATIBILITY_SLICE].ds_size
= lp->d_secperunit;
Don't warn about missing labels for non-BSD slices. Don't print debugging messages by default. Initialize the compatibility slice here and not in the machine-dependent code. Fix initialization of the label for the whole disk slice. Make it clear that write protection of labels doesn't apply when there is no label.
1995-03-04 11:42:27 +00:00
/* Point the compatibility slice at the BSD slice, if any. */
Search for labels on all slices whenever any minor for a drive is opened. If DEVFS is configured, create devfs devices for previously invisible partitions on the slices. Fixed an old aliasing bug which caused E=17 errors from DEVFS for DIOCSDINFO when there were no real slices.
1996-10-29 13:15:30 +00:00
for (slice = BASE_SLICE; slice < ssp->dss_nslices; slice++) {
sp = &ssp->dss_slices[slice];
Don't warn about missing labels for non-BSD slices. Don't print debugging messages by default. Initialize the compatibility slice here and not in the machine-dependent code. Fix initialization of the label for the whole disk slice. Make it clear that write protection of labels doesn't apply when there is no label.
1995-03-04 11:42:27 +00:00
if (sp->ds_type == DOSPTYP_386BSD /* XXX */) {
ssp->dss_first_bsd_slice = slice;
ssp->dss_slices[COMPATIBILITY_SLICE].ds_offset
= sp->ds_offset;
ssp->dss_slices[COMPATIBILITY_SLICE].ds_size
= sp->ds_size;
ssp->dss_slices[COMPATIBILITY_SLICE].ds_type
= sp->ds_type;
break;
}
Search for labels on all slices whenever any minor for a drive is opened. If DEVFS is configured, create devfs devices for previously invisible partitions on the slices. Fixed an old aliasing bug which caused E=17 errors from DEVFS for DIOCSDINFO when there were no real slices.
1996-10-29 13:15:30 +00:00
}
Don't warn about missing labels for non-BSD slices. Don't print debugging messages by default. Initialize the compatibility slice here and not in the machine-dependent code. Fix initialization of the label for the whole disk slice. Make it clear that write protection of labels doesn't apply when there is no label.
1995-03-04 11:42:27 +00:00
Initialize more defaults for the in-core label for the whole disk. Callers only need to initialize d_secperunit now, but should initialize d_type (to reduce the IDE/SCSI confusion), d_typename (put the disk model in it) and geometry info (if it isn't completely ficticious). Callers will soon need to initialize d_secsize.
1998-07-20 14:35:27 +00:00
ssp->dss_slices[WHOLE_DISK_SLICE].ds_label = clone_label(lp);
Don't warn about missing labels for non-BSD slices. Don't print debugging messages by default. Initialize the compatibility slice here and not in the machine-dependent code. Fix initialization of the label for the whole disk slice. Make it clear that write protection of labels doesn't apply when there is no label.
1995-03-04 11:42:27 +00:00
ssp->dss_slices[WHOLE_DISK_SLICE].ds_wlabel = TRUE;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
}
Add compatibility cruft. Slice 0 is now for the first BSD slice. The first BSD slice is the first DOSpartition with id 0xa5 or the whole disk if their are no DOSpartitions (except the latter is not yet implemented). Existing partitions on it work the same as in 2.0 except the 'd' partition is no longer special and partitions are relative to the skice. Slice 1 is now for the whole disk and gets a read-only label describing the disk. Previously, slice 0 was for the whole disk and there was no label on it. Slices 2-31 are for DOSpartitions. Slice 0 is an alias for one of these if there is a BSD slice. Previously, slices 1-31 were for DOSpartitions. diskslice_machdep.c: Expand whole disk slice to include all DOSpartitions. More work is required for >1024 cylinders and to rewrite the label iff the driver is unsure about the geometry. subr_diskslice.c: New function dsisopen() to help handle media changes.
1995-02-16 15:19:19 +00:00
Avoid the modules madness I inadvertently introduced by making the cloning infrastructure standard in kern_conf. Modules are now the same with or without devfs support. If you need to detect if devfs is present, in modules or elsewhere, check the integer variable "devfs_present". This happily removes an ugly hack from kern/vfs_conf.c. This forces a rename of the eventhandler and the standard clone helper function. Include <sys/eventhandler.h> in <sys/conf.h>: it's a helper #include like <sys/queue.h> Remove all #includes of opt_devfs.h they no longer matter.
2000-09-02 19:17:34 +00:00
/* Initialize secondary info for all slices. */
Search for labels on all slices whenever any minor for a drive is opened. If DEVFS is configured, create devfs devices for previously invisible partitions on the slices. Fixed an old aliasing bug which caused E=17 errors from DEVFS for DIOCSDINFO when there were no real slices.
1996-10-29 13:15:30 +00:00
for (slice = 0; slice < ssp->dss_nslices; slice++) {
sp = &ssp->dss_slices[slice];
Hack the diskslice stuff so that it allows the alpha sysinstall to manipulate the disklabel. This is almost certainly not the right way to do it but I'm desperate.
1999-05-09 11:27:41 +00:00
if (sp->ds_label != NULL
#ifdef __alpha__
&& slice != WHOLE_DISK_SLICE
#endif
)
Search for labels on all slices whenever any minor for a drive is opened. If DEVFS is configured, create devfs devices for previously invisible partitions on the slices. Fixed an old aliasing bug which caused E=17 errors from DEVFS for DIOCSDINFO when there were no real slices.
1996-10-29 13:15:30 +00:00
continue;
dev1 = dkmodslice(dkmodpart(dev, RAW_PART), slice);
Create a general facility for making dev_t's depend on another dev_t. The dev_depends(dev_t, dev_t) function is for tying them to each other. When destroy_dev() is called on a dev_t, all dev_t's depending on it will also be destroyed (depth first order). Rewrite the make_dev_alias() to use this dependency facility. kern/subr_disk.c: Make the disk mini-layer use dependencies to make sure all relevant dev_t's are removed when the disk disappears. Make the disk mini-layer precreate some magic sub devices which the disk/slice/label code expects to be there. kern/subr_disklabel.c: Remove some now unneeded variables. kern/subr_diskmbr.c: Remove some ancient, commented out code. kern/subr_diskslice.c: Minor cleanup. Use name from dev_t instead of dsname()
2001-05-26 08:27:58 +00:00
#if 0
We don't need to pass the diskname argument all over the diskslice/label code, we can find the name from any convenient dev_t
1999-08-28 14:33:44 +00:00
sname = dsname(dev, unit, slice, RAW_PART, partname);
Create a general facility for making dev_t's depend on another dev_t. The dev_depends(dev_t, dev_t) function is for tying them to each other. When destroy_dev() is called on a dev_t, all dev_t's depending on it will also be destroyed (depth first order). Rewrite the make_dev_alias() to use this dependency facility. kern/subr_disk.c: Make the disk mini-layer use dependencies to make sure all relevant dev_t's are removed when the disk disappears. Make the disk mini-layer precreate some magic sub devices which the disk/slice/label code expects to be there. kern/subr_disklabel.c: Remove some now unneeded variables. kern/subr_diskmbr.c: Remove some ancient, commented out code. kern/subr_diskslice.c: Minor cleanup. Use name from dev_t instead of dsname()
2001-05-26 08:27:58 +00:00
#else
*partname='\0';
sname = dev1->si_name;
#endif
Search for labels on all slices whenever any minor for a drive is opened. If DEVFS is configured, create devfs devices for previously invisible partitions on the slices. Fixed an old aliasing bug which caused E=17 errors from DEVFS for DIOCSDINFO when there were no real slices.
1996-10-29 13:15:30 +00:00
/*
* XXX this should probably only be done for the need_init
* case, but there may be a problem with DIOCSYNCSLICEINFO.
*/
Don't warn about missing labels for non-BSD slices. Don't print debugging messages by default. Initialize the compatibility slice here and not in the machine-dependent code. Fix initialization of the label for the whole disk slice. Make it clear that write protection of labels doesn't apply when there is no label.
1995-03-04 11:42:27 +00:00
set_ds_wlabel(ssp, slice, TRUE); /* XXX invert */
Initialize more defaults for the in-core label for the whole disk. Callers only need to initialize d_secperunit now, but should initialize d_type (to reduce the IDE/SCSI confusion), d_typename (put the disk model in it) and geometry info (if it isn't completely ficticious). Callers will soon need to initialize d_secsize.
1998-07-20 14:35:27 +00:00
lp1 = clone_label(lp);
Don't warn about missing labels for non-BSD slices. Don't print debugging messages by default. Initialize the compatibility slice here and not in the machine-dependent code. Fix initialization of the label for the whole disk slice. Make it clear that write protection of labels doesn't apply when there is no label.
1995-03-04 11:42:27 +00:00
TRACE(("readdisklabel\n"));
Added a flags arg to dsopen() and updated drivers. The DSO_ONESLICE and DSO_NOLABELS flags prevent searching for slices and labels respectively. Current drivers don't set these flags. When DSO_NOLABELS is set, the in-core label for the whole disk is cloned to create an in-core label for each slice. This gives the correct result (a good in-core label for the compatibility slice) if DSO_ONESLICE is set or only one slice is found, but usually gives broken labels otherwise, so DSO_ONESLICE should be set if DSO_NOLABELS is set.
1998-07-30 15:16:06 +00:00
if (flags & DSO_NOLABELS)
msg = NULL;
Write support for the cd(4) driver. This allows writing to DVD-RAM, PD and similar drives that probe as CD devices. Note that these are randomly writeable devices, not sequential-only devices like CD-R drives, which are supported by cdrecord. Add a new flag value for dsopen(), DSO_COMPATLABEL. The cd(4) driver now uses this flag instead of the DSO_NOLABELS flag. The DSO_NOLABELS always used a "fake" disklabel for the entire disk, provided by the caller. With the DSO_COMPATLABEL flag, dsopen() will first search the media for a label, and if it finds a label, it will use that label. Otherwise it will use the fake disklabel provided by the caller. This provides backwards compatibility, since we will still have labels for ISO9660 media. It also provides new functionality, since you can now have a regular BSD disklabel on read-only media, or on writeable media (e.g. DVD-RAM). Bruce and I both think that we should eventually (in a few years) get away from using disklabels for ISO9660 media, and just use the whole disk device (/dev/cd0). At that point disklabel handling in the cd(4) driver could follow the "normal" model, as used in the da(4) driver. Also, clean up the path in a couple of places in cdregister(). (Thanks to Nick Hibma for catching that bug.) Reviewed by: bde
2000-10-30 07:03:00 +00:00
else {
Spring cleaning around strategy and disklabels/slices: Introduce BUF_STRATEGY(struct buf *, int flag) macro, and use it throughout. please see comment in sys/conf.h about the flag argument. Remove strategy argument from all the diskslice/label/bad144 implementations, it should be found from the dev_t. Remove bogus and unused strategy1 routines. Remove open/close arguments from dssize(). Pick them up from dev_t. Remove unused and unfinished setgeom support from diskslice/label/bad144 code.
1999-08-14 11:40:51 +00:00
msg = readdisklabel(dev1, lp1);
Write support for the cd(4) driver. This allows writing to DVD-RAM, PD and similar drives that probe as CD devices. Note that these are randomly writeable devices, not sequential-only devices like CD-R drives, which are supported by cdrecord. Add a new flag value for dsopen(), DSO_COMPATLABEL. The cd(4) driver now uses this flag instead of the DSO_NOLABELS flag. The DSO_NOLABELS always used a "fake" disklabel for the entire disk, provided by the caller. With the DSO_COMPATLABEL flag, dsopen() will first search the media for a label, and if it finds a label, it will use that label. Otherwise it will use the fake disklabel provided by the caller. This provides backwards compatibility, since we will still have labels for ISO9660 media. It also provides new functionality, since you can now have a regular BSD disklabel on read-only media, or on writeable media (e.g. DVD-RAM). Bruce and I both think that we should eventually (in a few years) get away from using disklabels for ISO9660 media, and just use the whole disk device (/dev/cd0). At that point disklabel handling in the cd(4) driver could follow the "normal" model, as used in the da(4) driver. Also, clean up the path in a couple of places in cdregister(). (Thanks to Nick Hibma for catching that bug.) Reviewed by: bde
2000-10-30 07:03:00 +00:00
/*
* readdisklabel() returns NULL for success, and an
* error string for failure.
*
* If there isn't a label on the disk, and if the
* DSO_COMPATLABEL is set, we want to use the
* faked-up label provided by the caller.
*
* So we set msg to NULL to indicate that there is
* no failure (since we have a faked-up label),
* free lp1, and then clone it again from lp.
* (In case readdisklabel() modified lp1.)
*/
if (msg != NULL && (flags & DSO_COMPATLABEL)) {
msg = NULL;
free(lp1, M_DEVBUF);
lp1 = clone_label(lp);
}
}
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
if (msg == NULL)
Search for labels on all slices whenever any minor for a drive is opened. If DEVFS is configured, create devfs devices for previously invisible partitions on the slices. Fixed an old aliasing bug which caused E=17 errors from DEVFS for DIOCSDINFO when there were no real slices.
1996-10-29 13:15:30 +00:00
msg = fixlabel(sname, sp, lp1, FALSE);
Centralized and optimized handling of large sectors. Centralized checking of transfer sizes and alignments. Old version tested with 2K-sectors on od disks by: Shunsuke Akiyama <akiyama@kme.mei.co.jp>.
1998-07-29 11:15:54 +00:00
if (msg == NULL && lp1->d_secsize != ssp->dss_secsize)
msg = "inconsistent sector size";
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
if (msg != NULL) {
Don't warn about missing labels for non-BSD slices. Don't print debugging messages by default. Initialize the compatibility slice here and not in the machine-dependent code. Fix initialization of the label for the whole disk slice. Make it clear that write protection of labels doesn't apply when there is no label.
1995-03-04 11:42:27 +00:00
if (sp->ds_type == DOSPTYP_386BSD /* XXX */)
log(LOG_WARNING, "%s: cannot find label (%s)\n",
sname, msg);
Fixed a memory leak for slices with an (unsupported) bad sector table. Broken in: rev.1.80.
2000-01-28 11:51:08 +00:00
free(lp1, M_DEVBUF);
Search for labels on all slices whenever any minor for a drive is opened. If DEVFS is configured, create devfs devices for previously invisible partitions on the slices. Fixed an old aliasing bug which caused E=17 errors from DEVFS for DIOCSDINFO when there were no real slices.
1996-10-29 13:15:30 +00:00
continue;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
}
Search for labels on all slices whenever any minor for a drive is opened. If DEVFS is configured, create devfs devices for previously invisible partitions on the slices. Fixed an old aliasing bug which caused E=17 errors from DEVFS for DIOCSDINFO when there were no real slices.
1996-10-29 13:15:30 +00:00
if (lp1->d_flags & D_BADSECT) {
Remove BAD144 support, it has already been disabled for some time.
1999-12-08 09:33:00 +00:00
log(LOG_ERR, "%s: bad sector table not supported\n",
sname);
Fixed a memory leak for slices with an (unsupported) bad sector table. Broken in: rev.1.80.
2000-01-28 11:51:08 +00:00
free(lp1, M_DEVBUF);
Remove BAD144 support, it has already been disabled for some time.
1999-12-08 09:33:00 +00:00
continue;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
}
Search for labels on all slices whenever any minor for a drive is opened. If DEVFS is configured, create devfs devices for previously invisible partitions on the slices. Fixed an old aliasing bug which caused E=17 errors from DEVFS for DIOCSDINFO when there were no real slices.
1996-10-29 13:15:30 +00:00
set_ds_label(ssp, slice, lp1);
We don't need to pass the diskname argument all over the diskslice/label code, we can find the name from any convenient dev_t
1999-08-28 14:33:44 +00:00
set_ds_labeldevs(dev1, ssp);
Don't warn about missing labels for non-BSD slices. Don't print debugging messages by default. Initialize the compatibility slice here and not in the machine-dependent code. Fix initialization of the label for the whole disk slice. Make it clear that write protection of labels doesn't apply when there is no label.
1995-03-04 11:42:27 +00:00
set_ds_wlabel(ssp, slice, FALSE);
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
}
Search for labels on all slices whenever any minor for a drive is opened. If DEVFS is configured, create devfs devices for previously invisible partitions on the slices. Fixed an old aliasing bug which caused E=17 errors from DEVFS for DIOCSDINFO when there were no real slices.
1996-10-29 13:15:30 +00:00
slice = dkslice(dev);
if (slice >= ssp->dss_nslices)
return (ENXIO);
sp = &ssp->dss_slices[slice];
part = dkpart(dev);
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
if (part != RAW_PART
&& (sp->ds_label == NULL || part >= sp->ds_label->d_npartitions))
return (EINVAL); /* XXX needs translation */
mask = 1 << part;
Cleanup some more remaining bdev fluff.
2000-01-16 09:25:34 +00:00
sp->ds_openmask |= mask;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
return (0);
}
Fix reopening of open subdevices for DIOCSYNCSLICEINFO: Reopen the bdev for the raw partition and not the cdev if only the bdev was open. Don't use a bogus limit for the number of partitions to possibly reopen (bug found by Julian). Add function dssize() to help fix wdsize() and sdsize(). The slice layer knows more about (un)open partitions and partition sizes than the driver layer.
1995-05-08 16:24:08 +00:00
int
Spring cleaning around strategy and disklabels/slices: Introduce BUF_STRATEGY(struct buf *, int flag) macro, and use it throughout. please see comment in sys/conf.h about the flag argument. Remove strategy argument from all the diskslice/label/bad144 implementations, it should be found from the dev_t. Remove bogus and unused strategy1 routines. Remove open/close arguments from dssize(). Pick them up from dev_t. Remove unused and unfinished setgeom support from diskslice/label/bad144 code.
1999-08-14 11:40:51 +00:00
dssize(dev, sspp)
Fix reopening of open subdevices for DIOCSYNCSLICEINFO: Reopen the bdev for the raw partition and not the cdev if only the bdev was open. Don't use a bogus limit for the number of partitions to possibly reopen (bug found by Julian). Add function dssize() to help fix wdsize() and sdsize(). The slice layer knows more about (un)open partitions and partition sizes than the driver layer.
1995-05-08 16:24:08 +00:00
dev_t dev;
struct diskslices **sspp;
{
struct disklabel *lp;
int part;
int slice;
struct diskslices *ssp;
slice = dkslice(dev);
part = dkpart(dev);
ssp = *sspp;
if (ssp == NULL || slice >= ssp->dss_nslices
Cleanup some more remaining bdev fluff.
2000-01-16 09:25:34 +00:00
|| !(ssp->dss_slices[slice].ds_openmask & (1 << part))) {
if (devsw(dev)->d_open(dev, FREAD, S_IFCHR,
KSE Milestone 2 Note ALL MODULES MUST BE RECOMPILED make the kernel aware that there are smaller units of scheduling than the process. (but only allow one thread per process at this time). This is functionally equivalent to teh previousl -current except that there is a thread associated with each process. Sorry john! (your next MFC will be a doosie!) Reviewed by: peter@freebsd.org, dillon@freebsd.org X-MFC after: ha ha ha ha
2001-09-12 08:38:13 +00:00
(struct thread *)NULL) != 0)
Fix reopening of open subdevices for DIOCSYNCSLICEINFO: Reopen the bdev for the raw partition and not the cdev if only the bdev was open. Don't use a bogus limit for the number of partitions to possibly reopen (bug found by Julian). Add function dssize() to help fix wdsize() and sdsize(). The slice layer knows more about (un)open partitions and partition sizes than the driver layer.
1995-05-08 16:24:08 +00:00
return (-1);
KSE Milestone 2 Note ALL MODULES MUST BE RECOMPILED make the kernel aware that there are smaller units of scheduling than the process. (but only allow one thread per process at this time). This is functionally equivalent to teh previousl -current except that there is a thread associated with each process. Sorry john! (your next MFC will be a doosie!) Reviewed by: peter@freebsd.org, dillon@freebsd.org X-MFC after: ha ha ha ha
2001-09-12 08:38:13 +00:00
devsw(dev)->d_close(dev, FREAD, S_IFCHR, (struct thread *)NULL);
Fix reopening of open subdevices for DIOCSYNCSLICEINFO: Reopen the bdev for the raw partition and not the cdev if only the bdev was open. Don't use a bogus limit for the number of partitions to possibly reopen (bug found by Julian). Add function dssize() to help fix wdsize() and sdsize(). The slice layer knows more about (un)open partitions and partition sizes than the driver layer.
1995-05-08 16:24:08 +00:00
ssp = *sspp;
}
lp = ssp->dss_slices[slice].ds_label;
if (lp == NULL)
return (-1);
return ((int)lp->d_partitions[part].p_size);
}
[Oops, forgot to commit this together with things that depend on it.] First attempt at creating devfs entries for sliced devices. Doesn't quite work yet, so the heart of it is disabled. Added bdev and cdev args to dsopen(). Create devfs entries in dsopen() and (unsuccessfully) attempt to make them go away at the right times. DEVFS is #undefed at the start so that this shouldn't cause problems.
1996-01-27 09:34:21 +00:00
static void
Fixed removal of devfs entries for the real slice corresponding to the compatibility slice. They were forgotten on last-close and then creating them on first-open failed. Devfs entries for slices other than the one containing the root file system are still invisible unless you open a non-devfs inode on the slice.
1996-04-19 19:22:29 +00:00
free_ds_label(ssp, slice)
[Oops, forgot to commit this together with things that depend on it.] First attempt at creating devfs entries for sliced devices. Doesn't quite work yet, so the heart of it is disabled. Added bdev and cdev args to dsopen(). Create devfs entries in dsopen() and (unsuccessfully) attempt to make them go away at the right times. DEVFS is #undefed at the start so that this shouldn't cause problems.
1996-01-27 09:34:21 +00:00
struct diskslices *ssp;
int slice;
{
struct disklabel *lp;
struct diskslice *sp;
sp = &ssp->dss_slices[slice];
lp = sp->ds_label;
Fixed removal of devfs entries for the real slice corresponding to the compatibility slice. They were forgotten on last-close and then creating them on first-open failed. Devfs entries for slices other than the one containing the root file system are still invisible unless you open a non-devfs inode on the slice.
1996-04-19 19:22:29 +00:00
if (lp == NULL)
return;
free(lp, M_DEVBUF);
set_ds_label(ssp, slice, (struct disklabel *)NULL);
}
[Oops, forgot to commit this together with things that depend on it.] First attempt at creating devfs entries for sliced devices. Doesn't quite work yet, so the heart of it is disabled. Added bdev and cdev args to dsopen(). Create devfs entries in dsopen() and (unsuccessfully) attempt to make them go away at the right times. DEVFS is #undefed at the start so that this shouldn't cause problems.
1996-01-27 09:34:21 +00:00
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
static char *
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
fixlabel(sname, sp, lp, writeflag)
char *sname;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
struct diskslice *sp;
struct disklabel *lp;
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
int writeflag;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
{
Discard junk from partition tables when reading the tables for applications the same as when initializing the in-core copies. Adjust checksums in labels after adjusting labels. This finishes fudging the on-disk label to make it coherent with the in-core label. Handle EIO during initialization better. Initialize the compatibility slice to the whole disk If there are no real slices. Don't warn about adjusting offsets in the label to make the 'c' partition start at 0. The 'c' offset is now always absolute on-disk and 0 in-core so an adjustment is usually required. Don't confuse LABEL_PART with RAW_PART so much. Check for partitions being within slices differently.
1995-02-21 08:38:24 +00:00
u_long end;
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
u_long offset;
Keep absolute offsets in on-disk labels for backwards compatibility. This requires complications to adjust the offsets to relative when a block containing the label is read and back to absolute when such a block is written. The adjustment is not made on the whole disk slice. Don't allow setting the offset of partition C to nonzero in in-core labels. This will cause some (nonstandard) disktab entries to fail. They will need to be changed to have relative offsets (and no partitions outside of the slice). Don't write protect the (nonexistent) label on the whole disk slice. Writing labels and bootstraps should work right now (except if there is no DOSpartition table).
1995-02-18 22:10:44 +00:00
int part;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
struct partition *pp;
Discard junk from partition tables when reading the tables for applications the same as when initializing the in-core copies. Adjust checksums in labels after adjusting labels. This finishes fudging the on-disk label to make it coherent with the in-core label. Handle EIO during initialization better. Initialize the compatibility slice to the whole disk If there are no real slices. Don't warn about adjusting offsets in the label to make the 'c' partition start at 0. The 'c' offset is now always absolute on-disk and 0 in-core so an adjustment is usually required. Don't confuse LABEL_PART with RAW_PART so much. Check for partitions being within slices differently.
1995-02-21 08:38:24 +00:00
u_long start;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
bool_t warned;
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
/* These errors "can't happen" so don't bother reporting details. */
if (lp->d_magic != DISKMAGIC || lp->d_magic2 != DISKMAGIC)
return ("fixlabel: invalid magic");
if (dkcksum(lp) != 0)
return ("fixlabel: invalid checksum");
Discard junk from partition tables when reading the tables for applications the same as when initializing the in-core copies. Adjust checksums in labels after adjusting labels. This finishes fudging the on-disk label to make it coherent with the in-core label. Handle EIO during initialization better. Initialize the compatibility slice to the whole disk If there are no real slices. Don't warn about adjusting offsets in the label to make the 'c' partition start at 0. The 'c' offset is now always absolute on-disk and 0 in-core so an adjustment is usually required. Don't confuse LABEL_PART with RAW_PART so much. Check for partitions being within slices differently.
1995-02-21 08:38:24 +00:00
pp = &lp->d_partitions[RAW_PART];
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
if (writeflag) {
start = 0;
offset = sp->ds_offset;
} else {
start = sp->ds_offset;
offset = -sp->ds_offset;
}
if (pp->p_offset != start) {
if (sname != NULL) {
printf(
"%s: rejecting BSD label: raw partition offset != slice offset\n",
sname);
slice_info(sname, sp);
partition_info(sname, RAW_PART, pp);
}
return ("fixlabel: raw partition offset != slice offset");
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
}
if (pp->p_size != sp->ds_size) {
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
if (sname != NULL) {
printf("%s: raw partition size != slice size\n", sname);
slice_info(sname, sp);
partition_info(sname, RAW_PART, pp);
}
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
if (pp->p_size > sp->ds_size) {
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
if (sname == NULL)
return ("fixlabel: raw partition size > slice size");
printf("%s: truncating raw partition\n", sname);
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
pp->p_size = sp->ds_size;
}
}
Discard junk from partition tables when reading the tables for applications the same as when initializing the in-core copies. Adjust checksums in labels after adjusting labels. This finishes fudging the on-disk label to make it coherent with the in-core label. Handle EIO during initialization better. Initialize the compatibility slice to the whole disk If there are no real slices. Don't warn about adjusting offsets in the label to make the 'c' partition start at 0. The 'c' offset is now always absolute on-disk and 0 in-core so an adjustment is usually required. Don't confuse LABEL_PART with RAW_PART so much. Check for partitions being within slices differently.
1995-02-21 08:38:24 +00:00
end = start + sp->ds_size;
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
if (start > end)
return ("fixlabel: slice wraps");
if (lp->d_secpercyl <= 0)
return ("fixlabel: d_secpercyl <= 0");
Discard junk from partition tables when reading the tables for applications the same as when initializing the in-core copies. Adjust checksums in labels after adjusting labels. This finishes fudging the on-disk label to make it coherent with the in-core label. Handle EIO during initialization better. Initialize the compatibility slice to the whole disk If there are no real slices. Don't warn about adjusting offsets in the label to make the 'c' partition start at 0. The 'c' offset is now always absolute on-disk and 0 in-core so an adjustment is usually required. Don't confuse LABEL_PART with RAW_PART so much. Check for partitions being within slices differently.
1995-02-21 08:38:24 +00:00
pp -= RAW_PART;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
warned = FALSE;
Keep absolute offsets in on-disk labels for backwards compatibility. This requires complications to adjust the offsets to relative when a block containing the label is read and back to absolute when such a block is written. The adjustment is not made on the whole disk slice. Don't allow setting the offset of partition C to nonzero in in-core labels. This will cause some (nonstandard) disktab entries to fail. They will need to be changed to have relative offsets (and no partitions outside of the slice). Don't write protect the (nonexistent) label on the whole disk slice. Writing labels and bootstraps should work right now (except if there is no DOSpartition table).
1995-02-18 22:10:44 +00:00
for (part = 0; part < lp->d_npartitions; part++, pp++) {
Discard junk from partition tables when reading the tables for applications the same as when initializing the in-core copies. Adjust checksums in labels after adjusting labels. This finishes fudging the on-disk label to make it coherent with the in-core label. Handle EIO during initialization better. Initialize the compatibility slice to the whole disk If there are no real slices. Don't warn about adjusting offsets in the label to make the 'c' partition start at 0. The 'c' offset is now always absolute on-disk and 0 in-core so an adjustment is usually required. Don't confuse LABEL_PART with RAW_PART so much. Check for partitions being within slices differently.
1995-02-21 08:38:24 +00:00
if (pp->p_offset != 0 || pp->p_size != 0) {
if (pp->p_offset < start
|| pp->p_offset + pp->p_size > end
|| pp->p_offset + pp->p_size < pp->p_offset) {
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
if (sname != NULL) {
printf(
"%s: rejecting partition in BSD label: it isn't entirely within the slice\n",
sname);
if (!warned) {
slice_info(sname, sp);
warned = TRUE;
}
partition_info(sname, part, pp);
Discard junk from partition tables when reading the tables for applications the same as when initializing the in-core copies. Adjust checksums in labels after adjusting labels. This finishes fudging the on-disk label to make it coherent with the in-core label. Handle EIO during initialization better. Initialize the compatibility slice to the whole disk If there are no real slices. Don't warn about adjusting offsets in the label to make the 'c' partition start at 0. The 'c' offset is now always absolute on-disk and 0 in-core so an adjustment is usually required. Don't confuse LABEL_PART with RAW_PART so much. Check for partitions being within slices differently.
1995-02-21 08:38:24 +00:00
}
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
/* XXX else silently discard junk. */
Discard junk from partition tables when reading the tables for applications the same as when initializing the in-core copies. Adjust checksums in labels after adjusting labels. This finishes fudging the on-disk label to make it coherent with the in-core label. Handle EIO during initialization better. Initialize the compatibility slice to the whole disk If there are no real slices. Don't warn about adjusting offsets in the label to make the 'c' partition start at 0. The 'c' offset is now always absolute on-disk and 0 in-core so an adjustment is usually required. Don't confuse LABEL_PART with RAW_PART so much. Check for partitions being within slices differently.
1995-02-21 08:38:24 +00:00
bzero(pp, sizeof *pp);
} else
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
pp->p_offset += offset;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
}
}
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
lp->d_ncylinders = sp->ds_size / lp->d_secpercyl;
lp->d_secperunit = sp->ds_size;
Discard junk from partition tables when reading the tables for applications the same as when initializing the in-core copies. Adjust checksums in labels after adjusting labels. This finishes fudging the on-disk label to make it coherent with the in-core label. Handle EIO during initialization better. Initialize the compatibility slice to the whole disk If there are no real slices. Don't warn about adjusting offsets in the label to make the 'c' partition start at 0. The 'c' offset is now always absolute on-disk and 0 in-core so an adjustment is usually required. Don't confuse LABEL_PART with RAW_PART so much. Check for partitions being within slices differently.
1995-02-21 08:38:24 +00:00
lp->d_checksum = 0;
lp->d_checksum = dkcksum(lp);
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
return (NULL);
}
static void
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
partition_info(sname, part, pp)
char *sname;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
int part;
struct partition *pp;
{
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
printf("%s%c: start %lu, end %lu, size %lu\n", sname, 'a' + part,
Fixed printf format errors.
1998-07-11 07:46:16 +00:00
(u_long)pp->p_offset, (u_long)(pp->p_offset + pp->p_size - 1),
(u_long)pp->p_size);
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
}
static void
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
slice_info(sname, sp)
char *sname;
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
struct diskslice *sp;
{
Fix initialization of the copy of the label passed to setdisklabel(). Fix the sign of the adjustment after writing a label. Writing of labels should work now. Merge adjust_label() into fixlabel(). Detect more errors and don't write if there is an error. Adjust sectors/unit and total sectors to the numbers on the slice. Add a function dsname() to print slice device names consistently, and use it.
1995-02-22 21:51:53 +00:00
printf("%s: start %lu, end %lu, size %lu\n", sname,
subr_diskslice.c implements everything related to slices and labels except reading and writing the slice tables and labels. subr_dkbad.c implements everything related to bad sector remapping using the bad144 format.
1994-12-12 00:20:34 +00:00
sp->ds_offset, sp->ds_offset + sp->ds_size - 1, sp->ds_size);
}
Add compatibility cruft. Slice 0 is now for the first BSD slice. The first BSD slice is the first DOSpartition with id 0xa5 or the whole disk if their are no DOSpartitions (except the latter is not yet implemented). Existing partitions on it work the same as in 2.0 except the 'd' partition is no longer special and partitions are relative to the skice. Slice 1 is now for the whole disk and gets a read-only label describing the disk. Previously, slice 0 was for the whole disk and there was no label on it. Slices 2-31 are for DOSpartitions. Slice 0 is an alias for one of these if there is a BSD slice. Previously, slices 1-31 were for DOSpartitions. diskslice_machdep.c: Expand whole disk slice to include all DOSpartitions. More work is required for >1024 cylinders and to rewrite the label iff the driver is unsure about the geometry. subr_diskslice.c: New function dsisopen() to help handle media changes.
1995-02-16 15:19:19 +00:00
static void
set_ds_label(ssp, slice, lp)
struct diskslices *ssp;
int slice;
struct disklabel *lp;
{
ssp->dss_slices[slice].ds_label = lp;
if (slice == COMPATIBILITY_SLICE)
ssp->dss_slices[ssp->dss_first_bsd_slice].ds_label = lp;
else if (slice == ssp->dss_first_bsd_slice)
ssp->dss_slices[COMPATIBILITY_SLICE].ds_label = lp;
}
[Oops, forgot to commit this together with things that depend on it.] First attempt at creating devfs entries for sliced devices. Doesn't quite work yet, so the heart of it is disabled. Added bdev and cdev args to dsopen(). Create devfs entries in dsopen() and (unsuccessfully) attempt to make them go away at the right times. DEVFS is #undefed at the start so that this shouldn't cause problems.
1996-01-27 09:34:21 +00:00
static void
We don't need to pass the diskname argument all over the diskslice/label code, we can find the name from any convenient dev_t
1999-08-28 14:33:44 +00:00
set_ds_labeldevs(dev, ssp)
[Oops, forgot to commit this together with things that depend on it.] First attempt at creating devfs entries for sliced devices. Doesn't quite work yet, so the heart of it is disabled. Added bdev and cdev args to dsopen(). Create devfs entries in dsopen() and (unsuccessfully) attempt to make them go away at the right times. DEVFS is #undefed at the start so that this shouldn't cause problems.
1996-01-27 09:34:21 +00:00
dev_t dev;
struct diskslices *ssp;
Fixed removal of devfs entries for the real slice corresponding to the compatibility slice. They were forgotten on last-close and then creating them on first-open failed. Devfs entries for slices other than the one containing the root file system are still invisible unless you open a non-devfs inode on the slice.
1996-04-19 19:22:29 +00:00
{
}
[Oops, forgot to commit this together with things that depend on it.] First attempt at creating devfs entries for sliced devices. Doesn't quite work yet, so the heart of it is disabled. Added bdev and cdev args to dsopen(). Create devfs entries in dsopen() and (unsuccessfully) attempt to make them go away at the right times. DEVFS is #undefed at the start so that this shouldn't cause problems.
1996-01-27 09:34:21 +00:00
Add compatibility cruft. Slice 0 is now for the first BSD slice. The first BSD slice is the first DOSpartition with id 0xa5 or the whole disk if their are no DOSpartitions (except the latter is not yet implemented). Existing partitions on it work the same as in 2.0 except the 'd' partition is no longer special and partitions are relative to the skice. Slice 1 is now for the whole disk and gets a read-only label describing the disk. Previously, slice 0 was for the whole disk and there was no label on it. Slices 2-31 are for DOSpartitions. Slice 0 is an alias for one of these if there is a BSD slice. Previously, slices 1-31 were for DOSpartitions. diskslice_machdep.c: Expand whole disk slice to include all DOSpartitions. More work is required for >1024 cylinders and to rewrite the label iff the driver is unsure about the geometry. subr_diskslice.c: New function dsisopen() to help handle media changes.
1995-02-16 15:19:19 +00:00
static void
set_ds_wlabel(ssp, slice, wlabel)
struct diskslices *ssp;
int slice;
int wlabel;
{
ssp->dss_slices[slice].ds_wlabel = wlabel;
if (slice == COMPATIBILITY_SLICE)
ssp->dss_slices[ssp->dss_first_bsd_slice].ds_wlabel = wlabel;
else if (slice == ssp->dss_first_bsd_slice)
ssp->dss_slices[COMPATIBILITY_SLICE].ds_wlabel = wlabel;
}
Reference in New Issue Copy Permalink