daemon/md.c

   1 /* libguestfs - the guestfsd daemon
   2  * Copyright (C) 2011 Red Hat Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 #include <config.h>
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <inttypes.h>
  25 #include <glob.h>
  26
  27 #include "daemon.h"
  28 #include "actions.h"
  29 #include "optgroups.h"
  30 #include "c-ctype.h"
  31
  32 int
  33 optgroup_mdadm_available (void)
  34 {
  35   return prog_exists ("mdadm");
  36 }
  37
  38 static size_t
  39 count_bits (uint64_t bitmap)
  40 {
  41   size_t c;
  42
  43   if (bitmap == 0)
  44     return 0;
  45
  46   c = bitmap & 1 ? 1 : 0;
  47   bitmap >>= 1;
  48   return c + count_bits (bitmap);
  49 }
  50
  51 /* Takes optional arguments, consult optargs_bitmask. */
  52 int
  53 do_md_create (const char *name, char *const *devices,
  54               int64_t missingbitmap, int nrdevices, int spare,
  55               int64_t chunk, const char *level)
  56 {
  57   char nrdevices_s[32];
  58   char spare_s[32];
  59   char chunk_s[32];
  60   size_t j;
  61   int r;
  62   char *err;
  63   uint64_t umissingbitmap = (uint64_t) missingbitmap;
  64
  65   /* Check the optional parameters and set defaults where appropriate. */
  66   if (!(optargs_bitmask & GUESTFS_MD_CREATE_MISSINGBITMAP_BITMASK))
  67     umissingbitmap = 0;
  68
  69   if (optargs_bitmask & GUESTFS_MD_CREATE_SPARE_BITMASK) {
  70     if (spare < 0) {
  71       reply_with_error ("spare must not be negative");
  72       return -1;
  73     }
  74   }
  75   else
  76     spare = 0;
  77
  78   if (optargs_bitmask & GUESTFS_MD_CREATE_NRDEVICES_BITMASK) {
  79     if (nrdevices < 2) {
  80       reply_with_error ("nrdevices is less than 2");
  81       return -1;
  82     }
  83   }
  84   else
  85     nrdevices = count_strings (devices) + count_bits (umissingbitmap);
  86
  87   if (optargs_bitmask & GUESTFS_MD_CREATE_LEVEL_BITMASK) {
  88     if (STRNEQ (level, "linear") && STRNEQ (level, "raid0") &&
  89         STRNEQ (level, "0") && STRNEQ (level, "stripe") &&
  90         STRNEQ (level, "raid1") && STRNEQ (level, "1") &&
  91         STRNEQ (level, "mirror") &&
  92         STRNEQ (level, "raid4") && STRNEQ (level, "4") &&
  93         STRNEQ (level, "raid5") && STRNEQ (level, "5") &&
  94         STRNEQ (level, "raid6") && STRNEQ (level, "6") &&
  95         STRNEQ (level, "raid10") && STRNEQ (level, "10")) {
  96       reply_with_error ("unknown level parameter: %s", level);
  97       return -1;
  98     }
  99   }
 100   else
 101     level = "raid1";
 102
 103   if (optargs_bitmask & GUESTFS_MD_CREATE_CHUNK_BITMASK) {
 104     /* chunk is bytes in the libguestfs API, but K when we pass it to mdadm */
 105     if ((chunk & 1023) != 0) {
 106       reply_with_error ("chunk size must be a multiple of 1024 bytes");
 107       return -1;
 108     }
 109   }
 110
 111   /* Check invariant. */
 112   if (count_strings (devices) + count_bits (umissingbitmap) !=
 113       (size_t) (nrdevices + spare)) {
 114     reply_with_error ("devices (%zu) + bits set in missingbitmap (%zu) is not equal to nrdevices (%d) + spare (%d)",
 115                       count_strings (devices), count_bits (umissingbitmap),
 116                       nrdevices, spare);
 117     return -1;
 118   }
 119
 120   size_t MAX_ARGS = nrdevices + 16;
 121   const char *argv[MAX_ARGS];
 122   size_t i = 0;
 123
 124   ADD_ARG (argv, i, "mdadm");
 125   ADD_ARG (argv, i, "--create");
 126   /* --run suppresses "Continue creating array" question */
 127   ADD_ARG (argv, i, "--run");
 128   ADD_ARG (argv, i, name);
 129   ADD_ARG (argv, i, "--level");
 130   ADD_ARG (argv, i, level);
 131   ADD_ARG (argv, i, "--raid-devices");
 132   snprintf (nrdevices_s, sizeof nrdevices_s, "%d", nrdevices);
 133   ADD_ARG (argv, i, nrdevices_s);
 134   if (optargs_bitmask & GUESTFS_MD_CREATE_SPARE_BITMASK) {
 135     ADD_ARG (argv, i, "--spare-devices");
 136     snprintf (spare_s, sizeof spare_s, "%d", spare);
 137     ADD_ARG (argv, i, spare_s);
 138   }
 139   if (optargs_bitmask & GUESTFS_MD_CREATE_CHUNK_BITMASK) {
 140     ADD_ARG (argv, i, "--chunk");
 141     snprintf (chunk_s, sizeof chunk_s, "%" PRIi64, chunk / 1024);
 142     ADD_ARG (argv, i, chunk_s);
 143   }
 144
 145   /* Add devices and "missing". */
 146   j = 0;
 147   while (devices[j] != NULL || umissingbitmap != 0) {
 148     if (umissingbitmap & 1)
 149       ADD_ARG (argv, i, "missing");
 150     else {
 151       ADD_ARG (argv, i, devices[j]);
 152       j++;
 153     }
 154     umissingbitmap >>= 1;
 155   }
 156
 157   ADD_ARG (argv, i, NULL);
 158
 159   r = commandv (NULL, &err, argv);
 160   if (r == -1) {
 161     reply_with_error ("mdadm: %s: %s", name, err);
 162     free (err);
 163     return -1;
 164   }
 165
 166   free (err);
 167
 168   udev_settle ();
 169
 170   return 0;
 171 }
 172
 173 static int
 174 glob_errfunc (const char *epath, int eerrno)
 175 {
 176   fprintf (stderr, "glob: failure reading %s: %s\n", epath, strerror (eerrno));
 177   return 1;
 178 }
 179
 180 char **
 181 do_list_md_devices (void)
 182 {
 183   char **r = NULL;
 184   int size = 0, alloc = 0;
 185   glob_t mds;
 186
 187   memset(&mds, 0, sizeof(mds));
 188
 189 #define PREFIX "/sys/block/md"
 190 #define SUFFIX "/md"
 191
 192   /* Look for directories under /sys/block matching md[0-9]*
 193    * As an additional check, we also make sure they have a md subdirectory.
 194    */
 195   int err = glob (PREFIX "[0-9]*" SUFFIX, GLOB_ERR, glob_errfunc, &mds);
 196   if (err == GLOB_NOSPACE) {
 197     reply_with_error ("glob: returned GLOB_NOSPACE: "
 198                       "rerun with LIBGUESTFS_DEBUG=1");
 199     goto error;
 200   } else if (err == GLOB_ABORTED) {
 201     reply_with_error ("glob: returned GLOB_ABORTED: "
 202                       "rerun with LIBGUESTFS_DEBUG=1");
 203     goto error;
 204   }
 205
 206   for (size_t i = 0; i < mds.gl_pathc; i++) {
 207     size_t len = strlen (mds.gl_pathv[i]) - strlen (PREFIX) - strlen (SUFFIX);
 208
 209 #define DEV "/dev/md"
 210     char *dev = malloc (strlen(DEV) + len  + 1);
 211     if (NULL == dev) {
 212       reply_with_perror("malloc");
 213       goto error;
 214     }
 215
 216     char *n = dev;
 217     n = mempcpy(n, DEV, strlen(DEV));
 218     n = mempcpy(n, &mds.gl_pathv[i][strlen(PREFIX)], len);
 219     *n = '\0';
 220
 221     if (add_string_nodup (&r, &size, &alloc, dev) == -1) goto error;
 222   }
 223
 224   if (add_string_nodup (&r, &size, &alloc, NULL) == -1) goto error;
 225   globfree (&mds);
 226
 227   return r;
 228
 229 error:
 230   globfree (&mds);
 231   if (r != NULL) free_strings (r);
 232   return NULL;
 233 }
 234
 235 char **
 236 do_md_detail(const char *md)
 237 {
 238   int r;
 239
 240   char *out = NULL, *err = NULL;
 241   char **lines = NULL;
 242
 243   char **ret = NULL;
 244   int size = 0, alloc = 0;
 245
 246   const char *mdadm[] = { "mdadm", "-D", "--export", md, NULL };
 247   r = commandv(&out, &err, mdadm);
 248   if (r == -1) {
 249     reply_with_error("%s", err);
 250     goto error;
 251   }
 252
 253   /* Split the command output into lines */
 254   lines = split_lines(out);
 255   if (lines == NULL) {
 256     reply_with_perror("malloc");
 257     goto error;
 258   }
 259
 260   /* Parse the output of mdadm -D --export:
 261    * MD_LEVEL=raid1
 262    * MD_DEVICES=2
 263    * MD_METADATA=1.0
 264    * MD_UUID=cfa81b59:b6cfbd53:3f02085b:58f4a2e1
 265    * MD_NAME=localhost.localdomain:0
 266    */
 267   for (char **i = lines; *i != NULL; i++) {
 268     char *line = *i;
 269
 270     /* Skip blank lines (shouldn't happen) */
 271     if (line[0] == '\0') continue;
 272
 273     /* Split the line in 2 at the equals sign */
 274     char *eq = strchr(line, '=');
 275     if (eq) {
 276       *eq = '\0'; eq++;
 277
 278       /* Remove the MD_ prefix from the key and translate the remainder to lower
 279        * case */
 280       if (STRPREFIX(line, "MD_")) {
 281         line += 3;
 282         for (char *j = line; *j != '\0'; j++) {
 283           *j = c_tolower(*j);
 284         }
 285       }
 286
 287       /* Add the key/value pair to the output */
 288       if (add_string(&ret, &size, &alloc, line) == -1 ||
 289           add_string(&ret, &size, &alloc, eq) == -1) goto error;
 290     } else {
 291       /* Ignore lines with no equals sign (shouldn't happen). Log to stderr so
 292        * it will show up in LIBGUESTFS_DEBUG. */
 293       fprintf(stderr, "md-detail: unexpected mdadm output ignored: %s", line);
 294     }
 295   }
 296
 297   free(out);
 298   free(err);
 299   free(lines); /* We freed the contained strings when we freed out */
 300
 301   if (add_string(&ret, &size, &alloc, NULL) == -1) return NULL;
 302
 303   return ret;
 304
 305 error:
 306   free(out);
 307   free(err);
 308   if (lines) free(lines);
 309   if (ret) free_strings(ret);
 310
 311   return NULL;
 312 }
 313
 314 int
 315 do_md_stop(const char *md)
 316 {
 317   int r;
 318   char *err = NULL;
 319
 320   const char *mdadm[] = { "mdadm", "--stop", md, NULL};
 321   r = commandv(NULL, &err, mdadm);
 322   if (r == -1) {
 323     reply_with_error("%s", err);
 324     free(err);
 325     return -1;
 326   }
 327   return 0;
 328 }