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(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(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 }