Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/usr.bin/rump_allserver/rump_allserver.c

790 lines
22 KiB
C
Raw Blame History

/* $NetBSD: rump_allserver.c,v 1.39 2015/04/16 10:05:43 pooka Exp $ */
/*-
* Copyright (c) 2010, 2011 Antti Kantee. 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.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*/
#include <rump/rumpuser_port.h>
#ifndef lint
__RCSID("$NetBSD: rump_allserver.c,v 1.39 2015/04/16 10:05:43 pooka Exp $");
#endif /* !lint */
#include <sys/types.h>
#include <sys/stat.h>
#include <dlfcn.h>
#include <errno.h>
#include <fcntl.h>
#include <semaphore.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <rump/rump.h>
#include <rump/rump_syscalls.h>
#include <rump/rumpdefs.h>
#include <rump/rumperr.h>
__dead static void
usage(void)
{
#ifndef HAVE_GETPROGNAME
#define getprogname() "rump_server"
#endif
fprintf(stderr, "usage: %s [-s] [-c ncpu] [-d drivespec] [-l libs] "
"[-m modules] bindurl\n", getprogname());
exit(1);
}
__dead static void
diedie(int sflag, const char *reason, int error, const char *errstr)
{
if (reason != NULL)
fputs(reason, stderr);
if (errstr) {
fprintf(stderr, ": %s", errstr);
}
fputc('\n', stderr);
if (!sflag)
rump_daemonize_done(error);
exit(1);
}
__dead static void
die(int sflag, int error, const char *reason)
{
diedie(sflag, reason, error, error == 0 ? NULL : strerror(error));
}
__dead static void
die_rumperr(int sflag, int error, const char *reason)
{
diedie(sflag, reason, error, error == 0 ? NULL : rump_strerror(error));
}
static sem_t sigsem;
static void
sigreboot(int sig)
{
sem_post(&sigsem);
}
static const char *const disktokens[] = {
#define DKEY 0
"key",
#define DFILE 1
"hostpath",
#define DSIZE 2
#define DSIZE_E -1
"size",
#define DOFFSET 3
"offset",
#define DLABEL 4
"disklabel",
#define DTYPE 5
"type",
NULL
};
struct etfsreg {
const char *key;
const char *hostpath;
off_t flen;
off_t foffset;
char partition;
enum rump_etfs_type type;
};
struct etfstype {
const char *name;
enum rump_etfs_type type;
} etfstypes[] = {
{ "blk", RUMP_ETFS_BLK },
{ "chr", RUMP_ETFS_CHR },
{ "reg", RUMP_ETFS_REG },
};
static void processlabel(int, int, int, off_t *, off_t *);
#define ALLOCCHUNK 32
int
main(int argc, char *argv[])
{
const char *serverurl;
struct etfsreg *etfs = NULL;
unsigned netfs = 0, curetfs = 0;
int error;
int ch, sflag, onthepath;
unsigned i;
char **modarray = NULL, **libarray = NULL;
unsigned nmods = 0, curmod = 0, nlibs = 0, curlib = 0, libidx;
unsigned liblast = -1; /* XXXgcc */
setprogname(argv[0]);
sflag = 0;
while ((ch = getopt(argc, argv, "c:d:l:m:r:sv")) != -1) {
switch (ch) {
case 'c':
setenv("RUMP_NCPU", optarg, 1);
break;
case 'd': {
char *options, *value;
char *key, *hostpath;
long long flen, foffset;
char partition;
int ftype;
flen = foffset = 0;
partition = 0;
key = hostpath = NULL;
ftype = -1;
options = optarg;
while (*options) {
switch (getsubopt(&options,
__UNCONST(disktokens), &value)) {
case DKEY:
if (key != NULL) {
fprintf(stderr,
"key already given\n");
usage();
}
key = value;
break;
case DFILE:
if (hostpath != NULL) {
fprintf(stderr,
"hostpath already given\n");
usage();
}
hostpath = value;
break;
case DSIZE:
if (flen != 0) {
fprintf(stderr,
"size already given\n");
usage();
}
if (strcmp(value, "host") == 0) {
if (foffset != 0) {
fprintf(stderr,
"cannot specify "
"offset with "
"size=host\n");
usage();
}
flen = DSIZE_E;
} else {
#ifdef HAVE_STRSUFTOLL
/* XXX: off_t max? */
flen = strsuftoll("-d size",
value, 0, LLONG_MAX);
#else
flen = strtoull(value,
NULL, 10);
#endif
}
break;
case DOFFSET:
if (foffset != 0) {
fprintf(stderr,
"offset already given\n");
usage();
}
if (flen == DSIZE_E) {
fprintf(stderr, "cannot "
"specify offset with "
"size=host\n");
usage();
}
#ifdef HAVE_STRSUFTOLL
/* XXX: off_t max? */
foffset = strsuftoll("-d offset", value,
0, LLONG_MAX);
#else
foffset = strtoull(value, NULL, 10);
#endif
break;
case DLABEL:
if (foffset != 0 || flen != 0) {
fprintf(stderr,
"disklabel needs to be "
"used alone\n");
usage();
}
if (strlen(value) != 1 ||
*value < 'a' || *value > 'z') {
fprintf(stderr,
"invalid label part\n");
usage();
}
partition = *value;
break;
case DTYPE:
if (ftype != -1) {
fprintf(stderr,
"type already specified\n");
usage();
}
for (i = 0;
i < __arraycount(etfstypes);
i++) {
if (strcmp(etfstypes[i].name,
value) == 0)
break;
}
if (i == __arraycount(etfstypes)) {
fprintf(stderr,
"invalid type %s\n", value);
usage();
}
ftype = etfstypes[i].type;
break;
default:
fprintf(stderr, "invalid dtoken\n");
usage();
break;
}
}
if (key == NULL || hostpath == NULL ||
(flen == 0
&& partition == 0 && ftype != RUMP_ETFS_REG)) {
fprintf(stderr, "incomplete drivespec\n");
usage();
}
if (ftype == -1)
ftype = RUMP_ETFS_BLK;
if (netfs - curetfs == 0) {
etfs = realloc(etfs,
(netfs+ALLOCCHUNK)*sizeof(*etfs));
if (etfs == NULL)
die(1, errno, "realloc etfs");
netfs += ALLOCCHUNK;
}
etfs[curetfs].key = key;
etfs[curetfs].hostpath = hostpath;
etfs[curetfs].flen = flen;
etfs[curetfs].foffset = foffset;
etfs[curetfs].partition = partition;
etfs[curetfs].type = ftype;
curetfs++;
break;
}
case 'l':
if (nlibs - curlib == 0) {
libarray = realloc(libarray,
(nlibs+ALLOCCHUNK) * sizeof(char *));
if (libarray == NULL)
die(1, errno, "realloc");
nlibs += ALLOCCHUNK;
}
libarray[curlib++] = optarg;
break;
case 'm':
if (nmods - curmod == 0) {
modarray = realloc(modarray,
(nmods+ALLOCCHUNK) * sizeof(char *));
if (modarray == NULL)
die(1, errno, "realloc");
nmods += ALLOCCHUNK;
}
modarray[curmod++] = optarg;
break;
case 'r':
setenv("RUMP_MEMLIMIT", optarg, 1);
break;
case 's':
sflag = 1;
break;
case 'v':
setenv("RUMP_VERBOSE", "1", 1);
break;
default:
usage();
/*NOTREACHED*/
}
}
argc -= optind;
argv += optind;
if (argc != 1)
usage();
/*
* Automatically "resolve" component dependencies, i.e.
* try to load libs in a loop until all are loaded or a
* full loop completes with no loads (latter case is an error).
*/
for (onthepath = 1, nlibs = curlib; onthepath && nlibs > 0;) {
onthepath = 0;
for (libidx = 0; libidx < curlib; libidx++) {
/* loaded already? */
if (libarray[libidx] == NULL)
continue;
/* try to load */
liblast = libidx;
if (dlopen(libarray[libidx],
RTLD_LAZY|RTLD_GLOBAL) == NULL) {
char pb[MAXPATHLEN];
/* try to mimic linker -l syntax */
snprintf(pb, sizeof(pb),
"lib%s.so", libarray[libidx]);
if (dlopen(pb, RTLD_LAZY|RTLD_GLOBAL) == NULL)
continue;
}
/* managed to load that one */
libarray[libidx] = NULL;
nlibs--;
onthepath = 1;
}
}
if (nlibs > 0) {
fprintf(stderr,
"failed to load -libraries, last error from \"%s\":\n",
libarray[liblast]);
fprintf(stderr, " %s", dlerror());
die(1, 0, NULL);
}
free(libarray);
serverurl = argv[0];
if (!sflag) {
error = rump_daemonize_begin();
if (error)
die_rumperr(1, error, "rump daemonize");
}
error = rump_init();
if (error)
die_rumperr(sflag, error, "rump init failed");
/* load modules */
for (i = 0; i < curmod; i++) {
struct rump_modctl_load ml;
#define ETFSKEY "/module.mod"
if ((error = rump_pub_etfs_register(ETFSKEY,
modarray[0], RUMP_ETFS_REG)) != 0)
die_rumperr(sflag,
error, "module etfs register failed");
memset(&ml, 0, sizeof(ml));
ml.ml_filename = ETFSKEY;
/*
* XXX: since this is a syscall, error namespace depends
* on loaded emulations. revisit and fix.
*/
if (rump_sys_modctl(RUMP_MODCTL_LOAD, &ml) == -1)
die(sflag, errno, "module load failed");
rump_pub_etfs_remove(ETFSKEY);
#undef ETFSKEY
}
free(modarray);
/* register host drives */
for (i = 0; i < curetfs; i++) {
struct stat sb;
off_t foffset, flen, fendoff;
int fd, oflags;
oflags = etfs[i].flen == DSIZE_E ? 0 : O_CREAT;
fd = open(etfs[i].hostpath, O_RDWR | oflags, 0644);
if (fd == -1)
die(sflag, errno, "etfs hostpath open");
if (etfs[i].partition) {
processlabel(sflag, fd, etfs[i].partition - 'a',
&foffset, &flen);
} else {
foffset = etfs[i].foffset;
flen = etfs[i].flen;
}
if (fstat(fd, &sb) == -1)
die(sflag, errno, "fstat etfs hostpath");
if (flen == DSIZE_E) {
if (sb.st_size == 0)
die(sflag, EINVAL, "size=host, but cannot "
"query non-zero size");
flen = sb.st_size;
}
fendoff = foffset + flen;
if (S_ISREG(sb.st_mode) && sb.st_size < fendoff) {
if (ftruncate(fd, fendoff) == -1)
die(sflag, errno, "truncate");
}
close(fd);
if ((error = rump_pub_etfs_register_withsize(etfs[i].key,
etfs[i].hostpath, etfs[i].type, foffset, flen)) != 0)
die_rumperr(sflag, error, "etfs register");
}
error = rump_init_server(serverurl);
if (error)
die_rumperr(sflag, error, "rump server init failed");
if (!sflag)
rump_daemonize_done(RUMP_DAEMONIZE_SUCCESS);
sem_init(&sigsem, 0, 0);
signal(SIGTERM, sigreboot);
signal(SIGINT, sigreboot);
sem_wait(&sigsem);
rump_sys_reboot(0, NULL);
/*NOTREACHED*/
return 0;
}
/*
* Copyright (c) 1987, 1988, 1993
* The 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. 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.
*
* @(#)disklabel.h 8.2 (Berkeley) 7/10/94
*/
#define RUMPSERVER_MAXPARTITIONS 22
#define RUMPSERVER_DISKMAGIC ((uint32_t)0x82564557) /* magic */
#define RUMPSERVER_DEVSHIFT 9
struct rumpserver_disklabel {
uint32_t d_magic; /* the magic number */
uint16_t d_type; /* drive type */
uint16_t d_subtype; /* controller/d_type specific */
char d_typename[16]; /* type name, e.g. "eagle" */
/*
* d_packname contains the pack identifier and is returned when
* the disklabel is read off the disk or in-core copy.
* d_boot0 and d_boot1 are the (optional) names of the
* primary (block 0) and secondary (block 1-15) bootstraps
* as found in /usr/mdec. These are returned when using
* getdiskbyname(3) to retrieve the values from /etc/disktab.
*/
union {
char un_d_packname[16]; /* pack identifier */
struct {
char *un_d_boot0; /* primary bootstrap name */
char *un_d_boot1; /* secondary bootstrap name */
} un_b;
} d_un;
#define d_packname d_un.un_d_packname
#define d_boot0 d_un.un_b.un_d_boot0
#define d_boot1 d_un.un_b.un_d_boot1
/* disk geometry: */
uint32_t d_secsize; /* # of bytes per sector */
uint32_t d_nsectors; /* # of data sectors per track */
uint32_t d_ntracks; /* # of tracks per cylinder */
uint32_t d_ncylinders; /* # of data cylinders per unit */
uint32_t d_secpercyl; /* # of data sectors per cylinder */
uint32_t d_secperunit; /* # of data sectors per unit */
/*
* Spares (bad sector replacements) below are not counted in
* d_nsectors or d_secpercyl. Spare sectors are assumed to
* be physical sectors which occupy space at the end of each
* track and/or cylinder.
*/
uint16_t d_sparespertrack; /* # of spare sectors per track */
uint16_t d_sparespercyl; /* # of spare sectors per cylinder */
/*
* Alternative cylinders include maintenance, replacement,
* configuration description areas, etc.
*/
uint32_t d_acylinders; /* # of alt. cylinders per unit */
/* hardware characteristics: */
/*
* d_interleave, d_trackskew and d_cylskew describe perturbations
* in the media format used to compensate for a slow controller.
* Interleave is physical sector interleave, set up by the
* formatter or controller when formatting. When interleaving is
* in use, logically adjacent sectors are not physically
* contiguous, but instead are separated by some number of
* sectors. It is specified as the ratio of physical sectors
* traversed per logical sector. Thus an interleave of 1:1
* implies contiguous layout, while 2:1 implies that logical
* sector 0 is separated by one sector from logical sector 1.
* d_trackskew is the offset of sector 0 on track N relative to
* sector 0 on track N-1 on the same cylinder. Finally, d_cylskew
* is the offset of sector 0 on cylinder N relative to sector 0
* on cylinder N-1.
*/
uint16_t d_rpm; /* rotational speed */
uint16_t d_interleave; /* hardware sector interleave */
uint16_t d_trackskew; /* sector 0 skew, per track */
uint16_t d_cylskew; /* sector 0 skew, per cylinder */
uint32_t d_headswitch; /* head switch time, usec */
uint32_t d_trkseek; /* track-to-track seek, usec */
uint32_t d_flags; /* generic flags */
#define NDDATA 5
uint32_t d_drivedata[NDDATA]; /* drive-type specific information */
#define NSPARE 5
uint32_t d_spare[NSPARE]; /* reserved for future use */
uint32_t d_magic2; /* the magic number (again) */
uint16_t d_checksum; /* xor of data incl. partitions */
/* filesystem and partition information: */
uint16_t d_npartitions; /* number of partitions in following */
uint32_t d_bbsize; /* size of boot area at sn0, bytes */
uint32_t d_sbsize; /* max size of fs superblock, bytes */
struct rumpserver_partition { /* the partition table */
uint32_t p_size; /* number of sectors in partition */
uint32_t p_offset; /* starting sector */
union {
uint32_t fsize; /* FFS, ADOS:
filesystem basic fragment size */
uint32_t cdsession; /* ISO9660: session offset */
} __partition_u2;
#define p_fsize __partition_u2.fsize
#define p_cdsession __partition_u2.cdsession
uint8_t p_fstype; /* filesystem type, see below */
uint8_t p_frag; /* filesystem fragments per block */
union {
uint16_t cpg; /* UFS: FS cylinders per group */
uint16_t sgs; /* LFS: FS segment shift */
} __partition_u1;
#define p_cpg __partition_u1.cpg
#define p_sgs __partition_u1.sgs
} d_partitions[RUMPSERVER_MAXPARTITIONS]; /* actually may be more */
};
/* for swapping disklabel, so don't care about perf, just portability */
#define bs32(x) \
((((x) & 0xff000000) >> 24)| \
(((x) & 0x00ff0000) >> 8) | \
(((x) & 0x0000ff00) << 8) | \
(((x) & 0x000000ff) << 24))
#define bs16(x) ((((x) & 0xff00) >> 8) | (((x) & 0x00ff) << 8))
/*
* From:
* $NetBSD: disklabel_dkcksum.c,v 1.4 2005/05/15 21:01:34 thorpej Exp
*/
/*-
* Copyright (c) 1991, 1993
* The 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. 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.
*/
static uint16_t
rs_dl_dkcksum(struct rumpserver_disklabel *lp, int imswapped)
{
uint16_t *start, *end;
uint16_t sum;
uint16_t npart;
if (imswapped)
npart = bs16(lp->d_npartitions);
else
npart = lp->d_npartitions;
sum = 0;
start = (uint16_t *)(void *)lp;
end = (uint16_t *)(void *)&lp->d_partitions[npart];
while (start < end) {
if (imswapped)
sum ^= bs16(*start);
else
sum ^= *start;
start++;
}
return (sum);
}
/*
* From:
* NetBSD: disklabel_scan.c,v 1.3 2009/01/18 12:13:03 lukem Exp
*/
/*-
* Copyright (c) 2002 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Roland C. Dowdeswell.
*
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
*/
static int
rs_dl_scan(struct rumpserver_disklabel *lp, int *isswapped,
char *buf, size_t buflen)
{
size_t i;
int imswapped;
uint16_t npart;
/* scan for the correct magic numbers. */
for (i=0; i <= buflen - sizeof(*lp); i += 4) {
memcpy(lp, buf + i, sizeof(*lp));
if (lp->d_magic == RUMPSERVER_DISKMAGIC &&
lp->d_magic2 == RUMPSERVER_DISKMAGIC) {
imswapped = 0;
goto sanity;
}
if (lp->d_magic == bs32(RUMPSERVER_DISKMAGIC) &&
lp->d_magic2 == bs32(RUMPSERVER_DISKMAGIC)) {
imswapped = 1;
goto sanity;
}
}
return 1;
sanity:
if (imswapped)
npart = bs16(lp->d_npartitions);
else
npart = lp->d_npartitions;
/* we've found something, let's sanity check it */
if (npart > RUMPSERVER_MAXPARTITIONS
|| rs_dl_dkcksum(lp, imswapped))
return 1;
*isswapped = imswapped;
return 0;
}
static void
processlabel(int sflag, int fd, int partition, off_t *foffp, off_t *flenp)
{
struct rumpserver_disklabel dl;
char buf[1<<16];
uint32_t foffset, flen;
int imswapped;
if (pread(fd, buf, sizeof(buf), 0) == -1)
die(sflag, errno, "could not read disk device");
if (rs_dl_scan(&dl, &imswapped, buf, sizeof(buf)))
die(sflag, ENOENT, "disklabel not found");
if (partition >= dl.d_npartitions)
die(sflag, ENOENT, "partition not available");
foffset = dl.d_partitions[partition].p_offset << RUMPSERVER_DEVSHIFT;
flen = dl.d_partitions[partition].p_size << RUMPSERVER_DEVSHIFT;
if (imswapped) {
foffset = bs32(foffset);
flen = bs32(flen);
}
*foffp = (off_t)foffset;
*flenp = (off_t)flen;
}
Reference in New Issue View Git Blame Copy Permalink