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

blob: remove SPDK_BLOB_STATE_SYNCING

Browse Source 
All metadata operations are now done on the metadata
thread, so we no longer have to worry about one thread
updating in-memory metadata structures while another
thread is transferring the in-memory structures to
on-disk structures.

This does not protect against multiple sync operations
outstanding at once - that will be coming in an
upcoming path.

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

Reviewed-on: https://review.gerrithub.io/401056
Tested-by: SPDK Automated Test System <sys_sgsw@intel.com>
Reviewed-by: Daniel Verkamp <daniel.verkamp@intel.com>
Reviewed-by: Maciej Szwed <maciej.szwed@intel.com>
Reviewed-by: Changpeng Liu <changpeng.liu@intel.com>
Reviewed-by: Shuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
This commit is contained in:
Jim Harris 2018-02-22 13:32:14 -07:00
parent 0928d63d20
commit 7d4705a257
3 changed files with 14 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
examples/blob/cli/blobcli.c
View File

@ -472,9 +472,6 @@ show_blob(struct cli_context_t *cli_context)
case SPDK_BLOB_STATE_LOADING: case SPDK_BLOB_STATE_LOADING:
printf("state: LOADING\n"); printf("state: LOADING\n");
break; break;
case SPDK_BLOB_STATE_SYNCING:
printf("state: SYNCING\n");
break;
default: default:
printf("state: UNKNOWN\n"); printf("state: UNKNOWN\n");
break; break;

31
lib/blob/blobstore.c
View File

@ -208,8 +208,6 @@ _spdk_blob_mark_clean(struct spdk_blob *blob)
uint32_t *pages = NULL; uint32_t *pages = NULL;
assert(blob != NULL); assert(blob != NULL);
assert(blob->state == SPDK_BLOB_STATE_LOADING ||
blob->state == SPDK_BLOB_STATE_SYNCING);
if (blob->active.num_clusters) { if (blob->active.num_clusters) {
assert(blob->active.clusters); assert(blob->active.clusters);
@ -241,7 +239,12 @@ _spdk_blob_mark_clean(struct spdk_blob *blob)
blob->active.clusters = clusters; blob->active.clusters = clusters;
blob->active.pages = pages; blob->active.pages = pages;
blob->state = SPDK_BLOB_STATE_CLEAN; /* If the metadata was dirtied again while the metadata was being written to disk,
* we do not want to revert the DIRTY state back to CLEAN here.
*/
if (blob->state == SPDK_BLOB_STATE_LOADING) {
blob->state = SPDK_BLOB_STATE_CLEAN;
}
return 0; return 0;
} }
@ -679,7 +682,7 @@ _spdk_blob_serialize(const struct spdk_blob *blob, struct spdk_blob_md_page **pa
assert(pages != NULL); assert(pages != NULL);
assert(page_count != NULL); assert(page_count != NULL);
assert(blob != NULL); assert(blob != NULL);
assert(blob->state == SPDK_BLOB_STATE_SYNCING); assert(blob->state == SPDK_BLOB_STATE_DIRTY);
*pages = NULL; *pages = NULL;
*page_count = 0; *page_count = 0;
@ -1124,8 +1127,7 @@ _spdk_resize_blob(struct spdk_blob *blob, uint64_t sz)
bs = blob->bs; bs = blob->bs;
assert(blob->state != SPDK_BLOB_STATE_LOADING && assert(blob->state != SPDK_BLOB_STATE_LOADING);
blob->state != SPDK_BLOB_STATE_SYNCING);
if (blob->active.num_clusters == sz) { if (blob->active.num_clusters == sz) {
return 0; return 0;
@ -1218,13 +1220,12 @@ _spdk_blob_persist(spdk_bs_sequence_t *seq, struct spdk_blob *blob,
ctx->cb_fn = cb_fn; ctx->cb_fn = cb_fn;
ctx->cb_arg = cb_arg; ctx->cb_arg = cb_arg;
blob->state = SPDK_BLOB_STATE_SYNCING;
if (blob->active.num_pages == 0) { if (blob->active.num_pages == 0) {
/* This is the signal that the blob should be deleted. /* This is the signal that the blob should be deleted.
* Immediately jump to the clean up routine. */ * Immediately jump to the clean up routine. */
assert(blob->clean.num_pages > 0); assert(blob->clean.num_pages > 0);
ctx->idx = blob->clean.num_pages - 1; ctx->idx = blob->clean.num_pages - 1;
blob->state = SPDK_BLOB_STATE_CLEAN;
_spdk_blob_persist_zero_pages(seq, ctx, 0); _spdk_blob_persist_zero_pages(seq, ctx, 0);
return; return;
@ -1259,7 +1260,6 @@ _spdk_blob_persist(spdk_bs_sequence_t *seq, struct spdk_blob *blob,
if (page_num >= spdk_bit_array_capacity(bs->used_md_pages)) { if (page_num >= spdk_bit_array_capacity(bs->used_md_pages)) {
spdk_dma_free(ctx->pages); spdk_dma_free(ctx->pages);
free(ctx); free(ctx);
blob->state = SPDK_BLOB_STATE_DIRTY;
cb_fn(seq, cb_arg, -ENOMEM); cb_fn(seq, cb_arg, -ENOMEM);
return; return;
} }
@ -1281,6 +1281,7 @@ _spdk_blob_persist(spdk_bs_sequence_t *seq, struct spdk_blob *blob,
ctx->pages[i - 1].crc = _spdk_blob_md_page_calc_crc(&ctx->pages[i - 1]); ctx->pages[i - 1].crc = _spdk_blob_md_page_calc_crc(&ctx->pages[i - 1]);
/* Start writing the metadata from last page to first */ /* Start writing the metadata from last page to first */
ctx->idx = blob->active.num_pages - 1; ctx->idx = blob->active.num_pages - 1;
blob->state = SPDK_BLOB_STATE_CLEAN;
_spdk_blob_persist_write_page_chain(seq, ctx, 0); _spdk_blob_persist_write_page_chain(seq, ctx, 0);
} }
@ -3542,8 +3543,7 @@ spdk_blob_sync_md(struct spdk_blob *blob, spdk_blob_op_complete cb_fn, void *cb_
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Syncing blob %lu\n", blob->id); SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Syncing blob %lu\n", blob->id);
assert(blob->state != SPDK_BLOB_STATE_LOADING && assert(blob->state != SPDK_BLOB_STATE_LOADING);
blob->state != SPDK_BLOB_STATE_SYNCING);
if (blob->md_ro) { if (blob->md_ro) {
assert(blob->state == SPDK_BLOB_STATE_CLEAN); assert(blob->state == SPDK_BLOB_STATE_CLEAN);
@ -3662,8 +3662,7 @@ void spdk_blob_close(struct spdk_blob *blob, spdk_blob_op_complete cb_fn, void *
SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Closing blob %lu\n", blob->id); SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Closing blob %lu\n", blob->id);
assert(blob->state != SPDK_BLOB_STATE_LOADING && assert(blob->state != SPDK_BLOB_STATE_LOADING);
blob->state != SPDK_BLOB_STATE_SYNCING);
if (blob->open_ref == 0) { if (blob->open_ref == 0) {
cb_fn(cb_arg, -EBADF); cb_fn(cb_arg, -EBADF);
@ -3880,8 +3879,7 @@ _spdk_blob_set_xattr(struct spdk_blob *blob, const char *name, const void *value
assert(blob != NULL); assert(blob != NULL);
assert(spdk_get_thread() == blob->bs->md_thread); assert(spdk_get_thread() == blob->bs->md_thread);
assert(blob->state != SPDK_BLOB_STATE_LOADING && assert(blob->state != SPDK_BLOB_STATE_LOADING);
blob->state != SPDK_BLOB_STATE_SYNCING);
if (blob->md_ro) { if (blob->md_ro) {
return -EPERM; return -EPERM;
@ -3938,8 +3936,7 @@ _spdk_blob_remove_xattr(struct spdk_blob *blob, const char *name, bool internal)
assert(blob != NULL); assert(blob != NULL);
assert(spdk_get_thread() == blob->bs->md_thread); assert(spdk_get_thread() == blob->bs->md_thread);
assert(blob->state != SPDK_BLOB_STATE_LOADING && assert(blob->state != SPDK_BLOB_STATE_LOADING);
blob->state != SPDK_BLOB_STATE_SYNCING);
if (blob->md_ro) { if (blob->md_ro) {
return -EPERM; return -EPERM;

5
lib/blob/blobstore.h
View File

@ -101,11 +101,6 @@ enum spdk_blob_state {
/* The in-memory state being synchronized with the on-disk /* The in-memory state being synchronized with the on-disk
* blob state. */ * blob state. */
SPDK_BLOB_STATE_LOADING, SPDK_BLOB_STATE_LOADING,
/* The disk state is being synchronized with the current
* blob state.
*/
SPDK_BLOB_STATE_SYNCING,
}; };
TAILQ_HEAD(spdk_xattr_tailq, spdk_xattr); TAILQ_HEAD(spdk_xattr_tailq, spdk_xattr);