//
// Routines
//
int
dump(char *name)
{
partition_map_header *map;
int junk;
map = open_partition_map(name, &junk, 0);
if (map == NULL) {
//error(-1, "No partition map in '%s'", name);
return 0;
}
dump_partition_map(map, 1);
close_partition_map(map);
return 1;
}
//
// Edit the file
//
void
edit(char *name, int ask_logical_size)
{
partition_map_header *map;
int command;
int order;
int get_type;
int valid_file;
map = open_partition_map(name, &valid_file, ask_logical_size);
if (!valid_file) {
return;
}
printf("Edit %s -\n", name);
#if 0 /* this check is not found in linux fdisk-0.1 */
if (map != NULL && map->blocks_in_map > MAX_LINUX_MAP) {
error(-1, "Map contains more than %d blocks - Linux may have trouble", MAX_LINUX_MAP);
}
#endif
while (get_command("Command (? for help): ", first_get, &command)) {
first_get = 0;
order = 1;
get_type = 0;
switch (command) {
case '?':
print_edit_notes();
// fall through
case 'H':
case 'h':
printf("Commands are:\n");
printf(" C (create with type also specified)\n");
printf(" c create new partition (standard unix root)\n");
printf(" d delete a partition\n");
printf(" h help\n");
printf(" i initialize partition map\n");
printf(" n (re)name a partition\n");
printf(" P (print ordered by base address)\n");
printf(" p print the partition table\n");
printf(" q quit editing\n");
printf(" r reorder partition entry in map\n");
printf(" s change size of partition map\n");
printf(" t change a partition's type\n");
if (!rflag) {
printf(" w write the partition table\n");
}
if (dflag) {
printf(" x extra extensions for experts\n");
}
break;
case 'P':
order = 0;
// fall through
case 'p':
dump_partition_map(map, order);
break;
case 'Q':
case 'q':
if (map && map->changed) {
if (get_okay("Discard changes? [n/y]: ", 0) != 1) {
break;
}
}
flush_to_newline(1);
goto finis;
break;
case 'I':
case 'i':
map = init_partition_map(name, map);
break;
case 'C':
get_type = 1;
// fall through
case 'c':
do_create_partition(map, get_type);
break;
case 'N':
case 'n':
do_rename_partition(map);
break;
case 'D':
case 'd':
do_delete_partition(map);
break;
case 'R':
case 'r':
do_reorder(map);
break;
case 'S':
case 's':
do_change_map_size(map);
break;
case 'T':
case 't':
do_change_type(map);
break;
case 'X':
case 'x':
if (!dflag) {
goto do_error;
} else if (do_expert(map, name)) {
flush_to_newline(1);
goto finis;
}
break;
case 'W':
case 'w':
if (!rflag) {
do_write_partition_map(map);
} else {
goto do_error;
}
break;
default:
do_error:
bad_input("No such command (%c)", command);
break;
}
}
finis:
close_partition_map(map);
}
int
do_expert(partition_map_header *map, char *name)
{
int command;
int quit = 0;
while (get_command("Expert command (? for help): ", first_get, &command)) {
first_get = 0;
switch (command) {
case '?':
print_expert_notes();
// fall through
case 'H':
case 'h':
printf("Commands are:\n");
printf(" h print help\n");
printf(" d dump block n\n");
printf(" p print the partition table\n");
if (dflag) {
printf(" P (show data structures - debugging)\n");
}
printf(" f full display of nth entry\n");
printf(" v validate map\n");
printf(" e examine patch partition\n");
printf(" q return to main edit menu\n");
printf(" Q quit editing\n");
break;
case 'q':
flush_to_newline(1);
goto finis;
break;
case 'Q':
if (map->changed) {
if (get_okay("Discard changes? [n/y]: ", 0) != 1) {
break;
}
}
quit = 1;
goto finis;
break;
case 'P':
if (dflag) {
show_data_structures(map);
break;
}
// fall through
case 'p':
dump_partition_map(map, 1);
break;
case 'D':
case 'd':
do_display_block(map, name);
break;
case 'F':
case 'f':
do_display_entry(map);
break;
case 'V':
case 'v':
validate_map(map);
break;
case 'E':
case 'e':
do_examine_patch_partition(map);
break;
default:
bad_input("No such command (%c)", command);
break;
}
}
finis:
return quit;
}
// main
int
main(int argc, const char *const *argv)
{
kArgc = argc;
kArgv = argv;
if (argc < 2)
print_usage_and_exit(true);
// parameters
const char **files = new const char*[argc];
int fileCount = 0;
bool dryRun = false;
off_t startOffset = 0;
// parse arguments
for (int argi = 1; argi < argc;) {
const char *arg = argv[argi++];
if (arg[0] == '-') {
if (strcmp(arg, "-h") == 0 || strcmp(arg, "--help") == 0) {
print_usage_and_exit(false);
} else if (strcmp(arg, "--dry-run") == 0) {
dryRun = true;
} else if (strcmp(arg, "-alert") == 0) {
// ignore
} else if (strcmp(arg, "-full") == 0) {
// ignore
} else if (strcmp(arg, "--start-offset") == 0) {
if (argi >= argc)
print_usage_and_exit(true);
startOffset = strtoll(argv[argi++], NULL, 0);
} else if (strcmp(arg, "-safe") == 0) {
fprintf(stderr, "Error: Sorry, BeOS R3 isn't supported!\n");
exit(1);
} else {
print_usage_and_exit(true);
}
} else {
files[fileCount++] = arg;
}
}
// we need at least one file
if (fileCount == 0)
print_usage_and_exit(true);
// read the boot code
uint8 *bootCodeData = NULL;
#ifndef __ANTARES__
bootCodeData = read_boot_code_data(argv[0]);
#else
image_info info;
if (find_own_image(&info) == B_OK)
bootCodeData = read_boot_code_data(info.name);
#endif
if (!bootCodeData) {
fprintf(stderr, "Error: Failed to read \n");
exit(1);
}
// iterate through the files and make them bootable
status_t error;
for (int i = 0; i < fileCount; i++) {
const char *fileName = files[i];
BEntry entry;
error = entry.SetTo(fileName, true);
if (error != B_OK) {
fprintf(stderr, "Error: Failed to open \"%s\": %s\n",
fileName, strerror(error));
exit(1);
}
// get stat to check the type of the file
struct stat st;
error = entry.GetStat(&st);
if (error != B_OK) {
fprintf(stderr, "Error: Failed to stat \"%s\": %s\n",
fileName, strerror(error));
exit(1);
}
bool noPartition = false;
int64 partitionOffset = 0;
fs_info info; // needs to be here (we use the device name later)
if (S_ISDIR(st.st_mode)) {
#if defined(__BEOS__) || defined(__ANTARES__)
// a directory: get the device
error = fs_stat_dev(st.st_dev, &info);
if (error != B_OK) {
fprintf(stderr, "Error: Failed to determine device for "
"\"%s\": %s\n", fileName, strerror(error));
exit(1);
}
fileName = info.device_name;
#else
(void)info;
fprintf(stderr, "Error: Specifying directories not supported "
"on this platform!\n");
exit(1);
#endif
} else if (S_ISREG(st.st_mode)) {
// a regular file: fine
noPartition = true;
} else if (S_ISCHR(st.st_mode)) {
// character special: a device or partition under BeOS
// or under FreeBSD
#if !(defined(__BEOS__) || defined(__ANTARES__)) && !defined(ANTARES_HOST_PLATFORM_FREEBSD)
fprintf(stderr, "Error: Character special devices not "
"supported on this platform.\n");
exit(1);
#endif
#ifdef ANTARES_HOST_PLATFORM_FREEBSD
// chop off the trailing number
int fileNameLen = strlen(fileName);
int baseNameLen = -1;
for (int k = fileNameLen - 1; k >= 0; k--) {
if (!isdigit(fileName[k])) {
baseNameLen = k + 1;
break;
}
}
// Remove de 's' from 'ad2s2' slice device (partition for DOS
// users) to get 'ad2' base device
baseNameLen--;
if (baseNameLen < 0) {
// only digits?
fprintf(stderr, "Error: Failed to get base device name.\n");
exit(1);
}
if (baseNameLen < fileNameLen) {
// get base device name and partition index
char baseDeviceName[B_PATH_NAME_LENGTH];
int partitionIndex = atoi(fileName + baseNameLen + 1);
// Don't forget the 's' of slice :)
memcpy(baseDeviceName, fileName, baseNameLen);
baseDeviceName[baseNameLen] = '\0';
// open base device
int baseFD = open(baseDeviceName, O_RDONLY);
if (baseFD < 0) {
fprintf(stderr, "Error: Failed to open \"%s\": %s\n",
baseDeviceName, strerror(errno));
exit(1);
}
// get device size
int64 deviceSize;
if (ioctl(baseFD, DIOCGMEDIASIZE, &deviceSize) == -1) {
fprintf(stderr, "Error: Failed to get device geometry "
"for \"%s\": %s\n", baseDeviceName,
strerror(errno));
exit(1);
}
// parse the partition map
// TODO: block size!
PartitionMapParser parser(baseFD, 0, deviceSize, 512);
PartitionMap map;
error = parser.Parse(NULL, &map);
if (error != B_OK) {
fprintf(stderr, "Error: Parsing partition table on "
"device \"%s\" failed: %s\n", baseDeviceName,
strerror(error));
exit(1);
}
close(baseFD);
// check the partition we are supposed to write at
Partition *partition = map.PartitionAt(partitionIndex - 1);
if (!partition || partition->IsEmpty()) {
fprintf(stderr, "Error: Invalid partition index %d.\n",
partitionIndex);
dump_partition_map(map);
exit(1);
}
if (partition->IsExtended()) {
fprintf(stderr, "Error: Partition %d is an extended "
"partition.\n", partitionIndex);
dump_partition_map(map);
exit(1);
}
partitionOffset = partition->Offset();
} else {
// The given device is the base device. We'll write at
// offset 0.
}
#endif // ANTARES_HOST_PLATFORM_FREEBSD
} else if (S_ISBLK(st.st_mode)) {
// block device: a device or partition under Linux or Darwin
#ifdef ANTARES_HOST_PLATFORM_LINUX
// chop off the trailing number
int fileNameLen = strlen(fileName);
int baseNameLen = -1;
for (int k = fileNameLen - 1; k >= 0; k--) {
if (!isdigit(fileName[k])) {
baseNameLen = k + 1;
break;
}
}
if (baseNameLen < 0) {
// only digits?
fprintf(stderr, "Error: Failed to get base device name.\n");
exit(1);
}
if (baseNameLen < fileNameLen) {
// get base device name and partition index
char baseDeviceName[B_PATH_NAME_LENGTH];
int partitionIndex = atoi(fileName + baseNameLen);
memcpy(baseDeviceName, fileName, baseNameLen);
baseDeviceName[baseNameLen] = '\0';
// open base device
int baseFD = open(baseDeviceName, O_RDONLY);
if (baseFD < 0) {
fprintf(stderr, "Error: Failed to open \"%s\": %s\n",
baseDeviceName, strerror(errno));
exit(1);
}
// get device size -- try BLKGETSIZE64, but, if it doesn't
// work, fall back to the obsolete HDIO_GETGEO
int64 deviceSize;
hd_geometry geometry;
if (ioctl(baseFD, BLKGETSIZE64, &deviceSize) == 0
&& deviceSize > 0) {
// looks good
} else if (ioctl(baseFD, HDIO_GETGEO, &geometry) == 0) {
deviceSize = (int64)geometry.heads * geometry.sectors
* geometry.cylinders * 512;
} else {
fprintf(stderr, "Error: Failed to get device geometry "
"for \"%s\": %s\n", baseDeviceName,
strerror(errno));
exit(1);
}
// parse the partition map
// TODO: block size!
PartitionMapParser parser(baseFD, 0, deviceSize, 512);
PartitionMap map;
error = parser.Parse(NULL, &map);
if (error != B_OK) {
fprintf(stderr, "Error: Parsing partition table on "
"device \"%s\" failed: %s\n", baseDeviceName,
strerror(error));
exit(1);
}
close(baseFD);
// check the partition we are supposed to write at
Partition *partition = map.PartitionAt(partitionIndex - 1);
if (!partition || partition->IsEmpty()) {
fprintf(stderr, "Error: Invalid partition index %d.\n",
partitionIndex);
dump_partition_map(map);
exit(1);
}
if (partition->IsExtended()) {
fprintf(stderr, "Error: Partition %d is an extended "
"partition.\n", partitionIndex);
dump_partition_map(map);
exit(1);
}
partitionOffset = partition->Offset();
} else {
// The given device is the base device. We'll write at
// offset 0.
}
#elif defined(ANTARES_HOST_PLATFORM_DARWIN)
// chop off the trailing number
int fileNameLen = strlen(fileName);
int baseNameLen = fileNameLen - 2;
// get base device name and partition index
char baseDeviceName[B_PATH_NAME_LENGTH];
int partitionIndex = atoi(fileName + baseNameLen + 1);
memcpy(baseDeviceName, fileName, baseNameLen);
baseDeviceName[baseNameLen] = '\0';
// open base device
int baseFD = open(baseDeviceName, O_RDONLY);
if (baseFD < 0) {
fprintf(stderr, "Error: Failed to open \"%s\": %s\n",
baseDeviceName, strerror(errno));
exit(1);
}
// get device size
int64 blockSize;
int64 blockCount;
int64 deviceSize;
if (ioctl(baseFD, DKIOCGETBLOCKSIZE, &blockSize) == -1) {
fprintf(stderr, "Error: Failed to get block size "
"for \"%s\": %s\n", baseDeviceName,
strerror(errno));
exit(1);
}
if (ioctl(baseFD, DKIOCGETBLOCKCOUNT, &blockCount) == -1) {
fprintf(stderr, "Error: Failed to get block count "
"for \"%s\": %s\n", baseDeviceName,
strerror(errno));
exit(1);
}
deviceSize = blockSize * blockCount;
// parse the partition map
PartitionMapParser parser(baseFD, 0, deviceSize, blockSize);
PartitionMap map;
error = parser.Parse(NULL, &map);
if (error != B_OK) {
fprintf(stderr, "Error: Parsing partition table on "
"device \"%s\" failed: %s\n", baseDeviceName,
strerror(error));
exit(1);
}
close(baseFD);
// check the partition we are supposed to write at
Partition *partition = map.PartitionAt(partitionIndex - 1);
if (!partition || partition->IsEmpty()) {
fprintf(stderr, "Error: Invalid partition index %d.\n",
partitionIndex);
dump_partition_map(map);
exit(1);
}
if (partition->IsExtended()) {
fprintf(stderr, "Error: Partition %d is an extended "
"partition.\n", partitionIndex);
dump_partition_map(map);
exit(1);
}
partitionOffset = partition->Offset();
#else
// partitions are block devices under Antares, but not under BeOS
#ifndef __ANTARES__
fprintf(stderr, "Error: Block devices not supported on this "
"platform!\n");
exit(1);
#endif // __ANTARES__
#endif
} else {
fprintf(stderr, "Error: File type of \"%s\" is not supported.\n",
fileName);
exit(1);
}
// open the file
int fd = open(fileName, O_RDWR);
if (fd < 0) {
fprintf(stderr, "Error: Failed to open \"%s\": %s\n", fileName,
strerror(errno));
exit(1);
}
#if (defined(__BEOS__) || defined(__ANTARES__))
// get a partition info
if (!noPartition
&& strlen(fileName) >= 3
&& strncmp("raw", fileName + strlen(fileName) - 3, 3)) {
partition_info partitionInfo;
if (ioctl(fd, B_GET_PARTITION_INFO, &partitionInfo,
sizeof(partitionInfo)) == 0) {
partitionOffset = partitionInfo.offset;
} else {
fprintf(stderr, "Error: Failed to get partition info: %s\n",
strerror(errno));
exit(1);
}
}
#endif // __BEOS__
// adjust the partition offset in the boot code data
// hard coded sector size: 512 bytes
*(uint32*)(bootCodeData + kPartitionOffsetOffset)
= B_HOST_TO_LENDIAN_INT32((uint32)(partitionOffset / 512));
// write the boot code
printf("Writing boot code to \"%s\" (partition offset: %" B_PRId64
" bytes, start offset = %" B_PRIdOFF ") "
"...\n", fileName, partitionOffset, startOffset);
write_boot_code_part(fileName, fd, startOffset, bootCodeData, 0,
kFirstBootCodePartSize, dryRun);
write_boot_code_part(fileName, fd, startOffset, bootCodeData,
kSecondBootCodePartOffset, kSecondBootCodePartSize,
dryRun);
#ifdef __ANTARES__
// check if this partition is mounted
BDiskDeviceRoster roster;
BPartition* partition;
BDiskDevice device;
status_t status = roster.GetPartitionForPath(fileName, &device,
&partition);
if (status != B_OK) {
status = roster.GetFileDeviceForPath(fileName, &device);
if (status == B_OK)
partition = &device;
}
if (status == B_OK && partition->IsMounted() && !dryRun) {
// This partition is mounted, we need to tell BFS to update its
// boot block (we are using part of the same logical block).
BPath path;
status = partition->GetMountPoint(&path);
if (status == B_OK) {
update_boot_block update;
update.offset = kSecondBootCodePartOffset - 512;
update.data = bootCodeData + kSecondBootCodePartOffset;
update.length = kSecondBootCodePartSize;
int mountFD = open(path.Path(), O_RDONLY);
if (ioctl(mountFD, BFS_IOCTL_UPDATE_BOOT_BLOCK, &update,
sizeof(update_boot_block)) != 0) {
fprintf(stderr, "Could not update BFS boot block: %s\n",
strerror(errno));
}
close(mountFD);
} else {
fprintf(stderr, "Could not update BFS boot code while the "
"partition is mounted!\n");
}
}
#endif // __ANTARES__
close(fd);
}
return 0;
}
