g_raid3.h

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 2004-2006 Pawel Jakub Dawidek <pjd@FreeBSD.org>
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  *
   16  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
   17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
   20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   26  * SUCH DAMAGE.
   27  *
   28  * $FreeBSD$
   29  */
   30 
   31 #ifndef _G_RAID3_H_
   32 #define _G_RAID3_H_
   33 
   34 #include <sys/endian.h>
   35 #include <sys/md5.h>
   36 
   37 #define G_RAID3_CLASS_NAME      "RAID3"
   38 
   39 #define G_RAID3_MAGIC           "GEOM::RAID3"
   40 /*
   41  * Version history:
   42  * 0 - Initial version number.
   43  * 1 - Added 'round-robin reading' algorithm.
   44  * 2 - Added 'verify reading' algorithm.
   45  * 3 - Added md_genid field to metadata.
   46  * 4 - Added md_provsize field to metadata.
   47  * 5 - Added 'no failure synchronization' flag.
   48  */
   49 #define G_RAID3_VERSION         5
   50 
   51 #define G_RAID3_DISK_FLAG_DIRTY         0x0000000000000001ULL
   52 #define G_RAID3_DISK_FLAG_SYNCHRONIZING 0x0000000000000002ULL
   53 #define G_RAID3_DISK_FLAG_FORCE_SYNC    0x0000000000000004ULL
   54 #define G_RAID3_DISK_FLAG_HARDCODED     0x0000000000000008ULL
   55 #define G_RAID3_DISK_FLAG_BROKEN        0x0000000000000010ULL
   56 #define G_RAID3_DISK_FLAG_MASK          (G_RAID3_DISK_FLAG_DIRTY |      \
   57                                          G_RAID3_DISK_FLAG_SYNCHRONIZING | \
   58                                          G_RAID3_DISK_FLAG_FORCE_SYNC)
   59 
   60 #define G_RAID3_DEVICE_FLAG_NOAUTOSYNC  0x0000000000000001ULL
   61 #define G_RAID3_DEVICE_FLAG_ROUND_ROBIN 0x0000000000000002ULL
   62 #define G_RAID3_DEVICE_FLAG_VERIFY      0x0000000000000004ULL
   63 #define G_RAID3_DEVICE_FLAG_NOFAILSYNC  0x0000000000000008ULL
   64 #define G_RAID3_DEVICE_FLAG_MASK        (G_RAID3_DEVICE_FLAG_NOAUTOSYNC | \
   65                                          G_RAID3_DEVICE_FLAG_ROUND_ROBIN | \
   66                                          G_RAID3_DEVICE_FLAG_VERIFY | \
   67                                          G_RAID3_DEVICE_FLAG_NOFAILSYNC)
   68 
   69 #ifdef _KERNEL
   70 extern u_int g_raid3_debug;
   71 
   72 #define G_RAID3_DEBUG(lvl, ...) \
   73     _GEOM_DEBUG("GEOM_RAID3", g_raid3_debug, (lvl), NULL, __VA_ARGS__)
   74 #define G_RAID3_LOGREQ(lvl, bp, ...) \
   75     _GEOM_DEBUG("GEOM_RAID3", g_raid3_debug, (lvl), (bp), __VA_ARGS__)
   76 
   77 #define G_RAID3_BIO_CFLAG_REGULAR       0x01
   78 #define G_RAID3_BIO_CFLAG_SYNC          0x02
   79 #define G_RAID3_BIO_CFLAG_PARITY        0x04
   80 #define G_RAID3_BIO_CFLAG_NODISK        0x08
   81 #define G_RAID3_BIO_CFLAG_REGSYNC       0x10
   82 #define G_RAID3_BIO_CFLAG_MASK          (G_RAID3_BIO_CFLAG_REGULAR |    \
   83                                          G_RAID3_BIO_CFLAG_SYNC |       \
   84                                          G_RAID3_BIO_CFLAG_PARITY |     \
   85                                          G_RAID3_BIO_CFLAG_NODISK |     \
   86                                          G_RAID3_BIO_CFLAG_REGSYNC)
   87 
   88 #define G_RAID3_BIO_PFLAG_DEGRADED      0x01
   89 #define G_RAID3_BIO_PFLAG_NOPARITY      0x02
   90 #define G_RAID3_BIO_PFLAG_VERIFY        0x04
   91 #define G_RAID3_BIO_PFLAG_MASK          (G_RAID3_BIO_PFLAG_DEGRADED |   \
   92                                          G_RAID3_BIO_PFLAG_NOPARITY |   \
   93                                          G_RAID3_BIO_PFLAG_VERIFY)
   94 
   95 /*
   96  * Informations needed for synchronization.
   97  */
   98 struct g_raid3_disk_sync {
   99         struct g_consumer *ds_consumer; /* Consumer connected to our device. */
  100         off_t             ds_offset;    /* Offset of next request to send. */
  101         off_t             ds_offset_done; /* Offset of already synchronized
  102                                            region. */
  103         off_t             ds_resync;    /* Resynchronize from this offset. */
  104         u_int             ds_syncid;    /* Disk's synchronization ID. */
  105         u_int             ds_inflight;  /* Number of in-flight sync requests. */
  106         struct bio      **ds_bios;      /* BIOs for synchronization I/O. */
  107 };
  108 
  109 /*
  110  * Informations needed for synchronization.
  111  */
  112 struct g_raid3_device_sync {
  113         struct g_geom   *ds_geom;       /* Synchronization geom. */
  114 };
  115 
  116 #define G_RAID3_DISK_STATE_NODISK               0
  117 #define G_RAID3_DISK_STATE_NONE                 1
  118 #define G_RAID3_DISK_STATE_NEW                  2
  119 #define G_RAID3_DISK_STATE_ACTIVE               3
  120 #define G_RAID3_DISK_STATE_STALE                4
  121 #define G_RAID3_DISK_STATE_SYNCHRONIZING        5
  122 #define G_RAID3_DISK_STATE_DISCONNECTED         6
  123 #define G_RAID3_DISK_STATE_DESTROY              7
  124 struct g_raid3_disk {
  125         u_int            d_no;          /* Disk number. */
  126         struct g_consumer *d_consumer;  /* Consumer. */
  127         struct g_raid3_softc *d_softc;  /* Back-pointer to softc. */
  128         int              d_state;       /* Disk state. */
  129         uint64_t         d_flags;       /* Additional flags. */
  130         u_int            d_genid;       /* Disk's generation ID. */
  131         struct g_raid3_disk_sync d_sync; /* Sync information. */
  132         LIST_ENTRY(g_raid3_disk) d_next;
  133 };
  134 #define d_name  d_consumer->provider->name
  135 
  136 #define G_RAID3_EVENT_DONTWAIT  0x1
  137 #define G_RAID3_EVENT_WAIT      0x2
  138 #define G_RAID3_EVENT_DEVICE    0x4
  139 #define G_RAID3_EVENT_DONE      0x8
  140 struct g_raid3_event {
  141         struct g_raid3_disk     *e_disk;
  142         int                      e_state;
  143         int                      e_flags;
  144         int                      e_error;
  145         TAILQ_ENTRY(g_raid3_event) e_next;
  146 };
  147 
  148 #define G_RAID3_DEVICE_FLAG_DESTROY     0x0100000000000000ULL
  149 #define G_RAID3_DEVICE_FLAG_WAIT        0x0200000000000000ULL
  150 #define G_RAID3_DEVICE_FLAG_DESTROYING  0x0400000000000000ULL
  151 
  152 #define G_RAID3_DEVICE_STATE_STARTING           0
  153 #define G_RAID3_DEVICE_STATE_DEGRADED           1
  154 #define G_RAID3_DEVICE_STATE_COMPLETE           2
  155 
  156 /* Bump syncid on first write. */
  157 #define G_RAID3_BUMP_SYNCID     0x1
  158 /* Bump genid immediately. */
  159 #define G_RAID3_BUMP_GENID      0x2
  160 
  161 enum g_raid3_zones {
  162         G_RAID3_ZONE_64K,
  163         G_RAID3_ZONE_16K,
  164         G_RAID3_ZONE_4K,
  165         G_RAID3_NUM_ZONES
  166 };
  167 
  168 static __inline enum g_raid3_zones
  169 g_raid3_zone(size_t nbytes) {
  170         if (nbytes > 65536)
  171                 return (G_RAID3_NUM_ZONES);
  172         else if (nbytes > 16384)
  173                 return (G_RAID3_ZONE_64K);
  174         else if (nbytes > 4096)
  175                 return (G_RAID3_ZONE_16K);
  176         else
  177                 return (G_RAID3_ZONE_4K);
  178 };
  179 
  180 struct g_raid3_softc {
  181         u_int           sc_state;       /* Device state. */
  182         uint64_t        sc_mediasize;   /* Device size. */
  183         uint32_t        sc_sectorsize;  /* Sector size. */
  184         uint64_t        sc_flags;       /* Additional flags. */
  185 
  186         struct g_geom   *sc_geom;
  187         struct g_provider *sc_provider;
  188 
  189         uint32_t        sc_id;          /* Device unique ID. */
  190 
  191         struct sx        sc_lock;
  192         struct bio_queue_head sc_queue;
  193         struct mtx       sc_queue_mtx;
  194         struct proc     *sc_worker;
  195         struct bio_queue_head sc_regular_delayed; /* Delayed I/O requests due
  196                                                      collision with sync
  197                                                      requests. */
  198         struct bio_queue_head sc_inflight; /* In-flight regular write
  199                                               requests. */
  200         struct bio_queue_head sc_sync_delayed; /* Delayed sync requests due
  201                                                   collision with regular
  202                                                   requests. */
  203 
  204         struct g_raid3_disk *sc_disks;
  205         u_int           sc_ndisks;      /* Number of disks. */
  206         u_int           sc_round_robin;
  207         struct g_raid3_disk *sc_syncdisk;
  208 
  209         struct g_raid3_zone {
  210                 uma_zone_t      sz_zone;
  211                 size_t          sz_inuse;
  212                 size_t          sz_max;
  213                 u_int           sz_requested;
  214                 u_int           sz_failed;
  215         } sc_zones[G_RAID3_NUM_ZONES];
  216 
  217         u_int           sc_genid;       /* Generation ID. */
  218         u_int           sc_syncid;      /* Synchronization ID. */
  219         int             sc_bump_id;
  220         struct g_raid3_device_sync sc_sync;
  221         int             sc_idle;        /* DIRTY flags removed. */
  222         time_t          sc_last_write;
  223         u_int           sc_writes;
  224 
  225         TAILQ_HEAD(, g_raid3_event) sc_events;
  226         struct mtx      sc_events_mtx;
  227 
  228         struct callout  sc_callout;
  229 
  230         struct root_hold_token *sc_rootmount;
  231 };
  232 #define sc_name sc_geom->name
  233 
  234 const char *g_raid3_get_diskname(struct g_raid3_disk *disk);
  235 u_int g_raid3_ndisks(struct g_raid3_softc *sc, int state);
  236 #define G_RAID3_DESTROY_SOFT    0
  237 #define G_RAID3_DESTROY_DELAYED 1
  238 #define G_RAID3_DESTROY_HARD    2
  239 int g_raid3_destroy(struct g_raid3_softc *sc, int how);
  240 int g_raid3_event_send(void *arg, int state, int flags);
  241 struct g_raid3_metadata;
  242 int g_raid3_add_disk(struct g_raid3_softc *sc, struct g_provider *pp,
  243     struct g_raid3_metadata *md);
  244 int g_raid3_read_metadata(struct g_consumer *cp, struct g_raid3_metadata *md);
  245 void g_raid3_fill_metadata(struct g_raid3_disk *disk,
  246     struct g_raid3_metadata *md);
  247 int g_raid3_clear_metadata(struct g_raid3_disk *disk);
  248 void g_raid3_update_metadata(struct g_raid3_disk *disk);
  249 
  250 g_ctl_req_t g_raid3_config;
  251 #endif  /* _KERNEL */
  252 
  253 struct g_raid3_metadata {
  254         char            md_magic[16];   /* Magic value. */
  255         uint32_t        md_version;     /* Version number. */
  256         char            md_name[16];    /* Device name. */
  257         uint32_t        md_id;          /* Device unique ID. */
  258         uint16_t        md_no;          /* Component number. */
  259         uint16_t        md_all;         /* Number of disks in device. */
  260         uint32_t        md_genid;       /* Generation ID. */
  261         uint32_t        md_syncid;      /* Synchronization ID. */
  262         uint64_t        md_mediasize;   /* Size of whole device. */
  263         uint32_t        md_sectorsize;  /* Sector size. */
  264         uint64_t        md_sync_offset; /* Synchronized offset. */
  265         uint64_t        md_mflags;      /* Additional device flags. */
  266         uint64_t        md_dflags;      /* Additional disk flags. */
  267         char            md_provider[16]; /* Hardcoded provider. */
  268         uint64_t        md_provsize;    /* Provider's size. */
  269         u_char          md_hash[16];    /* MD5 hash. */
  270 };
  271 static __inline void
  272 raid3_metadata_encode(struct g_raid3_metadata *md, u_char *data)
  273 {
  274         MD5_CTX ctx;
  275 
  276         bcopy(md->md_magic, data, 16);
  277         le32enc(data + 16, md->md_version);
  278         bcopy(md->md_name, data + 20, 16);
  279         le32enc(data + 36, md->md_id);
  280         le16enc(data + 40, md->md_no);
  281         le16enc(data + 42, md->md_all);
  282         le32enc(data + 44, md->md_genid);
  283         le32enc(data + 48, md->md_syncid);
  284         le64enc(data + 52, md->md_mediasize);
  285         le32enc(data + 60, md->md_sectorsize);
  286         le64enc(data + 64, md->md_sync_offset);
  287         le64enc(data + 72, md->md_mflags);
  288         le64enc(data + 80, md->md_dflags);
  289         bcopy(md->md_provider, data + 88, 16);
  290         le64enc(data + 104, md->md_provsize);
  291         MD5Init(&ctx);
  292         MD5Update(&ctx, data, 112);
  293         MD5Final(md->md_hash, &ctx);
  294         bcopy(md->md_hash, data + 112, 16);
  295 }
  296 static __inline int
  297 raid3_metadata_decode_v0v1v2(const u_char *data, struct g_raid3_metadata *md)
  298 {
  299         MD5_CTX ctx;
  300 
  301         bcopy(data + 20, md->md_name, 16);
  302         md->md_id = le32dec(data + 36);
  303         md->md_no = le16dec(data + 40);
  304         md->md_all = le16dec(data + 42);
  305         md->md_syncid = le32dec(data + 44);
  306         md->md_mediasize = le64dec(data + 48);
  307         md->md_sectorsize = le32dec(data + 56);
  308         md->md_sync_offset = le64dec(data + 60);
  309         md->md_mflags = le64dec(data + 68);
  310         md->md_dflags = le64dec(data + 76);
  311         bcopy(data + 84, md->md_provider, 16);
  312         bcopy(data + 100, md->md_hash, 16);
  313         MD5Init(&ctx);
  314         MD5Update(&ctx, data, 100);
  315         MD5Final(md->md_hash, &ctx);
  316         if (bcmp(md->md_hash, data + 100, 16) != 0)
  317                 return (EINVAL);
  318 
  319         /* New fields. */
  320         md->md_genid = 0;
  321         md->md_provsize = 0;
  322 
  323         return (0);
  324 }
  325 static __inline int
  326 raid3_metadata_decode_v3(const u_char *data, struct g_raid3_metadata *md)
  327 {
  328         MD5_CTX ctx;
  329 
  330         bcopy(data + 20, md->md_name, 16);
  331         md->md_id = le32dec(data + 36);
  332         md->md_no = le16dec(data + 40);
  333         md->md_all = le16dec(data + 42);
  334         md->md_genid = le32dec(data + 44);
  335         md->md_syncid = le32dec(data + 48);
  336         md->md_mediasize = le64dec(data + 52);
  337         md->md_sectorsize = le32dec(data + 60);
  338         md->md_sync_offset = le64dec(data + 64);
  339         md->md_mflags = le64dec(data + 72);
  340         md->md_dflags = le64dec(data + 80);
  341         bcopy(data + 88, md->md_provider, 16);
  342         bcopy(data + 104, md->md_hash, 16);
  343         MD5Init(&ctx);
  344         MD5Update(&ctx, data, 104);
  345         MD5Final(md->md_hash, &ctx);
  346         if (bcmp(md->md_hash, data + 104, 16) != 0)
  347                 return (EINVAL);
  348 
  349         /* New fields. */
  350         md->md_provsize = 0;
  351 
  352         return (0);
  353 }
  354 static __inline int
  355 raid3_metadata_decode_v4v5(const u_char *data, struct g_raid3_metadata *md)
  356 {
  357         MD5_CTX ctx;
  358 
  359         bcopy(data + 20, md->md_name, 16);
  360         md->md_id = le32dec(data + 36);
  361         md->md_no = le16dec(data + 40);
  362         md->md_all = le16dec(data + 42);
  363         md->md_genid = le32dec(data + 44);
  364         md->md_syncid = le32dec(data + 48);
  365         md->md_mediasize = le64dec(data + 52);
  366         md->md_sectorsize = le32dec(data + 60);
  367         md->md_sync_offset = le64dec(data + 64);
  368         md->md_mflags = le64dec(data + 72);
  369         md->md_dflags = le64dec(data + 80);
  370         bcopy(data + 88, md->md_provider, 16);
  371         md->md_provsize = le64dec(data + 104);
  372         bcopy(data + 112, md->md_hash, 16);
  373         MD5Init(&ctx);
  374         MD5Update(&ctx, data, 112);
  375         MD5Final(md->md_hash, &ctx);
  376         if (bcmp(md->md_hash, data + 112, 16) != 0)
  377                 return (EINVAL);
  378         return (0);
  379 }
  380 static __inline int
  381 raid3_metadata_decode(const u_char *data, struct g_raid3_metadata *md)
  382 {
  383         int error;
  384 
  385         bcopy(data, md->md_magic, 16);
  386         md->md_version = le32dec(data + 16);
  387         switch (md->md_version) {
  388         case 0:
  389         case 1:
  390         case 2:
  391                 error = raid3_metadata_decode_v0v1v2(data, md);
  392                 break;
  393         case 3:
  394                 error = raid3_metadata_decode_v3(data, md);
  395                 break;
  396         case 4:
  397         case 5:
  398                 error = raid3_metadata_decode_v4v5(data, md);
  399                 break;
  400         default:
  401                 error = EINVAL;
  402                 break;
  403         }
  404         return (error);
  405 }
  406 
  407 static __inline void
  408 raid3_metadata_dump(const struct g_raid3_metadata *md)
  409 {
  410         static const char hex[] = "0123456789abcdef";
  411         char hash[16 * 2 + 1];
  412         u_int i;
  413 
  414         printf("     magic: %s\n", md->md_magic);
  415         printf("   version: %u\n", (u_int)md->md_version);
  416         printf("      name: %s\n", md->md_name);
  417         printf("        id: %u\n", (u_int)md->md_id);
  418         printf("        no: %u\n", (u_int)md->md_no);
  419         printf("       all: %u\n", (u_int)md->md_all);
  420         printf("     genid: %u\n", (u_int)md->md_genid);
  421         printf("    syncid: %u\n", (u_int)md->md_syncid);
  422         printf(" mediasize: %jd\n", (intmax_t)md->md_mediasize);
  423         printf("sectorsize: %u\n", (u_int)md->md_sectorsize);
  424         printf("syncoffset: %jd\n", (intmax_t)md->md_sync_offset);
  425         printf("    mflags:");
  426         if (md->md_mflags == 0)
  427                 printf(" NONE");
  428         else {
  429                 if ((md->md_mflags & G_RAID3_DEVICE_FLAG_NOAUTOSYNC) != 0)
  430                         printf(" NOAUTOSYNC");
  431                 if ((md->md_mflags & G_RAID3_DEVICE_FLAG_ROUND_ROBIN) != 0)
  432                         printf(" ROUND-ROBIN");
  433                 if ((md->md_mflags & G_RAID3_DEVICE_FLAG_VERIFY) != 0)
  434                         printf(" VERIFY");
  435                 if ((md->md_mflags & G_RAID3_DEVICE_FLAG_NOFAILSYNC) != 0)
  436                         printf(" NOFAILSYNC");
  437         }
  438         printf("\n");
  439         printf("    dflags:");
  440         if (md->md_dflags == 0)
  441                 printf(" NONE");
  442         else {
  443                 if ((md->md_dflags & G_RAID3_DISK_FLAG_DIRTY) != 0)
  444                         printf(" DIRTY");
  445                 if ((md->md_dflags & G_RAID3_DISK_FLAG_SYNCHRONIZING) != 0)
  446                         printf(" SYNCHRONIZING");
  447                 if ((md->md_dflags & G_RAID3_DISK_FLAG_FORCE_SYNC) != 0)
  448                         printf(" FORCE_SYNC");
  449         }
  450         printf("\n");
  451         printf("hcprovider: %s\n", md->md_provider);
  452         printf("  provsize: %ju\n", (uintmax_t)md->md_provsize);
  453         bzero(hash, sizeof(hash));
  454         for (i = 0; i < 16; i++) {
  455                 hash[i * 2] = hex[md->md_hash[i] >> 4];
  456                 hash[i * 2 + 1] = hex[md->md_hash[i] & 0x0f];
  457         }
  458         printf("  MD5 hash: %s\n", hash);
  459 }
  460 #endif  /* !_G_RAID3_H_ */
Cache object: 4ef7d77341693e2061c7df2d2ab70eee
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/geom/raid3/g_raid3.h

FreeBSD/Linux Kernel Cross Reference
sys/geom/raid3/g_raid3.h
