ivampiresp/Spdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

bdev/error: use bdev_part helper functions

Browse Source 
Signed-off-by: Jim Harris <james.r.harris@intel.com>
Change-Id: I7f80467ce09bfb65559fab647a89a5fcc6ec5c57

Reviewed-on: https://review.gerrithub.io/377621
Tested-by: SPDK Automated Test System <sys_sgsw@intel.com>
Reviewed-by: Cunyin Chang <cunyin.chang@intel.com>
Reviewed-by: Ziye Yang <optimistyzy@gmail.com>
Reviewed-by: Daniel Verkamp <daniel.verkamp@intel.com>
This commit is contained in:
Jim Harris 2017-08-28 11:06:41 -07:00
parent 1f6fe13ff7
commit cd28ee8b7d
1 changed files with 59 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

165
lib/bdev/error/vbdev_error.c
View File

@ -57,25 +57,25 @@ struct vbdev_error_info {
};
/* Context for each error bdev */
struct vbdev_error_disk {
struct spdk_bdev disk;
struct spdk_bdev *base_bdev;
struct spdk_bdev_desc *base_bdev_desc;
struct error_disk {
struct spdk_bdev_part part;
struct vbdev_error_info error_vector[SPDK_BDEV_IO_TYPE_RESET];
TAILQ_ENTRY(vbdev_error_disk) tailq;
TAILQ_HEAD(, spdk_bdev_io) pending_ios;
};
struct error_channel {
struct spdk_bdev_part_channel part_ch;
};
static pthread_mutex_t g_vbdev_error_mutex = PTHREAD_MUTEX_INITIALIZER;
static TAILQ_HEAD(, vbdev_error_disk) g_vbdev_error_disks = TAILQ_HEAD_INITIALIZER(
g_vbdev_error_disks);
static SPDK_BDEV_PART_TAILQ g_error_disks = TAILQ_HEAD_INITIALIZER(g_error_disks);
int
spdk_vbdev_inject_error(char *name, uint32_t io_type, uint32_t error_type, uint32_t error_num)
{
struct spdk_bdev *bdev;
struct vbdev_error_disk *error_disk;
struct spdk_bdev_part *part;
struct error_disk *error_disk = NULL;
uint32_t i;
pthread_mutex_lock(&g_vbdev_error_mutex);
@ -86,8 +86,9 @@ spdk_vbdev_inject_error(char *name, uint32_t io_type, uint32_t error_type, uint3
return -1;
}
TAILQ_FOREACH(error_disk, &g_vbdev_error_disks, tailq) {
if (bdev == &error_disk->disk) {
TAILQ_FOREACH(part, &g_error_disks, tailq) {
if (bdev == &part->bdev) {
error_disk = (struct error_disk *)part;
break;
}
}
@ -119,7 +120,7 @@ spdk_vbdev_inject_error(char *name, uint32_t io_type, uint32_t error_type, uint3
}
static void
vbdev_error_reset(struct vbdev_error_disk *error_disk, struct spdk_bdev_io *bdev_io)
vbdev_error_reset(struct error_disk *error_disk, struct spdk_bdev_io *bdev_io)
{
struct spdk_bdev_io *pending_io, *tmp;
@ -131,7 +132,7 @@ vbdev_error_reset(struct vbdev_error_disk *error_disk, struct spdk_bdev_io *bdev
}
static uint32_t
vbdev_error_get_error_type(struct vbdev_error_disk *error_disk, uint32_t io_type)
vbdev_error_get_error_type(struct error_disk *error_disk, uint32_t io_type)
{
if (error_disk->error_vector[io_type].enabled &&
error_disk->error_vector[io_type].error_num) {
@ -141,9 +142,10 @@ vbdev_error_get_error_type(struct vbdev_error_disk *error_disk, uint32_t io_type
}
static void
vbdev_error_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
vbdev_error_submit_request(struct spdk_io_channel *_ch, struct spdk_bdev_io *bdev_io)
{
struct vbdev_error_disk *error_disk = bdev_io->bdev->ctxt;
struct error_channel *ch = spdk_io_channel_get_ctx(_ch);
struct error_disk *error_disk = bdev_io->bdev->ctxt;
uint32_t error_type;
switch (bdev_io->type) {
@ -163,7 +165,7 @@ vbdev_error_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev
error_type = vbdev_error_get_error_type(error_disk, bdev_io->type);
if (error_type == 0) {
spdk_bdev_io_resubmit(bdev_io, error_disk->base_bdev_desc);
spdk_bdev_part_submit_request(&ch->part_ch, bdev_io);
return;
} else if (error_type == VBDEV_IO_FAILURE) {
error_disk->error_vector[bdev_io->type].error_num--;
@ -174,73 +176,25 @@ vbdev_error_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev
}
}
static void
vbdev_error_disk_free(struct vbdev_error_disk *disk)
{
if (!disk) {
return;
}
if (disk->base_bdev) {
spdk_bdev_module_release_bdev(disk->base_bdev);
}
if (disk->base_bdev_desc) {
spdk_bdev_close(disk->base_bdev_desc);
}
free(disk->disk.name);
free(disk);
}
static void
vbdev_error_free(struct vbdev_error_disk *error_disk)
{
if (!error_disk) {
return;
}
TAILQ_REMOVE(&g_vbdev_error_disks, error_disk, tailq);
vbdev_error_disk_free(error_disk);
}
static int
vbdev_error_destruct(void *ctx)
{
struct vbdev_error_disk *error_disk = ctx;
struct error_disk *error_disk = ctx;
vbdev_error_free(error_disk);
spdk_bdev_part_free(&error_disk->part);
return 0;
}
static bool
vbdev_error_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type)
{
struct vbdev_error_disk *error_disk = ctx;
return error_disk->base_bdev->fn_table->io_type_supported(error_disk->base_bdev,
io_type);
}
static struct spdk_io_channel *
vbdev_error_get_io_channel(void *ctx)
{
struct vbdev_error_disk *error_disk = ctx;
return error_disk->base_bdev->fn_table->get_io_channel(error_disk->base_bdev);
}
static int
vbdev_error_dump_config_json(void *ctx, struct spdk_json_write_ctx *w)
{
struct vbdev_error_disk *error_disk = ctx;
struct error_disk *error_disk = ctx;
spdk_json_write_name(w, "error_disk");
spdk_json_write_object_begin(w);
spdk_json_write_name(w, "base_bdev");
spdk_json_write_string(w, error_disk->base_bdev->name);
spdk_json_write_string(w, error_disk->part.base->bdev->name);
spdk_json_write_object_end(w);
@ -249,58 +203,61 @@ vbdev_error_dump_config_json(void *ctx, struct spdk_json_write_ctx *w)
static struct spdk_bdev_fn_table vbdev_error_fn_table = {
.destruct = vbdev_error_destruct,
.io_type_supported = vbdev_error_io_type_supported,
.submit_request = vbdev_error_submit_request,
.get_io_channel = vbdev_error_get_io_channel,
.dump_config_json = vbdev_error_dump_config_json,
};
int
spdk_vbdev_error_create(struct spdk_bdev *base_bdev)
{
struct vbdev_error_disk *disk;
struct spdk_bdev_part_base *base = NULL;
struct error_disk *disk = NULL;
char *name;
int rc;
base = calloc(1, sizeof(*base));
if (!base) {
SPDK_ERRLOG("Memory allocation failure\n");
return -1;
}
rc = spdk_bdev_part_base_construct(base, base_bdev, NULL,
SPDK_GET_BDEV_MODULE(error), &vbdev_error_fn_table,
&g_error_disks, sizeof(struct error_channel), NULL, NULL);
if (rc) {
SPDK_ERRLOG("could not construct part base for bdev %s\n", spdk_bdev_get_name(base_bdev));
free(base);
return -1;
}
disk = calloc(1, sizeof(*disk));
if (!disk) {
SPDK_ERRLOG("Memory allocation failure\n");
rc = -1;
goto cleanup;
free(base);
return -1;
}
rc = spdk_bdev_open(base_bdev, false, NULL, NULL, &disk->base_bdev_desc);
name = spdk_sprintf_alloc("EE_%s", spdk_bdev_get_name(base_bdev));
if (!name) {
SPDK_ERRLOG("name allocation failure\n");
free(disk);
free(base);
return -1;
}
rc = spdk_bdev_part_construct(&disk->part, base, name, 0, base_bdev->blockcnt,
"Error Injection Disk");
if (rc) {
SPDK_ERRLOG("could not open bdev %s\n", spdk_bdev_get_name(base_bdev));
SPDK_ERRLOG("could not construct part for bdev %s\n", spdk_bdev_get_name(base_bdev));
/* spdk_bdev_part_construct will free name on failure */
free(disk);
free(base);
return -1;
}
rc = spdk_bdev_module_claim_bdev(base_bdev, disk->base_bdev_desc, SPDK_GET_BDEV_MODULE(error));
if (rc) {
SPDK_ERRLOG("could not claim bdev %s\n", spdk_bdev_get_name(base_bdev));
goto cleanup;
}
disk->base_bdev = base_bdev;
disk->disk.name = spdk_sprintf_alloc("EE_%s", base_bdev->name);
if (!disk->disk.name) {
rc = -ENOMEM;
goto cleanup;
}
disk->disk.blockcnt = base_bdev->blockcnt;
disk->disk.blocklen = base_bdev->blocklen;
disk->disk.write_cache = base_bdev->write_cache;
disk->disk.product_name = "Error Injection Disk";
disk->disk.ctxt = disk;
disk->disk.fn_table = &vbdev_error_fn_table;
disk->disk.module = SPDK_GET_BDEV_MODULE(error);
spdk_vbdev_register(&disk->disk, &base_bdev, 1);
TAILQ_INIT(&disk->pending_ios);
TAILQ_INSERT_TAIL(&g_vbdev_error_disks, disk, tailq);
rc = 0;
return rc;
cleanup:
vbdev_error_disk_free(disk);
return rc;
return 0;
}
static int
@ -349,11 +306,7 @@ vbdev_error_examine(struct spdk_bdev *bdev)
static void
vbdev_error_fini(void)
{
struct vbdev_error_disk *error_disk, *tmp;
TAILQ_FOREACH_SAFE(error_disk, &g_vbdev_error_disks, tailq, tmp) {
vbdev_error_free(error_disk);
}
spdk_bdev_part_tailq_fini(&g_error_disks);
}
SPDK_BDEV_MODULE_REGISTER(error, vbdev_error_init, vbdev_error_fini, NULL, NULL,