d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
93f62be898
freebsd-skq/sys/geom/raid3/g_raid3.h
pjd 668a028670 - Add md_provsize field to metadata, which will help with 
shared-last-sector problem.
  After this change, even if there is more than one provider with the same
  last sector, the proper one will be chosen based on its size.
  It still doesn't fix the 'c' partition problem (when da0s1 can be confused
  with da0s1c) and situation when 'a' partition starts at offset 0
  (then da0s1a can be confused with da0s1 and da0s1c). One can use '-h'
  option there, when creating device or avoid sharing last sector.
  Actually, when providers share the same last sector and their size is equal,
  they provide exactly the same data, so the name (da0s1, da0s1a, da0s1c)
  isn't important at all.
- Provide backward compatibility.
- Update copyright's year.

MFC after:	1 week
2005-02-27 23:07:47 +00:00

429 lines
13 KiB
C
Raw Blame History

/*-
* Copyright (c) 2004-2005 Pawel Jakub Dawidek <pjd@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#ifndef _G_RAID3_H_
#define _G_RAID3_H_
#include <sys/endian.h>
#include <sys/md5.h>
#define G_RAID3_CLASS_NAME "RAID3"
#define G_RAID3_MAGIC "GEOM::RAID3"
/*
* Version history:
* 0 - Initial version number.
* 1 - Added 'round-robin reading' algorithm.
* 2 - Added 'verify reading' algorithm.
* 3 - Added md_genid field to metadata.
* 4 - Added md_provsize field to metadata.
*/
#define G_RAID3_VERSION 4
#define G_RAID3_DISK_FLAG_DIRTY 0x0000000000000001ULL
#define G_RAID3_DISK_FLAG_SYNCHRONIZING 0x0000000000000002ULL
#define G_RAID3_DISK_FLAG_FORCE_SYNC 0x0000000000000004ULL
#define G_RAID3_DISK_FLAG_HARDCODED 0x0000000000000008ULL
#define G_RAID3_DISK_FLAG_MASK (G_RAID3_DISK_FLAG_DIRTY | \
G_RAID3_DISK_FLAG_SYNCHRONIZING | \
G_RAID3_DISK_FLAG_FORCE_SYNC)
#define G_RAID3_DEVICE_FLAG_NOAUTOSYNC 0x0000000000000001ULL
#define G_RAID3_DEVICE_FLAG_ROUND_ROBIN 0x0000000000000002ULL
#define G_RAID3_DEVICE_FLAG_VERIFY 0x0000000000000004ULL
#define G_RAID3_DEVICE_FLAG_MASK (G_RAID3_DEVICE_FLAG_NOAUTOSYNC | \
G_RAID3_DEVICE_FLAG_ROUND_ROBIN | \
G_RAID3_DEVICE_FLAG_VERIFY)
#ifdef _KERNEL
extern u_int g_raid3_debug;
#define G_RAID3_DEBUG(lvl, ...) do { \
if (g_raid3_debug >= (lvl)) { \
printf("GEOM_RAID3"); \
if (g_raid3_debug > 0) \
printf("[%u]", lvl); \
printf(": "); \
printf(__VA_ARGS__); \
printf("\n"); \
} \
} while (0)
#define G_RAID3_LOGREQ(lvl, bp, ...) do { \
if (g_raid3_debug >= (lvl)) { \
printf("GEOM_RAID3"); \
if (g_raid3_debug > 0) \
printf("[%u]", lvl); \
printf(": "); \
printf(__VA_ARGS__); \
printf(" "); \
g_print_bio(bp); \
printf("\n"); \
} \
} while (0)
#define G_RAID3_BIO_CFLAG_REGULAR 0x01
#define G_RAID3_BIO_CFLAG_SYNC 0x02
#define G_RAID3_BIO_CFLAG_PARITY 0x04
#define G_RAID3_BIO_CFLAG_NODISK 0x08
#define G_RAID3_BIO_CFLAG_REGSYNC 0x10
#define G_RAID3_BIO_CFLAG_MASK (G_RAID3_BIO_CFLAG_REGULAR | \
G_RAID3_BIO_CFLAG_SYNC | \
G_RAID3_BIO_CFLAG_PARITY | \
G_RAID3_BIO_CFLAG_NODISK | \
G_RAID3_BIO_CFLAG_REGSYNC)
#define G_RAID3_BIO_PFLAG_DEGRADED 0x01
#define G_RAID3_BIO_PFLAG_NOPARITY 0x02
#define G_RAID3_BIO_PFLAG_VERIFY 0x04
#define G_RAID3_BIO_PFLAG_MASK (G_RAID3_BIO_PFLAG_DEGRADED | \
G_RAID3_BIO_PFLAG_NOPARITY | \
G_RAID3_BIO_PFLAG_VERIFY)
/*
* Informations needed for synchronization.
*/
struct g_raid3_disk_sync {
struct g_consumer *ds_consumer; /* Consumer connected to our device. */
off_t ds_offset; /* Offset of next request to send. */
off_t ds_offset_done; /* Offset of already synchronized
region. */
off_t ds_resync; /* Resynchronize from this offset. */
u_int ds_syncid; /* Disk's synchronization ID. */
u_char *ds_data;
};
/*
* Informations needed for synchronization.
*/
struct g_raid3_device_sync {
struct g_geom *ds_geom; /* Synchronization geom. */
};
#define G_RAID3_DISK_STATE_NODISK 0
#define G_RAID3_DISK_STATE_NONE 1
#define G_RAID3_DISK_STATE_NEW 2
#define G_RAID3_DISK_STATE_ACTIVE 3
#define G_RAID3_DISK_STATE_STALE 4
#define G_RAID3_DISK_STATE_SYNCHRONIZING 5
#define G_RAID3_DISK_STATE_DISCONNECTED 6
#define G_RAID3_DISK_STATE_DESTROY 7
struct g_raid3_disk {
u_int d_no; /* Disk number. */
struct g_consumer *d_consumer; /* Consumer. */
struct g_raid3_softc *d_softc; /* Back-pointer to softc. */
int d_state; /* Disk state. */
uint64_t d_flags; /* Additional flags. */
u_int d_genid; /* Disk's generation ID. */
struct g_raid3_disk_sync d_sync; /* Sync information. */
LIST_ENTRY(g_raid3_disk) d_next;
};
#define d_name d_consumer->provider->name
#define G_RAID3_EVENT_DONTWAIT 0x1
#define G_RAID3_EVENT_WAIT 0x2
#define G_RAID3_EVENT_DEVICE 0x4
#define G_RAID3_EVENT_DONE 0x8
struct g_raid3_event {
struct g_raid3_disk *e_disk;
int e_state;
int e_flags;
int e_error;
TAILQ_ENTRY(g_raid3_event) e_next;
};
#define G_RAID3_DEVICE_FLAG_DESTROY 0x0100000000000000ULL
#define G_RAID3_DEVICE_FLAG_WAIT 0x0200000000000000ULL
#define G_RAID3_DEVICE_STATE_STARTING 0
#define G_RAID3_DEVICE_STATE_DEGRADED 1
#define G_RAID3_DEVICE_STATE_COMPLETE 2
/* Bump syncid on first write. */
#define G_RAID3_BUMP_SYNCID 0x1
/* Bump genid immediately. */
#define G_RAID3_BUMP_GENID 0x2
struct g_raid3_softc {
u_int sc_state; /* Device state. */
uint64_t sc_mediasize; /* Device size. */
uint32_t sc_sectorsize; /* Sector size. */
uint64_t sc_flags; /* Additional flags. */
struct g_geom *sc_geom;
struct g_provider *sc_provider;
uint32_t sc_id; /* Device unique ID. */
struct bio_queue_head sc_queue;
struct mtx sc_queue_mtx;
struct proc *sc_worker;
struct g_raid3_disk *sc_disks;
u_int sc_ndisks; /* Number of disks. */
u_int sc_round_robin;
struct g_raid3_disk *sc_syncdisk;
uma_zone_t sc_zone_64k;
uma_zone_t sc_zone_16k;
uma_zone_t sc_zone_4k;
u_int sc_genid; /* Generation ID. */
u_int sc_syncid; /* Synchronization ID. */
int sc_bump_id;
struct g_raid3_device_sync sc_sync;
int sc_idle; /* DIRTY flags removed. */
TAILQ_HEAD(, g_raid3_event) sc_events;
struct mtx sc_events_mtx;
struct callout sc_callout;
};
#define sc_name sc_geom->name
const char *g_raid3_get_diskname(struct g_raid3_disk *disk);
u_int g_raid3_ndisks(struct g_raid3_softc *sc, int state);
int g_raid3_destroy(struct g_raid3_softc *sc, boolean_t force);
int g_raid3_event_send(void *arg, int state, int flags);
struct g_raid3_metadata;
int g_raid3_add_disk(struct g_raid3_softc *sc, struct g_provider *pp,
struct g_raid3_metadata *md);
int g_raid3_read_metadata(struct g_consumer *cp, struct g_raid3_metadata *md);
void g_raid3_fill_metadata(struct g_raid3_disk *disk,
struct g_raid3_metadata *md);
int g_raid3_clear_metadata(struct g_raid3_disk *disk);
void g_raid3_update_metadata(struct g_raid3_disk *disk);
g_ctl_req_t g_raid3_config;
#endif /* _KERNEL */
struct g_raid3_metadata {
char md_magic[16]; /* Magic value. */
uint32_t md_version; /* Version number. */
char md_name[16]; /* Device name. */
uint32_t md_id; /* Device unique ID. */
uint16_t md_no; /* Component number. */
uint16_t md_all; /* Number of disks in device. */
uint32_t md_genid; /* Generation ID. */
uint32_t md_syncid; /* Synchronization ID. */
uint64_t md_mediasize; /* Size of whole device. */
uint32_t md_sectorsize; /* Sector size. */
uint64_t md_sync_offset; /* Synchronized offset. */
uint64_t md_mflags; /* Additional device flags. */
uint64_t md_dflags; /* Additional disk flags. */
char md_provider[16]; /* Hardcoded provider. */
uint64_t md_provsize; /* Provider's size. */
u_char md_hash[16]; /* MD5 hash. */
};
static __inline void
raid3_metadata_encode(struct g_raid3_metadata *md, u_char *data)
{
MD5_CTX ctx;
bcopy(md->md_magic, data, 16);
le32enc(data + 16, md->md_version);
bcopy(md->md_name, data + 20, 16);
le32enc(data + 36, md->md_id);
le16enc(data + 40, md->md_no);
le16enc(data + 42, md->md_all);
le32enc(data + 44, md->md_genid);
le32enc(data + 48, md->md_syncid);
le64enc(data + 52, md->md_mediasize);
le32enc(data + 60, md->md_sectorsize);
le64enc(data + 64, md->md_sync_offset);
le64enc(data + 72, md->md_mflags);
le64enc(data + 80, md->md_dflags);
bcopy(md->md_provider, data + 88, 16);
le64enc(data + 104, md->md_provsize);
MD5Init(&ctx);
MD5Update(&ctx, data, 112);
MD5Final(md->md_hash, &ctx);
bcopy(md->md_hash, data + 112, 16);
}
static __inline int
raid3_metadata_decode_v0v1v2(const u_char *data, struct g_raid3_metadata *md)
{
MD5_CTX ctx;
bcopy(data + 20, md->md_name, 16);
md->md_id = le32dec(data + 36);
md->md_no = le16dec(data + 40);
md->md_all = le16dec(data + 42);
md->md_syncid = le32dec(data + 44);
md->md_mediasize = le64dec(data + 48);
md->md_sectorsize = le32dec(data + 56);
md->md_sync_offset = le64dec(data + 60);
md->md_mflags = le64dec(data + 68);
md->md_dflags = le64dec(data + 76);
bcopy(data + 84, md->md_provider, 16);
bcopy(data + 100, md->md_hash, 16);
MD5Init(&ctx);
MD5Update(&ctx, data, 100);
MD5Final(md->md_hash, &ctx);
if (bcmp(md->md_hash, data + 100, 16) != 0)
return (EINVAL);
/* New fields. */
md->md_genid = 0;
md->md_provsize = 0;
return (0);
}
static __inline int
raid3_metadata_decode_v3(const u_char *data, struct g_raid3_metadata *md)
{
MD5_CTX ctx;
bcopy(data + 20, md->md_name, 16);
md->md_id = le32dec(data + 36);
md->md_no = le16dec(data + 40);
md->md_all = le16dec(data + 42);
md->md_genid = le32dec(data + 44);
md->md_syncid = le32dec(data + 48);
md->md_mediasize = le64dec(data + 52);
md->md_sectorsize = le32dec(data + 60);
md->md_sync_offset = le64dec(data + 64);
md->md_mflags = le64dec(data + 72);
md->md_dflags = le64dec(data + 80);
bcopy(data + 88, md->md_provider, 16);
bcopy(data + 104, md->md_hash, 16);
MD5Init(&ctx);
MD5Update(&ctx, data, 104);
MD5Final(md->md_hash, &ctx);
if (bcmp(md->md_hash, data + 104, 16) != 0)
return (EINVAL);
/* New fields. */
md->md_provsize = 0;
return (0);
}
static __inline int
raid3_metadata_decode_v4(const u_char *data, struct g_raid3_metadata *md)
{
MD5_CTX ctx;
bcopy(data + 20, md->md_name, 16);
md->md_id = le32dec(data + 36);
md->md_no = le16dec(data + 40);
md->md_all = le16dec(data + 42);
md->md_genid = le32dec(data + 44);
md->md_syncid = le32dec(data + 48);
md->md_mediasize = le64dec(data + 52);
md->md_sectorsize = le32dec(data + 60);
md->md_sync_offset = le64dec(data + 64);
md->md_mflags = le64dec(data + 72);
md->md_dflags = le64dec(data + 80);
bcopy(data + 88, md->md_provider, 16);
md->md_provsize = le64dec(data + 104);
bcopy(data + 112, md->md_hash, 16);
MD5Init(&ctx);
MD5Update(&ctx, data, 112);
MD5Final(md->md_hash, &ctx);
if (bcmp(md->md_hash, data + 112, 16) != 0)
return (EINVAL);
return (0);
}
static __inline int
raid3_metadata_decode(const u_char *data, struct g_raid3_metadata *md)
{
int error;
bcopy(data, md->md_magic, 16);
md->md_version = le32dec(data + 16);
switch (md->md_version) {
case 0:
case 1:
case 2:
error = raid3_metadata_decode_v0v1v2(data, md);
break;
case 3:
error = raid3_metadata_decode_v3(data, md);
break;
case 4:
error = raid3_metadata_decode_v4(data, md);
break;
default:
error = EINVAL;
break;
}
return (error);
}
static __inline void
raid3_metadata_dump(const struct g_raid3_metadata *md)
{
static const char hex[] = "0123456789abcdef";
char hash[16 * 2 + 1];
u_int i;
printf(" magic: %s\n", md->md_magic);
printf(" version: %u\n", (u_int)md->md_version);
printf(" name: %s\n", md->md_name);
printf(" id: %u\n", (u_int)md->md_id);
printf(" no: %u\n", (u_int)md->md_no);
printf(" all: %u\n", (u_int)md->md_all);
printf(" genid: %u\n", (u_int)md->md_genid);
printf(" syncid: %u\n", (u_int)md->md_syncid);
printf(" mediasize: %jd\n", (intmax_t)md->md_mediasize);
printf("sectorsize: %u\n", (u_int)md->md_sectorsize);
printf("syncoffset: %jd\n", (intmax_t)md->md_sync_offset);
printf(" mflags:");
if (md->md_mflags == 0)
printf(" NONE");
else {
if ((md->md_mflags & G_RAID3_DEVICE_FLAG_NOAUTOSYNC) != 0)
printf(" NOAUTOSYNC");
if ((md->md_mflags & G_RAID3_DEVICE_FLAG_ROUND_ROBIN) != 0)
printf(" ROUND-ROBIN");
if ((md->md_mflags & G_RAID3_DEVICE_FLAG_VERIFY) != 0)
printf(" VERIFY");
}
printf("\n");
printf(" dflags:");
if (md->md_dflags == 0)
printf(" NONE");
else {
if ((md->md_dflags & G_RAID3_DISK_FLAG_DIRTY) != 0)
printf(" DIRTY");
if ((md->md_dflags & G_RAID3_DISK_FLAG_SYNCHRONIZING) != 0)
printf(" SYNCHRONIZING");
if ((md->md_dflags & G_RAID3_DISK_FLAG_FORCE_SYNC) != 0)
printf(" FORCE_SYNC");
}
printf("\n");
printf("hcprovider: %s\n", md->md_provider);
printf(" provsize: %ju\n", (uintmax_t)md->md_provsize);
bzero(hash, sizeof(hash));
for (i = 0; i < 16; i++) {
hash[i * 2] = hex[md->md_hash[i] >> 4];
hash[i * 2 + 1] = hex[md->md_hash[i] & 0x0f];
}
printf(" MD5 hash: %s\n", hash);
}
#endif /* !_G_RAID3_H_ */
Reference in New Issue View Git Blame Copy Permalink