/*
* Write disk label back to device after modification.
*/
int
writedisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp)
{
struct buf *bp = NULL;
int error;
/* get a buffer and initialize it */
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
/* Read it in, slap the new label in, and write it back out */
bp->b_blkno = LABELSECTOR;
bp->b_bcount = lp->d_secsize;
CLR(bp->b_flags, B_READ | B_WRITE | B_DONE);
SET(bp->b_flags, B_BUSY | B_READ | B_RAW);
(*strat)(bp);
if ((error = biowait(bp)) != 0)
goto done;
bsdtocpulabel(lp, (struct mvmedisklabel *)bp->b_data);
CLR(bp->b_flags, B_READ | B_WRITE | B_DONE);
SET(bp->b_flags, B_BUSY | B_WRITE | B_RAW);
(*strat)(bp);
error = biowait(bp);
done:
if (bp) {
bp->b_flags |= B_INVAL;
brelse(bp);
}
disk_change = 1;
return (error);
}
/*
* iinit is called once (from main)
* very early in initialization.
* It reads the root's super block
* and initializes the current date
* from the last modified date.
*
* panic: iinit -- cannot read the super
* block. Usually because of an IO error.
*/
iinit()
{
register struct buf *cp, *bp;
register struct filsys *fp;
register unsigned i , j ;
(*bdevsw[major(rootdev)].d_open)(rootdev, 1);
bp = bread(rootdev, SUPERB);
cp = geteblk();
if(u.u_error)
panic("iinit");
bcopy(bp->b_un.b_addr, cp->b_un.b_addr, sizeof(struct filsys));
brelse(bp);
mount[0].m_bufp = cp;
mount[0].m_dev = rootdev;
fp = cp->b_un.b_filsys;
fp->s_flock = 0;
fp->s_ilock = 0;
fp->s_ronly = 0;
/* on boot, read VAX TODR register (GMT 10 ms.
* clicks into current year) and set software time
* in 'int time' (GMT seconds since year YRREF)
*/
for (i = 0 , j = YRREF ; j < YRCURR ; j++)
i += (SECYR + (j%4?0:SECDAY)) ;
time = udiv(mfpr(TODR),100) + i ;
}
/*
* Write disk label back to device after modification.
*/
int
writedisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp,
struct cpu_disklabel *osdep)
{
mbr_args_t a;
memset(&a, 0, sizeof a);
a.lp = lp;
a.strat = strat;
/* get a buffer and initialize it */
a.bp = geteblk(2 * (int)lp->d_secsize);
a.bp->b_dev = dev;
/* osdep => we expect an mbr with label in netbsd ptn */
a.action = osdep != NULL ? WRITE_LABEL : UPDATE_LABEL;
/* Write/update the label to every netbsd mbr partition */
scan_mbr(&a, write_netbsd_label);
/* Old write the label at the start of the volume on disks that
* don't have a valid mbr (always update an existing one) */
a.action = a.found_mbr ? UPDATE_LABEL : WRITE_LABEL;
validate_label(&a, 0);
if (a.written == 0 && a.error == 0)
a.error = ESRCH;
brelse(a.bp, 0);
return a.error;
}
/*
* iinit is called once (from main)
* very early in initialization.
* It reads the root's super block
* and initializes the current date
* from the last modified date.
*
* panic: iinit -- cannot read the super
* block. Usually because of an I/O error.
*/
void iinit(void) {
struct buf *cp, *bp;
struct filsys *fp;
if (debugIinit) {
printf("----- iinit -----\n");
}
(*bdevsw[major(rootdev)].d_open)(rootdev, 1);
bp = bread(rootdev, SUPERB);
cp = geteblk();
if (u.u_error) {
panic("error reading super block of root file system");
}
bcopy(bp->b_un.b_addr, cp->b_un.b_addr, sizeof(struct filsys));
brelse(bp);
mount[0].m_bufp = cp;
mount[0].m_dev = rootdev;
fp = cp->b_un.b_filsys;
time = fp->s_time;
fp->s_flock = 0;
fp->s_ilock = 0;
fp->s_fmod = 0;
fp->s_ronly = 0;
if (debugIinit) {
showSuperBlock("super block of root file system", fp);
}
}
/*
* Write disk label back to device after modification.
*/
int
writedisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp)
{
struct buf *bp = NULL;
int error;
/* get buffer and initialize it */
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
error = disklabel_bsd_to_sun(lp, (struct sun_disklabel *)bp->b_data);
if (error)
goto done;
/* Write out the updated label. */
bp->b_blkno = LABELSECTOR;
bp->b_bcount = lp->d_secsize;
CLR(bp->b_flags, B_READ | B_WRITE | B_DONE);
SET(bp->b_flags, B_BUSY | B_WRITE | B_RAW);
(*strat)(bp);
error = biowait(bp);
done:
if (bp) {
bp->b_flags |= B_INVAL;
brelse(bp);
}
disk_change = 1;
return (error);
}
/*
* Write disk label back to device after modification.
* this means write out the Rigid disk blocks to represent the
* label. Hope the user was carefull.
*/
int
writedisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp,
struct cpu_disklabel *clp)
{
struct buf *bp;
struct disklabel *dlp;
int error = 0;
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
bp->b_blkno = LABELSECTOR;
bp->b_cylinder = 0;
bp->b_bcount = lp->d_secsize;
bp->b_flags |= B_READ; /* get current label */
(*strat)(bp);
if ((error = biowait(bp)) != 0)
goto done;
dlp = (struct disklabel *)((char *)bp->b_data + LABELOFFSET);
*dlp = *lp; /* struct assignment */
bp->b_oflags &= ~(BO_DONE);
bp->b_flags &= ~(B_READ);
bp->b_flags |= B_WRITE;
(*strat)(bp);
error = biowait(bp);
done:
brelse(bp, 0);
return (error);
}
/*
* Write disk label back to device after modification.
* Current label is already in clp->cd_block[]
*/
int
writedisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp, struct cpu_disklabel *clp)
{
struct buf *bp;
struct disklabel *dlp;
int error;
/* implant NetBSD disklabel at LABELOFFSET. */
dlp = (struct disklabel *)(clp->cd_block + LABELOFFSET);
*dlp = *lp; /* struct assignment */
error = disklabel_bsd_to_om(lp, clp->cd_block);
if (error)
return (error);
/* Get a buffer and copy the new label into it. */
bp = geteblk((int)lp->d_secsize);
memcpy(bp->b_data, clp->cd_block, sizeof(clp->cd_block));
/* Write out the updated label. */
bp->b_dev = dev;
bp->b_blkno = LABELSECTOR;
bp->b_cylinder = 0;
bp->b_bcount = lp->d_secsize;
bp->b_flags |= B_WRITE;
(*strat)(bp);
error = biowait(bp);
brelse(bp, 0);
return (error);
}
/*
* Attempt to read a disk label from a device
* using the indicated strategy routine.
* The label must be partly set up before this:
* secpercyl, secsize and anything required for a block i/o read
* operation in the driver's strategy/start routines
* must be filled in before calling us.
*
* If dos partition table requested, attempt to load it and
* find disklabel inside a DOS partition.
*
* We would like to check if each MBR has a valid DOSMBR_SIGNATURE, but
* we cannot because it doesn't always exist. So.. we assume the
* MBR is valid.
*/
int
readdisklabel(dev_t dev, void (*strat)(struct buf *),
struct disklabel *lp, int spoofonly)
{
bios_diskinfo_t *pdi;
struct buf *bp = NULL;
dev_t devno;
int error;
if ((error = initdisklabel(lp)))
goto done;
/* Look for any BIOS geometry information we should honour. */
devno = chrtoblk(dev);
if (devno == NODEV)
devno = dev;
pdi = bios_getdiskinfo(MAKEBOOTDEV(major(devno), 0, 0, DISKUNIT(devno),
RAW_PART));
if (pdi != NULL && pdi->bios_heads > 0 && pdi->bios_sectors > 0) {
#ifdef DEBUG
printf("Disk GEOM %u/%u/%u -> BIOS GEOM %u/%u/%u\n",
lp->d_ntracks, lp->d_nsectors, lp->d_ncylinders,
pdi->bios_heads, pdi->bios_sectors,
DL_GETDSIZE(lp) / (pdi->bios_heads * pdi->bios_sectors));
#endif
lp->d_ntracks = pdi->bios_heads;
lp->d_nsectors = pdi->bios_sectors;
lp->d_secpercyl = pdi->bios_sectors * pdi->bios_heads;
lp->d_ncylinders = DL_GETDSIZE(lp) / lp->d_secpercyl;
}
/* get a buffer and initialize it */
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
error = readdoslabel(bp, strat, lp, NULL, spoofonly);
if (error == 0)
goto done;
#if defined(CD9660)
error = iso_disklabelspoof(dev, strat, lp);
if (error == 0)
goto done;
#endif
#if defined(UDF)
error = udf_disklabelspoof(dev, strat, lp);
if (error == 0)
goto done;
#endif
done:
if (bp) {
bp->b_flags |= B_INVAL;
brelse(bp);
}
disk_change = 1;
return (error);
}
void
DInit(int abuffers)
{
/* Initialize the venus buffer system. */
register int i;
register struct buffer *tb;
#if defined(AFS_USEBUFFERS)
struct buf *tub; /* unix buffer for allocation */
#endif
AFS_STATCNT(DInit);
if (dinit_flag)
return;
dinit_flag = 1;
#if defined(AFS_USEBUFFERS)
/* round up to next multiple of NPB, since we allocate multiple pages per chunk */
abuffers = ((abuffers - 1) | (NPB - 1)) + 1;
#endif
LOCK_INIT(&afs_bufferLock, "afs_bufferLock");
Buffers =
(struct buffer *)afs_osi_Alloc(abuffers * sizeof(struct buffer));
#if !defined(AFS_USEBUFFERS)
BufferData = (char *)afs_osi_Alloc(abuffers * AFS_BUFFER_PAGESIZE);
#endif
timecounter = 1;
afs_stats_cmperf.bufAlloced = nbuffers = abuffers;
for (i = 0; i < PHSIZE; i++)
phTable[i] = 0;
for (i = 0; i < abuffers; i++) {
#if defined(AFS_USEBUFFERS)
if ((i & (NPB - 1)) == 0) {
/* time to allocate a fresh buffer */
tub = geteblk(AFS_BUFFER_PAGESIZE * NPB);
BufferData = (char *)tub->b_un.b_addr;
}
#endif
/* Fill in each buffer with an empty indication. */
tb = &Buffers[i];
tb->fid = NULLIDX;
tb->inode = 0;
tb->accesstime = 0;
tb->lockers = 0;
#if defined(AFS_USEBUFFERS)
if ((i & (NPB - 1)) == 0)
tb->bufp = tub;
else
tb->bufp = 0;
tb->data = &BufferData[AFS_BUFFER_PAGESIZE * (i & (NPB - 1))];
#else
tb->data = &BufferData[AFS_BUFFER_PAGESIZE * i];
#endif
tb->hashIndex = 0;
tb->dirty = 0;
AFS_RWLOCK_INIT(&tb->lock, "buffer lock");
}
return;
}
/*
* Attempt to read a disk label from a device
* using the indicated strategy routine.
* The label must be partly set up before this:
* secpercyl, secsize and anything required for a block i/o read
* operation in the driver's strategy/start routines
* must be filled in before calling us.
*/
int
readdisklabel(dev_t dev, void (*strat)(struct buf *),
struct disklabel *lp, int spoofonly)
{
struct buf *bp = NULL;
int error;
if ((error = initdisklabel(lp)))
goto done;
/* get a buffer and initialize it */
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
if (spoofonly)
goto doslabel;
bp->b_blkno = LABELSECTOR;
bp->b_bcount = lp->d_secsize;
CLR(bp->b_flags, B_READ | B_WRITE | B_DONE);
SET(bp->b_flags, B_BUSY | B_READ | B_RAW);
(*strat)(bp);
if (biowait(bp)) {
error = bp->b_error;
goto done;
}
error = checkdisklabel(bp->b_data + LABELOFFSET, lp, 0,
DL_GETDSIZE(lp));
if (error == 0)
goto done;
doslabel:
error = readdoslabel(bp, strat, lp, NULL, spoofonly);
if (error == 0)
goto done;
#if defined(CD9660)
error = iso_disklabelspoof(dev, strat, lp);
if (error == 0)
goto done;
#endif
#if defined(UDF)
error = udf_disklabelspoof(dev, strat, lp);
if (error == 0)
goto done;
#endif
done:
if (bp) {
bp->b_flags |= B_INVAL;
brelse(bp);
}
disk_change = 1;
return (error);
}
/*
* Attempt to read a disk label from a device
* using the indicated strategy routine.
* The label must be partly set up before this:
* secpercyl and anything required in the strategy routine
* (e.g., sector size) must be filled in before calling us.
* Returns null on success and an error string on failure.
*/
const char *
readdisklabel(dev_t dev, void (*strat)(struct buf *bp), struct disklabel *lp,
struct cpu_disklabel *osdep)
{
struct buf *bp;
struct disklabel *dlp;
const char *msg = NULL;
if (lp->d_secperunit == 0)
lp->d_secperunit = 0x1fffffff;
lp->d_npartitions = 1;
if (lp->d_partitions[0].p_size == 0)
lp->d_partitions[0].p_size = 0x1fffffff;
lp->d_partitions[0].p_offset = 0;
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
bp->b_blkno = LABELSECTOR;
bp->b_bcount = lp->d_secsize;
bp->b_flags |= B_READ;
bp->b_cylinder = LABELSECTOR / lp->d_secpercyl;
(*strat)(bp);
if (biowait(bp)) {
msg = "I/O error";
} else for (dlp = (struct disklabel *)bp->b_data;
dlp <= (struct disklabel *)
((char *)bp->b_data + DEV_BSIZE - sizeof(*dlp));
dlp = (struct disklabel *)((char *)dlp + sizeof(long))) {
if (dlp->d_magic != DISKMAGIC || dlp->d_magic2 != DISKMAGIC) {
if (msg == NULL)
msg = "no disk label";
} else if (dlp->d_npartitions > MAXPARTITIONS ||
dkcksum(dlp) != 0)
msg = "disk label corrupted";
else {
*lp = *dlp;
msg = NULL;
break;
}
}
brelse(bp, 0);
/*
* If no NetBSD label was found, check for an Ultrix label and
* construct tne incore label from the Ultrix partition information.
*/
if (msg != NULL) {
msg = compat_label(dev, strat, lp, osdep);
if (msg == NULL) {
printf("WARNING: using Ultrix partition information\n");
/* set geometry? */
}
}
/* XXX If no NetBSD label or Ultrix label found, generate default label here */
return msg;
}
/*ARGSUSED*/
int
cflopen(dev_t dev, int flag, int mode, struct lwp *l)
{
if (vax_cputype != VAX_780)
return (ENXIO);
if (cfltab.cfl_state != IDLE)
return (EALREADY);
cfltab.cfl_state = OPEN;
cfltab.cfl_buf = geteblk(512);
return (0);
}
/*
* Attempt to read a disk label from a device
* using the indicated strategy routine.
* The label must be partly set up before this:
* secpercyl and anything required in the strategy routine
* (e.g., sector size) must be filled in before calling us.
* Returns null on success and an error string on failure.
*/
const char *
readdisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp,
struct cpu_disklabel *osdep)
{
struct buf *bp;
struct disklabel *dlp;
const char *msg = NULL;
int i;
if (lp->d_secsize == 0)
lp->d_secsize = DEV_BSIZE;
if (lp->d_secperunit == 0)
lp->d_secperunit = 0x1fffffff;
if (lp->d_npartitions < RAW_PART + 1)
lp->d_npartitions = RAW_PART + 1;
for (i = 0; i < RAW_PART; i++) {
lp->d_partitions[i].p_size = 0;
lp->d_partitions[i].p_offset = 0;
}
if (lp->d_partitions[RAW_PART].p_size == 0)
lp->d_partitions[RAW_PART].p_size = lp->d_secperunit;
lp->d_partitions[RAW_PART].p_offset = 0;
lp->d_partitions[0].p_size = lp->d_partitions[RAW_PART].p_size;
lp->d_partitions[0].p_fstype = FS_BSDFFS;
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
bp->b_blkno = LABELSECTOR;
bp->b_bcount = lp->d_secsize;
bp->b_flags |= B_READ;
bp->b_cylinder = LABELSECTOR / lp->d_secpercyl;
(*strat)(bp);
if (biowait(bp))
msg = "I/O error";
else for (dlp = (struct disklabel *)bp->b_data;
dlp <= (struct disklabel *)((char *)bp->b_data + DEV_BSIZE
- sizeof(*dlp));
dlp = (struct disklabel *)((char *)dlp + sizeof(long))) {
if (dlp->d_magic != DISKMAGIC || dlp->d_magic2 != DISKMAGIC) {
if (msg == NULL)
msg = "no disk label";
} else if (dlp->d_npartitions > MAXPARTITIONS ||
dkcksum(dlp) != 0)
msg = "disk label corrupted";
else {
*lp = *dlp;
msg = NULL;
break;
}
}
brelse(bp, 0);
return msg;
}
/*ARGSUSED*/
int
crlopen(dev_t dev, int flag, int mode, struct lwp *l)
{
if (vax_cputype != VAX_8600)
return (ENXIO);
if (crltab.crl_state != CRL_IDLE)
return (EALREADY);
crltab.crl_state = CRL_OPEN;
crltab.crl_buf = geteblk(512);
return (0);
}
/*
* Attempt to read a disk label from a device
* using the indicated strategy routine.
* The label must be partly set up before this:
* secpercyl, secsize and anything required for a block i/o read
* operation in the driver's strategy/start routines
* must be filled in before calling us.
*/
int
readdisklabel(dev_t dev, void (*strat)(struct buf *),
struct disklabel *lp, int spoofonly)
{
struct sun_disklabel *slp;
struct buf *bp = NULL;
int error;
if ((error = initdisklabel(lp)))
goto done;
lp->d_flags |= D_VENDOR;
/* get a buffer and initialize it */
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
if (spoofonly)
goto done;
error = readdisksector(bp, strat, lp, DL_BLKTOSEC(lp, LABELSECTOR));
if (error)
goto done;
slp = (struct sun_disklabel *)bp->b_data;
if (slp->sl_magic == SUN_DKMAGIC) {
error = disklabel_om_to_bsd(slp, lp);
goto done;
}
error = checkdisklabel(bp->b_data + LABELOFFSET, lp, 0,
DL_GETDSIZE(lp));
if (error == 0)
goto done;
#if defined(CD9660)
error = iso_disklabelspoof(dev, strat, lp);
if (error == 0)
goto done;
#endif
#if defined(UDF)
error = udf_disklabelspoof(dev, strat, lp);
if (error == 0)
goto done;
#endif
done:
if (bp) {
bp->b_flags |= B_INVAL;
brelse(bp);
}
disk_change = 1;
return (error);
}
/*
* Attempt to read a disk label from a device
* using the indicated strategy routine.
* The label must be partly set up before this:
* secpercyl and anything required in the strategy routine
* (e.g., sector size) must be filled in before calling us.
*/
int
readdisklabel(dev_t dev, void (*strat)(struct buf *),
struct disklabel *lp, int spoofonly)
{
struct buf *bp = NULL;
int error;
if ((error = initdisklabel(lp)))
goto done;
/* get a buffer and initialize it */
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
/* don't read the on-disk label if we are in spoofed-only mode */
if (spoofonly)
goto done;
bp->b_blkno = LABELSECTOR;
bp->b_bcount = lp->d_secsize;
CLR(bp->b_flags, B_READ | B_WRITE | B_DONE);
SET(bp->b_flags, B_BUSY | B_READ | B_RAW);
(*strat)(bp);
if (biowait(bp)) {
error = bp->b_error;
goto done;
}
error = cputobsdlabel(lp, (struct mvmedisklabel *)bp->b_data);
if (error == 0)
goto done;
#if defined(CD9660)
error = iso_disklabelspoof(dev, strat, lp);
if (error == 0)
goto done;
#endif
#if defined(UDF)
error = udf_disklabelspoof(dev, strat, lp);
if (error == 0)
goto done;
#endif
done:
if (bp) {
bp->b_flags |= B_INVAL;
brelse(bp);
}
disk_change = 1;
return (error);
}
/*
* Attempt to read a disk label from a device.
*
* Returns NULL on sucess, and an error string on failure
*/
static const char *
l32_readdisklabel(cdev_t dev, struct diskslice *sp, disklabel_t *lpp,
struct disk_info *info)
{
disklabel_t lpx;
struct buf *bp;
struct disklabel32 *dlp;
const char *msg = NULL;
int secsize = info->d_media_blksize;
bp = geteblk(secsize);
bp->b_bio1.bio_offset = (off_t)LABELSECTOR32 * secsize;
bp->b_bio1.bio_done = biodone_sync;
bp->b_bio1.bio_flags |= BIO_SYNC;
bp->b_bcount = secsize;
bp->b_flags &= ~B_INVAL;
bp->b_cmd = BUF_CMD_READ;
dev_dstrategy(dev, &bp->b_bio1);
if (biowait(&bp->b_bio1, "labrd"))
msg = "I/O error";
else for (dlp = (struct disklabel32 *)bp->b_data;
dlp <= (struct disklabel32 *)((char *)bp->b_data +
secsize - sizeof(*dlp));
dlp = (struct disklabel32 *)((char *)dlp + sizeof(long))) {
if (dlp->d_magic != DISKMAGIC32 ||
dlp->d_magic2 != DISKMAGIC32) {
/*
* NOTE! dsreadandsetlabel() does a strcmp() on
* this string.
*/
if (msg == NULL)
msg = "no disk label";
} else if (dlp->d_npartitions > MAXPARTITIONS32 ||
dkcksum32(dlp) != 0) {
msg = "disk label corrupted";
} else {
lpx.lab32 = dlp;
msg = l32_fixlabel(NULL, sp, lpx, FALSE);
if (msg == NULL) {
(*lpp).lab32 = kmalloc(sizeof(*dlp),
M_DEVBUF, M_WAITOK|M_ZERO);
*(*lpp).lab32 = *dlp;
}
break;
}
}
bp->b_flags |= B_INVAL | B_AGE;
brelse(bp);
return (msg);
}
void *
sector_init(dev_t dev, void (*strat)(struct buf *))
{
struct sector_rw *rw =& __context;
if (rw->busy)
return 0;
rw->busy = true;
rw->strategy = strat;
rw->buf = geteblk(DEV_BSIZE);
rw->buf->b_dev = dev;
return rw;
}
/*
* Write disk label back to device after modification.
*/
int
writedisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp,
struct cpu_disklabel *osdep)
{
struct buf *bp;
struct disklabel *dlp;
int error;
#ifdef maybe
/* disklabel in appropriate location? */
if (lp->d_partitions[2].p_offset != 0
&& lp->d_partitions[2].p_offset != dospartoff) {
error = EXDEV;
goto done;
}
#endif
/* get a buffer and initialize it */
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
bp->b_blkno = LABELSECTOR;
bp->b_cylinder = 0;
bp->b_bcount = lp->d_secsize;
bp->b_flags |= B_READ;
(*strat)(bp);
/* if successful, locate disk label within block and validate */
if ((error = biowait(bp)) != 0)
goto done;
for (dlp = (struct disklabel *)bp->b_data;
dlp <= (struct disklabel *)((char *)bp->b_data + lp->d_secsize -
sizeof(*dlp));
dlp = (struct disklabel *)((char *)dlp + sizeof(long))) {
if (dlp->d_magic == DISKMAGIC && dlp->d_magic2 == DISKMAGIC &&
dkcksum(dlp) == 0) {
*dlp = *lp;
bp->b_cflags = BC_BUSY;
bp->b_flags = B_WRITE;
CLR(bp->b_oflags, BO_DONE);
(*strat)(bp);
error = biowait(bp);
goto done;
}
}
error = ESRCH;
done:
brelse(bp, 0);
return (error);
}
/*
* Attempt to read a disk label from a device
* using the indicated strategy routine.
* The label must be partly set up before this:
* secpercyl, secsize and anything required for a block i/o read
* operation in the driver's strategy/start routines
* must be filled in before calling us.
*/
int
readdisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp,
int spoofonly)
{
struct buf *bp = NULL;
int error;
if ((error = initdisklabel(lp)))
goto done;
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
/*
* Check for a VDIT or native-in-VDM label first.
* If a valid VDM signature is found, but neither a VDIT nor a
* native label are found, do not attempt to check for any other
* label scheme.
*/
error = readvdmlabel(bp, strat, lp, NULL, spoofonly);
if (error == 0)
goto done;
if (error == ENOENT) {
error = EINVAL;
goto done;
}
error = readdoslabel(bp, strat, lp, NULL, spoofonly);
if (error == 0)
goto done;
#if defined(CD9660)
error = iso_disklabelspoof(dev, strat, lp);
if (error == 0)
goto done;
#endif
#if defined(UDF)
error = udf_disklabelspoof(dev, strat, lp);
if (error == 0)
goto done;
#endif
done:
if (bp) {
bp->b_flags |= B_INVAL;
brelse(bp);
}
disk_change = 1;
return (error);
}
V11open(dev,flag)
{
struct buf *geteblk() ;
if (V11opn) {
u.u_error = EBUSY;
return;
}
V11opn++;
if (V11tab.bp == 0) /* grab system buffer */
V11tab.bp = geteblk() ; /* VAX call */
((struct lnkreg *)LNKADR)->drst |= IE ;
V11tab.state |= OPEN ;
}
static struct buf * create_vmstack(void)
{
struct buf * vmstack;
vmstack = geteblk(configUSRINIT_SSIZE);
if (!vmstack)
return NULL;
vmstack->b_uflags = VM_PROT_READ | VM_PROT_WRITE;
vmstack->b_mmu.vaddr = vmstack->b_mmu.paddr;
vmstack->b_mmu.ap = MMU_AP_RWRW;
vmstack->b_mmu.control = MMU_CTRL_XN;
return vmstack;
}
xfs_buf_t*
xfs_buf_get_noaddr(size_t len, xfs_buftarg_t *target)
{
struct buf *bp;
if (len >= MAXPHYS)
return (NULL);
bp = geteblk(len, 0);
if (bp != NULL) {
BUF_ASSERT_HELD(bp);
xfs_buf_set_target(bp, target);
}
return (bp);
}
/*
* Attempt to read a disk label from a device
* using the indicated strategy routine.
* The label must be partly set up before this:
* secpercyl, secsize and anything required for a block i/o read
* operation in the driver's strategy/start routines
* must be filled in before calling us.
*
* Returns null on success and an error string on failure.
*/
const char *
readdisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp,
struct cpu_disklabel *osdep)
{
int spoofonly = 0;
struct buf *bp = NULL;
const char *msg = "no disk label";
int i;
struct disklabel fallbacklabel;
/* minimal requirements for archetypal disk label */
if (lp->d_secsize == 0)
lp->d_secsize = DEV_BSIZE;
if (lp->d_secperunit == 0)
lp->d_secperunit = 0x1fffffff;
if (lp->d_secpercyl == 0)
return "invalid geometry";
lp->d_npartitions = RAW_PART + 1;
for (i = 0; i < RAW_PART; i++) {
lp->d_partitions[i].p_size = 0;
lp->d_partitions[i].p_offset = 0;
}
if (lp->d_partitions[i].p_size == 0)
lp->d_partitions[i].p_size = 0x1fffffff;
lp->d_partitions[i].p_offset = 0;
fallbacklabel = *lp;
/* get a buffer and initialize it */
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
msg = readliflabel(bp, strat, lp, osdep, 0, 0, spoofonly);
#if defined(CD9660)
if (msg && iso_disklabelspoof(dev, strat, lp) == 0)
msg = NULL;
#endif
/* If there was an error, still provide a decent fake one. */
if (msg)
*lp = fallbacklabel;
if (bp) {
brelse(bp, BC_INVAL);
}
return (msg);
}
struct buf *
nandfs_geteblk(int size, int flags)
{
struct buf *bp;
/*
* XXX
* Right now we can call geteblk with GB_NOWAIT_BD flag, which means
* it can return NULL. But we cannot afford to get NULL, hence this panic.
*/
bp = geteblk(size, flags);
if (bp == NULL)
panic("geteblk returned NULL");
return (bp);
}
xfs_buf_t*
xfs_buf_get_empty(size_t size, xfs_buftarg_t *target)
{
struct buf *bp;
bp = geteblk(0, 0);
if (bp != NULL) {
bp->b_bufsize = size;
bp->b_bcount = size;
BUF_ASSERT_HELD(bp);
xfs_buf_set_target(bp, target);
}
return (bp);
}
/*
* Write disk label back to device after modification.
*/
int
writedisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp)
{
daddr_t partoff = -1;
int error = EIO;
int offset;
struct disklabel *dlp;
struct buf *bp = NULL;
/* get a buffer and initialize it */
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
if (readdpmelabel(bp, strat, lp, &partoff, 1) == 0) {
bp->b_blkno = partoff;
offset = 0;
} else if (readdoslabel(bp, strat, lp, &partoff, 1) == 0) {
bp->b_blkno = DL_BLKTOSEC(lp, partoff + DOS_LABELSECTOR) *
DL_BLKSPERSEC(lp);
offset = DL_BLKOFFSET(lp, partoff + DOS_LABELSECTOR);
} else
goto done;
/* Read it in, slap the new label in, and write it back out */
bp->b_bcount = lp->d_secsize;
CLR(bp->b_flags, B_READ | B_WRITE | B_DONE);
SET(bp->b_flags, B_BUSY | B_READ | B_RAW);
(*strat)(bp);
if ((error = biowait(bp)) != 0)
goto done;
dlp = (struct disklabel *)(bp->b_data + offset);
*dlp = *lp;
CLR(bp->b_flags, B_READ | B_WRITE | B_DONE);
SET(bp->b_flags, B_BUSY | B_WRITE | B_RAW);
(*strat)(bp);
error = biowait(bp);
done:
if (bp) {
bp->b_flags |= B_INVAL;
brelse(bp);
}
disk_change = 1;
return (error);
}
/*
* Write disk label back to device after modification.
*/
int
writedisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp,
struct cpu_disklabel *osdep)
{
const char *msg = "no disk label";
struct buf *bp;
struct disklabel dl;
struct cpu_disklabel cdl;
int labeloffset, error, partoff = 0, cyl = 0;
/* get a buffer and initialize it */
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
/*
* I once played with the thought of using osdep->label{tag,sector}
* as a cache for knowing where (and what) to write. However, now I
* think it might be useful to reprobe if someone has written
* a newer disklabel of another type with disklabel(8) and -r.
*/
dl = *lp;
msg = readliflabel(bp, strat, &dl, &cdl, &partoff, &cyl, 0);
labeloffset = LABELOFFSET;
if (msg) {
if (partoff == -1)
return EIO;
/* Write it in the regular place with native byte order. */
labeloffset = LABELOFFSET;
bp->b_blkno = partoff + LABELSECTOR;
bp->b_cylinder = cyl;
bp->b_bcount = lp->d_secsize;
}
*(struct disklabel *)((char *)bp->b_data + labeloffset) = *lp;
bp->b_cflags = BC_BUSY;
bp->b_flags = B_WRITE;
(*strat)(bp);
error = biowait(bp);
brelse(bp, BC_INVAL);
return (error);
}
/*
* Write disk label back to device after modification.
*/
int
writedisklabel(dev_t dev, void (*strat)(struct buf *bp), struct disklabel *lp,
struct cpu_disklabel *osdep)
{
struct buf *bp;
struct disklabel *dlp;
int labelpart;
int error = 0;
labelpart = DISKPART(dev);
if (lp->d_partitions[labelpart].p_offset != 0) {
if (lp->d_partitions[0].p_offset != 0)
return EXDEV; /* not quite right */
labelpart = 0;
}
bp = geteblk((int)lp->d_secsize);
bp->b_dev = makedev(major(dev), DISKMINOR(DISKUNIT(dev), labelpart));
bp->b_blkno = LABELSECTOR;
bp->b_bcount = lp->d_secsize;
bp->b_flags |= B_READ;
(*strat)(bp);
if ((error = biowait(bp)) != 0)
goto done;
for (dlp = (struct disklabel *)bp->b_data;
dlp <= (struct disklabel *)
((char *)bp->b_data + lp->d_secsize - sizeof(*dlp));
dlp = (struct disklabel *)((char *)dlp + sizeof(long))) {
if (dlp->d_magic == DISKMAGIC && dlp->d_magic2 == DISKMAGIC &&
dkcksum(dlp) == 0) {
*dlp = *lp;
bp->b_oflags &= ~(BO_DONE);
bp->b_flags &= ~(B_READ);
bp->b_flags |= B_WRITE;
(*strat)(bp);
error = biowait(bp);
goto done;
}
}
error = ESRCH;
done:
brelse(bp, 0);
return error;
}
struct fs_queue * fs_queue_create(size_t nr_blocks, size_t block_size)
{
struct buf * bp;
struct fs_queue * fsq;
bp = geteblk(sizeof(struct fs_queue)
+ nr_blocks * (sizeof(struct fs_queue_packet) + block_size));
if (!bp)
return NULL;
fsq = (struct fs_queue *)(bp->b_data);
fsq->qcb = queue_create(fsq->packet, block_size, nr_blocks);
mtx_init(&fsq->wr_lock, MTX_TYPE_TICKET, MTX_OPT_DEFAULT);
mtx_init(&fsq->rd_lock, MTX_TYPE_TICKET, MTX_OPT_DEFAULT);
fsq->bp = bp;
return fsq;
}
