partitions: fix sometimes unreadable partition strings

Fix this garbage happening quite often:

==>	 sda:
	scsi 3:0:0:0: CD-ROM            TOSHIBA
==>	 sda1 sda2 sda3 sda4 <sr0: scsi3-mmc drive: 24x/24x writer dvd-ram cd/rw xa/form2 cdda tray
			    ^^^
	Uniform CD-ROM driver Revision: 3.20
	sr 3:0:0:0: Attached scsi CD-ROM sr0
==>	 sda5 sda6 sda7 >

Make "sda: sda1 ..." lines actually lines.

Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Alexey Dobriyan 2010-08-10 18:03:14 -07:00 committed by Linus Torvalds
parent ecd6269174
commit 9c867fbe06
16 changed files with 136 additions and 72 deletions

View File

@ -45,8 +45,11 @@ adfs_partition(struct parsed_partitions *state, char *name, char *data,
nr_sects = (le32_to_cpu(dr->disc_size_high) << 23) | nr_sects = (le32_to_cpu(dr->disc_size_high) << 23) |
(le32_to_cpu(dr->disc_size) >> 9); (le32_to_cpu(dr->disc_size) >> 9);
if (name) if (name) {
printk(" [%s]", name); strlcat(state->pp_buf, " [", PAGE_SIZE);
strlcat(state->pp_buf, name, PAGE_SIZE);
strlcat(state->pp_buf, "]", PAGE_SIZE);
}
put_partition(state, slot, first_sector, nr_sects); put_partition(state, slot, first_sector, nr_sects);
return dr; return dr;
} }
@ -81,14 +84,14 @@ static int riscix_partition(struct parsed_partitions *state,
if (!rr) if (!rr)
return -1; return -1;
printk(" [RISCiX]"); strlcat(state->pp_buf, " [RISCiX]", PAGE_SIZE);
if (rr->magic == RISCIX_MAGIC) { if (rr->magic == RISCIX_MAGIC) {
unsigned long size = nr_sects > 2 ? 2 : nr_sects; unsigned long size = nr_sects > 2 ? 2 : nr_sects;
int part; int part;
printk(" <"); strlcat(state->pp_buf, " <", PAGE_SIZE);
put_partition(state, slot++, first_sect, size); put_partition(state, slot++, first_sect, size);
for (part = 0; part < 8; part++) { for (part = 0; part < 8; part++) {
@ -97,11 +100,13 @@ static int riscix_partition(struct parsed_partitions *state,
put_partition(state, slot++, put_partition(state, slot++,
le32_to_cpu(rr->part[part].start), le32_to_cpu(rr->part[part].start),
le32_to_cpu(rr->part[part].length)); le32_to_cpu(rr->part[part].length));
printk("(%s)", rr->part[part].name); strlcat(state->pp_buf, "(", PAGE_SIZE);
strlcat(state->pp_buf, rr->part[part].name, PAGE_SIZE);
strlcat(state->pp_buf, ")", PAGE_SIZE);
} }
} }
printk(" >\n"); strlcat(state->pp_buf, " >\n", PAGE_SIZE);
} else { } else {
put_partition(state, slot++, first_sect, nr_sects); put_partition(state, slot++, first_sect, nr_sects);
} }
@ -131,7 +136,7 @@ static int linux_partition(struct parsed_partitions *state,
struct linux_part *linuxp; struct linux_part *linuxp;
unsigned long size = nr_sects > 2 ? 2 : nr_sects; unsigned long size = nr_sects > 2 ? 2 : nr_sects;
printk(" [Linux]"); strlcat(state->pp_buf, " [Linux]", PAGE_SIZE);
put_partition(state, slot++, first_sect, size); put_partition(state, slot++, first_sect, size);
@ -139,7 +144,7 @@ static int linux_partition(struct parsed_partitions *state,
if (!linuxp) if (!linuxp)
return -1; return -1;
printk(" <"); strlcat(state->pp_buf, " <", PAGE_SIZE);
while (linuxp->magic == cpu_to_le32(LINUX_NATIVE_MAGIC) || while (linuxp->magic == cpu_to_le32(LINUX_NATIVE_MAGIC) ||
linuxp->magic == cpu_to_le32(LINUX_SWAP_MAGIC)) { linuxp->magic == cpu_to_le32(LINUX_SWAP_MAGIC)) {
if (slot == state->limit) if (slot == state->limit)
@ -149,7 +154,7 @@ static int linux_partition(struct parsed_partitions *state,
le32_to_cpu(linuxp->nr_sects)); le32_to_cpu(linuxp->nr_sects));
linuxp ++; linuxp ++;
} }
printk(" >"); strlcat(state->pp_buf, " >", PAGE_SIZE);
put_dev_sector(sect); put_dev_sector(sect);
return slot; return slot;
@ -294,7 +299,7 @@ int adfspart_check_ADFS(struct parsed_partitions *state)
break; break;
} }
} }
printk("\n"); strlcat(state->pp_buf, "\n", PAGE_SIZE);
return 1; return 1;
} }
#endif #endif
@ -367,7 +372,7 @@ int adfspart_check_ICS(struct parsed_partitions *state)
return 0; return 0;
} }
printk(" [ICS]"); strlcat(state->pp_buf, " [ICS]", PAGE_SIZE);
for (slot = 1, p = (const struct ics_part *)data; p->size; p++) { for (slot = 1, p = (const struct ics_part *)data; p->size; p++) {
u32 start = le32_to_cpu(p->start); u32 start = le32_to_cpu(p->start);
@ -401,7 +406,7 @@ int adfspart_check_ICS(struct parsed_partitions *state)
} }
put_dev_sector(sect); put_dev_sector(sect);
printk("\n"); strlcat(state->pp_buf, "\n", PAGE_SIZE);
return 1; return 1;
} }
#endif #endif
@ -461,7 +466,7 @@ int adfspart_check_POWERTEC(struct parsed_partitions *state)
return 0; return 0;
} }
printk(" [POWERTEC]"); strlcat(state->pp_buf, " [POWERTEC]", PAGE_SIZE);
for (i = 0, p = (const struct ptec_part *)data; i < 12; i++, p++) { for (i = 0, p = (const struct ptec_part *)data; i < 12; i++, p++) {
u32 start = le32_to_cpu(p->start); u32 start = le32_to_cpu(p->start);
@ -472,7 +477,7 @@ int adfspart_check_POWERTEC(struct parsed_partitions *state)
} }
put_dev_sector(sect); put_dev_sector(sect);
printk("\n"); strlcat(state->pp_buf, "\n", PAGE_SIZE);
return 1; return 1;
} }
#endif #endif
@ -543,7 +548,7 @@ int adfspart_check_EESOX(struct parsed_partitions *state)
size = get_capacity(state->bdev->bd_disk); size = get_capacity(state->bdev->bd_disk);
put_partition(state, slot++, start, size - start); put_partition(state, slot++, start, size - start);
printk("\n"); strlcat(state->pp_buf, "\n", PAGE_SIZE);
} }
return i ? 1 : 0; return i ? 1 : 0;

View File

@ -69,7 +69,13 @@ int amiga_partition(struct parsed_partitions *state)
/* blksize is blocks per 512 byte standard block */ /* blksize is blocks per 512 byte standard block */
blksize = be32_to_cpu( rdb->rdb_BlockBytes ) / 512; blksize = be32_to_cpu( rdb->rdb_BlockBytes ) / 512;
printk(" RDSK (%d)", blksize * 512); /* Be more informative */ {
char tmp[7 + 10 + 1 + 1];
/* Be more informative */
snprintf(tmp, sizeof(tmp), " RDSK (%d)", blksize * 512);
strlcat(state->pp_buf, tmp, PAGE_SIZE);
}
blk = be32_to_cpu(rdb->rdb_PartitionList); blk = be32_to_cpu(rdb->rdb_PartitionList);
put_dev_sector(sect); put_dev_sector(sect);
for (part = 1; blk>0 && part<=16; part++, put_dev_sector(sect)) { for (part = 1; blk>0 && part<=16; part++, put_dev_sector(sect)) {
@ -106,23 +112,27 @@ int amiga_partition(struct parsed_partitions *state)
{ {
/* Be even more informative to aid mounting */ /* Be even more informative to aid mounting */
char dostype[4]; char dostype[4];
char tmp[42];
__be32 *dt = (__be32 *)dostype; __be32 *dt = (__be32 *)dostype;
*dt = pb->pb_Environment[16]; *dt = pb->pb_Environment[16];
if (dostype[3] < ' ') if (dostype[3] < ' ')
printk(" (%c%c%c^%c)", snprintf(tmp, sizeof(tmp), " (%c%c%c^%c)",
dostype[0], dostype[1], dostype[0], dostype[1],
dostype[2], dostype[3] + '@' ); dostype[2], dostype[3] + '@' );
else else
printk(" (%c%c%c%c)", snprintf(tmp, sizeof(tmp), " (%c%c%c%c)",
dostype[0], dostype[1], dostype[0], dostype[1],
dostype[2], dostype[3]); dostype[2], dostype[3]);
printk("(res %d spb %d)", strlcat(state->pp_buf, tmp, PAGE_SIZE);
snprintf(tmp, sizeof(tmp), "(res %d spb %d)",
be32_to_cpu(pb->pb_Environment[6]), be32_to_cpu(pb->pb_Environment[6]),
be32_to_cpu(pb->pb_Environment[4])); be32_to_cpu(pb->pb_Environment[4]));
strlcat(state->pp_buf, tmp, PAGE_SIZE);
} }
res = 1; res = 1;
} }
printk("\n"); strlcat(state->pp_buf, "\n", PAGE_SIZE);
rdb_done: rdb_done:
return res; return res;

View File

@ -62,7 +62,7 @@ int atari_partition(struct parsed_partitions *state)
} }
pi = &rs->part[0]; pi = &rs->part[0];
printk (" AHDI"); strlcat(state->pp_buf, " AHDI", PAGE_SIZE);
for (slot = 1; pi < &rs->part[4] && slot < state->limit; slot++, pi++) { for (slot = 1; pi < &rs->part[4] && slot < state->limit; slot++, pi++) {
struct rootsector *xrs; struct rootsector *xrs;
Sector sect2; Sector sect2;
@ -81,7 +81,7 @@ int atari_partition(struct parsed_partitions *state)
#ifdef ICD_PARTS #ifdef ICD_PARTS
part_fmt = 1; part_fmt = 1;
#endif #endif
printk(" XGM<"); strlcat(state->pp_buf, " XGM<", PAGE_SIZE);
partsect = extensect = be32_to_cpu(pi->st); partsect = extensect = be32_to_cpu(pi->st);
while (1) { while (1) {
xrs = read_part_sector(state, partsect, &sect2); xrs = read_part_sector(state, partsect, &sect2);
@ -120,14 +120,14 @@ int atari_partition(struct parsed_partitions *state)
break; break;
} }
} }
printk(" >"); strlcat(state->pp_buf, " >", PAGE_SIZE);
} }
#ifdef ICD_PARTS #ifdef ICD_PARTS
if ( part_fmt!=1 ) { /* no extended partitions -> test ICD-format */ if ( part_fmt!=1 ) { /* no extended partitions -> test ICD-format */
pi = &rs->icdpart[0]; pi = &rs->icdpart[0];
/* sanity check: no ICD format if first partition invalid */ /* sanity check: no ICD format if first partition invalid */
if (OK_id(pi->id)) { if (OK_id(pi->id)) {
printk(" ICD<"); strlcat(state->pp_buf, " ICD<", PAGE_SIZE);
for (; pi < &rs->icdpart[8] && slot < state->limit; slot++, pi++) { for (; pi < &rs->icdpart[8] && slot < state->limit; slot++, pi++) {
/* accept only GEM,BGM,RAW,LNX,SWP partitions */ /* accept only GEM,BGM,RAW,LNX,SWP partitions */
if (!((pi->flg & 1) && OK_id(pi->id))) if (!((pi->flg & 1) && OK_id(pi->id)))
@ -137,13 +137,13 @@ int atari_partition(struct parsed_partitions *state)
be32_to_cpu(pi->st), be32_to_cpu(pi->st),
be32_to_cpu(pi->siz)); be32_to_cpu(pi->siz));
} }
printk(" >"); strlcat(state->pp_buf, " >", PAGE_SIZE);
} }
} }
#endif #endif
put_dev_sector(sect); put_dev_sector(sect);
printk ("\n"); strlcat(state->pp_buf, "\n", PAGE_SIZE);
return 1; return 1;
} }

View File

@ -164,10 +164,16 @@ check_partition(struct gendisk *hd, struct block_device *bdev)
state = kzalloc(sizeof(struct parsed_partitions), GFP_KERNEL); state = kzalloc(sizeof(struct parsed_partitions), GFP_KERNEL);
if (!state) if (!state)
return NULL; return NULL;
state->pp_buf = (char *)__get_free_page(GFP_KERNEL);
if (!state->pp_buf) {
kfree(state);
return NULL;
}
state->pp_buf[0] = '\0';
state->bdev = bdev; state->bdev = bdev;
disk_name(hd, 0, state->name); disk_name(hd, 0, state->name);
printk(KERN_INFO " %s:", state->name); snprintf(state->pp_buf, PAGE_SIZE, " %s:", state->name);
if (isdigit(state->name[strlen(state->name)-1])) if (isdigit(state->name[strlen(state->name)-1]))
sprintf(state->name, "p"); sprintf(state->name, "p");
@ -185,17 +191,25 @@ check_partition(struct gendisk *hd, struct block_device *bdev)
} }
} }
if (res > 0) if (res > 0) {
printk(KERN_INFO "%s", state->pp_buf);
free_page((unsigned long)state->pp_buf);
return state; return state;
}
if (state->access_beyond_eod) if (state->access_beyond_eod)
err = -ENOSPC; err = -ENOSPC;
if (err) if (err)
/* The partition is unrecognized. So report I/O errors if there were any */ /* The partition is unrecognized. So report I/O errors if there were any */
res = err; res = err;
if (!res) if (!res)
printk(" unknown partition table\n"); strlcat(state->pp_buf, " unknown partition table\n", PAGE_SIZE);
else if (warn_no_part) else if (warn_no_part)
printk(" unable to read partition table\n"); strlcat(state->pp_buf, " unable to read partition table\n", PAGE_SIZE);
printk(KERN_INFO "%s", state->pp_buf);
free_page((unsigned long)state->pp_buf);
kfree(state); kfree(state);
return ERR_PTR(res); return ERR_PTR(res);
} }

View File

@ -16,6 +16,7 @@ struct parsed_partitions {
int next; int next;
int limit; int limit;
bool access_beyond_eod; bool access_beyond_eod;
char *pp_buf;
}; };
static inline void *read_part_sector(struct parsed_partitions *state, static inline void *read_part_sector(struct parsed_partitions *state,
@ -32,9 +33,12 @@ static inline void
put_partition(struct parsed_partitions *p, int n, sector_t from, sector_t size) put_partition(struct parsed_partitions *p, int n, sector_t from, sector_t size)
{ {
if (n < p->limit) { if (n < p->limit) {
char tmp[1 + BDEVNAME_SIZE + 10 + 1];
p->parts[n].from = from; p->parts[n].from = from;
p->parts[n].size = size; p->parts[n].size = size;
printk(" %s%d", p->name, n); snprintf(tmp, sizeof(tmp), " %s%d", p->name, n);
strlcat(p->pp_buf, tmp, PAGE_SIZE);
} }
} }

View File

@ -630,6 +630,6 @@ int efi_partition(struct parsed_partitions *state)
} }
kfree(ptes); kfree(ptes);
kfree(gpt); kfree(gpt);
printk("\n"); strlcat(state->pp_buf, "\n", PAGE_SIZE);
return 1; return 1;
} }

View File

@ -75,6 +75,7 @@ int ibm_partition(struct parsed_partitions *state)
unsigned char *data; unsigned char *data;
Sector sect; Sector sect;
sector_t labelsect; sector_t labelsect;
char tmp[64];
res = 0; res = 0;
blocksize = bdev_logical_block_size(bdev); blocksize = bdev_logical_block_size(bdev);
@ -144,13 +145,15 @@ int ibm_partition(struct parsed_partitions *state)
*/ */
blocksize = label->cms.block_size; blocksize = label->cms.block_size;
if (label->cms.disk_offset != 0) { if (label->cms.disk_offset != 0) {
printk("CMS1/%8s(MDSK):", name); snprintf(tmp, sizeof(tmp), "CMS1/%8s(MDSK):", name);
strlcat(state->pp_buf, tmp, PAGE_SIZE);
/* disk is reserved minidisk */ /* disk is reserved minidisk */
offset = label->cms.disk_offset; offset = label->cms.disk_offset;
size = (label->cms.block_count - 1) size = (label->cms.block_count - 1)
* (blocksize >> 9); * (blocksize >> 9);
} else { } else {
printk("CMS1/%8s:", name); snprintf(tmp, sizeof(tmp), "CMS1/%8s:", name);
strlcat(state->pp_buf, tmp, PAGE_SIZE);
offset = (info->label_block + 1); offset = (info->label_block + 1);
size = label->cms.block_count size = label->cms.block_count
* (blocksize >> 9); * (blocksize >> 9);
@ -159,7 +162,8 @@ int ibm_partition(struct parsed_partitions *state)
size-offset*(blocksize >> 9)); size-offset*(blocksize >> 9));
} else { } else {
if (strncmp(type, "LNX1", 4) == 0) { if (strncmp(type, "LNX1", 4) == 0) {
printk("LNX1/%8s:", name); snprintf(tmp, sizeof(tmp), "LNX1/%8s:", name);
strlcat(state->pp_buf, tmp, PAGE_SIZE);
if (label->lnx.ldl_version == 0xf2) { if (label->lnx.ldl_version == 0xf2) {
fmt_size = label->lnx.formatted_blocks fmt_size = label->lnx.formatted_blocks
* (blocksize >> 9); * (blocksize >> 9);
@ -178,7 +182,7 @@ int ibm_partition(struct parsed_partitions *state)
offset = (info->label_block + 1); offset = (info->label_block + 1);
} else { } else {
/* unlabeled disk */ /* unlabeled disk */
printk("(nonl)"); strlcat(tmp, sizeof(tmp), "(nonl)", PAGE_SIZE);
size = i_size >> 9; size = i_size >> 9;
offset = (info->label_block + 1); offset = (info->label_block + 1);
} }
@ -197,7 +201,8 @@ int ibm_partition(struct parsed_partitions *state)
* if not, something is wrong, skipping partition detection * if not, something is wrong, skipping partition detection
*/ */
if (strncmp(type, "VOL1", 4) == 0) { if (strncmp(type, "VOL1", 4) == 0) {
printk("VOL1/%8s:", name); snprintf(tmp, sizeof(tmp), "VOL1/%8s:", name);
strlcat(state->pp_buf, tmp, PAGE_SIZE);
/* /*
* get block number and read then go through format1 * get block number and read then go through format1
* labels * labels
@ -253,7 +258,7 @@ int ibm_partition(struct parsed_partitions *state)
} }
printk("\n"); strlcat(state->pp_buf, "\n", PAGE_SIZE);
goto out_freeall; goto out_freeall;

View File

@ -50,7 +50,7 @@ int karma_partition(struct parsed_partitions *state)
} }
slot++; slot++;
} }
printk("\n"); strlcat(state->pp_buf, "\n", PAGE_SIZE);
put_dev_sector(sect); put_dev_sector(sect);
return 1; return 1;
} }

View File

@ -643,7 +643,7 @@ static bool ldm_create_data_partitions (struct parsed_partitions *pp,
return false; return false;
} }
printk (" [LDM]"); strlcat(pp->pp_buf, " [LDM]", PAGE_SIZE);
/* Create the data partitions */ /* Create the data partitions */
list_for_each (item, &ldb->v_part) { list_for_each (item, &ldb->v_part) {
@ -658,7 +658,7 @@ static bool ldm_create_data_partitions (struct parsed_partitions *pp,
part_num++; part_num++;
} }
printk ("\n"); strlcat(pp->pp_buf, "\n", PAGE_SIZE);
return true; return true;
} }

View File

@ -59,7 +59,7 @@ int mac_partition(struct parsed_partitions *state)
put_dev_sector(sect); put_dev_sector(sect);
return 0; /* not a MacOS disk */ return 0; /* not a MacOS disk */
} }
printk(" [mac]"); strlcat(state->pp_buf, " [mac]", PAGE_SIZE);
blocks_in_map = be32_to_cpu(part->map_count); blocks_in_map = be32_to_cpu(part->map_count);
for (blk = 1; blk <= blocks_in_map; ++blk) { for (blk = 1; blk <= blocks_in_map; ++blk) {
int pos = blk * secsize; int pos = blk * secsize;
@ -128,6 +128,6 @@ int mac_partition(struct parsed_partitions *state)
#endif #endif
put_dev_sector(sect); put_dev_sector(sect);
printk("\n"); strlcat(state->pp_buf, "\n", PAGE_SIZE);
return 1; return 1;
} }

View File

@ -213,10 +213,18 @@ static void parse_solaris_x86(struct parsed_partitions *state,
put_dev_sector(sect); put_dev_sector(sect);
return; return;
} }
printk(" %s%d: <solaris:", state->name, origin); {
char tmp[1 + BDEVNAME_SIZE + 10 + 11 + 1];
snprintf(tmp, sizeof(tmp), " %s%d: <solaris:", state->name, origin);
strlcat(state->pp_buf, tmp, PAGE_SIZE);
}
if (le32_to_cpu(v->v_version) != 1) { if (le32_to_cpu(v->v_version) != 1) {
printk(" cannot handle version %d vtoc>\n", char tmp[64];
le32_to_cpu(v->v_version));
snprintf(tmp, sizeof(tmp), " cannot handle version %d vtoc>\n",
le32_to_cpu(v->v_version));
strlcat(state->pp_buf, tmp, PAGE_SIZE);
put_dev_sector(sect); put_dev_sector(sect);
return; return;
} }
@ -224,9 +232,12 @@ static void parse_solaris_x86(struct parsed_partitions *state,
max_nparts = le16_to_cpu (v->v_nparts) > 8 ? SOLARIS_X86_NUMSLICE : 8; max_nparts = le16_to_cpu (v->v_nparts) > 8 ? SOLARIS_X86_NUMSLICE : 8;
for (i=0; i<max_nparts && state->next<state->limit; i++) { for (i=0; i<max_nparts && state->next<state->limit; i++) {
struct solaris_x86_slice *s = &v->v_slice[i]; struct solaris_x86_slice *s = &v->v_slice[i];
char tmp[3 + 10 + 1 + 1];
if (s->s_size == 0) if (s->s_size == 0)
continue; continue;
printk(" [s%d]", i); snprintf(tmp, sizeof(tmp), " [s%d]", i);
strlcat(state->pp_buf, tmp, PAGE_SIZE);
/* solaris partitions are relative to current MS-DOS /* solaris partitions are relative to current MS-DOS
* one; must add the offset of the current partition */ * one; must add the offset of the current partition */
put_partition(state, state->next++, put_partition(state, state->next++,
@ -234,7 +245,7 @@ static void parse_solaris_x86(struct parsed_partitions *state,
le32_to_cpu(s->s_size)); le32_to_cpu(s->s_size));
} }
put_dev_sector(sect); put_dev_sector(sect);
printk(" >\n"); strlcat(state->pp_buf, " >\n", PAGE_SIZE);
#endif #endif
} }
@ -250,6 +261,7 @@ static void parse_bsd(struct parsed_partitions *state,
Sector sect; Sector sect;
struct bsd_disklabel *l; struct bsd_disklabel *l;
struct bsd_partition *p; struct bsd_partition *p;
char tmp[64];
l = read_part_sector(state, offset + 1, &sect); l = read_part_sector(state, offset + 1, &sect);
if (!l) if (!l)
@ -258,7 +270,9 @@ static void parse_bsd(struct parsed_partitions *state,
put_dev_sector(sect); put_dev_sector(sect);
return; return;
} }
printk(" %s%d: <%s:", state->name, origin, flavour);
snprintf(tmp, sizeof(tmp), " %s%d: <%s:", state->name, origin, flavour);
strlcat(state->pp_buf, tmp, PAGE_SIZE);
if (le16_to_cpu(l->d_npartitions) < max_partitions) if (le16_to_cpu(l->d_npartitions) < max_partitions)
max_partitions = le16_to_cpu(l->d_npartitions); max_partitions = le16_to_cpu(l->d_npartitions);
@ -275,16 +289,18 @@ static void parse_bsd(struct parsed_partitions *state,
/* full parent partition, we have it already */ /* full parent partition, we have it already */
continue; continue;
if (offset > bsd_start || offset+size < bsd_start+bsd_size) { if (offset > bsd_start || offset+size < bsd_start+bsd_size) {
printk("bad subpartition - ignored\n"); strlcat(state->pp_buf, "bad subpartition - ignored\n", PAGE_SIZE);
continue; continue;
} }
put_partition(state, state->next++, bsd_start, bsd_size); put_partition(state, state->next++, bsd_start, bsd_size);
} }
put_dev_sector(sect); put_dev_sector(sect);
if (le16_to_cpu(l->d_npartitions) > max_partitions) if (le16_to_cpu(l->d_npartitions) > max_partitions) {
printk(" (ignored %d more)", snprintf(tmp, sizeof(tmp), " (ignored %d more)",
le16_to_cpu(l->d_npartitions) - max_partitions); le16_to_cpu(l->d_npartitions) - max_partitions);
printk(" >\n"); strlcat(state->pp_buf, tmp, PAGE_SIZE);
}
strlcat(state->pp_buf, " >\n", PAGE_SIZE);
} }
#endif #endif
@ -333,7 +349,12 @@ static void parse_unixware(struct parsed_partitions *state,
put_dev_sector(sect); put_dev_sector(sect);
return; return;
} }
printk(" %s%d: <unixware:", state->name, origin); {
char tmp[1 + BDEVNAME_SIZE + 10 + 12 + 1];
snprintf(tmp, sizeof(tmp), " %s%d: <unixware:", state->name, origin);
strlcat(state->pp_buf, tmp, PAGE_SIZE);
}
p = &l->vtoc.v_slice[1]; p = &l->vtoc.v_slice[1];
/* I omit the 0th slice as it is the same as whole disk. */ /* I omit the 0th slice as it is the same as whole disk. */
while (p - &l->vtoc.v_slice[0] < UNIXWARE_NUMSLICE) { while (p - &l->vtoc.v_slice[0] < UNIXWARE_NUMSLICE) {
@ -347,7 +368,7 @@ static void parse_unixware(struct parsed_partitions *state,
p++; p++;
} }
put_dev_sector(sect); put_dev_sector(sect);
printk(" >\n"); strlcat(state->pp_buf, " >\n", PAGE_SIZE);
#endif #endif
} }
@ -376,8 +397,10 @@ static void parse_minix(struct parsed_partitions *state,
* the normal boot sector. */ * the normal boot sector. */
if (msdos_magic_present (data + 510) && if (msdos_magic_present (data + 510) &&
SYS_IND(p) == MINIX_PARTITION) { /* subpartition table present */ SYS_IND(p) == MINIX_PARTITION) { /* subpartition table present */
char tmp[1 + BDEVNAME_SIZE + 10 + 9 + 1];
printk(" %s%d: <minix:", state->name, origin); snprintf(tmp, sizeof(tmp), " %s%d: <minix:", state->name, origin);
strlcat(state->pp_buf, tmp, PAGE_SIZE);
for (i = 0; i < MINIX_NR_SUBPARTITIONS; i++, p++) { for (i = 0; i < MINIX_NR_SUBPARTITIONS; i++, p++) {
if (state->next == state->limit) if (state->next == state->limit)
break; break;
@ -386,7 +409,7 @@ static void parse_minix(struct parsed_partitions *state,
put_partition(state, state->next++, put_partition(state, state->next++,
start_sect(p), nr_sects(p)); start_sect(p), nr_sects(p));
} }
printk(" >\n"); strlcat(state->pp_buf, " >\n", PAGE_SIZE);
} }
put_dev_sector(sect); put_dev_sector(sect);
#endif /* CONFIG_MINIX_SUBPARTITION */ #endif /* CONFIG_MINIX_SUBPARTITION */
@ -425,7 +448,7 @@ int msdos_partition(struct parsed_partitions *state)
if (aix_magic_present(state, data)) { if (aix_magic_present(state, data)) {
put_dev_sector(sect); put_dev_sector(sect);
printk( " [AIX]"); strlcat(state->pp_buf, " [AIX]", PAGE_SIZE);
return 0; return 0;
} }
@ -446,7 +469,7 @@ int msdos_partition(struct parsed_partitions *state)
fb = (struct fat_boot_sector *) data; fb = (struct fat_boot_sector *) data;
if (slot == 1 && fb->reserved && fb->fats if (slot == 1 && fb->reserved && fb->fats
&& fat_valid_media(fb->media)) { && fat_valid_media(fb->media)) {
printk("\n"); strlcat(state->pp_buf, "\n", PAGE_SIZE);
put_dev_sector(sect); put_dev_sector(sect);
return 1; return 1;
} else { } else {
@ -491,21 +514,21 @@ int msdos_partition(struct parsed_partitions *state)
n = min(size, max(sector_size, n)); n = min(size, max(sector_size, n));
put_partition(state, slot, start, n); put_partition(state, slot, start, n);
printk(" <"); strlcat(state->pp_buf, " <", PAGE_SIZE);
parse_extended(state, start, size); parse_extended(state, start, size);
printk(" >"); strlcat(state->pp_buf, " >", PAGE_SIZE);
continue; continue;
} }
put_partition(state, slot, start, size); put_partition(state, slot, start, size);
if (SYS_IND(p) == LINUX_RAID_PARTITION) if (SYS_IND(p) == LINUX_RAID_PARTITION)
state->parts[slot].flags = ADDPART_FLAG_RAID; state->parts[slot].flags = ADDPART_FLAG_RAID;
if (SYS_IND(p) == DM6_PARTITION) if (SYS_IND(p) == DM6_PARTITION)
printk("[DM]"); strlcat(state->pp_buf, "[DM]", PAGE_SIZE);
if (SYS_IND(p) == EZD_PARTITION) if (SYS_IND(p) == EZD_PARTITION)
printk("[EZD]"); strlcat(state->pp_buf, "[EZD]", PAGE_SIZE);
} }
printk("\n"); strlcat(state->pp_buf, "\n", PAGE_SIZE);
/* second pass - output for each on a separate line */ /* second pass - output for each on a separate line */
p = (struct partition *) (0x1be + data); p = (struct partition *) (0x1be + data);

View File

@ -72,7 +72,7 @@ int osf_partition(struct parsed_partitions *state)
le32_to_cpu(partition->p_size)); le32_to_cpu(partition->p_size));
slot++; slot++;
} }
printk("\n"); strlcat(state->pp_buf, "\n", PAGE_SIZE);
put_dev_sector(sect); put_dev_sector(sect);
return 1; return 1;
} }

View File

@ -76,7 +76,7 @@ int sgi_partition(struct parsed_partitions *state)
} }
slot++; slot++;
} }
printk("\n"); strlcat(state->pp_buf, "\n", PAGE_SIZE);
put_dev_sector(sect); put_dev_sector(sect);
return 1; return 1;
} }

View File

@ -116,7 +116,7 @@ int sun_partition(struct parsed_partitions *state)
} }
slot++; slot++;
} }
printk("\n"); strlcat(state->pp_buf, "\n", PAGE_SIZE);
put_dev_sector(sect); put_dev_sector(sect);
return 1; return 1;
} }

View File

@ -54,6 +54,7 @@ int sysv68_partition(struct parsed_partitions *state)
unsigned char *data; unsigned char *data;
struct dkblk0 *b; struct dkblk0 *b;
struct slice *slice; struct slice *slice;
char tmp[64];
data = read_part_sector(state, 0, &sect); data = read_part_sector(state, 0, &sect);
if (!data) if (!data)
@ -73,7 +74,8 @@ int sysv68_partition(struct parsed_partitions *state)
return -1; return -1;
slices -= 1; /* last slice is the whole disk */ slices -= 1; /* last slice is the whole disk */
printk("sysV68: %s(s%u)", state->name, slices); snprintf(tmp, sizeof(tmp), "sysV68: %s(s%u)", state->name, slices);
strlcat(state->pp_buf, tmp, PAGE_SIZE);
slice = (struct slice *)data; slice = (struct slice *)data;
for (i = 0; i < slices; i++, slice++) { for (i = 0; i < slices; i++, slice++) {
if (slot == state->limit) if (slot == state->limit)
@ -82,11 +84,12 @@ int sysv68_partition(struct parsed_partitions *state)
put_partition(state, slot, put_partition(state, slot,
be32_to_cpu(slice->blkoff), be32_to_cpu(slice->blkoff),
be32_to_cpu(slice->nblocks)); be32_to_cpu(slice->nblocks));
printk("(s%u)", i); snprintf(tmp, sizeof(tmp), "(s%u)", i);
strlcat(state->pp_buf, tmp, PAGE_SIZE);
} }
slot++; slot++;
} }
printk("\n"); strlcat(state->pp_buf, "\n", PAGE_SIZE);
put_dev_sector(sect); put_dev_sector(sect);
return 1; return 1;
} }

View File

@ -39,7 +39,7 @@ int ultrix_partition(struct parsed_partitions *state)
label->pt_part[i].pi_blkoff, label->pt_part[i].pi_blkoff,
label->pt_part[i].pi_nblocks); label->pt_part[i].pi_nblocks);
put_dev_sector(sect); put_dev_sector(sect);
printk ("\n"); strlcat(state->pp_buf, "\n", PAGE_SIZE);
return 1; return 1;
} else { } else {
put_dev_sector(sect); put_dev_sector(sect);