Grow.c

   1 /*
   2  * mdadm - manage Linux "md" devices aka RAID arrays.
   3  *
   4  * Copyright (C) 2001-2004 Neil Brown <neilb@cse.unsw.edu.au>
   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: <neilb@cse.unsw.edu.au>
  23  *    Paper: Neil Brown
  24  *           School of Computer Science and Engineering
  25  *           The University of New South Wales
  26  *           Sydney, 2052
  27  *           Australia
  28  */
  29 #include        "mdadm.h"
  30 #include        "dlink.h"
  31
  32 #if ! defined(__BIG_ENDIAN) && ! defined(__LITTLE_ENDIAN)
  33 #error no endian defined
  34 #endif
  35 #include        "md_u.h"
  36 #include        "md_p.h"
  37
  38 int Grow_Add_device(char *devname, int fd, char *newdev)
  39 {
  40         /* Add a device to an active array.
  41          * Currently, just extend a linear array.
  42          * This requires writing a new superblock on the
  43          * new device, calling the kernel to add the device,
  44          * and if that succeeds, update the superblock on
  45          * all other devices.
  46          * This means that we need to *find* all other devices.
  47          */
  48         struct mdinfo info;
  49
  50         void *super = NULL;
  51         struct stat stb;
  52         int nfd, fd2;
  53         int d, nd;
  54         struct supertype *st = NULL;
  55
  56
  57         if (ioctl(fd, GET_ARRAY_INFO, &info.array) < 0) {
  58                 fprintf(stderr, Name ": cannot get array info for %s\n", devname);
  59                 return 1;
  60         }
  61
  62         st = super_by_version(info.array.major_version, info.array.minor_version);
  63         if (!st) {
  64                 fprintf(stderr, Name ": cannot handle arrays with superblock version %d\n", info.array.major_version);
  65                 return 1;
  66         }
  67
  68         if (info.array.level != -1) {
  69                 fprintf(stderr, Name ": can only add devices to linear arrays\n");
  70                 return 1;
  71         }
  72
  73         nfd = open(newdev, O_RDWR|O_EXCL);
  74         if (nfd < 0) {
  75                 fprintf(stderr, Name ": cannot open %s\n", newdev);
  76                 return 1;
  77         }
  78         fstat(nfd, &stb);
  79         if ((stb.st_mode & S_IFMT) != S_IFBLK) {
  80                 fprintf(stderr, Name ": %s is not a block device!\n", newdev);
  81                 close(nfd);
  82                 return 1;
  83         }
  84         /* now check out all the devices and make sure we can read the superblock */
  85         for (d=0 ; d < info.array.raid_disks ; d++) {
  86                 mdu_disk_info_t disk;
  87                 char *dv;
  88
  89                 disk.number = d;
  90                 if (ioctl(fd, GET_DISK_INFO, &disk) < 0) {
  91                         fprintf(stderr, Name ": cannot get device detail for device %d\n",
  92                                 d);
  93                         return 1;
  94                 }
  95                 dv = map_dev(disk.major, disk.minor);
  96                 if (!dv) {
  97                         fprintf(stderr, Name ": cannot find device file for device %d\n",
  98                                 d);
  99                         return 1;
 100                 }
 101                 fd2 = open(dv, O_RDWR);
 102                 if (!fd2) {
 103                         fprintf(stderr, Name ": cannot open device file %s\n", dv);
 104                         return 1;
 105                 }
 106                 if (super) free(super);
 107                 super= NULL;
 108                 if (st->ss->load_super(st, fd2, &super, NULL)) {
 109                         fprintf(stderr, Name ": cannot find super block on %s\n", dv);
 110                         close(fd2);
 111                         return 1;
 112                 }
 113                 close(fd2);
 114         }
 115         /* Ok, looks good. Lets update the superblock and write it out to
 116          * newdev.
 117          */
 118
 119         info.disk.number = d;
 120         info.disk.major = major(stb.st_rdev);
 121         info.disk.minor = minor(stb.st_rdev);
 122         info.disk.raid_disk = d;
 123         info.disk.state = (1 << MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE);
 124         st->ss->update_super(&info, super, "grow", newdev, 0);
 125
 126         if (st->ss->store_super(st, nfd, super)) {
 127                 fprintf(stderr, Name ": Cannot store new superblock on %s\n", newdev);
 128                 close(nfd);
 129                 return 1;
 130         }
 131         close(nfd);
 132
 133         if (ioctl(fd, ADD_NEW_DISK, &info.disk) != 0) {
 134                 fprintf(stderr, Name ": Cannot add new disk to this array\n");
 135                 return 1;
 136         }
 137         /* Well, that seems to have worked.
 138          * Now go through and update all superblocks
 139          */
 140
 141         if (ioctl(fd, GET_ARRAY_INFO, &info.array) < 0) {
 142                 fprintf(stderr, Name ": cannot get array info for %s\n", devname);
 143                 return 1;
 144         }
 145
 146         nd = d;
 147         for (d=0 ; d < info.array.raid_disks ; d++) {
 148                 mdu_disk_info_t disk;
 149                 char *dv;
 150
 151                 disk.number = d;
 152                 if (ioctl(fd, GET_DISK_INFO, &disk) < 0) {
 153                         fprintf(stderr, Name ": cannot get device detail for device %d\n",
 154                                 d);
 155                         return 1;
 156                 }
 157                 dv = map_dev(disk.major, disk.minor);
 158                 if (!dv) {
 159                         fprintf(stderr, Name ": cannot find device file for device %d\n",
 160                                 d);
 161                         return 1;
 162                 }
 163                 fd2 = open(dv, O_RDWR);
 164                 if (fd2 < 0) {
 165                         fprintf(stderr, Name ": cannot open device file %s\n", dv);
 166                         return 1;
 167                 }
 168                 if (st->ss->load_super(st, fd2, &super, NULL)) {
 169                         fprintf(stderr, Name ": cannot find super block on %s\n", dv);
 170                         close(fd);
 171                         return 1;
 172                 }
 173                 info.array.raid_disks = nd+1;
 174                 info.array.nr_disks = nd+1;
 175                 info.array.active_disks = nd+1;
 176                 info.array.working_disks = nd+1;
 177                 info.disk.number = nd;
 178                 info.disk.major = major(stb.st_rdev);
 179                 info.disk.minor = minor(stb.st_rdev);
 180                 info.disk.raid_disk = nd;
 181                 info.disk.state = (1 << MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE);
 182                 st->ss->update_super(&info, super, "grow", dv, 0);
 183
 184                 if (st->ss->store_super(st, fd2, super)) {
 185                         fprintf(stderr, Name ": Cannot store new superblock on %s\n", dv);
 186                         close(fd2);
 187                         return 1;
 188                 }
 189                 close(fd2);
 190         }
 191
 192         return 0;
 193 }
 194
 195 int Grow_addbitmap(char *devname, int fd, char *file, int chunk, int delay)
 196 {
 197         /*
 198          * First check that array doesn't have a bitmap
 199          * Then create the bitmap
 200          * Then add it
 201          *
 202          * For internal bitmaps, we need to check the version,
 203          * find all the active devices, and write the bitmap block
 204          * to all devices
 205          */
 206         mdu_bitmap_file_t bmf;
 207         mdu_array_info_t array;
 208         struct supertype *st;
 209
 210         if (ioctl(fd, GET_BITMAP_FILE, &bmf) != 0) {
 211                 if (errno == ENOMEM)
 212                         fprintf(stderr, Name ": Memory allocation failure.\n");
 213                 else
 214                         fprintf(stderr, Name ": bitmaps not supported by this kernel.\n");
 215                 return 1;
 216         }
 217         if (bmf.pathname[0]) {
 218                 fprintf(stderr, Name ": %s already has a bitmap (%s)\n",
 219                         devname, bmf.pathname);
 220                 return 1;
 221         }
 222         if (ioctl(fd, GET_ARRAY_INFO, &array) != 0) {
 223                 fprintf(stderr, Name ": cannot get array status for %s\n", devname);
 224                 return 1;
 225         }
 226         if (array.state & (1<<MD_SB_BITMAP_PRESENT)) {
 227                 fprintf(stderr, Name ": Internal bitmap already present on %s\n",
 228                         devname);
 229                 return 1;
 230         }
 231         st = super_by_version(array.major_version, array.minor_version);
 232         if (!st) {
 233                 fprintf(stderr, Name ": Cannot understand version %d.%d\n",
 234                         array.major_version, array.minor_version);
 235                 return 1;
 236         }
 237         if (strcmp(file, "internal") == 0) {
 238                 int d;
 239                 for (d=0; d< st->max_devs; d++) {
 240                         mdu_disk_info_t disk;
 241                         char *dv;
 242                         disk.number = d;
 243                         if (ioctl(fd, GET_DISK_INFO, &disk) < 0)
 244                                 continue;
 245                         if (disk.major == 0 &&
 246                             disk.minor == 0)
 247                                 continue;
 248                         if ((disk.state & (1<<MD_DISK_SYNC))==0)
 249                                 continue;
 250                         dv = map_dev(disk.major, disk.minor);
 251                         if (dv) {
 252                                 void *super;
 253                                 int fd2 = open(dv, O_RDWR);
 254                                 if (fd2 < 0)
 255                                         continue;
 256                                 if (st->ss->load_super(st, fd2, &super, NULL)==0) {
 257                                         st->ss->add_internal_bitmap(super,
 258                                                                     chunk, delay,
 259                                                                     array.size);
 260                                         st->ss->write_bitmap(st, fd2, super);
 261                                 }
 262                                 close(fd2);
 263                         }
 264                 }
 265                 array.state |= (1<<MD_SB_BITMAP_PRESENT);
 266                 if (ioctl(fd, SET_ARRAY_INFO, &array)!= 0) {
 267                         fprintf(stderr, Name ": failed to set internal bitmap.\n");
 268                         return 1;
 269                 }
 270         } else
 271                 abort(); /* FIXME */
 272
 273         return 0;
 274 }
 275
 276