super-mbr.c

   1 /*
   2  * mdadm - manage Linux "md" devices aka RAID arrays.
   3  *
   4  * Copyright (C) 2010 Neil Brown <neilb@suse.de>
   5  *
   6  *
   7  *    This program is free software; you can redistribute it and/or modify
   8  *    it under the terms of the GNU General Public License as published by
   9  *    the Free Software Foundation; either version 2 of the License, or
  10  *    (at your option) any later version.
  11  *
  12  *    This program is distributed in the hope that it will be useful,
  13  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *    GNU General Public License for more details.
  16  *
  17  *    You should have received a copy of the GNU General Public License
  18  *    along with this program; if not, write to the Free Software
  19  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  *    Author: Neil Brown
  22  *    Email: <neil@brown.name>
  23  *
  24  */
  25
  26 /*
  27  * 'mbr' is a pseudo metadata type for devices which have a
  28  * partition table in the Master Boot Record (mbr) also known
  29  * as a dos partition table.
  30  *
  31  * Obviously arrays cannot be created or assembled for this type.
  32  * It is used to allow a new bare device to have an partition table
  33  * added so the member partitions can then be included in other
  34  * arrays as relevant.
  35  *
  36  * The meaning operations are:
  37  * examine_super, but not brief_examine_super or export_examine
  38  * load_super
  39  * store_super
  40  */
  41
  42 #include "mdadm.h"
  43 #include "part.h"
  44
  45 static void free_mbr(struct supertype *st)
  46 {
  47         free(st->sb);
  48         st->sb = NULL;
  49 }
  50
  51 #ifndef MDASSEMBLE
  52
  53 static void examine_mbr(struct supertype *st, char *homehost)
  54 {
  55         struct MBR *sb = st->sb;
  56         int i;
  57
  58         printf("   MBR Magic : %04x\n", sb->magic);
  59         for (i = 0; i < MBR_PARTITIONS; i++)
  60                 /*
  61                  * Have to make every access through sb rather than using a
  62                  * pointer to the partition table (or an entry), since the
  63                  * entries are not properly aligned.
  64                  */
  65                 if (sb->parts[i].blocks_num)
  66                         printf("Partition[%d] : %12lu sectors at %12lu (type %02x)\n",
  67                                i,
  68                                (unsigned long)__le32_to_cpu(sb->parts[i].blocks_num),
  69                                (unsigned long)__le32_to_cpu(sb->parts[i].first_sect_lba),
  70                                sb->parts[i].part_type);
  71
  72 }
  73
  74 #endif /*MDASSEMBLE */
  75
  76 static int load_super_mbr(struct supertype *st, int fd, char *devname)
  77 {
  78         /* try to read an mbr
  79          * Return
  80          *  0 on success
  81          *  1 cannot get record
  82          *  2 record is meaningless
  83          */
  84         struct MBR *super;
  85
  86         free_mbr(st);
  87
  88         if (posix_memalign((void**)&super, 512, 512) != 0) {
  89                 pr_err("could not allocate superblock\n");
  90                 return 1;
  91         }
  92
  93         lseek(fd, 0, 0);
  94         if (read(fd, super, sizeof(*super)) != sizeof(*super)) {
  95                 if (devname)
  96                         pr_err("Cannot read partition table on %s\n",
  97                                 devname);
  98                 free(super);
  99                 return 1;
 100         }
 101
 102         if (super->magic != MBR_SIGNATURE_MAGIC) {
 103                 if (devname)
 104                         pr_err("No partition table found on %s\n",
 105                                 devname);
 106                 free(super);
 107                 return 1;
 108         }
 109
 110         st->sb = super;
 111
 112         if (st->ss == NULL) {
 113                 st->ss = &mbr;
 114                 st->minor_version = 0;
 115                 st->max_devs = 1;
 116                 st->info = NULL;
 117         }
 118         return 0;
 119 }
 120
 121 static int store_mbr(struct supertype *st, int fd)
 122 {
 123         struct MBR *old, *super;
 124
 125         if (posix_memalign((void**)&old, 512, 512) != 0) {
 126                 pr_err("could not allocate superblock\n");
 127                 return 1;
 128         }
 129
 130         lseek(fd, 0, 0);
 131         if (read(fd, old, sizeof(*old)) != sizeof(*old)) {
 132                 free(old);
 133                 return 1;
 134         }
 135
 136         super = st->sb;
 137         memcpy(super->pad, old->pad, sizeof(super->pad));
 138         free(old);
 139         lseek(fd, 0, 0);
 140         if (write(fd, super, sizeof(*super)) != sizeof(*super))
 141                 return 4;
 142         fsync(fd);
 143         ioctl(fd, BLKRRPART, 0);
 144         return 0;
 145 }
 146
 147 static void getinfo_mbr(struct supertype *st, struct mdinfo *info, char *map)
 148 {
 149         struct MBR *sb = st->sb;
 150         int i;
 151
 152         memset(&info->array, 0, sizeof(info->array));
 153         memset(&info->disk, 0, sizeof(info->disk));
 154         strcpy(info->text_version, "mbr");
 155         strcpy(info->name, "mbr");
 156         info->component_size = 0;
 157
 158         for (i = 0; i < MBR_PARTITIONS ; i++)
 159                 /*
 160                  * Have to make every access through sb rather than using a
 161                  * pointer to the partition table (or an entry), since the
 162                  * entries are not properly aligned.
 163                  */
 164                 if (sb->parts[i].blocks_num) {
 165                         unsigned long last =
 166                                 (unsigned long)__le32_to_cpu(sb->parts[i].blocks_num)
 167                                 + (unsigned long)__le32_to_cpu(sb->parts[i].first_sect_lba);
 168                         if (last > info->component_size)
 169                                 info->component_size = last;
 170                 }
 171
 172 }
 173
 174 static struct supertype *match_metadata_desc(char *arg)
 175 {
 176         struct supertype *st;
 177
 178         if (strcmp(arg, "mbr") != 0)
 179                 return NULL;
 180
 181         st = xmalloc(sizeof(*st));
 182         st->ss = &mbr;
 183         st->info = NULL;
 184         st->minor_version = 0;
 185         st->max_devs = 1;
 186         st->sb = NULL;
 187         return st;
 188 }
 189
 190 #ifndef MDASSEMBLE
 191 static int validate_geometry(struct supertype *st, int level,
 192                              int layout, int raiddisks,
 193                              int *chunk, unsigned long long size,
 194                              unsigned long long data_offset,
 195                              char *subdev, unsigned long long *freesize,
 196                              int verbose)
 197 {
 198         pr_err("mbr metadata cannot be used this way\n");
 199         return 0;
 200 }
 201 #endif
 202
 203 struct superswitch mbr = {
 204 #ifndef MDASSEMBLE
 205         .examine_super = examine_mbr,
 206         .validate_geometry = validate_geometry,
 207 #endif
 208         .match_metadata_desc = match_metadata_desc,
 209         .load_super = load_super_mbr,
 210         .store_super = store_mbr,
 211         .getinfo_super = getinfo_mbr,
 212         .free_super = free_mbr,
 213         .name = "mbr",
 214 };