sys/geom/mirror/g_mirror.h

   1 /*-
   2  * Copyright (c) 2004-2006 Pawel Jakub Dawidek <pjd@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28
  29 #ifndef _G_MIRROR_H_
  30 #define _G_MIRROR_H_
  31
  32 #include <sys/endian.h>
  33 #include <sys/md5.h>
  34
  35 #define G_MIRROR_CLASS_NAME     "MIRROR"
  36
  37 #define G_MIRROR_MAGIC          "GEOM::MIRROR"
  38 /*
  39  * Version history:
  40  * 0 - Initial version number.
  41  * 1 - Added 'prefer' balance algorithm.
  42  * 2 - Added md_genid field to metadata.
  43  * 3 - Added md_provsize field to metadata.
  44  * 4 - Added 'no failure synchronization' flag.
  45  */
  46 #define G_MIRROR_VERSION        4
  47
  48 #define G_MIRROR_BALANCE_NONE           0
  49 #define G_MIRROR_BALANCE_ROUND_ROBIN    1
  50 #define G_MIRROR_BALANCE_LOAD           2
  51 #define G_MIRROR_BALANCE_SPLIT          3
  52 #define G_MIRROR_BALANCE_PREFER         4
  53 #define G_MIRROR_BALANCE_MIN            G_MIRROR_BALANCE_NONE
  54 #define G_MIRROR_BALANCE_MAX            G_MIRROR_BALANCE_PREFER
  55
  56 #define G_MIRROR_DISK_FLAG_DIRTY                0x0000000000000001ULL
  57 #define G_MIRROR_DISK_FLAG_SYNCHRONIZING        0x0000000000000002ULL
  58 #define G_MIRROR_DISK_FLAG_FORCE_SYNC           0x0000000000000004ULL
  59 #define G_MIRROR_DISK_FLAG_INACTIVE             0x0000000000000008ULL
  60 #define G_MIRROR_DISK_FLAG_HARDCODED            0x0000000000000010ULL
  61 #define G_MIRROR_DISK_FLAG_BROKEN               0x0000000000000020ULL
  62 #define G_MIRROR_DISK_FLAG_MASK         (G_MIRROR_DISK_FLAG_DIRTY |     \
  63                                          G_MIRROR_DISK_FLAG_SYNCHRONIZING | \
  64                                          G_MIRROR_DISK_FLAG_FORCE_SYNC | \
  65                                          G_MIRROR_DISK_FLAG_INACTIVE)
  66
  67 #define G_MIRROR_DEVICE_FLAG_NOAUTOSYNC 0x0000000000000001ULL
  68 #define G_MIRROR_DEVICE_FLAG_NOFAILSYNC 0x0000000000000002ULL
  69 #define G_MIRROR_DEVICE_FLAG_MASK       (G_MIRROR_DEVICE_FLAG_NOAUTOSYNC | \
  70                                          G_MIRROR_DEVICE_FLAG_NOFAILSYNC)
  71
  72 #ifdef _KERNEL
  73 extern u_int g_mirror_debug;
  74
  75 #define G_MIRROR_DEBUG(lvl, ...)        do {                            \
  76         if (g_mirror_debug >= (lvl)) {                                  \
  77                 printf("GEOM_MIRROR");                                  \
  78                 if (g_mirror_debug > 0)                                 \
  79                         printf("[%u]", lvl);                            \
  80                 printf(": ");                                           \
  81                 printf(__VA_ARGS__);                                    \
  82                 printf("\n");                                           \
  83         }                                                               \
  84 } while (0)
  85 #define G_MIRROR_LOGREQ(lvl, bp, ...)   do {                            \
  86         if (g_mirror_debug >= (lvl)) {                                  \
  87                 printf("GEOM_MIRROR");                                  \
  88                 if (g_mirror_debug > 0)                                 \
  89                         printf("[%u]", lvl);                            \
  90                 printf(": ");                                           \
  91                 printf(__VA_ARGS__);                                    \
  92                 printf(" ");                                            \
  93                 g_print_bio(bp);                                        \
  94                 printf("\n");                                           \
  95         }                                                               \
  96 } while (0)
  97
  98 #define G_MIRROR_BIO_FLAG_REGULAR       0x01
  99 #define G_MIRROR_BIO_FLAG_SYNC          0x02
 100
 101 /*
 102  * Informations needed for synchronization.
 103  */
 104 struct g_mirror_disk_sync {
 105         struct g_consumer *ds_consumer; /* Consumer connected to our mirror. */
 106         off_t             ds_offset;    /* Offset of next request to send. */
 107         off_t             ds_offset_done; /* Offset of already synchronized
 108                                            region. */
 109         u_int             ds_syncid;    /* Disk's synchronization ID. */
 110         u_int             ds_inflight;  /* Number of in-flight sync requests. */
 111         struct bio      **ds_bios;      /* BIOs for synchronization I/O. */
 112 };
 113
 114 /*
 115  * Informations needed for synchronization.
 116  */
 117 struct g_mirror_device_sync {
 118         struct g_geom   *ds_geom;       /* Synchronization geom. */
 119         u_int            ds_ndisks;     /* Number of disks in SYNCHRONIZING
 120                                            state. */
 121 };
 122
 123 #define G_MIRROR_DISK_STATE_NONE                0
 124 #define G_MIRROR_DISK_STATE_NEW                 1
 125 #define G_MIRROR_DISK_STATE_ACTIVE              2
 126 #define G_MIRROR_DISK_STATE_STALE               3
 127 #define G_MIRROR_DISK_STATE_SYNCHRONIZING       4
 128 #define G_MIRROR_DISK_STATE_DISCONNECTED        5
 129 #define G_MIRROR_DISK_STATE_DESTROY             6
 130 struct g_mirror_disk {
 131         uint32_t         d_id;          /* Disk ID. */
 132         struct g_consumer *d_consumer;  /* Consumer. */
 133         struct g_mirror_softc   *d_softc; /* Back-pointer to softc. */
 134         int              d_state;       /* Disk state. */
 135         u_int            d_priority;    /* Disk priority. */
 136         u_int            load;          /* Averaged queue length */
 137         off_t            d_last_offset; /* Last read offset */
 138         uint64_t         d_flags;       /* Additional flags. */
 139         u_int            d_genid;       /* Disk's generation ID. */
 140         struct g_mirror_disk_sync d_sync;/* Sync information. */
 141         LIST_ENTRY(g_mirror_disk) d_next;
 142 };
 143 #define d_name  d_consumer->provider->name
 144
 145 #define G_MIRROR_EVENT_DONTWAIT 0x1
 146 #define G_MIRROR_EVENT_WAIT     0x2
 147 #define G_MIRROR_EVENT_DEVICE   0x4
 148 #define G_MIRROR_EVENT_DONE     0x8
 149 struct g_mirror_event {
 150         struct g_mirror_disk    *e_disk;
 151         int                      e_state;
 152         int                      e_flags;
 153         int                      e_error;
 154         TAILQ_ENTRY(g_mirror_event) e_next;
 155 };
 156
 157 #define G_MIRROR_DEVICE_FLAG_DESTROY    0x0100000000000000ULL
 158 #define G_MIRROR_DEVICE_FLAG_WAIT       0x0200000000000000ULL
 159 #define G_MIRROR_DEVICE_FLAG_DESTROYING 0x0400000000000000ULL
 160
 161 #define G_MIRROR_DEVICE_STATE_STARTING          0
 162 #define G_MIRROR_DEVICE_STATE_RUNNING           1
 163
 164 /* Bump syncid on first write. */
 165 #define G_MIRROR_BUMP_SYNCID    0x1
 166 /* Bump genid immediately. */
 167 #define G_MIRROR_BUMP_GENID     0x2
 168 struct g_mirror_softc {
 169         u_int           sc_state;       /* Device state. */
 170         uint32_t        sc_slice;       /* Slice size. */
 171         uint8_t         sc_balance;     /* Balance algorithm. */
 172         uint64_t        sc_mediasize;   /* Device size. */
 173         uint32_t        sc_sectorsize;  /* Sector size. */
 174         uint64_t        sc_flags;       /* Additional flags. */
 175
 176         struct g_geom   *sc_geom;
 177         struct g_provider *sc_provider;
 178
 179         uint32_t        sc_id;          /* Mirror unique ID. */
 180
 181         struct sx        sc_lock;
 182         struct bio_queue_head sc_queue;
 183         struct mtx       sc_queue_mtx;
 184         struct proc     *sc_worker;
 185         struct bio_queue_head sc_regular_delayed; /* Delayed I/O requests due
 186                                                      collision with sync
 187                                                      requests. */
 188         struct bio_queue_head sc_inflight; /* In-flight regular write
 189                                               requests. */
 190         struct bio_queue_head sc_sync_delayed; /* Delayed sync requests due
 191                                                   collision with regular
 192                                                   requests. */
 193
 194         LIST_HEAD(, g_mirror_disk) sc_disks;
 195         u_int           sc_ndisks;      /* Number of disks. */
 196         struct g_mirror_disk *sc_hint;
 197
 198         u_int           sc_genid;       /* Generation ID. */
 199         u_int           sc_syncid;      /* Synchronization ID. */
 200         int             sc_bump_id;
 201         struct g_mirror_device_sync sc_sync;
 202         int             sc_idle;        /* DIRTY flags removed. */
 203         time_t          sc_last_write;
 204         u_int           sc_writes;
 205
 206         TAILQ_HEAD(, g_mirror_event) sc_events;
 207         struct mtx      sc_events_mtx;
 208
 209         struct callout  sc_callout;
 210
 211         struct root_hold_token *sc_rootmount;
 212 };
 213 #define sc_name sc_geom->name
 214
 215 u_int g_mirror_ndisks(struct g_mirror_softc *sc, int state);
 216 #define G_MIRROR_DESTROY_SOFT           0
 217 #define G_MIRROR_DESTROY_DELAYED        1
 218 #define G_MIRROR_DESTROY_HARD           2
 219 int g_mirror_destroy(struct g_mirror_softc *sc, int how);
 220 int g_mirror_event_send(void *arg, int state, int flags);
 221 struct g_mirror_metadata;
 222 int g_mirror_add_disk(struct g_mirror_softc *sc, struct g_provider *pp,
 223     struct g_mirror_metadata *md);
 224 int g_mirror_read_metadata(struct g_consumer *cp, struct g_mirror_metadata *md);
 225 void g_mirror_fill_metadata(struct g_mirror_softc *sc,
 226     struct g_mirror_disk *disk, struct g_mirror_metadata *md);
 227 void g_mirror_update_metadata(struct g_mirror_disk *disk);
 228
 229 g_ctl_req_t g_mirror_config;
 230 #endif  /* _KERNEL */
 231
 232 struct g_mirror_metadata {
 233         char            md_magic[16];   /* Magic value. */
 234         uint32_t        md_version;     /* Version number. */
 235         char            md_name[16];    /* Mirror name. */
 236         uint32_t        md_mid;         /* Mirror unique ID. */
 237         uint32_t        md_did;         /* Disk unique ID. */
 238         uint8_t         md_all;         /* Number of disks in mirror. */
 239         uint32_t        md_genid;       /* Generation ID. */
 240         uint32_t        md_syncid;      /* Synchronization ID. */
 241         uint8_t         md_priority;    /* Disk priority. */
 242         uint32_t        md_slice;       /* Slice size. */
 243         uint8_t         md_balance;     /* Balance type. */
 244         uint64_t        md_mediasize;   /* Size of the smallest
 245                                            disk in mirror. */
 246         uint32_t        md_sectorsize;  /* Sector size. */
 247         uint64_t        md_sync_offset; /* Synchronized offset. */
 248         uint64_t        md_mflags;      /* Additional mirror flags. */
 249         uint64_t        md_dflags;      /* Additional disk flags. */
 250         char            md_provider[16]; /* Hardcoded provider. */
 251         uint64_t        md_provsize;    /* Provider's size. */
 252         u_char          md_hash[16];    /* MD5 hash. */
 253 };
 254 static __inline void
 255 mirror_metadata_encode(struct g_mirror_metadata *md, u_char *data)
 256 {
 257         MD5_CTX ctx;
 258
 259         bcopy(md->md_magic, data, 16);
 260         le32enc(data + 16, md->md_version);
 261         bcopy(md->md_name, data + 20, 16);
 262         le32enc(data + 36, md->md_mid);
 263         le32enc(data + 40, md->md_did);
 264         *(data + 44) = md->md_all;
 265         le32enc(data + 45, md->md_genid);
 266         le32enc(data + 49, md->md_syncid);
 267         *(data + 53) = md->md_priority;
 268         le32enc(data + 54, md->md_slice);
 269         *(data + 58) = md->md_balance;
 270         le64enc(data + 59, md->md_mediasize);
 271         le32enc(data + 67, md->md_sectorsize);
 272         le64enc(data + 71, md->md_sync_offset);
 273         le64enc(data + 79, md->md_mflags);
 274         le64enc(data + 87, md->md_dflags);
 275         bcopy(md->md_provider, data + 95, 16);
 276         le64enc(data + 111, md->md_provsize);
 277         MD5Init(&ctx);
 278         MD5Update(&ctx, data, 119);
 279         MD5Final(md->md_hash, &ctx);
 280         bcopy(md->md_hash, data + 119, 16);
 281 }
 282 static __inline int
 283 mirror_metadata_decode_v0v1(const u_char *data, struct g_mirror_metadata *md)
 284 {
 285         MD5_CTX ctx;
 286
 287         bcopy(data + 20, md->md_name, 16);
 288         md->md_mid = le32dec(data + 36);
 289         md->md_did = le32dec(data + 40);
 290         md->md_all = *(data + 44);
 291         md->md_syncid = le32dec(data + 45);
 292         md->md_priority = *(data + 49);
 293         md->md_slice = le32dec(data + 50);
 294         md->md_balance = *(data + 54);
 295         md->md_mediasize = le64dec(data + 55);
 296         md->md_sectorsize = le32dec(data + 63);
 297         md->md_sync_offset = le64dec(data + 67);
 298         md->md_mflags = le64dec(data + 75);
 299         md->md_dflags = le64dec(data + 83);
 300         bcopy(data + 91, md->md_provider, 16);
 301         bcopy(data + 107, md->md_hash, 16);
 302         MD5Init(&ctx);
 303         MD5Update(&ctx, data, 107);
 304         MD5Final(md->md_hash, &ctx);
 305         if (bcmp(md->md_hash, data + 107, 16) != 0)
 306                 return (EINVAL);
 307
 308         /* New fields. */
 309         md->md_genid = 0;
 310         md->md_provsize = 0;
 311
 312         return (0);
 313 }
 314 static __inline int
 315 mirror_metadata_decode_v2(const u_char *data, struct g_mirror_metadata *md)
 316 {
 317         MD5_CTX ctx;
 318
 319         bcopy(data + 20, md->md_name, 16);
 320         md->md_mid = le32dec(data + 36);
 321         md->md_did = le32dec(data + 40);
 322         md->md_all = *(data + 44);
 323         md->md_genid = le32dec(data + 45);
 324         md->md_syncid = le32dec(data + 49);
 325         md->md_priority = *(data + 53);
 326         md->md_slice = le32dec(data + 54);
 327         md->md_balance = *(data + 58);
 328         md->md_mediasize = le64dec(data + 59);
 329         md->md_sectorsize = le32dec(data + 67);
 330         md->md_sync_offset = le64dec(data + 71);
 331         md->md_mflags = le64dec(data + 79);
 332         md->md_dflags = le64dec(data + 87);
 333         bcopy(data + 95, md->md_provider, 16);
 334         bcopy(data + 111, md->md_hash, 16);
 335         MD5Init(&ctx);
 336         MD5Update(&ctx, data, 111);
 337         MD5Final(md->md_hash, &ctx);
 338         if (bcmp(md->md_hash, data + 111, 16) != 0)
 339                 return (EINVAL);
 340
 341         /* New fields. */
 342         md->md_provsize = 0;
 343
 344         return (0);
 345 }
 346 static __inline int
 347 mirror_metadata_decode_v3v4(const u_char *data, struct g_mirror_metadata *md)
 348 {
 349         MD5_CTX ctx;
 350
 351         bcopy(data + 20, md->md_name, 16);
 352         md->md_mid = le32dec(data + 36);
 353         md->md_did = le32dec(data + 40);
 354         md->md_all = *(data + 44);
 355         md->md_genid = le32dec(data + 45);
 356         md->md_syncid = le32dec(data + 49);
 357         md->md_priority = *(data + 53);
 358         md->md_slice = le32dec(data + 54);
 359         md->md_balance = *(data + 58);
 360         md->md_mediasize = le64dec(data + 59);
 361         md->md_sectorsize = le32dec(data + 67);
 362         md->md_sync_offset = le64dec(data + 71);
 363         md->md_mflags = le64dec(data + 79);
 364         md->md_dflags = le64dec(data + 87);
 365         bcopy(data + 95, md->md_provider, 16);
 366         md->md_provsize = le64dec(data + 111);
 367         bcopy(data + 119, md->md_hash, 16);
 368         MD5Init(&ctx);
 369         MD5Update(&ctx, data, 119);
 370         MD5Final(md->md_hash, &ctx);
 371         if (bcmp(md->md_hash, data + 119, 16) != 0)
 372                 return (EINVAL);
 373         return (0);
 374 }
 375 static __inline int
 376 mirror_metadata_decode(const u_char *data, struct g_mirror_metadata *md)
 377 {
 378         int error;
 379
 380         bcopy(data, md->md_magic, 16);
 381         md->md_version = le32dec(data + 16);
 382         switch (md->md_version) {
 383         case 0:
 384         case 1:
 385                 error = mirror_metadata_decode_v0v1(data, md);
 386                 break;
 387         case 2:
 388                 error = mirror_metadata_decode_v2(data, md);
 389                 break;
 390         case 3:
 391         case 4:
 392                 error = mirror_metadata_decode_v3v4(data, md);
 393                 break;
 394         default:
 395                 error = EINVAL;
 396                 break;
 397         }
 398         return (error);
 399 }
 400
 401 static __inline const char *
 402 balance_name(u_int balance)
 403 {
 404         static const char *algorithms[] = {
 405                 [G_MIRROR_BALANCE_NONE] = "none",
 406                 [G_MIRROR_BALANCE_ROUND_ROBIN] = "round-robin",
 407                 [G_MIRROR_BALANCE_LOAD] = "load",
 408                 [G_MIRROR_BALANCE_SPLIT] = "split",
 409                 [G_MIRROR_BALANCE_PREFER] = "prefer",
 410                 [G_MIRROR_BALANCE_MAX + 1] = "unknown"
 411         };
 412
 413         if (balance > G_MIRROR_BALANCE_MAX)
 414                 balance = G_MIRROR_BALANCE_MAX + 1;
 415
 416         return (algorithms[balance]);
 417 }
 418
 419 static __inline int
 420 balance_id(const char *name)
 421 {
 422         static const char *algorithms[] = {
 423                 [G_MIRROR_BALANCE_NONE] = "none",
 424                 [G_MIRROR_BALANCE_ROUND_ROBIN] = "round-robin",
 425                 [G_MIRROR_BALANCE_LOAD] = "load",
 426                 [G_MIRROR_BALANCE_SPLIT] = "split",
 427                 [G_MIRROR_BALANCE_PREFER] = "prefer"
 428         };
 429         int n;
 430
 431         for (n = G_MIRROR_BALANCE_MIN; n <= G_MIRROR_BALANCE_MAX; n++) {
 432                 if (strcmp(name, algorithms[n]) == 0)
 433                         return (n);
 434         }
 435         return (-1);
 436 }
 437
 438 static __inline void
 439 mirror_metadata_dump(const struct g_mirror_metadata *md)
 440 {
 441         static const char hex[] = "0123456789abcdef";
 442         char hash[16 * 2 + 1];
 443         u_int i;
 444
 445         printf("     magic: %s\n", md->md_magic);
 446         printf("   version: %u\n", (u_int)md->md_version);
 447         printf("      name: %s\n", md->md_name);
 448         printf("       mid: %u\n", (u_int)md->md_mid);
 449         printf("       did: %u\n", (u_int)md->md_did);
 450         printf("       all: %u\n", (u_int)md->md_all);
 451         printf("     genid: %u\n", (u_int)md->md_genid);
 452         printf("    syncid: %u\n", (u_int)md->md_syncid);
 453         printf("  priority: %u\n", (u_int)md->md_priority);
 454         printf("     slice: %u\n", (u_int)md->md_slice);
 455         printf("   balance: %s\n", balance_name((u_int)md->md_balance));
 456         printf(" mediasize: %jd\n", (intmax_t)md->md_mediasize);
 457         printf("sectorsize: %u\n", (u_int)md->md_sectorsize);
 458         printf("syncoffset: %jd\n", (intmax_t)md->md_sync_offset);
 459         printf("    mflags:");
 460         if (md->md_mflags == 0)
 461                 printf(" NONE");
 462         else {
 463                 if ((md->md_mflags & G_MIRROR_DEVICE_FLAG_NOFAILSYNC) != 0)
 464                         printf(" NOFAILSYNC");
 465                 if ((md->md_mflags & G_MIRROR_DEVICE_FLAG_NOAUTOSYNC) != 0)
 466                         printf(" NOAUTOSYNC");
 467         }
 468         printf("\n");
 469         printf("    dflags:");
 470         if (md->md_dflags == 0)
 471                 printf(" NONE");
 472         else {
 473                 if ((md->md_dflags & G_MIRROR_DISK_FLAG_DIRTY) != 0)
 474                         printf(" DIRTY");
 475                 if ((md->md_dflags & G_MIRROR_DISK_FLAG_SYNCHRONIZING) != 0)
 476                         printf(" SYNCHRONIZING");
 477                 if ((md->md_dflags & G_MIRROR_DISK_FLAG_FORCE_SYNC) != 0)
 478                         printf(" FORCE_SYNC");
 479                 if ((md->md_dflags & G_MIRROR_DISK_FLAG_INACTIVE) != 0)
 480                         printf(" INACTIVE");
 481         }
 482         printf("\n");
 483         printf("hcprovider: %s\n", md->md_provider);
 484         printf("  provsize: %ju\n", (uintmax_t)md->md_provsize);
 485         bzero(hash, sizeof(hash));
 486         for (i = 0; i < 16; i++) {
 487                 hash[i * 2] = hex[md->md_hash[i] >> 4];
 488                 hash[i * 2 + 1] = hex[md->md_hash[i] & 0x0f];
 489         }
 490         printf("  MD5 hash: %s\n", hash);
 491 }
 492 #endif  /* !_G_MIRROR_H_ */