d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fixed style(9)

Browse Source
This commit is contained in:
Yoshihiro Takahashi 2002-11-15 13:24:29 +00:00
parent 552d12e2ce
commit 021587f8c1
14 changed files with 484 additions and 409 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
lib/libdisk/change.c
View File

@ -21,6 +21,7 @@ __FBSDID("$FreeBSD$");
void
Set_Bios_Geom(struct disk *disk, u_long cyl, u_long hd, u_long sect)
{
disk->bios_cyl = cyl;
disk->bios_hd = hd;
disk->bios_sect = sect;
@ -47,7 +48,8 @@ Sanitize_Bios_Geom(struct disk *disk)
if (disk->bios_sect > 63)
#endif
sane = 0;
if (disk->bios_cyl*disk->bios_hd*disk->bios_sect != disk->chunks->size)
if (disk->bios_cyl * disk->bios_hd * disk->bios_sect !=
disk->chunks->size)
sane = 0;
if (sane)
return;
@ -55,7 +57,8 @@ Sanitize_Bios_Geom(struct disk *disk)
/* First try something that IDE can handle */
disk->bios_sect = 63;
disk->bios_hd = 16;
disk->bios_cyl = disk->chunks->size / (disk->bios_sect*disk->bios_hd);
disk->bios_cyl = disk->chunks->size /
(disk->bios_sect * disk->bios_hd);
#ifdef PC98
if (disk->bios_cyl < 65536)
@ -72,9 +75,8 @@ Sanitize_Bios_Geom(struct disk *disk)
#else
disk->bios_hd = 255;
#endif
disk->bios_cyl = disk->chunks->size / (disk->bios_sect*disk->bios_hd);
return;
disk->bios_cyl = disk->chunks->size /
(disk->bios_sect * disk->bios_hd);
}
void
@ -89,7 +91,7 @@ All_FreeBSD(struct disk *d, int force_all)
type = 0xa5;
#endif
again:
again:
for (c = d->chunks->part; c; c = c->next)
if (c->type != unused) {
Delete_Chunk(d, c);

129
lib/libdisk/chunk.c
View File

@ -44,40 +44,40 @@ Chunk_Inside(const struct chunk *c1, const struct chunk *c2)
}
static struct chunk *
Find_Mother_Chunk(struct chunk *chunks, u_long offset, u_long end, chunk_e type)
Find_Mother_Chunk(struct chunk *chunks, u_long offset, u_long end,
chunk_e type)
{
struct chunk *c1,*c2,ct;
struct chunk *c1, *c2, ct;
ct.offset = offset;
ct.end = end;
switch (type) {
case whole:
if (Chunk_Inside(chunks, &ct))
return chunks;
case extended:
for(c1 = chunks->part; c1; c1 = c1->next) {
if (c1->type != type)
continue;
case whole:
if (Chunk_Inside(chunks, &ct))
return chunks;
case extended:
for (c1 = chunks->part; c1; c1 = c1->next) {
if (c1->type != type)
continue;
if (Chunk_Inside(c1, &ct))
return c1;
}
return 0;
case freebsd:
for (c1 = chunks->part; c1; c1 = c1->next) {
if (c1->type == type)
if (Chunk_Inside(c1, &ct))
return c1;
}
return 0;
case freebsd:
for(c1 = chunks->part; c1; c1 = c1->next) {
if (c1->type == type)
if (Chunk_Inside(c1, &ct))
return c1;
if (c1->type != extended)
continue;
for(c2 = c1->part; c2; c2 = c2->next)
if (c2->type == type
&& Chunk_Inside(c2, &ct))
return c2;
}
return 0;
default:
warn("Unsupported mother type in Find_Mother_Chunk");
return 0;
if (c1->type != extended)
continue;
for (c2 = c1->part; c2; c2 = c2->next)
if (c2->type == type && Chunk_Inside(c2, &ct))
return c2;
}
return 0;
default:
warn("Unsupported mother type in Find_Mother_Chunk");
return 0;
}
}
@ -149,7 +149,7 @@ Insert_Chunk(struct chunk *c2, u_long offset, u_long size, const char *name,
return __LINE__;
}
if(type==freebsd || type==extended) {
if (type == freebsd || type == extended) {
cs = New_Chunk();
if (cs == NULL)
return __LINE__;
@ -173,9 +173,9 @@ Insert_Chunk(struct chunk *c2, u_long offset, u_long size, const char *name,
cs->disk = c2->disk;
cs->offset = ct->end + 1;
cs->size = c2->end - ct->end;
if(c2->sname != NULL)
if (c2->sname != NULL)
cs->sname = strdup(c2->sname);
if(c2->name)
if (c2->name)
cs->name = strdup(c2->name);
c2->next = cs;
c2->size -= c2->end - ct->end;
@ -205,9 +205,9 @@ Insert_Chunk(struct chunk *c2, u_long offset, u_long size, const char *name,
int
Add_Chunk(struct disk *d, long offset, u_long size, const char *name,
chunk_e type, int subtype, u_long flags, const char *sname)
chunk_e type, int subtype, u_long flags, const char *sname)
{
struct chunk *c1,*c2,ct;
struct chunk *c1, *c2, ct;
u_long end = offset + size - 1;
ct.offset = offset;
ct.end = end;
@ -322,8 +322,8 @@ Add_Chunk(struct disk *d, long offset, u_long size, const char *name,
break;
if (!(flags & CHUNK_ALIGN))
break;
if (offset == d->chunks->offset
&& end == d->chunks->end)
if (offset == d->chunks->offset &&
end == d->chunks->end)
break;
/* Round down to prev cylinder */
@ -355,20 +355,24 @@ Add_Chunk(struct disk *d, long offset, u_long size, const char *name,
}
if (c2 == NULL)
return (__LINE__);
return Insert_Chunk(c2, offset, size, name,
type, subtype, flags, sname);
return Insert_Chunk(c2, offset, size, name, type, subtype, flags,
sname);
}
char *
ShowChunkFlags(struct chunk *c)
{
static char ret[10];
int i = 0;
int i=0;
if (c->flags & CHUNK_ACTIVE) ret[i++] = 'A';
if (c->flags & CHUNK_ALIGN) ret[i++] = '=';
if (c->flags & CHUNK_IS_ROOT) ret[i++] = 'R';
if (c->flags & CHUNK_ACTIVE)
ret[i++] = 'A';
if (c->flags & CHUNK_ALIGN)
ret[i++] = '=';
if (c->flags & CHUNK_IS_ROOT)
ret[i++] = 'R';
ret[i++] = '\0';
return ret;
}
@ -376,11 +380,16 @@ static void
Print_Chunk(struct chunk *c1,int offset)
{
int i;
if(!c1) return;
for(i = 0; i < offset - 2; i++) putchar(' ');
for(; i < offset; i++) putchar('-');
if (!c1)
return;
for (i = 0; i < offset - 2; i++)
putchar(' ');
for (; i < offset; i++)
putchar('-');
putchar('>');
for(; i < 10; i++) putchar(' ');
for (; i < 10; i++)
putchar(' ');
printf("%p %8ld %8lu %8lu %-8s %-16s %-8s 0x%02x %s",
c1, c1->offset, c1->size, c1->end, c1->name, c1->sname,
chunk_name(c1->type), c1->subtype,
@ -393,39 +402,41 @@ Print_Chunk(struct chunk *c1,int offset)
void
Debug_Chunk(struct chunk *c1)
{
Print_Chunk(c1,2);
}
int
Delete_Chunk(struct disk *d, struct chunk *c)
{
return(Delete_Chunk2(d, c, 0));
}
int
Delete_Chunk2(struct disk *d, struct chunk *c, int rflags)
{
struct chunk *c1=0, *c2, *c3;
struct chunk *c1 = 0, *c2, *c3;
chunk_e type = c->type;
u_long offset = c->offset;
if(type == whole)
return 1;
#ifndef PC98
if(!c1 && (type == freebsd || type == fat || type == unknown))
if (!c1 && (type == freebsd || type == fat || type == unknown))
c1 = Find_Mother_Chunk(d->chunks, c->offset, c->end, extended);
#endif
if(!c1 && (type == freebsd || type == fat || type == unknown))
if (!c1 && (type == freebsd || type == fat || type == unknown))
c1 = Find_Mother_Chunk(d->chunks, c->offset, c->end, whole);
#ifndef PC98
if(!c1 && type == extended)
if (!c1 && type == extended)
c1 = Find_Mother_Chunk(d->chunks, c->offset, c->end, whole);
#endif
if(!c1 && type == part)
if (!c1 && type == part)
c1 = Find_Mother_Chunk(d->chunks, c->offset, c->end, freebsd);
if(!c1)
if (!c1)
return 1;
for(c2 = c1->part; c2; c2 = c2->next) {
for (c2 = c1->part; c2; c2 = c2->next) {
if (c2 == c) {
c2->type = unused;
c2->subtype = 0;
@ -441,7 +452,7 @@ Delete_Chunk2(struct disk *d, struct chunk *c, int rflags)
}
}
return 1;
scan:
scan:
/*
* Collapse multiple unused elements together, and attempt
* to extend the previous chunk into the freed chunk.
@ -450,7 +461,7 @@ Delete_Chunk2(struct disk *d, struct chunk *c, int rflags)
* for newfs (we can't extend working filesystems), and
* only if we are called with DELCHUNK_RECOVER.
*/
for(c2 = c1->part; c2; c2 = c2->next) {
for (c2 = c1->part; c2; c2 = c2->next) {
if (c2->type != unused) {
if (c2->offset + c2->size != offset ||
(rflags & DELCHUNK_RECOVER) == 0 ||
@ -481,10 +492,10 @@ Collapse_Chunk(struct disk *d, struct chunk *c1)
{
struct chunk *c2, *c3;
if(c1->next && Collapse_Chunk(d, c1->next))
if (c1->next && Collapse_Chunk(d, c1->next))
return 1;
if(c1->type == unused && c1->next && c1->next->type == unused) {
if (c1->type == unused && c1->next && c1->next->type == unused) {
c3 = c1->next;
c1->size += c3->size;
c1->end = c3->end;
@ -494,7 +505,7 @@ Collapse_Chunk(struct disk *d, struct chunk *c1)
return 1;
}
c3 = c1->part;
if(!c3)
if (!c3)
return 0;
if (Collapse_Chunk(d, c1->part))
return 1;
@ -502,11 +513,11 @@ Collapse_Chunk(struct disk *d, struct chunk *c1)
if (c1->type == whole)
return 0;
if(c3->type == unused && c3->size == c1->size) {
if (c3->type == unused && c3->size == c1->size) {
Delete_Chunk(d, c1);
return 1;
}
if(c3->type == unused) {
if (c3->type == unused) {
c2 = New_Chunk();
if (c2 == NULL)
barfout(1, "malloc failed");
@ -528,7 +539,7 @@ Collapse_Chunk(struct disk *d, struct chunk *c1)
Free_Chunk(c3);
return 1;
}
for(c2=c3;c2->next;c2 = c2->next)
for (c2 = c3; c2->next; c2 = c2->next)
c3 = c2;
if (c2 && c2->type == unused) {
c3->next = 0;

86
lib/libdisk/create_chunk.c
View File

@ -39,57 +39,66 @@ Fixup_FreeBSD_Names(struct disk *d, struct chunk *c)
struct chunk *c1, *c3;
int j;
if (!strcmp(c->name, "X")) return 0;
if (!strcmp(c->name, "X"))
return 0;
/* reset all names to "X" */
for (c1 = c->part; c1; c1 = c1->next) {
c1->oname = c1->name;
c1->name = malloc(12);
if(!c1->name) return -1;
if (!c1->name)
return -1;
strcpy(c1->name,"X");
}
/* Allocate the first swap-partition we find */
for (c1 = c->part; c1; c1 = c1->next) {
if (c1->type == unused) continue;
if (c1->subtype != FS_SWAP) continue;
if (c1->type == unused)
continue;
if (c1->subtype != FS_SWAP)
continue;
sprintf(c1->name, "%s%c", c->name, SWAP_PART + 'a');
break;
}
/* Allocate the first root-partition we find */
for (c1 = c->part; c1; c1 = c1->next) {
if (c1->type == unused) continue;
if (!(c1->flags & CHUNK_IS_ROOT)) continue;
if (c1->type == unused)
continue;
if (!(c1->flags & CHUNK_IS_ROOT))
continue;
sprintf(c1->name, "%s%c", c->name, 0 + 'a');
break;
}
/* Try to give them the same as they had before */
for (c1 = c->part; c1; c1 = c1->next) {
if (strcmp(c1->name, "X")) continue;
for(c3 = c->part; c3 ; c3 = c3->next)
if (c1 != c3 && !strcmp(c3->name, c1->oname)) {
goto newname;
}
if (strcmp(c1->name, "X"))
continue;
for (c3 = c->part; c3 ; c3 = c3->next)
if (c1 != c3 && !strcmp(c3->name, c1->oname))
goto newname;
strcpy(c1->name, c1->oname);
newname: ;
newname:
;
}
/* Allocate the rest sequentially */
for (c1 = c->part; c1; c1 = c1->next) {
const char order[] = "defghab";
if (c1->type == unused) continue;
if (strcmp("X", c1->name)) continue;
if (c1->type == unused)
continue;
if (strcmp("X", c1->name))
continue;
for(j = 0; j < strlen(order); j++) {
for (j = 0; j < strlen(order); j++) {
sprintf(c1->name, "%s%c", c->name, order[j]);
for(c3 = c->part; c3 ; c3 = c3->next)
for (c3 = c->part; c3 ; c3 = c3->next)
if (c1 != c3 && !strcmp(c3->name, c1->name))
goto match;
break;
match:
match:
strcpy(c1->name, "X");
continue;
}
@ -106,13 +115,15 @@ static int
Fixup_Extended_Names(struct disk *d, struct chunk *c)
{
struct chunk *c1;
int j=5;
int j = 5;
for (c1 = c->part; c1; c1 = c1->next) {
if (c1->type == unused) continue;
if (c1->type == unused)
continue;
free(c1->name);
c1->name = malloc(12);
if(!c1->name) return -1;
if (!c1->name)
return -1;
sprintf(c1->name, "%ss%d", d->chunks->name, j++);
if (c1->type == freebsd)
if (Fixup_FreeBSD_Names(d, c1) != 0)
@ -132,17 +143,18 @@ Fixup_Names(struct disk *d)
#endif
c1 = d->chunks;
for(c2 = c1->part; c2 ; c2 = c2->next) {
for (c2 = c1->part; c2 ; c2 = c2->next) {
if (c2->type == unused)
continue;
if (strcmp(c2->name, "X"))
continue;
#if defined(__i386__) || defined(__ia64__)
c2->oname = malloc(12);
if(!c2->oname) return -1;
for(j = 1; j <= NDOSPART; j++) {
if (!c2->oname)
return -1;
for (j = 1; j <= NDOSPART; j++) {
sprintf(c2->oname, "%ss%d", c1->name, j);
for(c3 = c1->part; c3; c3 = c3->next)
for (c3 = c1->part; c3; c3 = c3->next)
if (c3 != c2 && !strcmp(c3->name, c2->oname))
goto match;
free(c2->name);
@ -159,7 +171,7 @@ Fixup_Names(struct disk *d)
c2->name = strdup(c1->name);
#endif /*__i386__*/
}
for(c2 = c1->part; c2; c2 = c2->next) {
for (c2 = c1->part; c2; c2 = c2->next) {
if (c2->type == freebsd)
Fixup_FreeBSD_Names(d, c2);
#ifndef PC98
@ -171,12 +183,13 @@ Fixup_Names(struct disk *d)
}
int
Create_Chunk(struct disk *d, u_long offset, u_long size, chunk_e type, int subtype, u_long flags, const char *sname)
Create_Chunk(struct disk *d, u_long offset, u_long size, chunk_e type,
int subtype, u_long flags, const char *sname)
{
int i;
u_long l;
if(!(flags & CHUNK_FORCE_ALL)) {
if (!(flags & CHUNK_FORCE_ALL)) {
#ifdef PC98
/* Never use the first cylinder */
if (!offset) {
@ -202,7 +215,8 @@ Create_Chunk(struct disk *d, u_long offset, u_long size, chunk_e type, int subty
}
struct chunk *
Create_Chunk_DWIM(struct disk *d, const struct chunk *parent , u_long size, chunk_e type, int subtype, u_long flags)
Create_Chunk_DWIM(struct disk *d, const struct chunk *parent , u_long size,
chunk_e type, int subtype, u_long flags)
{
int i;
struct chunk *c1;
@ -210,19 +224,21 @@ Create_Chunk_DWIM(struct disk *d, const struct chunk *parent , u_long size, chun
if (!parent)
parent = d->chunks;
for (c1=parent->part; c1; c1 = c1->next) {
if (c1->type != unused) continue;
if (c1->size < size) continue;
for (c1 = parent->part; c1; c1 = c1->next) {
if (c1->type != unused)
continue;
if (c1->size < size)
continue;
offset = c1->offset;
goto found;
}
return 0;
found:
found:
i = Add_Chunk(d, offset, size, "X", type, subtype, flags, "-");
if (i)
return 0;
Fixup_Names(d);
for (c1=parent->part; c1; c1 = c1->next)
for (c1 = parent->part; c1; c1 = c1->next)
if (c1->offset == offset)
return c1;
/* barfout(1, "Serious internal trouble"); */

102
lib/libdisk/disk.c
View File

@ -90,6 +90,7 @@ uuid_type(uuid_t *uuid)
struct disk *
Open_Disk(const char *name)
{
return Int_Open_Disk(name);
}
@ -153,11 +154,17 @@ Int_Open_Disk(const char *name)
a = strsep(&p, " "); /* length in bytes */
len = strtoimax(a, &r, 0);
if (*r) { printf("BARF %d <%d>\n", __LINE__, *r); exit (0); }
if (*r) {
printf("BARF %d <%d>\n", __LINE__, *r);
exit (0);
}
a = strsep(&p, " "); /* sectorsize */
s = strtoul(a, &r, 0);
if (*r) { printf("BARF %d <%d>\n", __LINE__, *r); exit (0); }
if (*r) {
printf("BARF %d <%d>\n", __LINE__, *r);
exit (0);
}
d->sector_size = s;
len /= s; /* media size in number of sectors. */
@ -171,7 +178,10 @@ Int_Open_Disk(const char *name)
break;
b = strsep(&p, " ");
o = strtoul(b, &r, 0);
if (*r) { printf("BARF %d <%d>\n", __LINE__, *r); exit (0); }
if (*r) {
printf("BARF %d <%d>\n", __LINE__, *r);
exit (0);
}
if (!strcmp(a, "hd"))
d->bios_hd = o;
else if (!strcmp(a, "sc"))
@ -198,15 +208,24 @@ Int_Open_Disk(const char *name)
if (!strcmp(a, "0"))
break;
l = strtoimax(a, &r, 0);
if (*r) { printf("BARF %d <%d>\n", __LINE__, *r); exit (0); }
if (*r) {
printf("BARF %d <%d>\n", __LINE__, *r);
exit (0);
}
t = strsep(&p, " "); /* Type {SUN, BSD, MBR, GPT} */
n = strsep(&p, " "); /* name */
a = strsep(&p, " "); /* len */
len = strtoimax(a, &r, 0);
if (*r) { printf("BARF %d <%d>\n", __LINE__, *r); exit (0); }
if (*r) {
printf("BARF %d <%d>\n", __LINE__, *r);
exit (0);
}
a = strsep(&p, " "); /* secsize */
s = strtoimax(a, &r, 0);
if (*r) { printf("BARF %d <%d>\n", __LINE__, *r); exit (0); }
if (*r) {
printf("BARF %d <%d>\n", __LINE__, *r);
exit (0);
}
for (;;) {
a = strsep(&p, " ");
if (a == NULL)
@ -237,7 +256,7 @@ Int_Open_Disk(const char *name)
alt = o;
}
/* PLATFORM POLICY BEGIN ------------------------------------- */
/* PLATFORM POLICY BEGIN ----------------------------------- */
if (platform == p_sparc64 && !strcmp(t, "SUN") && i == 2)
continue;
if (platform == p_sparc64 && !strcmp(t, "SUN") &&
@ -252,12 +271,13 @@ Int_Open_Disk(const char *name)
}
if (platform == p_alpha && !strcmp(t, "BSD") &&
d->chunks->part->part == NULL) {
if (Add_Chunk(d, 0, d->chunks->size, name, freebsd, 0, 0, "-"))
if (Add_Chunk(d, 0, d->chunks->size, name, freebsd,
0, 0, "-"))
DPRINT(("Failed to add 'freebsd' chunk"));
}
if (!strcmp(t, "BSD") && i == RAW_PART)
continue;
/* PLATFORM POLICY END --------------------------------------- */
/* PLATFORM POLICY END ------------------------------------- */
off /= s;
len /= s;
@ -305,8 +325,10 @@ Int_Open_Disk(const char *name)
}
} else if (!strcmp(t, "GPT"))
i = Add_Chunk(d, off, len, n, ty, 0, 0, 0);
else
{ printf("BARF %d\n", __LINE__); exit(0); }
else {
printf("BARF %d\n", __LINE__);
exit(0);
}
}
/* PLATFORM POLICY BEGIN ------------------------------------- */
/* We have a chance to do things on a blank disk here */
@ -328,9 +350,11 @@ Int_Open_Disk(const char *name)
void
Debug_Disk(struct disk *d)
{
printf("Debug_Disk(%s)", d->name);
#if 0
printf(" real_geom=%lu/%lu/%lu", d->real_cyl, d->real_hd, d->real_sect);
printf(" real_geom=%lu/%lu/%lu",
d->real_cyl, d->real_hd, d->real_sect);
#endif
printf(" bios_geom=%lu/%lu/%lu = %lu\n",
d->bios_cyl, d->bios_hd, d->bios_sect,
@ -355,21 +379,28 @@ Debug_Disk(struct disk *d)
void
Free_Disk(struct disk *d)
{
if(d->chunks) Free_Chunk(d->chunks);
if(d->name) free(d->name);
if (d->chunks)
Free_Chunk(d->chunks);
if (d->name)
free(d->name);
#ifdef PC98
if(d->bootipl) free(d->bootipl);
if(d->bootmenu) free(d->bootmenu);
if (d->bootipl)
free(d->bootipl);
if (d->bootmenu)
free(d->bootmenu);
#else
#if !defined(__ia64__)
if(d->bootmgr) free(d->bootmgr);
if (d->bootmgr)
free(d->bootmgr);
#endif
#endif
#if !defined(__ia64__)
if(d->boot1) free(d->boot1);
if (d->boot1)
free(d->boot1);
#endif
#if defined(__i386__)
if(d->boot2) free(d->boot2);
if (d->boot2)
free(d->boot2);
#endif
free(d);
}
@ -379,7 +410,7 @@ void
Collapse_Disk(struct disk *d)
{
while(Collapse_Chunk(d, d->chunks))
while (Collapse_Chunk(d, d->chunks))
;
}
#endif
@ -387,9 +418,9 @@ Collapse_Disk(struct disk *d)
static int
qstrcmp(const void* a, const void* b)
{
char *str1 = *(char**)a;
char *str2 = *(char**)b;
return strcmp(str1, str2);
}
@ -428,7 +459,7 @@ Disk_Names()
disks[disk_cnt] = strsep(&disklist, " ");
if (disks[disk_cnt] == NULL)
break;
}
}
qsort(disks, disk_cnt, sizeof(char*), qstrcmp);
return disks;
}
@ -453,7 +484,8 @@ Set_Boot_Mgr(struct disk *d, const u_char *b, const size_t s)
} else {
d->bootipl_size = bootipl_size;
d->bootipl = malloc(bootipl_size);
if(!d->bootipl) return;
if (!d->bootipl)
return;
memcpy(d->bootipl, bootipl, bootipl_size);
}
@ -466,7 +498,8 @@ Set_Boot_Mgr(struct disk *d, const u_char *b, const size_t s)
} else {
d->bootmenu_size = bootmenu_size;
d->bootmenu = malloc(bootmenu_size);
if(!d->bootmenu) return;
if (!d->bootmenu)
return;
memcpy(d->bootmenu, bootmenu, bootmenu_size);
}
#else
@ -479,7 +512,8 @@ Set_Boot_Mgr(struct disk *d, const u_char *b, const size_t s)
} else {
d->bootmgr_size = s;
d->bootmgr = malloc(s);
if(!d->bootmgr) return;
if (!d->bootmgr)
return;
memcpy(d->bootmgr, b, s);
}
#endif
@ -490,18 +524,24 @@ int
Set_Boot_Blocks(struct disk *d, const u_char *b1, const u_char *b2)
{
#if defined(__i386__)
if (d->boot1) free(d->boot1);
if (d->boot1)
free(d->boot1);
d->boot1 = malloc(512);
if(!d->boot1) return -1;
if (!d->boot1)
return -1;
memcpy(d->boot1, b1, 512);
if (d->boot2) free(d->boot2);
if (d->boot2)
free(d->boot2);
d->boot2 = malloc(15 * 512);
if(!d->boot2) return -1;
if (!d->boot2)
return -1;
memcpy(d->boot2, b2, 15 * 512);
#elif defined(__alpha__)
if (d->boot1) free(d->boot1);
if (d->boot1)
free(d->boot1);
d->boot1 = malloc(15 * 512);
if(!d->boot1) return -1;
if (!d->boot1)
return -1;
memcpy(d->boot1, b1, 15 * 512);
#elif defined(__sparc64__)
if (d->boot1 != NULL)

77
lib/libdisk/libdisk.h
View File

@ -48,9 +48,6 @@ const static enum platform {
#endif
;
typedef enum {
whole,
unknown,
@ -151,33 +148,27 @@ const char *chunk_name(chunk_e);
const char *
slice_type_name(int, int);
/* "chunk_n" for subtypes too
*/
/* "chunk_n" for subtypes too */
struct disk *
Open_Disk(const char *);
/* Will open the named disk, and return populated tree.
*/
/* Will open the named disk, and return populated tree. */
void
Free_Disk(struct disk *);
/* Free a tree made with Open_Disk() or Clone_Disk()
*/
/* Free a tree made with Open_Disk() or Clone_Disk() */
void
Debug_Disk(struct disk *);
/* Print the content of the tree to stdout
*/
/* Print the content of the tree to stdout */
void
Set_Bios_Geom(struct disk *, u_long, u_long, u_long);
/* Set the geometry the bios uses.
*/
/* Set the geometry the bios uses. */
void
Sanitize_Bios_Geom(struct disk *);
/* Set the bios geometry to something sane
*/
/* Set the bios geometry to something sane */
int
Insert_Chunk(struct chunk *, u_long, u_long, const char *, chunk_e, int,
@ -185,44 +176,40 @@ Insert_Chunk(struct chunk *, u_long, u_long, const char *, chunk_e, int,
int
Delete_Chunk2(struct disk *, struct chunk *, int);
/* Free a chunk of disk_space modified by the passed
* flags.
*/
/* Free a chunk of disk_space modified by the passed flags. */
int
Delete_Chunk(struct disk *, struct chunk *);
/* Free a chunk of disk_space
*/
/* Free a chunk of disk_space */
void
Collapse_Disk(struct disk *);
/* Experimental, do not use.
*/
/* Experimental, do not use. */
int
Collapse_Chunk(struct disk *, struct chunk *);
/* Experimental, do not use.
*/
/* Experimental, do not use. */
int
Create_Chunk(struct disk *, u_long, u_long, chunk_e, int, u_long, const char *);
/* Create a chunk with the specified paramters
*/
/* Create a chunk with the specified paramters */
void
All_FreeBSD(struct disk *, int);
/* Make one FreeBSD chunk covering the entire disk;
/*
* Make one FreeBSD chunk covering the entire disk;
* if force_all is set, bypass all BIOS geometry
* considerations.
*/
char *
CheckRules(const struct disk *);
/* Return char* to warnings about broken design rules in this disklayout
*/
/* Return char* to warnings about broken design rules in this disklayout */
char **
Disk_Names(void);
/* Return char** with all disk's names (wd0, wd1 ...). You must free
/*
* Return char** with all disk's names (wd0, wd1 ...). You must free
* each pointer, as well as the array by hand
*/
@ -234,53 +221,47 @@ Set_Boot_Mgr(struct disk *, const u_char *, const size_t, const u_char *,
void
Set_Boot_Mgr(struct disk *, const u_char *, const size_t);
#endif
/* Use this boot-manager on this disk. Gets written when Write_Disk()
/*
* Use this boot-manager on this disk. Gets written when Write_Disk()
* is called
*/
int
Set_Boot_Blocks(struct disk *, const u_char *, const u_char *);
/* Use these boot-blocks on this disk. Gets written when Write_Disk()
/*
* Use these boot-blocks on this disk. Gets written when Write_Disk()
* is called. Returns nonzero upon failure.
*/
int
Write_Disk(const struct disk *);
/* Write all the MBRs, disklabels, bootblocks and boot managers
*/
/* Write all the MBRs, disklabels, bootblocks and boot managers */
u_long
Next_Cyl_Aligned(const struct disk *, u_long);
/* Round offset up to next cylinder according to the bios-geometry
*/
/* Round offset up to next cylinder according to the bios-geometry */
u_long
Prev_Cyl_Aligned(const struct disk *, u_long);
/* Round offset down to previous cylinder according to the bios-
* geometry
*/
/* Round offset down to previous cylinder according to the bios-geometry */
int
Track_Aligned(const struct disk *, u_long);
/* Check if offset is aligned on a track according to the
* bios geometry
*/
/* Check if offset is aligned on a track according to the bios geometry */
u_long
Next_Track_Aligned(const struct disk *, u_long);
/* Round offset up to next track according to the bios-geometry
*/
/* Round offset up to next track according to the bios-geometry */
u_long
Prev_Track_Aligned(const struct disk *, u_long);
/* Check if offset is aligned on a track according to the
* bios geometry
*/
/* Check if offset is aligned on a track according to the bios geometry */
struct chunk *
Create_Chunk_DWIM(struct disk *, const struct chunk *, u_long, chunk_e, int,
u_long);
/* This one creates a partition inside the given parent of the given
/*
* This one creates a partition inside the given parent of the given
* size, and returns a pointer to it. The first unused chunk big
* enough is used.
*/

43
lib/libdisk/rules.c
View File

@ -27,6 +27,7 @@ __FBSDID("$FreeBSD$");
int
Track_Aligned(const struct disk *d, u_long offset)
{
if (!d->bios_sect)
return 1;
if (offset % d->bios_sect)
@ -37,6 +38,7 @@ Track_Aligned(const struct disk *d, u_long offset)
u_long
Prev_Track_Aligned(const struct disk *d, u_long offset)
{
if (!d->bios_sect)
return offset;
return (offset / d->bios_sect) * d->bios_sect;
@ -45,6 +47,7 @@ Prev_Track_Aligned(const struct disk *d, u_long offset)
u_long
Next_Track_Aligned(const struct disk *d, u_long offset)
{
if (!d->bios_sect)
return offset;
return Prev_Track_Aligned(d, offset + d->bios_sect-1);
@ -53,6 +56,7 @@ Next_Track_Aligned(const struct disk *d, u_long offset)
static int
Cyl_Aligned(const struct disk *d, u_long offset)
{
if (!d->bios_sect || !d->bios_hd)
return 1;
if (offset % (d->bios_sect * d->bios_hd))
@ -63,6 +67,7 @@ Cyl_Aligned(const struct disk *d, u_long offset)
u_long
Prev_Cyl_Aligned(const struct disk *d, u_long offset)
{
if (!d->bios_sect || !d->bios_hd)
return offset;
return (offset / (d->bios_sect*d->bios_hd)) * d->bios_sect * d->bios_hd;
@ -71,9 +76,10 @@ Prev_Cyl_Aligned(const struct disk *d, u_long offset)
u_long
Next_Cyl_Aligned(const struct disk *d, u_long offset)
{
if (!d->bios_sect || !d->bios_hd)
return offset;
return Prev_Cyl_Aligned(d,offset + (d->bios_sect * d->bios_hd)-1);
return Prev_Cyl_Aligned(d,offset + (d->bios_sect * d->bios_hd) - 1);
}
/*
@ -85,16 +91,17 @@ static void
Rule_000(const struct disk *d, const struct chunk *c, char *msg)
{
#ifdef PC98
int i=0;
int i = 0;
#else
int i=0,j=0;
int i = 0, j = 0;
#endif
struct chunk *c1;
if (c->type != whole)
return;
for (c1 = c->part; c1; c1 = c1->next) {
if (c1->type != unused) continue;
if (c1->type != unused)
continue;
#ifndef PC98
if (c1->flags & CHUNK_ACTIVE)
j++;
@ -103,12 +110,12 @@ Rule_000(const struct disk *d, const struct chunk *c, char *msg)
}
if (i > NDOSPART)
sprintf(msg + strlen(msg),
"%d is too many children of the 'whole' chunk. Max is %d\n",
i, NDOSPART);
"%d is too many children of the 'whole' chunk."
" Max is %d\n", i, NDOSPART);
#ifndef PC98
if (j > 1)
sprintf(msg + strlen(msg),
"Too many active children of 'whole'");
"Too many active children of 'whole'");
#endif
}
@ -125,7 +132,8 @@ Rule_001(const struct disk *d, const struct chunk *c, char *msg)
if (c->type != whole && c->type != extended)
return;
for (c1 = c->part; c1; c1 = c1->next) {
if (c1->type == unused) continue;
if (c1->type == unused)
continue;
c1->flags |= CHUNK_ALIGN;
#ifdef PC98
if (!Cyl_Aligned(d, c1->offset))
@ -134,9 +142,11 @@ Rule_001(const struct disk *d, const struct chunk *c, char *msg)
#endif
sprintf(msg + strlen(msg),
#ifdef PC98
"chunk '%s' [%ld..%ld] does not start on a cylinder boundary\n",
"chunk '%s' [%ld..%ld] does not start"
" on a cylinder boundary\n",
#else
"chunk '%s' [%ld..%ld] does not start on a track boundary\n",
"chunk '%s' [%ld..%ld] does not start"
" on a track boundary\n",
#endif
c1->name, c1->offset, c1->end);
if ((c->type == whole || c->end == c1->end)
@ -144,7 +154,8 @@ Rule_001(const struct disk *d, const struct chunk *c, char *msg)
;
else
sprintf(msg + strlen(msg),
"chunk '%s' [%ld..%ld] does not end on a cylinder boundary\n",
"chunk '%s' [%ld..%ld] does not end"
" on a cylinder boundary\n",
c1->name, c1->offset, c1->end);
}
}
@ -168,7 +179,7 @@ Rule_002(const struct disk *d, const struct chunk *c, char *msg)
}
if (i > 1) {
sprintf(msg + strlen(msg),
"Max one 'fat' allowed as child of 'whole'\n");
"Max one 'fat' allowed as child of 'whole'\n");
}
}
@ -191,7 +202,7 @@ Rule_003(const struct disk *d, const struct chunk *c, char *msg)
}
if (i > 1) {
sprintf(msg + strlen(msg),
"Max one 'extended' allowed as child of 'whole'\n");
"Max one 'extended' allowed as child of 'whole'\n");
}
}
@ -203,7 +214,7 @@ Rule_003(const struct disk *d, const struct chunk *c, char *msg)
static void
Rule_004(const struct disk *d, const struct chunk *c, char *msg)
{
int i=0,k=0;
int i = 0, k = 0;
struct chunk *c1;
if (c->type != freebsd)
@ -218,11 +229,11 @@ Rule_004(const struct disk *d, const struct chunk *c, char *msg)
}
if (i > 7) {
sprintf(msg + strlen(msg),
"Max seven partitions per freebsd slice\n");
"Max seven partitions per freebsd slice\n");
}
if (k > 1) {
sprintf(msg + strlen(msg),
"Max one root partition child per freebsd slice\n");
"Max one root partition child per freebsd slice\n");
}
}

129
lib/libdisk/tst01.c
View File

@ -82,7 +82,7 @@ scan_block(int fd, daddr_t block)
if (-1 == lseek(fd, (off_t)block * 512, SEEK_SET))
err(1, "lseek");
if (512 != read(fd,foo, 512))
if (512 != read(fd, foo, 512))
return 1;
return 0;
}
@ -92,27 +92,27 @@ Scan_Disk(struct disk *d)
{
char device[64];
u_long l;
int i,j,fd;
int i, j, fd;
strcpy(device,_PATH_DEV);
strcat(device,d->name);
strcpy(device, _PATH_DEV);
strcat(device, d->name);
fd = open(device,O_RDWR);
fd = open(device, O_RDWR);
if (fd < 0) {
warn("open(%s) failed",device);
warn("open(%s) failed", device);
return;
}
for(i=-1,l=0;;l++) {
j = scan_block(fd,l);
for (i = -1, l = 0; ; l++) {
j = scan_block(fd, l);
if (j != i) {
if (i == -1) {
printf("%c: %lu.",j ? 'B' : 'G', l);
fflush(stdout);
} else if (i == 0) {
printf(".%lu\nB: %lu.",l-1,l);
printf(".%lu\nB: %lu.", l - 1, l);
fflush(stdout);
} else {
printf(".%lu\nG: %lu.",l-1,l);
printf(".%lu\nG: %lu.", l - 1, l);
fflush(stdout);
}
i = j;
@ -129,20 +129,20 @@ main(int argc, char **argv)
#ifndef READLINE
char input[BUFSIZ];
#endif
char *p,*q=0;
char **cp,*cmds[200];
int ncmd,i;
char *p,*q = 0;
char **cp, *cmds[200];
int ncmd, i;
if (argc < 2) {
fprintf(stderr,"Usage:\n\t%s diskname\n",argv[0]);
fprintf(stderr, "Usage:\n\t%s diskname\n", argv[0]);
exit(1);
}
d = Open_Disk(argv[1]);
if (!d)
err(1,"Couldn't open disk %s",argv[1]);
err(1, "Couldn't open disk %s", argv[1]);
sprintf(myprompt,"%s %s> ",argv[0],argv[1]);
while(1) {
sprintf(myprompt, "%s %s> ", argv[0], argv[1]);
while (1) {
printf("--==##==--\n");
p = CheckRules(d);
Debug_Disk(d);
@ -157,82 +157,84 @@ main(int argc, char **argv)
#else
printf("%s", myprompt);
fflush(stdout);
q = p = fgets(input,sizeof(input),stdin);
q = p = fgets(input, sizeof(input), stdin);
#endif
if(!p)
break;
for(cp = cmds; (*cp = strsep(&p, " \t\n")) != NULL;)
for (cp = cmds; (*cp = strsep(&p, " \t\n")) != NULL;)
if (**cp != '\0')
cp++;
ncmd = cp - cmds;
if(!ncmd)
if (!ncmd)
continue;
if (!strcasecmp(*cmds,"quit")) { break; }
if (!strcasecmp(*cmds,"exit")) { break; }
if (!strcasecmp(*cmds,"q")) { break; }
if (!strcasecmp(*cmds,"x")) { break; }
if (!strcasecmp(*cmds,"dwim") && ncmd == 6) {
if (!strcasecmp(*cmds, "quit"))
break;
if (!strcasecmp(*cmds, "exit"))
break;
if (!strcasecmp(*cmds, "q"))
break;
if (!strcasecmp(*cmds, "x"))
break;
if (!strcasecmp(*cmds, "dwim") && ncmd == 6) {
printf("dwim = %p\n",
Create_Chunk_DWIM(d,
(struct chunk *)strtol(cmds[1],0,0),
strtol(cmds[2],0,0),
strtol(cmds[3],0,0),
strtol(cmds[4],0,0),
strtol(cmds[5],0,0)));
Create_Chunk_DWIM(d,
(struct chunk *)strtol(cmds[1], 0, 0),
strtol(cmds[2], 0, 0),
strtol(cmds[3], 0, 0),
strtol(cmds[4], 0, 0),
strtol(cmds[5], 0, 0)));
continue;
}
if (!strcasecmp(*cmds,"delete") && ncmd == 2) {
if (!strcasecmp(*cmds, "delete") && ncmd == 2) {
printf("delete = %d\n",
Delete_Chunk(d,
(struct chunk *)strtol(cmds[1],0,0)));
Delete_Chunk(d,
(struct chunk *)strtol(cmds[1], 0, 0)));
continue;
}
if (!strcasecmp(*cmds,"allfreebsd")) {
if (!strcasecmp(*cmds, "allfreebsd")) {
All_FreeBSD(d, 0);
continue;
}
if (!strcasecmp(*cmds,"dedicate")) {
if (!strcasecmp(*cmds, "dedicate")) {
All_FreeBSD(d, 1);
continue;
}
if (!strcasecmp(*cmds,"sanitize")) {
if (!strcasecmp(*cmds, "sanitize")) {
Sanitize_Bios_Geom(d);
continue;
}
if (!strcasecmp(*cmds,"bios") && ncmd == 4) {
Set_Bios_Geom(d,
strtol(cmds[1],0,0),
strtol(cmds[2],0,0),
strtol(cmds[3],0,0));
if (!strcasecmp(*cmds, "bios") && ncmd == 4) {
Set_Bios_Geom(d, strtol(cmds[1], 0, 0),
strtol(cmds[2], 0, 0),
strtol(cmds[3], 0, 0));
continue;
}
if (!strcasecmp(*cmds,"list")) {
if (!strcasecmp(*cmds, "list")) {
cp = Disk_Names();
printf("Disks:");
for(i=0;cp[i];i++) {
printf(" %s",cp[i]);
for (i = 0; cp[i]; i++) {
printf(" %s", cp[i]);
free(cp[i]);
}
free(cp);
continue;
}
#ifdef PC98
if (!strcasecmp(*cmds,"create") && ncmd == 7) {
if (!strcasecmp(*cmds, "create") && ncmd == 7) {
#else
if (!strcasecmp(*cmds,"create") && ncmd == 6) {
#endif
printf("Create=%d\n",
Create_Chunk(d,
strtol(cmds[1],0,0),
strtol(cmds[2],0,0),
strtol(cmds[3],0,0),
strtol(cmds[4],0,0),
Create_Chunk(d,
strtol(cmds[1], 0, 0),
strtol(cmds[2], 0, 0),
strtol(cmds[3], 0, 0),
strtol(cmds[4], 0, 0),
#ifdef PC98
strtol(cmds[5],0,0),
cmds[6]));
strtol(cmds[5], 0, 0), cmds[6]));
#else
strtol(cmds[5],0,0), NULL));
strtol(cmds[5], 0, 0), NULL));
#endif
continue;
}
@ -254,28 +256,28 @@ main(int argc, char **argv)
}
#ifndef PC98
if (!strcasecmp(*cmds,"bteasy")) {
Set_Boot_Mgr(d,bteasy17,sizeof (bteasy17));
Set_Boot_Mgr(d, bteasy17, sizeof (bteasy17));
continue;
}
if (!strcasecmp(*cmds,"mbr")) {
Set_Boot_Mgr(d,mbrboot,sizeof (mbrboot));
if (!strcasecmp(*cmds, "mbr")) {
Set_Boot_Mgr(d, mbrboot, sizeof (mbrboot));
continue;
}
#endif
#if 0 /* XXX boot1 undefined, fix me */
if (!strcasecmp(*cmds,"boot")) {
Set_Boot_Blocks(d,boot1,boot2);
if (!strcasecmp(*cmds, "boot")) {
Set_Boot_Blocks(d, boot1, boot2);
continue;
}
#endif
if (!strcasecmp(*cmds,"write")) {
if (!strcasecmp(*cmds, "write")) {
printf("Write=%d\n",
Write_Disk(d));
Free_Disk(d);
d = Open_Disk(argv[1]);
continue;
}
if (strcasecmp(*cmds,"help"))
if (strcasecmp(*cmds, "help"))
printf("\007ERROR\n");
printf("CMDS:\n");
printf("\tallfreebsd\n");
@ -308,8 +310,9 @@ main(int argc, char **argv)
printf("\twrite\n");
printf("\nENUM:\n\t");
#if 0
for(i=0;chunk_n[i];i++)
printf("%d = %s%s",i,chunk_n[i],i == 4 ? "\n\t" : " ");
for (i = 0; chunk_n[i]; i++)
printf("%d = %s%s", i, chunk_n[i],
i == 4 ? "\n\t" : " ");
#endif
printf("\n");

8
lib/libdisk/write_alpha_disk.c
View File

@ -23,8 +23,10 @@ __FBSDID("$FreeBSD$");
#include <paths.h>
#include "libdisk.h"
/* XXX: A lot of hardcoded 512s probably should be foo->sector_size;
I'm not sure which, so I leave it like it worked before. --schweikh */
/*
* XXX: A lot of hardcoded 512s probably should be foo->sector_size;
* I'm not sure which, so I leave it like it worked before. --schweikh
*/
int
Write_Disk(const struct disk *d1)
{
@ -54,7 +56,7 @@ Write_Disk(const struct disk *d1)
memcpy(buf + 512 * i, p, 512);
free(p);
}
if(d1->boot1)
if (d1->boot1)
memcpy(buf + 512, d1->boot1, BBSIZE - 512);
dl = (struct disklabel *)(buf + 512 * LABELSECTOR + LABELOFFSET);

87
lib/libdisk/write_amd64_disk.c
View File

@ -23,34 +23,35 @@ __FBSDID("$FreeBSD$");
#include <paths.h>
#include "libdisk.h"
/* XXX: A lot of hardcoded 512s probably should be foo->sector_size;
I'm not sure which, so I leave it like it worked before. --schweikh */
/*
* XXX: A lot of hardcoded 512s probably should be foo->sector_size;
* I'm not sure which, so I leave it like it worked before. --schweikh
*/
static int
Write_FreeBSD(int fd, const struct disk *new, const struct disk *old, const struct chunk *c1)
Write_FreeBSD(int fd, const struct disk *new, const struct disk *old,
const struct chunk *c1)
{
struct disklabel *dl;
int i;
void *p;
u_char buf[BBSIZE];
for(i = 0; i < BBSIZE/512; i++) {
for (i = 0; i < BBSIZE/512; i++) {
p = read_block(fd, i + c1->offset, 512);
memcpy(buf + 512 * i, p, 512);
free(p);
}
if(new->boot1)
if (new->boot1)
memcpy(buf, new->boot1, 512);
if(new->boot2)
memcpy(buf + 512, new->boot2, BBSIZE-512);
if (new->boot2)
memcpy(buf + 512, new->boot2, BBSIZE - 512);
dl = (struct disklabel *)(buf + 512 * LABELSECTOR + LABELOFFSET);
Fill_Disklabel(dl, new, old, c1);
for(i=0;i<BBSIZE/512;i++) {
for (i = 0; i < BBSIZE / 512; i++)
write_block(fd, i + c1->offset, buf + 512 * i, 512);
}
return 0;
}
@ -58,11 +59,12 @@ Write_FreeBSD(int fd, const struct disk *new, const struct disk *old, const stru
static void
Write_Int32(u_int32_t *p, u_int32_t v)
{
u_int8_t *bp = (u_int8_t *)p;
bp[0] = (v >> 0) & 0xff;
bp[1] = (v >> 8) & 0xff;
bp[2] = (v >> 16) & 0xff;
bp[3] = (v >> 24) & 0xff;
u_int8_t *bp = (u_int8_t *)p;
bp[0] = (v >> 0) & 0xff;
bp[1] = (v >> 8) & 0xff;
bp[2] = (v >> 16) & 0xff;
bp[3] = (v >> 24) & 0xff;
}
/*
@ -71,19 +73,19 @@ Write_Int32(u_int32_t *p, u_int32_t v)
static void
Cfg_Boot_Mgr(u_char *mbr, int edd)
{
if (mbr[0x1b0] == 0x66 && mbr[0x1b1] == 0xbb) {
if (edd)
mbr[0x1bb] |= 0x80; /* Packet mode on */
else
mbr[0x1bb] &= 0x7f; /* Packet mode off */
}
if (mbr[0x1b0] == 0x66 && mbr[0x1b1] == 0xbb) {
if (edd)
mbr[0x1bb] |= 0x80; /* Packet mode on */
else
mbr[0x1bb] &= 0x7f; /* Packet mode off */
}
}
int
Write_Disk(const struct disk *d1)
{
int fd,i;
int j;
int fd, i, j;
struct disk *old = 0;
struct chunk *c1;
int ret = 0;
@ -93,23 +95,24 @@ Write_Disk(const struct disk *d1)
int s[4];
int need_edd = 0; /* Need EDD (packet interface) */
strcpy(device,_PATH_DEV);
strcat(device,d1->name);
strcpy(device, _PATH_DEV);
strcat(device, d1->name);
fd = open(device,O_RDWR);
fd = open(device, O_RDWR);
if (fd < 0)
return 1;
memset(s,0,sizeof s);
memset(s, 0, sizeof s);
mbr = read_block(fd, 0, d1->sector_size);
dp = (struct dos_partition*)(mbr + DOSPARTOFF);
dp = (struct dos_partition *)(mbr + DOSPARTOFF);
memcpy(work, dp, sizeof work);
dp = work;
free(mbr);
for (c1 = d1->chunks->part; c1; c1 = c1->next) {
if (c1->type == unused) continue;
if (!strcmp(c1->name, "X")) continue;
if (c1->type == unused)
continue;
if (!strcmp(c1->name, "X"))
continue;
j = c1->name[strlen(d1->name) + 1] - '1';
if (j < 0 || j > 3)
continue;
@ -121,7 +124,7 @@ Write_Disk(const struct disk *d1)
Write_Int32(&dp[j].dp_size, c1->size);
i = c1->offset;
if (i >= 1024*d1->bios_sect*d1->bios_hd) {
if (i >= 1024 * d1->bios_sect * d1->bios_hd) {
dp[j].dp_ssect = 0xff;
dp[j].dp_shd = 0xff;
dp[j].dp_scyl = 0xff;
@ -137,10 +140,9 @@ Write_Disk(const struct disk *d1)
i -= dp[j].dp_scyl;
dp[j].dp_ssect |= i >> 2;
}
#ifdef DEBUG
printf("S:%lu = (%x/%x/%x)",
c1->offset, dp[j].dp_scyl, dp[j].dp_shd, dp[j].dp_ssect);
printf("S:%lu = (%x/%x/%x)", c1->offset,
dp[j].dp_scyl, dp[j].dp_shd, dp[j].dp_ssect);
#endif
i = c1->end;
@ -150,14 +152,14 @@ Write_Disk(const struct disk *d1)
dp[j].dp_ehd = i % d1->bios_hd;
i -= dp[j].dp_ehd;
i /= d1->bios_hd;
if (i>1023) i = 1023;
if (i > 1023)
i = 1023;
dp[j].dp_ecyl = i;
i -= dp[j].dp_ecyl;
dp[j].dp_esect |= i >> 2;
#ifdef DEBUG
printf(" E:%lu = (%x/%x/%x)\n",
c1->end, dp[j].dp_ecyl, dp[j].dp_ehd, dp[j].dp_esect);
printf(" E:%lu = (%x/%x/%x)\n", c1->end,
dp[j].dp_ecyl, dp[j].dp_ehd, dp[j].dp_esect);
#endif
dp[j].dp_typ = c1->subtype;
@ -167,7 +169,7 @@ Write_Disk(const struct disk *d1)
dp[j].dp_flag = 0;
}
j = 0;
for(i = 0; i < NDOSPART; i++) {
for (i = 0; i < NDOSPART; i++) {
if (!s[i])
memset(dp + i, 0, sizeof *dp);
if (dp[i].dp_flag)
@ -188,8 +190,9 @@ Write_Disk(const struct disk *d1)
mbr[512-1] = 0xaa;
write_block(fd, 0, mbr, d1->sector_size);
if (d1->bootmgr && d1->bootmgr_size > d1->sector_size)
for(i = 1; i * d1->sector_size <= d1->bootmgr_size; i++)
write_block(fd, i, &d1->bootmgr[i * d1->sector_size], d1->sector_size);
for (i = 1; i * d1->sector_size <= d1->bootmgr_size; i++)
write_block(fd, i, &d1->bootmgr[i * d1->sector_size],
d1->sector_size);
close(fd);
return 0;

19
lib/libdisk/write_disk.c
View File

@ -24,16 +24,19 @@ __FBSDID("$FreeBSD$");
#include "libdisk.h"
void
Fill_Disklabel(struct disklabel *dl, const struct disk *new, const struct disk *old, const struct chunk *c1)
Fill_Disklabel(struct disklabel *dl, const struct disk *new,
const struct disk *old, const struct chunk *c1)
{
struct chunk *c2;
int j;
memset(dl, 0, sizeof *dl);
for(c2 = c1->part; c2; c2 = c2->next) {
if (c2->type == unused) continue;
if (!strcmp(c2->name, "X")) continue;
for (c2 = c1->part; c2; c2 = c2->next) {
if (c2->type == unused)
continue;
if (!strcmp(c2->name, "X"))
continue;
j = c2->name[strlen(c2->name) - 1] - 'a';
if (j < 0 || j >= MAXPARTITIONS || j == RAW_PART)
continue;
@ -52,9 +55,9 @@ Fill_Disklabel(struct disklabel *dl, const struct disk *new, const struct disk *
dl->d_secsize = 512;
dl->d_secperunit = new->chunks->size;
dl->d_ncylinders = new->bios_cyl;
dl->d_ntracks = new->bios_hd;
dl->d_nsectors = new->bios_sect;
dl->d_ncylinders = new->bios_cyl;
dl->d_ntracks = new->bios_hd;
dl->d_nsectors = new->bios_sect;
dl->d_secpercyl = dl->d_ntracks * dl->d_nsectors;
dl->d_npartitions = MAXPARTITIONS;
@ -69,6 +72,4 @@ Fill_Disklabel(struct disklabel *dl, const struct disk *new, const struct disk *
dl->d_magic = DISKMAGIC;
dl->d_magic2 = DISKMAGIC;
dl->d_checksum = dkcksum(dl);
return;
}

87
lib/libdisk/write_i386_disk.c
View File

@ -23,34 +23,35 @@ __FBSDID("$FreeBSD$");
#include <paths.h>
#include "libdisk.h"
/* XXX: A lot of hardcoded 512s probably should be foo->sector_size;
I'm not sure which, so I leave it like it worked before. --schweikh */
/*
* XXX: A lot of hardcoded 512s probably should be foo->sector_size;
* I'm not sure which, so I leave it like it worked before. --schweikh
*/
static int
Write_FreeBSD(int fd, const struct disk *new, const struct disk *old, const struct chunk *c1)
Write_FreeBSD(int fd, const struct disk *new, const struct disk *old,
const struct chunk *c1)
{
struct disklabel *dl;
int i;
void *p;
u_char buf[BBSIZE];
for(i = 0; i < BBSIZE/512; i++) {
for (i = 0; i < BBSIZE/512; i++) {
p = read_block(fd, i + c1->offset, 512);
memcpy(buf + 512 * i, p, 512);
free(p);
}
if(new->boot1)
if (new->boot1)
memcpy(buf, new->boot1, 512);
if(new->boot2)
memcpy(buf + 512, new->boot2, BBSIZE-512);
if (new->boot2)
memcpy(buf + 512, new->boot2, BBSIZE - 512);
dl = (struct disklabel *)(buf + 512 * LABELSECTOR + LABELOFFSET);
Fill_Disklabel(dl, new, old, c1);
for(i=0;i<BBSIZE/512;i++) {
for (i = 0; i < BBSIZE / 512; i++)
write_block(fd, i + c1->offset, buf + 512 * i, 512);
}
return 0;
}
@ -58,11 +59,12 @@ Write_FreeBSD(int fd, const struct disk *new, const struct disk *old, const stru
static void
Write_Int32(u_int32_t *p, u_int32_t v)
{
u_int8_t *bp = (u_int8_t *)p;
bp[0] = (v >> 0) & 0xff;
bp[1] = (v >> 8) & 0xff;
bp[2] = (v >> 16) & 0xff;
bp[3] = (v >> 24) & 0xff;
u_int8_t *bp = (u_int8_t *)p;
bp[0] = (v >> 0) & 0xff;
bp[1] = (v >> 8) & 0xff;
bp[2] = (v >> 16) & 0xff;
bp[3] = (v >> 24) & 0xff;
}
/*
@ -71,19 +73,19 @@ Write_Int32(u_int32_t *p, u_int32_t v)
static void
Cfg_Boot_Mgr(u_char *mbr, int edd)
{
if (mbr[0x1b0] == 0x66 && mbr[0x1b1] == 0xbb) {
if (edd)
mbr[0x1bb] |= 0x80; /* Packet mode on */
else
mbr[0x1bb] &= 0x7f; /* Packet mode off */
}
if (mbr[0x1b0] == 0x66 && mbr[0x1b1] == 0xbb) {
if (edd)
mbr[0x1bb] |= 0x80; /* Packet mode on */
else
mbr[0x1bb] &= 0x7f; /* Packet mode off */
}
}
int
Write_Disk(const struct disk *d1)
{
int fd,i;
int j;
int fd, i, j;
struct disk *old = 0;
struct chunk *c1;
int ret = 0;
@ -93,23 +95,24 @@ Write_Disk(const struct disk *d1)
int s[4];
int need_edd = 0; /* Need EDD (packet interface) */
strcpy(device,_PATH_DEV);
strcat(device,d1->name);
strcpy(device, _PATH_DEV);
strcat(device, d1->name);
fd = open(device,O_RDWR);
fd = open(device, O_RDWR);
if (fd < 0)
return 1;
memset(s,0,sizeof s);
memset(s, 0, sizeof s);
mbr = read_block(fd, 0, d1->sector_size);
dp = (struct dos_partition*)(mbr + DOSPARTOFF);
dp = (struct dos_partition *)(mbr + DOSPARTOFF);
memcpy(work, dp, sizeof work);
dp = work;
free(mbr);
for (c1 = d1->chunks->part; c1; c1 = c1->next) {
if (c1->type == unused) continue;
if (!strcmp(c1->name, "X")) continue;
if (c1->type == unused)
continue;
if (!strcmp(c1->name, "X"))
continue;
j = c1->name[strlen(d1->name) + 1] - '1';
if (j < 0 || j > 3)
continue;
@ -121,7 +124,7 @@ Write_Disk(const struct disk *d1)
Write_Int32(&dp[j].dp_size, c1->size);
i = c1->offset;
if (i >= 1024*d1->bios_sect*d1->bios_hd) {
if (i >= 1024 * d1->bios_sect * d1->bios_hd) {
dp[j].dp_ssect = 0xff;
dp[j].dp_shd = 0xff;
dp[j].dp_scyl = 0xff;
@ -137,10 +140,9 @@ Write_Disk(const struct disk *d1)
i -= dp[j].dp_scyl;
dp[j].dp_ssect |= i >> 2;
}
#ifdef DEBUG
printf("S:%lu = (%x/%x/%x)",
c1->offset, dp[j].dp_scyl, dp[j].dp_shd, dp[j].dp_ssect);
printf("S:%lu = (%x/%x/%x)", c1->offset,
dp[j].dp_scyl, dp[j].dp_shd, dp[j].dp_ssect);
#endif
i = c1->end;
@ -150,14 +152,14 @@ Write_Disk(const struct disk *d1)
dp[j].dp_ehd = i % d1->bios_hd;
i -= dp[j].dp_ehd;
i /= d1->bios_hd;
if (i>1023) i = 1023;
if (i > 1023)
i = 1023;
dp[j].dp_ecyl = i;
i -= dp[j].dp_ecyl;
dp[j].dp_esect |= i >> 2;
#ifdef DEBUG
printf(" E:%lu = (%x/%x/%x)\n",
c1->end, dp[j].dp_ecyl, dp[j].dp_ehd, dp[j].dp_esect);
printf(" E:%lu = (%x/%x/%x)\n", c1->end,
dp[j].dp_ecyl, dp[j].dp_ehd, dp[j].dp_esect);
#endif
dp[j].dp_typ = c1->subtype;
@ -167,7 +169,7 @@ Write_Disk(const struct disk *d1)
dp[j].dp_flag = 0;
}
j = 0;
for(i = 0; i < NDOSPART; i++) {
for (i = 0; i < NDOSPART; i++) {
if (!s[i])
memset(dp + i, 0, sizeof *dp);
if (dp[i].dp_flag)
@ -188,8 +190,9 @@ Write_Disk(const struct disk *d1)
mbr[512-1] = 0xaa;
write_block(fd, 0, mbr, d1->sector_size);
if (d1->bootmgr && d1->bootmgr_size > d1->sector_size)
for(i = 1; i * d1->sector_size <= d1->bootmgr_size; i++)
write_block(fd, i, &d1->bootmgr[i * d1->sector_size], d1->sector_size);
for (i = 1; i * d1->sector_size <= d1->bootmgr_size; i++)
write_block(fd, i, &d1->bootmgr[i * d1->sector_size],
d1->sector_size);
close(fd);
return 0;

22
lib/libdisk/write_ia64_disk.c
View File

@ -23,8 +23,10 @@ __FBSDID("$FreeBSD$");
#include <paths.h>
#include "libdisk.h"
/* XXX: A lot of hardcoded 512s probably should be foo->sector_size;
I'm not sure which, so I leave it like it worked before. --schweikh */
/*
* XXX: A lot of hardcoded 512s probably should be foo->sector_size;
* I'm not sure which, so I leave it like it worked before. --schweikh
*/
static int
Write_FreeBSD(int fd, const struct disk *new, const struct chunk *c1)
{
@ -44,7 +46,7 @@ Write_FreeBSD(int fd, const struct disk *new, const struct chunk *c1)
dl = (struct disklabel *)(buf + 512 * LABELSECTOR + LABELOFFSET);
Fill_Disklabel(dl, new, NULL, c1);
for (i = 0; i < BBSIZE/512; i++) {
for (i = 0; i < BBSIZE / 512; i++) {
if (write_block(fd, i + c1->offset, buf + 512 * i, 512) != 0)
return (1);
}
@ -56,6 +58,7 @@ static void
Write_Int32(u_int32_t *p, u_int32_t v)
{
u_int8_t *bp = (u_int8_t *)p;
bp[0] = (v >> 0) & 0xff;
bp[1] = (v >> 8) & 0xff;
bp[2] = (v >> 16) & 0xff;
@ -75,7 +78,7 @@ Write_Disk(const struct disk *d1)
strcpy(device, _PATH_DEV);
strcat(device, d1->name);
fd = open(device,O_RDWR);
fd = open(device, O_RDWR);
if (fd < 0)
return (1);
@ -83,7 +86,7 @@ Write_Disk(const struct disk *d1)
mbr = read_block(fd, 0, 512);
if (mbr == NULL)
goto fail;
dp = (struct dos_partition*)(mbr + DOSPARTOFF);
dp = (struct dos_partition *)(mbr + DOSPARTOFF);
memcpy(work, dp, sizeof(work));
dp = work;
free(mbr);
@ -102,7 +105,7 @@ Write_Disk(const struct disk *d1)
Write_Int32(&dp[j].dp_start, c1->offset);
Write_Int32(&dp[j].dp_size, c1->size);
i = 1024*d1->bios_sect*d1->bios_hd;
i = 1024 * d1->bios_sect * d1->bios_hd;
if (i == 0 || c1->offset >= i) {
/* Start */
dp[j].dp_ssect = 0xff;
@ -138,11 +141,10 @@ Write_Disk(const struct disk *d1)
i -= dp[j].dp_ecyl;
dp[j].dp_esect |= i >> 2;
}
#ifdef DEBUG
printf("S:%lu = (%x/%x/%x) E:%lu = (%x/%x/%x)\n", c1->offset,
dp[j].dp_scyl, dp[j].dp_shd, dp[j].dp_ssect, c1->end,
dp[j].dp_ecyl, dp[j].dp_ehd, dp[j].dp_esect);
dp[j].dp_scyl, dp[j].dp_shd, dp[j].dp_ssect, c1->end,
dp[j].dp_ecyl, dp[j].dp_ehd, dp[j].dp_esect);
#endif
dp[j].dp_typ = c1->subtype;
@ -152,7 +154,7 @@ Write_Disk(const struct disk *d1)
dp[j].dp_flag = 0;
}
for(i = 0; i < NDOSPART; i++) {
for (i = 0; i < NDOSPART; i++) {
if (!s[i])
memset(dp + i, 0, sizeof(*dp));
}

72
lib/libdisk/write_pc98_disk.c
View File

@ -25,56 +25,55 @@ __FBSDID("$FreeBSD$");
#include <paths.h>
#include "libdisk.h"
/* XXX: A lot of hardcoded 512s probably should be foo->sector_size;
I'm not sure which, so I leave it like it worked before. --schweikh */
/*
* XXX: A lot of hardcoded 512s probably should be foo->sector_size;
* I'm not sure which, so I leave it like it worked before. --schweikh
*/
static int
Write_FreeBSD(int fd, const struct disk *new, const struct disk *old, const struct chunk *c1)
Write_FreeBSD(int fd, const struct disk *new, const struct disk *old,
const struct chunk *c1)
{
struct disklabel *dl;
int i;
void *p;
u_char buf[BBSIZE];
for(i = 0; i < BBSIZE/512; i++) {
for (i = 0; i < BBSIZE / 512; i++) {
p = read_block(fd, i + c1->offset, 512);
memcpy(buf + 512 * i, p, 512);
free(p);
}
if(new->boot1)
if (new->boot1)
memcpy(buf, new->boot1, 512);
if(new->boot2)
memcpy(buf + 512, new->boot2, BBSIZE-512);
if (new->boot2)
memcpy(buf + 512, new->boot2, BBSIZE - 512);
dl = (struct disklabel *)(buf + 512 * LABELSECTOR + LABELOFFSET);
Fill_Disklabel(dl, new, old, c1);
for(i=0;i<BBSIZE/512;i++) {
for (i = 0; i < BBSIZE / 512; i++)
write_block(fd, i + c1->offset, buf + 512 * i, 512);
}
return 0;
}
int
Write_Disk(const struct disk *d1)
{
int fd,i;
int j;
struct disk *old = 0;
int fd, i, j;
struct disk *old = NULL;
struct chunk *c1;
int ret = 0;
char device[64];
u_char *mbr;
struct dos_partition *dp,work[NDOSPART];
struct dos_partition *dp, work[NDOSPART];
int s[7];
int PC98_EntireDisk = 0;
strcpy(device,_PATH_DEV);
strcat(device,d1->name);
strcpy(device, _PATH_DEV);
strcat(device, d1->name);
/* XXX - for entire FreeBSD(98) */
for (c1 = d1->chunks->part; c1; c1 = c1->next) {
@ -82,23 +81,25 @@ Write_Disk(const struct disk *d1)
device[9] = 0;
}
fd = open(device,O_RDWR);
if (fd < 0) {
fd = open(device, O_RDWR);
if (fd < 0) {
#ifdef DEBUG
warn("open(%s) failed", device);
warn("open(%s) failed", device);
#endif
return 1;
}
return 1;
}
memset(s,0,sizeof s);
memset(s, 0, sizeof s);
mbr = read_block(fd, 1, d1->sector_size);
dp = (struct dos_partition*)(mbr + DOSPARTOFF);
dp = (struct dos_partition *)(mbr + DOSPARTOFF);
memcpy(work, dp, sizeof work);
dp = work;
free(mbr);
for (c1 = d1->chunks->part; c1; c1 = c1->next) {
if (c1->type == unused) continue;
if (!strcmp(c1->name, "X")) continue;
if (c1->type == unused)
continue;
if (!strcmp(c1->name, "X"))
continue;
j = c1->name[strlen(d1->name) + 1] - '1';
if (j < 0 || j > 7)
continue;
@ -106,7 +107,6 @@ Write_Disk(const struct disk *d1)
if (c1->type == freebsd)
ret += Write_FreeBSD(fd, d1, old, c1);
i = c1->offset;
dp[j].dp_ssect = dp[j].dp_ipl_sct = i % d1->bios_sect;
i -= dp[j].dp_ssect;
@ -115,10 +115,9 @@ Write_Disk(const struct disk *d1)
i -= dp[j].dp_shd;
i /= d1->bios_hd;
dp[j].dp_scyl = dp[j].dp_ipl_cyl = i;
#ifdef DEBUG
printf("S:%lu = (%x/%x/%x)",
c1->offset, dp[j].dp_scyl, dp[j].dp_shd, dp[j].dp_ssect);
printf("S:%lu = (%x/%x/%x)", c1->offset,
dp[j].dp_scyl, dp[j].dp_shd, dp[j].dp_ssect);
#endif
i = c1->end;
@ -129,15 +128,14 @@ Write_Disk(const struct disk *d1)
dp[j].dp_esect = i % d1->bios_sect;
i -= dp[j].dp_esect;
i /= d1->bios_sect;
dp[j].dp_ehd = i % d1->bios_hd;
dp[j].dp_ehd = i % d1->bios_hd;
i -= dp[j].dp_ehd;
i /= d1->bios_hd;
dp[j].dp_ecyl = i;
#endif
#ifdef DEBUG
printf(" E:%lu = (%x/%x/%x)\n",
c1->end, dp[j].dp_ecyl, dp[j].dp_ehd, dp[j].dp_esect);
printf(" E:%lu = (%x/%x/%x)\n", c1->end,
dp[j].dp_ecyl, dp[j].dp_ehd, dp[j].dp_esect);
#endif
dp[j].dp_mid = c1->subtype & 0xff;
@ -148,7 +146,7 @@ Write_Disk(const struct disk *d1)
strncpy(dp[j].dp_name, c1->sname, 16);
}
j = 0;
for(i = 0; i < NDOSPART; i++) {
for (i = 0; i < NDOSPART; i++) {
if (!s[i])
memset(dp + i, 0, sizeof *dp);
}
@ -168,7 +166,9 @@ Write_Disk(const struct disk *d1)
if (d1->bootmenu)
for (i = 0; i * d1->sector_size < d1->bootmenu_size; i++)
write_block(fd, 2 + i, &d1->bootmenu[i * d1->sector_size], d1->sector_size);
write_block(fd, 2 + i,
&d1->bootmenu[i * d1->sector_size],
d1->sector_size);
close(fd);
return 0;

18
lib/libdisk/write_sparc64_disk.c
View File

@ -36,10 +36,10 @@ Write_Disk(const struct disk *d1)
char device[64];
int fd;
strcpy(device,_PATH_DEV);
strcat(device,d1->name);
strcpy(device, _PATH_DEV);
strcat(device, d1->name);
fd = open(device,O_RDWR);
fd = open(device, O_RDWR);
if (fd < 0) {
warn("open(%s) failed", device);
return (1);
@ -57,14 +57,14 @@ Write_Disk(const struct disk *d1)
sl->sl_ntracks = d1->bios_hd;
if (c->size > 4999 * 1024 * 2) {
sprintf(sl->sl_text, "FreeBSD%luG cyl %u alt %u hd %u sec %u",
(c->size + 1024 * 1024) / (2 * 1024 * 1024),
sl->sl_ncylinders, sl->sl_acylinders,
sl->sl_ntracks, sl->sl_nsectors);
(c->size + 1024 * 1024) / (2 * 1024 * 1024),
sl->sl_ncylinders, sl->sl_acylinders,
sl->sl_ntracks, sl->sl_nsectors);
} else {
sprintf(sl->sl_text, "FreeBSD%luM cyl %u alt %u hd %u sec %u",
(c->size + 1024) / (2 * 1024),
sl->sl_ncylinders, sl->sl_acylinders,
sl->sl_ntracks, sl->sl_nsectors);
(c->size + 1024) / (2 * 1024),
sl->sl_ncylinders, sl->sl_acylinders,
sl->sl_ntracks, sl->sl_nsectors);
}
sl->sl_interleave = 1;
sl->sl_sparespercyl = 0;