summaryrefslogtreecommitdiff
path: root/src/libpart/core.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/libpart/core.c')
-rw-r--r--src/libpart/core.c289
1 files changed, 289 insertions, 0 deletions
diff --git a/src/libpart/core.c b/src/libpart/core.c
new file mode 100644
index 0000000..030104d
--- /dev/null
+++ b/src/libpart/core.c
@@ -0,0 +1,289 @@
+/*
+ * <part.c>
+ *
+ * Open Hack'Ware BIOS partitions management
+ *
+ * Copyright (c) 2004-2005 Jocelyn Mayer
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License V2
+ * as published by the Free Software Foundation
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "bios.h"
+#include "libpart.h"
+
+/* Bootable partitions detection and management */
+part_t *part_open (bloc_device_t *bd,
+ uint32_t start, uint32_t size, uint32_t spb)
+{
+ part_t *part;
+
+ if (bd_seek(bd, (start + size) * spb, 0) < 0)
+ return NULL;
+ part = malloc(sizeof(part_t));
+ if (part == NULL)
+ return NULL;
+ part->bd = bd;
+ part->start = start;
+ part->size = size;
+ part->spb = spb;
+
+ return part;
+}
+
+int part_seek (part_t *part, uint32_t bloc, uint32_t pos)
+{
+ if (bloc > part->size) {
+ ERROR("bloc: %d part size: %d %p\n", bloc, part->size, part);
+ return -1;
+ }
+ bloc += part->start;
+ if (part->spb != 0) {
+ bloc *= part->spb;
+ pos = pos % part->bloc_size;
+ } else {
+ pos += (bloc % part->bps) * part->bloc_size;
+ bloc /= part->bps;
+ }
+
+ return bd_seek(part->bd, bloc, pos);
+}
+
+int part_read (part_t *part, void *buffer, int len)
+{
+ return bd_read(part->bd, buffer, len);
+}
+
+int part_write (part_t *part, const void *buffer, int len)
+{
+ return bd_write(part->bd, buffer, len);
+}
+
+void part_close (part_t *part)
+{
+ part->size = 0;
+}
+
+uint32_t part_blocsize (part_t *part)
+{
+ return part->bloc_size;
+}
+
+uint32_t part_flags (part_t *part)
+{
+ return part->flags;
+}
+
+uint32_t part_size (part_t *part)
+{
+ return part->size;
+}
+
+fs_t *part_fs (part_t *part)
+{
+ return part->fs;
+}
+
+void part_private_set (part_t *part, void *private)
+{
+ part->private = private;
+}
+
+void *part_private_get (part_t *part)
+{
+ return part->private;
+}
+
+void part_set_blocsize (bloc_device_t *bd, part_t *part, uint32_t blocsize)
+{
+ uint32_t seclen;
+
+ part->bloc_size = blocsize;
+ seclen = bd_seclen(bd);
+ if (blocsize < seclen) {
+ part->spb = 0;
+ part->bps = bd_seclen(bd) / part->bloc_size;
+ DPRINTF("%d part blocs in one sector (%d %d)\n", part->bps,
+ part->bloc_size, bd_seclen(bd));
+ } else {
+ part->spb = part->bloc_size / bd_seclen(bd);
+ part->bps = 0;
+ DPRINTF("%d sectors in one part bloc (%d %d)\n", part->spb,
+ part->bloc_size, bd_seclen(bd));
+ }
+}
+
+int part_register (bloc_device_t *bd, part_t *partition,
+ const unsigned char *name)
+{
+ part_t **cur;
+
+ DPRINTF("Register partition '%s'\n", name);
+ partition->bd = bd;
+ partition->next = NULL;
+ partition->name = strdup(name);
+ for (cur = _bd_parts(bd); *cur != NULL; cur = &(*cur)->next)
+ continue;
+ *cur = partition;
+
+ return 0;
+}
+
+static inline int set_boot_part (bloc_device_t *bd, int partnum)
+{
+ part_t *cur;
+
+ cur = part_get(bd, partnum);
+ if (cur == NULL)
+ return -1;
+ bd_set_boot_part(bd, cur);
+
+ return 0;
+}
+
+part_t *part_get (bloc_device_t *bd, int partnum)
+{
+ part_t **listp, *cur;
+ int i;
+
+ listp = _bd_parts(bd);
+ cur = *listp;
+ for (i = 0; i != partnum; i++) {
+ if (cur == NULL)
+ break;
+ cur = cur->next;
+ }
+
+ return cur;
+}
+
+part_t *part_get_raw (bloc_device_t *bd)
+{
+ part_t *part;
+ uint32_t seclen;
+
+ part = malloc(sizeof(part_t));
+ part->start = 0;
+ seclen = bd_seclen(bd);
+ part->size = bd_maxbloc(bd);
+ if (seclen > 512) {
+ part->size *= seclen / 512;
+ } else {
+ part->size *= 512 / seclen;
+ }
+ part->boot_start.bloc = 0;
+ part->boot_start.offset = 0;
+ part->boot_size.bloc = part->size;
+ part->boot_size.offset = 0;
+ part->boot_load = 0;
+ part->boot_entry = 0;
+ part_set_blocsize(bd, part, 512);
+ part->bd = bd;
+ part->flags = PART_TYPE_RAW | PART_FLAG_BOOT;
+ part_register(bd, part, "Raw");
+
+ return part;
+}
+
+part_t *part_probe (bloc_device_t *bd, int set_raw)
+{
+ part_t *part0, *boot_part, **cur;
+
+ /* Register the 0 partition: raw partition containing the whole disk */
+ part0 = part_get_raw(bd);
+ /* Try to find a valid boot partition */
+ boot_part = Apple_probe_partitions(bd);
+ if (boot_part == NULL) {
+ boot_part = isofs_probe_partitions(bd);
+ if (boot_part == NULL && arch == ARCH_PREP)
+ boot_part = PREP_find_partition(bd);
+ if (boot_part == NULL && set_raw != 0) {
+ boot_part = part0;
+ set_boot_part(bd, 0);
+ }
+ }
+ /* Probe filesystem on each found partition */
+ for (cur = _bd_parts(bd); *cur != NULL; cur = &(*cur)->next) {
+ const unsigned char *map, *type;
+ switch ((*cur)->flags & 0x0F) {
+ case PART_TYPE_PREP:
+ map = "PREP";
+ break;
+ case PART_TYPE_APPLE:
+ map = "Apple";
+ break;
+ case PART_TYPE_ISO9660:
+ map = "ISO9660";
+ break;
+ default:
+ map = "Raw";
+ break;
+ }
+ switch ((*cur)->flags & 0xF0) {
+ case PART_FLAG_DUMMY:
+ type = "dummy";
+ break;
+ case PART_FLAG_DRIVER:
+ type = "driver";
+ break;
+ case PART_FLAG_PATCH:
+ type = "patches";
+ break;
+ case PART_FLAG_FS:
+ type = "filesystem";
+ break;
+ default:
+ type = "unknown";
+ break;
+ }
+ DPRINTF("Probe filesystem on %s %s partition '%s' %s\n",
+ type, map, (*cur)->name,
+ ((*cur)->flags) & PART_FLAG_BOOT ? "(bootable)" : "");
+ if (((*cur)->flags) & PART_FLAG_FS) {
+ if (((*cur)->flags) & PART_FLAG_BOOT)
+ (*cur)->fs = fs_probe(*cur, 1);
+ else
+ (*cur)->fs = fs_probe(*cur, 0);
+ } else {
+ (*cur)->fs = fs_probe(*cur, 2);
+ }
+ if (((*cur)->flags) & PART_FLAG_BOOT) {
+ bd_set_boot_part(bd, *cur);
+ fs_get_bootfile((*cur)->fs);
+ }
+ }
+ DPRINTF("Boot partition: %p %p %p %p\n", boot_part, boot_part->fs,
+ part_fs(boot_part), part0);
+
+ return boot_part;
+}
+
+int part_set_boot_file (part_t *part, uint32_t start, uint32_t offset,
+ uint32_t size)
+{
+ part->boot_start.bloc = start;
+ part->boot_start.offset = offset;
+ part->boot_size.bloc = size;
+ part->boot_size.offset = 0;
+ part->boot_load = 0;
+ part->boot_entry = 0;
+
+ return 0;
+}
+
+unsigned int part_get_entry (part_t *part)
+{
+ return part->boot_entry;
+}
View Lorry Controller Status