libblkid/src/partitions/sgi.c

   1 /*
   2  * sgi partition parsing code
   3  *
   4  * Copyright (C) 2009 Karel Zak <kzak@redhat.com>
   5  *
   6  * This file may be redistributed under the terms of the
   7  * GNU Lesser General Public License.
   8  *
   9  */
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include <stdlib.h>
  13 #include <stdint.h>
  14
  15 #include "partitions.h"
  16
  17 #define SGI_MAXPARTITIONS       16
  18
  19 /* partition type */
  20 #define SGI_TYPE_VOLHDR         0x00
  21 #define SGI_TYPE_VOLULME        0x06    /* entire disk */
  22
  23 struct sgi_device_parameter {
  24         unsigned char skew;
  25         unsigned char gap1;
  26         unsigned char gap2;
  27         unsigned char sparecyl;
  28
  29         uint16_t pcylcount;
  30         uint16_t head_vol0;
  31         uint16_t ntrks;         /* tracks in cyl 0 or vol 0 */
  32
  33         unsigned char cmd_tag_queue_depth;
  34         unsigned char unused0;
  35
  36         uint16_t unused1;
  37         uint16_t nsect;         /* sectors/tracks in cyl 0 or vol 0 */
  38         uint16_t bytes;
  39         uint16_t ilfact;
  40         uint32_t flags;         /* controller flags */
  41         uint32_t datarate;
  42         uint32_t retries_on_error;
  43         uint32_t ms_per_word;
  44         uint16_t xylogics_gap1;
  45         uint16_t xylogics_syncdelay;
  46         uint16_t xylogics_readdelay;
  47         uint16_t xylogics_gap2;
  48         uint16_t xylogics_readgate;
  49         uint16_t xylogics_writecont;
  50 } __attribute__((packed));
  51
  52 struct sgi_disklabel {
  53         uint32_t magic;                 /* magic number */
  54         uint16_t root_part_num;         /* # root partition */
  55         uint16_t swap_part_num;         /* # swap partition */
  56         unsigned char boot_file[16];    /* name of boot file */
  57
  58         struct sgi_device_parameter     devparam;       /* not used now */
  59
  60         struct sgi_volume {
  61                 unsigned char name[8];  /* name of volume */
  62                 uint32_t block_num;     /* logical block number */
  63                 uint32_t num_bytes;     /* how big, in bytes */
  64         } __attribute__((packed)) volume[15];
  65
  66         struct sgi_partition {
  67                 uint32_t num_blocks;    /* size in logical blocks */
  68                 uint32_t first_block;   /* first logical block */
  69                 uint32_t type;          /* type of this partition */
  70         } __attribute__((packed)) partitions[SGI_MAXPARTITIONS];
  71
  72         /* checksum is the 32bit 2's complement sum of the disklabel */
  73         uint32_t csum;                  /* disk label checksum */
  74         uint32_t padding;               /* padding */
  75 } __attribute__((packed));
  76
  77 static uint32_t count_checksum(struct sgi_disklabel *label)
  78 {
  79         int i;
  80         uint32_t *ptr = (uint32_t *) label;
  81         uint32_t sum = 0;
  82
  83         i = sizeof(*label) / sizeof(*ptr);
  84
  85         while (i--)
  86                 sum += be32_to_cpu(ptr[i]);
  87
  88         return sum;
  89 }
  90
  91
  92 static int probe_sgi_pt(blkid_probe pr,
  93                 const struct blkid_idmag *mag __attribute__((__unused__)))
  94 {
  95         struct sgi_disklabel *l;
  96         struct sgi_partition *p;
  97         blkid_parttable tab = NULL;
  98         blkid_partlist ls;
  99         int i;
 100
 101         l = (struct sgi_disklabel *) blkid_probe_get_sector(pr, 0);
 102         if (!l)
 103                 goto nothing;
 104
 105         if (count_checksum(l)) {
 106                 DBG(DEBUG_LOWPROBE, printf(
 107                         "detected corrupted sgi disk label -- ignore\n"));
 108                 goto nothing;
 109         }
 110
 111         if (blkid_partitions_need_typeonly(pr))
 112                 /* caller does not ask for details about partitions */
 113                 return 0;
 114
 115         ls = blkid_probe_get_partlist(pr);
 116         if (!ls)
 117                 goto err;
 118
 119         tab = blkid_partlist_new_parttable(ls, "sgi", 0);
 120         if (!tab)
 121                 goto err;
 122
 123         for(i = 0, p = &l->partitions[0]; i < SGI_MAXPARTITIONS; i++, p++) {
 124                 uint32_t size = be32_to_cpu(p->num_blocks);
 125                 uint32_t start = be32_to_cpu(p->first_block);
 126                 uint32_t type = be32_to_cpu(p->type);
 127                 blkid_partition par;
 128
 129                 if (size == 0 || type == SGI_TYPE_VOLULME ||
 130                                  type == SGI_TYPE_VOLHDR) {
 131                         blkid_partlist_increment_partno(ls);
 132                         continue;
 133                 }
 134                 par = blkid_partlist_add_partition(ls, tab, start, size);
 135                 if (!par)
 136                         goto err;
 137
 138                 blkid_partition_set_type(par, type);
 139         }
 140
 141         return 0;
 142
 143 nothing:
 144         return 1;
 145 err:
 146         return -1;
 147 }
 148
 149 const struct blkid_idinfo sgi_pt_idinfo =
 150 {
 151         .name           = "sgi",
 152         .probefunc      = probe_sgi_pt,
 153         .magics         =
 154         {
 155                 { .magic = "\x0B\xE5\xA9\x41", .len = 4 },
 156                 { NULL }
 157         }
 158 };
 159