pdisk/dist/validate.c

//
// validate.c -
//
// Written by Eryk Vershen
//

/*
 * Copyright 1997,1998 by Apple Computer, Inc.
 *              All Rights Reserved
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation for any purpose and without fee is hereby granted,
 * provided that the above copyright notice appears in all copies and
 * that both the copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * APPLE COMPUTER DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE.
 *
 * IN NO EVENT SHALL APPLE COMPUTER BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
 * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */


// for *printf()
#include <stdio.h>
// for malloc(), free()
#ifndef __linux__
#include <stdlib.h>
#else
#include <malloc.h>
#endif
// for O_RDONLY
#include <fcntl.h>
// for errno
#include <errno.h>
#include <inttypes.h>

#include "validate.h"
#include "deblock_media.h"
#include "pathname.h"
#include "convert.h"
#include "io.h"
#include "errors.h"


//
// Defines
//


//
// Types
//
enum range_state {
    kUnallocated,
    kAllocated,
    kMultiplyAllocated
};

struct range_list {
    struct range_list *next;
    struct range_list *prev;
    enum range_state state;
    int valid;
    uint32_t start;
    uint32_t end;
};
typedef struct range_list range_list;


//
// Global Constants
//


//
// Global Variables
//
static char *buffer;
static Block0 *b0;
static DPME *mb;
static partition_map_header *the_map;
static MEDIA the_media;
static int g;


//
// Forward declarations
//
int get_block_zero(void);
int get_block_n(int n);
range_list *new_range_list_item(enum range_state state, int valid, uint32_t low, uint32_t high);
void initialize_list(range_list **list);
void add_range(range_list **list, uint32_t base, uint32_t len, int allocate);
void print_range_list(range_list *list);
void delete_list(range_list *list);
void coalesce_list(range_list *list);


//
// Routines
//
int
get_block_zero(void)
{
    int rtn_value;

    if (the_map != NULL) {
          b0 = the_map->misc;
          rtn_value = 1;
    } else {
          if (read_media(the_media, (long long) 0, PBLOCK_SIZE, buffer) == 0) {
              rtn_value = 0;
          } else {
              b0 = (Block0 *) buffer;
              convert_block0(b0, 1);
              rtn_value = 1;
          }
    }
    return rtn_value;
}


int
get_block_n(int n)
{
    partition_map * entry;
    int rtn_value;

    if (the_map != NULL) {
          entry = find_entry_by_disk_address(n, the_map);
          if (entry != 0) {
              mb = entry->data;
              rtn_value = 1;
          } else {
              rtn_value = 0;
          }
    } else {
          if (read_media(the_media, ((long long) n) * g, PBLOCK_SIZE, (void *)buffer) == 0) {
              rtn_value = 0;
          } else {
              mb = (DPME *) buffer;
              convert_dpme(mb, 1);
              rtn_value = 1;
          }
    }
    return rtn_value;
}


range_list *
new_range_list_item(enum range_state state, int valid, uint32_t low, uint32_t high)
{
    range_list *item;

    item = (range_list *) malloc(sizeof(struct range_list));
    item->next = 0;
    item->prev = 0;
    item->state = state;
    item->valid = valid;
    item->start = low;
    item->end = high;
    return item;
}


void
initialize_list(range_list **list)
{
    range_list *item;

    item = new_range_list_item(kUnallocated, 0, 0, 0xFFFFFFFF);
    *list = item;
}


void
delete_list(range_list *list)
{
    range_list *item;
    range_list *cur;

    for (cur = list; cur != 0; ) {
          item = cur;
          cur = cur->next;
          free(item);
    }
}


void
add_range(range_list **list, uint32_t base, uint32_t len, int allocate)
{
    range_list *item;
    range_list *cur;
    uint32_t low;
    uint32_t high;

    if (list == 0 || *list == 0) {
          /* XXX initialized list will always have one element */
          return;
    }

    low = base;
    high = base + len - 1;
    if (len == 0 || high < len - 1) {
          /* XXX wrapped around */
          return;
    }

    cur = *list;
    while (low <= high) {
          if (cur == 0) {
              /* XXX should never occur */
              break;
          }
          if (low <= cur->end) {
              if (cur->start < low) {
                    item = new_range_list_item(cur->state, cur->valid, cur->start, low-1);
                    /* insert before here */
                    if (cur->prev == 0) {
                        item->prev = 0;
                        *list = item;
                    } else {
                        item->prev = cur->prev;
                        item->prev->next = item;
                    }
                    cur->prev = item;
                    item->next = cur;

                    cur->start = low;
              }
              if (high < cur->end) {
                    item = new_range_list_item(cur->state, cur->valid, high+1, cur->end);
                    /* insert after here */
                    if (cur->next == 0) {
                        item->next = 0;
                    } else {
                        item->next = cur->next;
                        item->next->prev = item;
                    }
                    cur->next = item;
                    item->prev = cur;

                    cur->end = high;
              }

              if (allocate) {
                    switch (cur->state) {
                    case kUnallocated:
                        cur->state = kAllocated;
                        break;
                    case kAllocated:
                    case kMultiplyAllocated:
                        cur->state = kMultiplyAllocated;
                        break;
                    }
              } else {
                    cur->valid = 1;
              }
              low = cur->end + 1;
          }
          cur = cur->next;
    }
}


void
coalesce_list(range_list *list)
{
    range_list *cur;
    range_list *item;

    for (cur = list; cur != 0; ) {
          item = cur->next;
          if (item == 0) {
              break;
          }
          if (cur->valid == item->valid
                    && cur->state == item->state) {
              cur->end = item->end;
              cur->next = item->next;
              if (item->next != 0) {
                    item->next->prev = cur;
              }
              free(item);
          } else {
              cur = cur->next;
          }
    }
}


void
print_range_list(range_list *list)
{
    range_list *cur;
    int printed;
    const char *s;

    s = NULL;                 /* XXXGCC -Wuninitialized [powerpc] */

    if (list == 0) {
          printf("Empty range list\n");
          return;
    }
    printf("Range list:\n");
    printed = 0;
    for (cur = list; cur != 0; cur = cur->next) {
          if (cur->valid) {
              switch (cur->state) {
              case kUnallocated:
                    s = "unallocated";
                    break;
              case kAllocated:
                    continue;
                    //s = "allocated";
                    //break;
              case kMultiplyAllocated:
                    s = "multiply allocated";
                    break;
              }
              printed = 1;
              printf("\t%"PRIu32":%"PRIu32" %s\n", cur->start, cur->end, s);
          } else {
              switch (cur->state) {
              case kUnallocated:
                    continue;
                    //s = "unallocated";
                    //break;
              case kAllocated:
                    s = "allocated";
                    break;
              case kMultiplyAllocated:
                    s = "multiply allocated";
                    break;
              }
              printed = 1;
              printf("\t%"PRIu32":%"PRIu32" out of range, but %s\n", cur->start, cur->end, s);
          }
    }
    if (printed == 0) {
          printf("\tokay\n");
    }
}


void
validate_map(partition_map_header *map)
{
    range_list *list;
    char *name;
    uint32_t i;
    uint32_t limit;
    int printed;

    //printf("Validation not implemented yet.\n");

    if (map == NULL) {
          the_map = 0;
          if (get_string_argument("Name of device: ", &name, 1) == 0) {
              bad_input("Bad name");
              return;
          }
          the_media = open_pathname_as_media(name, O_RDONLY);
          if (the_media == 0) {
              error(errno, "can't open file '%s'", name);
              free(name);
              return;
          }
          g = media_granularity(the_media);
          if (g < PBLOCK_SIZE) {
              g = PBLOCK_SIZE;
          }
          the_media = open_deblock_media(PBLOCK_SIZE, the_media);

          buffer = malloc(PBLOCK_SIZE);
          if (buffer == NULL) {
              error(errno, "can't allocate memory for disk buffer");
              goto done;
          }

    } else {
          name = 0;
          the_map = map;
          g = map->logical_block;
    }

    initialize_list(&list);

    // get block 0
    if (get_block_zero() == 0) {
          printf("unable to read block 0\n");
          goto check_map;
    }
    // XXX signature valid
    // XXX size & count match DeviceCapacity
    // XXX number of descriptors matches array size
    // XXX each descriptor wholly contained in a partition
    // XXX the range below here is in physical blocks but the map is in logical blocks!!!
    add_range(&list, 1, b0->sbBlkCount-1, 0);     /* subtract one since args are base & len */

check_map:
    // compute size of map
    if (map != NULL) {
          limit = the_map->blocks_in_map;
    } else {
          if (get_block_n(1) == 0) {
              printf("unable to get first block\n");
              goto done;
          } else {
              if (mb->dpme_signature != DPME_SIGNATURE) {
                  limit = -1;
              } else {
                    limit = mb->dpme_map_entries;
              }
          }
    }

    // for each entry
    for (i = 1; ; i++) {
#if 0
          if (limit < 0) {
              /* XXX what to use for end of list? */
              if (i > 5) {
                    break;
              }
          } else
#endif
          if (i > limit) {
              break;
          }

          printf("block %d:\n", i);

          // get entry
          if (get_block_n(i) == 0) {
              printf("\tunable to get\n");
              goto post_processing;
          }
          printed = 0;

          // signature matches
          if (mb->dpme_signature != DPME_SIGNATURE) {
              printed = 1;
              printf("\tsignature is 0x%x, should be 0x%x\n", mb->dpme_signature, DPME_SIGNATURE);
          }
          // reserved1 == 0
          if (mb->dpme_reserved_1 != 0) {
              printed = 1;
              printf("\treserved word is 0x%x, should be 0\n", mb->dpme_reserved_1);
          }
          // entry count matches
#if 0
          if (limit < 0) {
              printed = 1;
              printf("\tentry count is 0x%"PRIx32", real value unknown\n", mb->dpme_map_entries);
          } else
#endif
          if (mb->dpme_map_entries != limit) {
              printed = 1;
              printf("\tentry count is 0x%"PRIx32", should be %"PRId32"\n", mb->dpme_map_entries, limit);
          }
          // lblocks contained within physical
          if (mb->dpme_lblock_start >= mb->dpme_pblocks
                    || mb->dpme_lblocks > mb->dpme_pblocks - mb->dpme_lblock_start) {
              printed = 1;
              printf("\tlogical blocks (%"PRId32" for %"PRId32") not within physical size (%"PRId32")\n",
                        mb->dpme_lblock_start, mb->dpme_lblocks, mb->dpme_pblocks);
          }
          // remember stuff for post processing
          add_range(&list, mb->dpme_pblock_start, mb->dpme_pblocks, 1);

          // XXX type is known type?
          // XXX no unknown flags?
          // XXX boot blocks either within or outside of logical
          // XXX checksum matches contents
          // XXX other fields zero if boot_bytes  is zero
          // XXX processor id is known value?
          // XXX no data in reserved3
          if (printed == 0) {
              printf("\tokay\n");
          }
    }

post_processing:
    // properties of whole map

    // every block on disk in one & only one partition
    coalesce_list(list);
    print_range_list(list);
    // there is a partition for the map
    // map fits within partition that contains it

    // try to detect 512/2048 mixed partition map?

done:
    if (map == NULL) {
          close_media(the_media);
          free(buffer);
          free(name);
    }
}