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

1326 lines
35 KiB
C
Raw Blame History

/* $NetBSD: sunlabel.c,v 1.16 2004/10/30 15:46:31 dsl Exp $ */
/*-
* Copyright (c) 2002 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by der Mouse.
*
* 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 NetBSD
* Foundation, Inc. and its contributors.
* 4. Neither the name of The NetBSD Foundation 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 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.
*/
#include <sys/cdefs.h>
#if defined(__RCSID) && !defined(lint)
__RCSID("$NetBSD: sunlabel.c,v 1.16 2004/10/30 15:46:31 dsl Exp $");
#endif
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <ctype.h>
#include <stdlib.h>
#include <unistd.h>
#ifndef NO_TERMCAP_WIDTH
#include <termcap.h>
#endif
#include <string.h>
#include <strings.h>
#include <inttypes.h>
#include <err.h>
#include <sys/ioctl.h>
/* If neither S_COMMAND nor NO_S_COMMAND is defined, guess. */
#if !defined(S_COMMAND) && !defined(NO_S_COMMAND)
#define S_COMMAND
#include <util.h>
#include <sys/disklabel.h>
#endif
/*
* NPART is the total number of partitions. This must be <= 43, given the
* amount of space available to store extended partitions. It also must be
* <=26, given the use of single letters to name partitions. The 8 is the
* number of `standard' partitions; this arguably should be a #define, since
* it occurs not only here but scattered throughout the code.
*/
#define NPART 16
#define NXPART (NPART - 8)
#define PARTLETTER(i) ((i) + 'a')
#define LETTERPART(i) ((i) - 'a')
/*
* A partition. We keep redundant information around, making sure
* that whenever we change one, we keep another constant and update
* the third. Which one is which depends. Arguably a partition
* should also know its partition number; here, if we need that we
* cheat, using (effectively) ptr-&label.partitions[0].
*/
struct part {
uint32_t startcyl;
uint32_t nblk;
uint32_t endcyl;
};
/*
* A label. As the embedded comments indicate, much of this structure
* corresponds directly to Sun's struct dk_label. Some of the values
* here are historical holdovers. Apparently really old Suns did
* their own sparing in software, so a sector or two per cylinder,
* plus a whole cylinder or two at the end, got set aside as spares.
* acyl and apc count those spares, and this is also why ncyl and pcyl
* both exist. These days the spares generally are hidden from the
* host by the disk, and there's no reason not to set
* ncyl=pcyl=ceil(device size/spc) and acyl=apc=0.
*
* Note also that the geometry assumptions behind having nhead and
* nsect assume that the sect/trk and trk/cyl values are constant
* across the whole drive. The latter is still usually true; the
* former isn't. In my experience, you can just put fixed values
* here; the basis for software knowing the drive geometry is also
* mostly invalid these days anyway. (I just use nhead=32 nsect=64,
* which gives me 1M "cylinders", a convenient size.)
*/
struct label {
/* BEGIN fields taken directly from struct dk_label */
char asciilabel[128];
uint32_t rpm; /* Spindle rotation speed - useless now */
uint32_t pcyl; /* Physical cylinders */
uint32_t apc; /* Alternative sectors per cylinder */
uint32_t obs1; /* Obsolete? */
uint32_t obs2; /* Obsolete? */
uint32_t intrlv; /* Interleave - never anything but 1 IME */
uint32_t ncyl; /* Number of usable cylinders */
uint32_t acyl; /* Alternative cylinders - pcyl minus ncyl */
uint32_t nhead; /* Tracks-per-cylinder (usually # of heads) */
uint32_t nsect; /* Sectors-per-track */
uint32_t obs3; /* Obsolete? */
uint32_t obs4; /* Obsolete? */
/* END fields taken directly from struct dk_label */
uint32_t spc; /* Sectors per cylinder - nhead*nsect */
uint32_t dirty:1;/* Modified since last read */
struct part partitions[NPART];/* The partitions themselves */
};
/*
* Describes a field in the label.
*
* tag is a short name for the field, like "apc" or "nsect". loc is a
* pointer to the place in the label where it's stored. print is a
* function to print the value; the second argument is the current
* column number, and the return value is the new current column
* number. (This allows print functions to do proper line wrapping.)
* chval is called to change a field; the first argument is the
* command line portion that contains the new value (in text form).
* The chval function is responsible for parsing and error-checking as
* well as doing the modification. changed is a function which does
* field-specific actions necessary when the field has been changed.
* This could be rolled into the chval function, but I believe this
* way provides better code sharing.
*
* Note that while the fields in the label vary in size (8, 16, or 32
* bits), we store everything as ints in the label struct, above, and
* convert when packing and unpacking. This allows us to have only
* one numeric chval function.
*/
struct field {
const char *tag;
void *loc;
int (*print)(struct field *, int);
void (*chval)(const char *, struct field *);
void (*changed)(void);
int taglen;
};
/* LABEL_MAGIC was chosen by Sun and cannot be trivially changed. */
#define LABEL_MAGIC 0xdabe
/*
* LABEL_XMAGIC needs to agree between here and any other code that uses
* extended partitions (mainly the kernel).
*/
#define LABEL_XMAGIC (0x199d1fe2+8)
static int diskfd; /* fd on the disk */
static const char *diskname; /* name of the disk, for messages */
static int readonly; /* true iff it's open RO */
static unsigned char labelbuf[512]; /* Buffer holding the label sector */
static struct label label; /* The label itself. */
static int fixmagic; /* -m, ignore bad magic #s */
static int fixcksum; /* -s, ignore bad cksums */
static int newlabel; /* -n, ignore all on-disk values */
static int quiet; /* -q, don't print chatter */
/*
* The various functions that go in the field function pointers. The
* _ascii functions are for 128-byte string fields (the ASCII label);
* the _int functions are for int-valued fields (everything else).
* update_spc is a `changed' function for updating the spc value when
* changing one of the two values that make it up.
*/
static int print_ascii(struct field *, int);
static void chval_ascii(const char *, struct field *);
static int print_int(struct field *, int);
static void chval_int(const char *, struct field *);
static void update_spc(void);
int main(int, char **);
/* The fields themselves. */
static struct field fields[] =
{
{"ascii", &label.asciilabel[0], print_ascii, chval_ascii, 0},
{"rpm", &label.rpm, print_int, chval_int, 0},
{"pcyl", &label.pcyl, print_int, chval_int, 0},
{"apc", &label.apc, print_int, chval_int, 0},
{"obs1", &label.obs1, print_int, chval_int, 0},
{"obs2", &label.obs2, print_int, chval_int, 0},
{"intrlv", &label.intrlv, print_int, chval_int, 0},
{"ncyl", &label.ncyl, print_int, chval_int, 0},
{"acyl", &label.acyl, print_int, chval_int, 0},
{"nhead", &label.nhead, print_int, chval_int, update_spc},
{"nsect", &label.nsect, print_int, chval_int, update_spc},
{"obs3", &label.obs3, print_int, chval_int, 0},
{"obs4", &label.obs4, print_int, chval_int, 0},
{NULL, NULL, NULL, NULL, 0}
};
/*
* We'd _like_ to use howmany() from the include files, but can't count
* on its being present or working.
*/
static __inline__ uint32_t how_many(uint32_t amt, uint32_t unit)
__attribute__((__const__));
static __inline__ uint32_t
how_many(uint32_t amt, uint32_t unit)
{
return ((amt + unit - 1) / unit);
}
/*
* Try opening the disk, given a name. If mustsucceed is true, we
* "cannot fail"; failures produce gripe-and-exit, and if we return,
* our return value is 1. Otherwise, we return 1 on success and 0 on
* failure.
*/
static int
trydisk(const char *s, int mustsucceed)
{
int ro = 0;
diskname = s;
if ((diskfd = open(s, O_RDWR)) == -1 ||
(diskfd = open(s, O_RDWR | O_NDELAY)) == -1) {
if ((diskfd = open(s, O_RDONLY)) == -1) {
if (mustsucceed)
err(1, "Cannot open `%s'", s);
else
return 0;
}
ro = 1;
}
if (ro && !quiet)
warnx("No write access, label is readonly");
readonly = ro;
return 1;
}
/*
* Set the disk device, given the user-supplied string. Note that even
* if we malloc, we never free, because either trydisk eventually
* succeeds, in which case the string is saved in diskname, or it
* fails, in which case we exit and freeing is irrelevant.
*/
static void
setdisk(const char *s)
{
char *tmp;
if (strchr(s, '/')) {
trydisk(s, 1);
return;
}
if (trydisk(s, 0))
return;
#ifndef DISTRIB /* native tool: search in /dev */
asprintf(&tmp, "/dev/%s", s);
if (!tmp)
err(1, "malloc");
if (trydisk(tmp, 0)) {
free(tmp);
return;
}
free(tmp);
asprintf(&tmp, "/dev/%s%c", s, getrawpartition() + 'a');
if (!tmp)
err(1, "malloc");
if (trydisk(tmp, 0)) {
free(tmp);
return;
}
#endif
errx(1, "Can't find device for disk `%s'", s);
}
static void usage(void) __attribute__((__noreturn__));
static void
usage(void)
{
(void)fprintf(stderr, "usage: %s [-mnqs] disk\n", getprogname());
exit(1);
}
/*
* Command-line arguments. We can have at most one non-flag
* argument, which is the disk name; we can also have flags
*
* -m
* Turns on fixmagic, which causes bad magic numbers to be
* ignored (though a complaint is still printed), rather
* than being fatal errors.
*
* -s
* Turns on fixcksum, which causes bad checksums to be
* ignored (though a complaint is still printed), rather
* than being fatal errors.
*
* -n
* Turns on newlabel, which means we're creating a new
* label and anything in the label sector should be
* ignored. This is a bit like -m -s, except that it
* doesn't print complaints and it ignores possible
* garbage on-disk.
*
* -q
* Turns on quiet, which suppresses printing of prompts
* and other irrelevant chatter. If you're trying to use
* sunlabel in an automated way, you probably want this.
*/
static void
handleargs(int ac, char **av)
{
int c;
while ((c = getopt(ac, av, "mnqs")) != -1) {
switch (c) {
case 'm':
fixmagic++;
break;
case 'n':
newlabel++;
break;
case 'q':
quiet++;
break;
case 's':
fixcksum++;
break;
case '?':
warnx("Illegal option `%c'", c);
usage();
}
}
ac -= optind;
av += optind;
if (ac != 1)
usage();
setdisk(av[0]);
}
/*
* Sets the ending cylinder for a partition. This exists mainly to
* centralize the check. (If spc is zero, cylinder numbers make
* little sense, and the code would otherwise die on divide-by-0 if we
* barged blindly ahead.) We need to call this on a partition
* whenever we change it; we need to call it on all partitions
* whenever we change spc.
*/
static void
set_endcyl(struct part *p)
{
if (label.spc == 0) {
p->endcyl = p->startcyl;
} else {
p->endcyl = p->startcyl + how_many(p->nblk, label.spc);
}
}
/*
* Unpack a label from disk into the in-core label structure. If
* newlabel is set, we don't actually do so; we just synthesize a
* blank label instead. This is where knowledge of the Sun label
* format is kept for read; pack_label is the corresponding routine
* for write. We are careful to use labelbuf, l_s, or l_l as
* appropriate to avoid byte-sex issues, so we can work on
* little-endian machines.
*
* Note that a bad magic number for the extended partition information
* is not considered an error; it simply indicates there is no
* extended partition information. Arguably this is the Wrong Thing,
* and we should take zero as meaning no info, and anything other than
* zero or LABEL_XMAGIC as reason to gripe.
*/
static const char *
unpack_label(void)
{
unsigned short int l_s[256];
unsigned long int l_l[128];
int i;
unsigned long int sum;
int have_x;
if (newlabel) {
bzero(&label.asciilabel[0], 128);
label.rpm = 0;
label.pcyl = 0;
label.apc = 0;
label.obs1 = 0;
label.obs2 = 0;
label.intrlv = 0;
label.ncyl = 0;
label.acyl = 0;
label.nhead = 0;
label.nsect = 0;
label.obs3 = 0;
label.obs4 = 0;
for (i = 0; i < NPART; i++) {
label.partitions[i].startcyl = 0;
label.partitions[i].nblk = 0;
set_endcyl(&label.partitions[i]);
}
label.spc = 0;
label.dirty = 1;
return (0);
}
for (i = 0; i < 256; i++)
l_s[i] = (labelbuf[i + i] << 8) | labelbuf[i + i + 1];
for (i = 0; i < 128; i++)
l_l[i] = (l_s[i + i] << 16) | l_s[i + i + 1];
if (l_s[254] != LABEL_MAGIC) {
if (fixmagic) {
label.dirty = 1;
warnx("ignoring incorrect magic number.");
} else {
return "bad magic number";
}
}
sum = 0;
for (i = 0; i < 256; i++)
sum ^= l_s[i];
label.dirty = 0;
if (sum != 0) {
if (fixcksum) {
label.dirty = 1;
warnx("ignoring incorrect checksum.");
} else {
return "checksum wrong";
}
}
(void)memcpy(&label.asciilabel[0], &labelbuf[0], 128);
label.rpm = l_s[210];
label.pcyl = l_s[211];
label.apc = l_s[212];
label.obs1 = l_s[213];
label.obs2 = l_s[214];
label.intrlv = l_s[215];
label.ncyl = l_s[216];
label.acyl = l_s[217];
label.nhead = l_s[218];
label.nsect = l_s[219];
label.obs3 = l_s[220];
label.obs4 = l_s[221];
label.spc = label.nhead * label.nsect;
for (i = 0; i < 8; i++) {
label.partitions[i].startcyl = (uint32_t)l_l[i + i + 111];
label.partitions[i].nblk = (uint32_t)l_l[i + i + 112];
set_endcyl(&label.partitions[i]);
}
have_x = 0;
if (l_l[33] == LABEL_XMAGIC) {
sum = 0;
for (i = 0; i < ((NXPART * 2) + 1); i++)
sum += l_l[33 + i];
if (sum != l_l[32]) {
if (fixcksum) {
label.dirty = 1;
warnx("Ignoring incorrect extended-partition checksum.");
have_x = 1;
} else {
warnx("Extended-partition magic right but checksum wrong.");
}
} else {
have_x = 1;
}
}
if (have_x) {
for (i = 0; i < NXPART; i++) {
int j = i + i + 34;
label.partitions[i + 8].startcyl = (uint32_t)l_l[j++];
label.partitions[i + 8].nblk = (uint32_t)l_l[j++];
set_endcyl(&label.partitions[i + 8]);
}
} else {
for (i = 0; i < NXPART; i++) {
label.partitions[i + 8].startcyl = 0;
label.partitions[i + 8].nblk = 0;
set_endcyl(&label.partitions[i + 8]);
}
}
return 0;
}
/*
* Pack a label from the in-core label structure into on-disk format.
* This is where knowledge of the Sun label format is kept for write;
* unpack_label is the corresponding routine for read. If all
* partitions past the first 8 are size=0 cyl=0, we store all-0s in
* the extended partition space, to be fully compatible with Sun
* labels. Since AFIAK nothing works in that case that would break if
* we put extended partition info there in the same format we'd use if
* there were real info there, this is arguably unnecessary, but it's
* easy to do.
*
* We are careful to avoid endianness issues by constructing everything
* in an array of shorts. We do this rather than using chars or longs
* because the checksum is defined in terms of shorts; using chars or
* longs would simplify small amounts of code at the price of
* complicating more.
*/
static void
pack_label(void)
{
unsigned short int l_s[256];
int i;
unsigned short int sum;
memset(&l_s[0], 0, 512);
memcpy(&labelbuf[0], &label.asciilabel[0], 128);
for (i = 0; i < 64; i++)
l_s[i] = (labelbuf[i + i] << 8) | labelbuf[i + i + 1];
l_s[210] = label.rpm;
l_s[211] = label.pcyl;
l_s[212] = label.apc;
l_s[213] = label.obs1;
l_s[214] = label.obs2;
l_s[215] = label.intrlv;
l_s[216] = label.ncyl;
l_s[217] = label.acyl;
l_s[218] = label.nhead;
l_s[219] = label.nsect;
l_s[220] = label.obs3;
l_s[221] = label.obs4;
for (i = 0; i < 8; i++) {
l_s[(i * 4) + 222] = label.partitions[i].startcyl >> 16;
l_s[(i * 4) + 223] = label.partitions[i].startcyl & 0xffff;
l_s[(i * 4) + 224] = label.partitions[i].nblk >> 16;
l_s[(i * 4) + 225] = label.partitions[i].nblk & 0xffff;
}
for (i = 0; i < NXPART; i++) {
if (label.partitions[i + 8].startcyl ||
label.partitions[i + 8].nblk)
break;
}
if (i < NXPART) {
unsigned long int xsum;
l_s[66] = LABEL_XMAGIC >> 16;
l_s[67] = LABEL_XMAGIC & 0xffff;
for (i = 0; i < NXPART; i++) {
int j = (i * 4) + 68;
l_s[j++] = label.partitions[i + 8].startcyl >> 16;
l_s[j++] = label.partitions[i + 8].startcyl & 0xffff;
l_s[j++] = label.partitions[i + 8].nblk >> 16;
l_s[j++] = label.partitions[i + 8].nblk & 0xffff;
}
xsum = 0;
for (i = 0; i < ((NXPART * 2) + 1); i++)
xsum += (l_s[i + i + 66] << 16) | l_s[i + i + 67];
l_s[64] = (int32_t)(xsum >> 16);
l_s[65] = (int32_t)(xsum & 0xffff);
}
l_s[254] = LABEL_MAGIC;
sum = 0;
for (i = 0; i < 255; i++)
sum ^= l_s[i];
l_s[255] = sum;
for (i = 0; i < 256; i++) {
labelbuf[i + i] = ((uint32_t)l_s[i]) >> 8;
labelbuf[i + i + 1] = l_s[i] & 0xff;
}
}
/*
* Get the label. Read it off the disk and unpack it. This function
* is nothing but lseek, read, unpack_label, and error checking.
*/
static void
getlabel(void)
{
int rv;
const char *lerr;
if (lseek(diskfd, (off_t)0, SEEK_SET) == (off_t)-1)
err(1, "lseek to 0 on `%s' failed", diskname);
if ((rv = read(diskfd, &labelbuf[0], 512)) == -1)
err(1, "read label from `%s' failed", diskname);
if (rv != 512)
errx(1, "short read from `%s' wanted %d, got %d.", diskname,
512, rv);
lerr = unpack_label();
if (lerr)
errx(1, "bogus label on `%s' (%s)", diskname, lerr);
}
/*
* Put the label. Pack it and write it to the disk. This function is
* little more than pack_label, lseek, write, and error checking.
*/
static void
putlabel(void)
{
int rv;
if (readonly) {
warnx("No write access to `%s'", diskname);
return;
}
if (lseek(diskfd, (off_t)0, SEEK_SET) < (off_t)-1)
err(1, "lseek to 0 on `%s' failed", diskname);
pack_label();
if ((rv = write(diskfd, &labelbuf[0], 512)) == -1) {
err(1, "write label to `%s' failed", diskname);
exit(1);
}
if (rv != 512)
errx(1, "short write to `%s': wanted %d, got %d",
diskname, 512, rv);
label.dirty = 0;
}
/*
* Skip whitespace. Used several places in the command-line parsing
* code.
*/
static void
skipspaces(const char **cpp)
{
const char *cp = *cpp;
while (*cp && isspace((unsigned char)*cp))
cp++;
*cpp = cp;
}
/*
* Scan a number. The first arg points to the char * that's moving
* along the string. The second arg points to where we should store
* the result. The third arg says what we're scanning, for errors.
* The return value is 0 on error, or nonzero if all goes well.
*/
static int
scannum(const char **cpp, uint32_t *np, const char *tag)
{
uint32_t v;
int nd;
const char *cp;
skipspaces(cpp);
v = 0;
nd = 0;
cp = *cpp;
while (*cp && isdigit((unsigned char)*cp)) {
v = (10 * v) + (*cp++ - '0');
nd++;
}
*cpp = cp;
if (nd == 0) {
printf("Missing/invalid %s: %s\n", tag, cp);
return (0);
}
*np = v;
return (1);
}
/*
* Change a partition. pno is the number of the partition to change;
* numbers is a pointer to the string containing the specification for
* the new start and size. This always takes the form "start size",
* where start can be
*
* a number
* The partition starts at the beginning of that cylinder.
*
* start-X
* The partition starts at the same place partition X does.
*
* end-X
* The partition starts at the place partition X ends. If
* partition X does not exactly on a cylinder boundary, it
* is effectively rounded up.
*
* and size can be
*
* a number
* The partition is that many sectors long.
*
* num/num/num
* The three numbers are cyl/trk/sect counts. n1/n2/n3 is
* equivalent to specifying a single number
* ((n1*label.nhead)+n2)*label.nsect)+n3. In particular,
* if label.nhead or label.nsect is zero, this has limited
* usefulness.
*
* end-X
* The partition ends where partition X ends. It is an
* error for partition X to end before the specified start
* point. This always goes to exactly where partition X
* ends, even if that's partway through a cylinder.
*
* start-X
* The partition extends to end exactly where partition X
* begins. It is an error for partition X to begin before
* the specified start point.
*
* size-X
* The partition has the same size as partition X.
*
* If label.spc is nonzero but the partition size is not a multiple of
* it, a warning is printed, since you usually don't want this. Most
* often, in my experience, this comes from specifying a cylinder
* count as a single number N instead of N/0/0.
*/
static void
chpart(int pno, const char *numbers)
{
uint32_t cyl0;
uint32_t size;
uint32_t sizec;
uint32_t sizet;
uint32_t sizes;
skipspaces(&numbers);
if (!memcmp(numbers, "end-", 4) && numbers[4]) {
int epno = LETTERPART(numbers[4]);
if ((epno >= 0) && (epno < NPART)) {
cyl0 = label.partitions[epno].endcyl;
numbers += 5;
} else {
if (!scannum(&numbers, &cyl0, "starting cylinder"))
return;
}
} else if (!memcmp(numbers, "start-", 6) && numbers[6]) {
int spno = LETTERPART(numbers[6]);
if ((spno >= 0) && (spno < NPART)) {
cyl0 = label.partitions[spno].startcyl;
numbers += 7;
} else {
if (!scannum(&numbers, &cyl0, "starting cylinder"))
return;
}
} else {
if (!scannum(&numbers, &cyl0, "starting cylinder"))
return;
}
skipspaces(&numbers);
if (!memcmp(numbers, "end-", 4) && numbers[4]) {
int epno = LETTERPART(numbers[4]);
if ((epno >= 0) && (epno < NPART)) {
if (label.partitions[epno].endcyl <= cyl0) {
warnx("Partition %c ends before cylinder %u",
PARTLETTER(epno), cyl0);
return;
}
size = label.partitions[epno].nblk;
/* Be careful of unsigned arithmetic */
if (cyl0 > label.partitions[epno].startcyl) {
size -= (cyl0 - label.partitions[epno].startcyl)
* label.spc;
} else if (cyl0 < label.partitions[epno].startcyl) {
size += (label.partitions[epno].startcyl - cyl0)
* label.spc;
}
numbers += 5;
} else {
if (!scannum(&numbers, &size, "partition size"))
return;
}
} else if (!memcmp(numbers, "start-", 6) && numbers[6]) {
int spno = LETTERPART(numbers[6]);
if ((spno >= 0) && (spno < NPART)) {
if (label.partitions[spno].startcyl <= cyl0) {
warnx("Partition %c starts before cylinder %u",
PARTLETTER(spno), cyl0);
return;
}
size = (label.partitions[spno].startcyl - cyl0)
* label.spc;
numbers += 7;
} else {
if (!scannum(&numbers, &size, "partition size"))
return;
}
} else if (!memcmp(numbers, "size-", 5) && numbers[5]) {
int spno = LETTERPART(numbers[5]);
if ((spno >= 0) && (spno < NPART)) {
size = label.partitions[spno].nblk;
numbers += 6;
} else {
if (!scannum(&numbers, &size, "partition size"))
return;
}
} else {
if (!scannum(&numbers, &size, "partition size"))
return;
skipspaces(&numbers);
if (*numbers == '/') {
sizec = size;
numbers++;
if (!scannum(&numbers, &sizet,
"partition size track value"))
return;
skipspaces(&numbers);
if (*numbers != '/') {
warnx("Invalid c/t/s syntax - no second slash");
return;
}
numbers++;
if (!scannum(&numbers, &sizes,
"partition size sector value"))
return;
size = sizes + (label.nsect * (sizet
+ (label.nhead * sizec)));
}
}
if (label.spc && (size % label.spc)) {
warnx("Size is not a multiple of cylinder size (is %u/%u/%u)",
size / label.spc,
(size % label.spc) / label.nsect, size % label.nsect);
}
label.partitions[pno].startcyl = cyl0;
label.partitions[pno].nblk = size;
set_endcyl(&label.partitions[pno]);
if ((label.partitions[pno].startcyl * label.spc)
+ label.partitions[pno].nblk > label.spc * label.ncyl) {
warnx("Partition extends beyond end of disk");
}
label.dirty = 1;
}
/*
* Change a 128-byte-string field. There's currently only one such,
* the ASCII label field.
*/
static void
chval_ascii(const char *cp, struct field *f)
{
const char *nl;
skipspaces(&cp);
if ((nl = strchr(cp, '\n')) == NULL)
nl = cp + strlen(cp);
if (nl - cp > 128) {
warnx("Ascii label string too long - max 128 characters");
} else {
memset(f->loc, 0, 128);
memcpy(f->loc, cp, (size_t)(nl - cp));
label.dirty = 1;
}
}
/*
* Change an int-valued field. As noted above, there's only one
* function, regardless of the field size in the on-disk label.
*/
static void
chval_int(const char *cp, struct field *f)
{
uint32_t v;
if (!scannum(&cp, &v, "value"))
return;
*(uint32_t *)f->loc = v;
label.dirty = 1;
}
/*
* Change a field's value. The string argument contains the field name
* and the new value in text form. Look up the field and call its
* chval and changed functions.
*/
static void
chvalue(const char *str)
{
const char *cp;
int i;
size_t n;
if (fields[0].taglen < 1) {
for (i = 0; fields[i].tag; i++)
fields[i].taglen = strlen(fields[i].tag);
}
skipspaces(&str);
cp = str;
while (*cp && !isspace((unsigned char)*cp))
cp++;
n = cp - str;
for (i = 0; fields[i].tag; i++) {
if ((n == fields[i].taglen) && !memcmp(str, fields[i].tag, n)) {
(*fields[i].chval) (cp, &fields[i]);
if (fields[i].changed)
(*fields[i].changed)();
break;
}
}
if (!fields[i].tag)
warnx("Bad name %.*s - see L output for names", (int)n, str);
}
/*
* `changed' function for the ntrack and nsect fields; update label.spc
* and call set_endcyl on all partitions.
*/
static void
update_spc(void)
{
int i;
label.spc = label.nhead * label.nsect;
for (i = 0; i < NPART; i++)
set_endcyl(&label.partitions[i]);
}
/*
* Print function for 128-byte-string fields. Currently only the ASCII
* label, but we don't depend on that.
*/
static int
/*ARGSUSED*/
print_ascii(struct field *f, int sofar __attribute__((__unused__)))
{
printf("%s: %.128s\n", f->tag, (char *)f->loc);
return 0;
}
/*
* Print an int-valued field. We are careful to do proper line wrap,
* making each value occupy 16 columns.
*/
static int
print_int(struct field *f, int sofar)
{
if (sofar >= 60) {
printf("\n");
sofar = 0;
}
printf("%s: %-*u", f->tag, 14 - (int)strlen(f->tag),
*(uint32_t *)f->loc);
return sofar + 16;
}
/*
* Print the whole label. Just call the print function for each field,
* then append a newline if necessary.
*/
static void
print_label(void)
{
int i;
int c;
c = 0;
for (i = 0; fields[i].tag; i++)
c = (*fields[i].print) (&fields[i], c);
if (c > 0)
printf("\n");
}
/*
* Figure out how many columns wide the screen is. We impose a minimum
* width of 20 columns; I suspect the output code has some issues if
* we have fewer columns than partitions.
*/
static int
screen_columns(void)
{
int ncols;
#ifndef NO_TERMCAP_WIDTH
char *term;
char tbuf[1024];
#endif
#if defined(TIOCGWINSZ)
struct winsize wsz;
#elif defined(TIOCGSIZE)
struct ttysize tsz;
#endif
ncols = 80;
#ifndef NO_TERMCAP_WIDTH
term = getenv("TERM");
if (term && (tgetent(&tbuf[0], term) == 1)) {
int n = tgetnum("co");
if (n > 1)
ncols = n;
}
#endif
#if defined(TIOCGWINSZ)
if ((ioctl(1, TIOCGWINSZ, &wsz) == 0) && (wsz.ws_col > 0)) {
ncols = wsz.ws_col;
}
#elif defined(TIOCGSIZE)
if ((ioctl(1, TIOCGSIZE, &tsz) == 0) && (tsz.ts_cols > 0)) {
ncols = tsz.ts_cols;
}
#endif
if (ncols < 20)
ncols = 20;
return ncols;
}
/*
* Print the partitions. The argument is true iff we should print all
* partitions, even those set start=0 size=0. We generate one line
* per partition (or, if all==0, per `interesting' partition), plus a
* visually graphic map of partition letters. Most of the hair in the
* visual display lies in ensuring that nothing takes up less than one
* character column, that if two boundaries appear visually identical,
* they _are_ identical. Within that constraint, we try to make the
* number of character columns proportional to the size....
*/
static void
print_part(int all)
{
int i, j, k, n, r, c;
size_t ncols;
uint32_t edges[2 * NPART];
int ce[2 * NPART];
int row[NPART];
unsigned char table[2 * NPART][NPART];
char *line;
struct part *p = label.partitions;
for (i = 0; i < NPART; i++) {
if (all || p[i].startcyl || p[i].nblk) {
printf("%c: start cyl = %6u, size = %8u (",
PARTLETTER(i), p[i].startcyl, p[i].nblk);
if (label.spc) {
printf("%u/%u/%u - ", p[i].nblk / label.spc,
(p[i].nblk % label.spc) / label.nsect,
p[i].nblk % label.nsect);
}
printf("%gMb)\n", p[i].nblk / 2048.0);
}
}
j = 0;
for (i = 0; i < NPART; i++) {
if (p[i].nblk > 0) {
edges[j++] = p[i].startcyl;
edges[j++] = p[i].endcyl;
}
}
do {
n = 0;
for (i = 1; i < j; i++) {
if (edges[i] < edges[i - 1]) {
uint32_t t;
t = edges[i];
edges[i] = edges[i - 1];
edges[i - 1] = t;
n++;
}
}
} while (n > 0);
for (i = 1; i < j; i++) {
if (edges[i] != edges[n]) {
n++;
if (n != i)
edges[n] = edges[i];
}
}
n++;
for (i = 0; i < NPART; i++) {
if (p[i].nblk > 0) {
for (j = 0; j < n; j++) {
if ((p[i].startcyl <= edges[j]) &&
(p[i].endcyl > edges[j])) {
table[j][i] = 1;
} else {
table[j][i] = 0;
}
}
}
}
ncols = screen_columns() - 2;
for (i = 0; i < n; i++)
ce[i] = (edges[i] * ncols) / (double) edges[n - 1];
for (i = 1; i < n; i++)
if (ce[i] <= ce[i - 1])
ce[i] = ce[i - 1] + 1;
if (ce[n - 1] > ncols) {
ce[n - 1] = ncols;
for (i = n - 1; (i > 0) && (ce[i] <= ce[i - 1]); i--)
ce[i - 1] = ce[i] - 1;
if (ce[0] < 0)
for (i = 0; i < n; i++)
ce[i] = i;
}
printf("\n");
for (i = 0; i < NPART; i++) {
if (p[i].nblk > 0) {
r = -1;
do {
r++;
for (j = i - 1; j >= 0; j--) {
if (row[j] != r)
continue;
for (k = 0; k < n; k++)
if (table[k][i] && table[k][j])
break;
if (k < n)
break;
}
} while (j >= 0);
row[i] = r;
} else {
row[i] = -1;
}
}
r = row[0];
for (i = 1; i < NPART; i++)
if (row[i] > r)
r = row[i];
if ((line = malloc(ncols + 1)) == NULL)
err(1, "Can't allocate memory");
for (i = 0; i <= r; i++) {
for (j = 0; j < ncols; j++)
line[j] = ' ';
for (j = 0; j < NPART; j++) {
if (row[j] != i)
continue;
k = 0;
for (k = 0; k < n; k++) {
if (table[k][j]) {
for (c = ce[k]; c < ce[k + 1]; c++)
line[c] = 'a' + j;
}
}
}
for (j = ncols - 1; (j >= 0) && (line[j] == ' '); j--);
printf("%.*s\n", j + 1, line);
}
free(line);
}
#ifdef S_COMMAND
/*
* This computes an appropriate checksum for an in-core label. It's
* not really related to the S command, except that it's needed only
* by setlabel(), which is #ifdef S_COMMAND.
*/
static unsigned short int
dkcksum(const struct disklabel *lp)
{
const unsigned short int *start;
const unsigned short int *end;
unsigned short int sum;
const unsigned short int *p;
start = (const void *)lp;
end = (const void *)&lp->d_partitions[lp->d_npartitions];
sum = 0;
for (p = start; p < end; p++)
sum ^= *p;
return (sum);
}
/*
* Set the in-core label. This is basically putlabel, except it builds
* a struct disklabel instead of a Sun label buffer, and uses
* DIOCSDINFO instead of lseek-and-write.
*/
static void
setlabel(void)
{
union {
struct disklabel l;
char pad[sizeof(struct disklabel) -
(MAXPARTITIONS * sizeof(struct partition)) +
(16 * sizeof(struct partition))];
} u;
int i;
struct part *p = label.partitions;
if (ioctl(diskfd, DIOCGDINFO, &u.l) == -1) {
warn("ioctl DIOCGDINFO failed");
return;
}
if (u.l.d_secsize != 512) {
warnx("Disk claims %d-byte sectors", (int)u.l.d_secsize);
}
u.l.d_nsectors = label.nsect;
u.l.d_ntracks = label.nhead;
u.l.d_ncylinders = label.ncyl;
u.l.d_secpercyl = label.nsect * label.nhead;
u.l.d_rpm = label.rpm;
u.l.d_interleave = label.intrlv;
u.l.d_npartitions = getmaxpartitions();
memset(&u.l.d_partitions[0], 0,
u.l.d_npartitions * sizeof(struct partition));
for (i = 0; i < u.l.d_npartitions; i++) {
u.l.d_partitions[i].p_size = p[i].nblk;
u.l.d_partitions[i].p_offset = p[i].startcyl
* label.nsect * label.nhead;
u.l.d_partitions[i].p_fsize = 0;
u.l.d_partitions[i].p_fstype = (i == 1) ? FS_SWAP :
(i == 2) ? FS_UNUSED : FS_BSDFFS;
u.l.d_partitions[i].p_frag = 0;
u.l.d_partitions[i].p_cpg = 0;
}
u.l.d_checksum = 0;
u.l.d_checksum = dkcksum(&u.l);
if (ioctl(diskfd, DIOCSDINFO, &u.l) == -1) {
warn("ioctl DIOCSDINFO failed");
return;
}
}
#endif
static const char *help[] = {
"?\t- print this help",
"L\t- print label, except for partition table",
"P\t- print partition table",
"PP\t- print partition table including size=0 offset=0 entries",
"[abcdefghijklmnop] <cylno> <size> - change partition",
"V <name> <value> - change a non-partition label value",
"W\t- write (possibly modified) label out",
#ifdef S_COMMAND
"S\t- set label in the kernel (orthogonal to W)",
#endif
"Q\t- quit program (error if no write since last change)",
"Q!\t- quit program (unconditionally) [EOF also quits]",
NULL
};
/*
* Read and execute one command line from the user.
*/
static void
docmd(void)
{
char cmdline[512];
int i;
if (!quiet)
printf("sunlabel> ");
if (fgets(&cmdline[0], sizeof(cmdline), stdin) != &cmdline[0])
exit(0);
switch (cmdline[0]) {
case '?':
for (i = 0; help[i]; i++)
printf("%s\n", help[i]);
break;
case 'L':
print_label();
break;
case 'P':
print_part(cmdline[1] == 'P');
break;
case 'W':
putlabel();
break;
case 'S':
#ifdef S_COMMAND
setlabel();
#else
printf("This compilation doesn't support S.\n");
#endif
break;
case 'Q':
if ((cmdline[1] == '!') || !label.dirty)
exit(0);
printf("Label is dirty - use w to write it\n");
printf("Use Q! to quit anyway.\n");
break;
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
chpart(LETTERPART(cmdline[0]), &cmdline[1]);
break;
case 'V':
chvalue(&cmdline[1]);
break;
case '\n':
break;
default:
printf("(Unrecognized command character %c ignored.)\n",
cmdline[0]);
break;
}
}
/*
* main() (duh!). Pretty boring.
*/
int
main(int ac, char **av)
{
handleargs(ac, av);
getlabel();
for (;;)
docmd();
}
Reference in New Issue View Git Blame Copy Permalink