Commit 2172c432 authored by Tomasz Zawadzki's avatar Tomasz Zawadzki
Browse files

log: simplify SPDK_LOG_REGISTER_COMPONENT 



This patch removes the string from register component.
Removed are all instances in libs or hardcoded in apps.

Starting with this patch literal passed to register,
serves as name for the flag.

All instances of SPDK_LOG_* were replaced with just *
in lowercase.
No actual name change for flags occur in this patch.

Affected are SPDK_LOG_REGISTER_COMPONENT() and
SPDK_*LOG() macros.

Signed-off-by: default avatarTomasz Zawadzki <tomasz.zawadzki@intel.com>
Change-Id: I002b232fde57ecf9c6777726b181fc0341f1bb17
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/4495


Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Mellanox Build Bot
Reviewed-by: default avatarAnil Veerabhadrappa <anil.veerabhadrappa@broadcom.com>
Reviewed-by: default avatarAleksey Marchuk <alexeymar@mellanox.com>
Reviewed-by: default avatarBen Walker <benjamin.walker@intel.com>
Community-CI: Broadcom CI
parent e19b294a

include/spdk_internal/log.h

+3 −3
Original line number Diff line number Diff line
@@ -56,14 +56,14 @@ void spdk_log_register_flag(const char *name, struct spdk_log_flag *flag); 
struct spdk_log_flag *spdk_log_get_first_flag(void);

struct spdk_log_flag *spdk_log_get_next_flag(struct spdk_log_flag *flag);



#define SPDK_LOG_REGISTER_COMPONENT(str, FLAG) \

#define SPDK_LOG_REGISTER_COMPONENT(FLAG) \

struct spdk_log_flag SPDK_LOG_##FLAG = { \

	.enabled = false, \

	.name = str, \

	.name = #FLAG, \

}; \

__attribute__((constructor)) static void register_flag_##FLAG(void) \

{ \

	spdk_log_register_flag(str, &SPDK_LOG_##FLAG); \

	spdk_log_register_flag(#FLAG, &SPDK_LOG_##FLAG); \

}



#define SPDK_INFOLOG(FLAG, ...)									\

lib/bdev/bdev.c

+20 −20
Original line number Diff line number Diff line
@@ -551,7 +551,7 @@ spdk_bdev_first(void) 


	bdev = TAILQ_FIRST(&g_bdev_mgr.bdevs);

	if (bdev) {

		SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Starting bdev iteration at %s\n", bdev->name);

		SPDK_DEBUGLOG(bdev, "Starting bdev iteration at %s\n", bdev->name);

	}



	return bdev;
@@ -564,7 +564,7 @@ spdk_bdev_next(struct spdk_bdev *prev) 


	bdev = TAILQ_NEXT(prev, internal.link);

	if (bdev) {

		SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Continuing bdev iteration at %s\n", bdev->name);

		SPDK_DEBUGLOG(bdev, "Continuing bdev iteration at %s\n", bdev->name);

	}



	return bdev;
@@ -592,7 +592,7 @@ spdk_bdev_first_leaf(void) 
	bdev = _bdev_next_leaf(TAILQ_FIRST(&g_bdev_mgr.bdevs));



	if (bdev) {

		SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Starting bdev iteration at %s\n", bdev->name);

		SPDK_DEBUGLOG(bdev, "Starting bdev iteration at %s\n", bdev->name);

	}



	return bdev;
@@ -606,7 +606,7 @@ spdk_bdev_next_leaf(struct spdk_bdev *prev) 
	bdev = _bdev_next_leaf(TAILQ_NEXT(prev, internal.link));



	if (bdev) {

		SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Continuing bdev iteration at %s\n", bdev->name);

		SPDK_DEBUGLOG(bdev, "Continuing bdev iteration at %s\n", bdev->name);

	}



	return bdev;
@@ -1478,7 +1478,7 @@ bdev_finish_unregister_bdevs_iter(void *cb_arg, int bdeverrno) 
	}



	if (TAILQ_EMPTY(&g_bdev_mgr.bdevs)) {

		SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Done unregistering bdevs\n");

		SPDK_DEBUGLOG(bdev, "Done unregistering bdevs\n");

		/*

		 * Bdev module finish need to be deferred as we might be in the middle of some context

		 * (like bdev part free) that will use this bdev (or private bdev driver ctx data)
@@ -1499,12 +1499,12 @@ bdev_finish_unregister_bdevs_iter(void *cb_arg, int bdeverrno) 
	for (bdev = TAILQ_LAST(&g_bdev_mgr.bdevs, spdk_bdev_list);

	     bdev; bdev = TAILQ_PREV(bdev, spdk_bdev_list, internal.link)) {

		if (bdev->internal.claim_module != NULL) {

			SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Skipping claimed bdev '%s'(<-'%s').\n",

			SPDK_DEBUGLOG(bdev, "Skipping claimed bdev '%s'(<-'%s').\n",

				      bdev->name, bdev->internal.claim_module->name);

			continue;

		}



		SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Unregistering bdev '%s'\n", bdev->name);

		SPDK_DEBUGLOG(bdev, "Unregistering bdev '%s'\n", bdev->name);

		spdk_bdev_unregister(bdev, bdev_finish_unregister_bdevs_iter, bdev);

		return;

	}
@@ -2458,7 +2458,7 @@ bdev_enable_qos(struct spdk_bdev *bdev, struct spdk_bdev_channel *ch) 
		if (qos->ch == NULL) {

			struct spdk_io_channel *io_ch;



			SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Selecting channel %p as QoS channel for bdev %s on thread %p\n", ch,

			SPDK_DEBUGLOG(bdev, "Selecting channel %p as QoS channel for bdev %s on thread %p\n", ch,

				      bdev->name, spdk_get_thread());



			/* No qos channel has been selected, so set one up */
@@ -2831,7 +2831,7 @@ bdev_qos_channel_destroy(void *cb_arg) 
	spdk_put_io_channel(spdk_io_channel_from_ctx(qos->ch));

	spdk_poller_unregister(&qos->poller);



	SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Free QoS %p.\n", qos);

	SPDK_DEBUGLOG(bdev, "Free QoS %p.\n", qos);



	free(qos);

}
@@ -2915,7 +2915,7 @@ bdev_channel_destroy(void *io_device, void *ctx_buf) 
	struct spdk_bdev_mgmt_channel	*mgmt_ch;

	struct spdk_bdev_shared_resource *shared_resource = ch->shared_resource;



	SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Destroying channel %p for bdev %s on thread %p\n", ch, ch->bdev->name,

	SPDK_DEBUGLOG(bdev, "Destroying channel %p for bdev %s on thread %p\n", ch, ch->bdev->name,

		      spdk_get_thread());



	/* This channel is going away, so add its statistics into the bdev so that they don't get lost. */
@@ -2984,7 +2984,7 @@ spdk_bdev_alias_del(struct spdk_bdev *bdev, const char *alias) 
		}

	}



	SPDK_INFOLOG(SPDK_LOG_BDEV, "Alias %s does not exists\n", alias);

	SPDK_INFOLOG(bdev, "Alias %s does not exists\n", alias);



	return -ENOENT;

}
@@ -5260,7 +5260,7 @@ bdev_qos_config_limit(struct spdk_bdev *bdev, uint64_t *limits) 


	for (i = 0; i < SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES; i++) {

		bdev->internal.qos->rate_limits[i].limit = limits[i];

		SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Bdev:%s QoS type:%d set:%lu\n",

		SPDK_DEBUGLOG(bdev, "Bdev:%s QoS type:%d set:%lu\n",

			      bdev->name, i, limits[i]);

	}
@@ -5436,7 +5436,7 @@ bdev_fini(struct spdk_bdev *bdev) 
static void

bdev_start(struct spdk_bdev *bdev)

{

	SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Inserting bdev %s into list\n", bdev->name);

	SPDK_DEBUGLOG(bdev, "Inserting bdev %s into list\n", bdev->name);

	TAILQ_INSERT_TAIL(&g_bdev_mgr.bdevs, bdev, internal.link);



	/* Examine configuration before initializing I/O */
@@ -5526,7 +5526,7 @@ bdev_unregister_unsafe(struct spdk_bdev *bdev) 
	/* If there are no descriptors, proceed removing the bdev */

	if (rc == 0) {

		TAILQ_REMOVE(&g_bdev_mgr.bdevs, bdev, internal.link);

		SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Removing bdev %s from list done\n", bdev->name);

		SPDK_DEBUGLOG(bdev, "Removing bdev %s from list done\n", bdev->name);

		spdk_notify_send("bdev_unregister", spdk_bdev_get_name(bdev));

	}
@@ -5539,7 +5539,7 @@ spdk_bdev_unregister(struct spdk_bdev *bdev, spdk_bdev_unregister_cb cb_fn, void 
	struct spdk_thread	*thread;

	int			rc;



	SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Removing bdev %s from list\n", bdev->name);

	SPDK_DEBUGLOG(bdev, "Removing bdev %s from list\n", bdev->name);



	thread = spdk_get_thread();

	if (!thread) {
@@ -5578,7 +5578,7 @@ spdk_bdev_unregister(struct spdk_bdev *bdev, spdk_bdev_unregister_cb cb_fn, void 
static void

bdev_dummy_event_cb(void *remove_ctx)

{

	SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Bdev remove event received with no remove callback specified");

	SPDK_DEBUGLOG(bdev, "Bdev remove event received with no remove callback specified");

}



static int
@@ -5614,7 +5614,7 @@ bdev_open(struct spdk_bdev *bdev, bool write, struct spdk_bdev_desc *desc) 
		return -ENOTSUP;

	}



	SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Opening descriptor %p for bdev %s on thread %p\n", desc, bdev->name,

	SPDK_DEBUGLOG(bdev, "Opening descriptor %p for bdev %s on thread %p\n", desc, bdev->name,

		      spdk_get_thread());



	desc->bdev = bdev;
@@ -5762,7 +5762,7 @@ spdk_bdev_close(struct spdk_bdev_desc *desc) 
	struct spdk_bdev *bdev = spdk_bdev_desc_get_bdev(desc);

	int rc;



	SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Closing descriptor %p for bdev %s on thread %p\n", desc, bdev->name,

	SPDK_DEBUGLOG(bdev, "Closing descriptor %p for bdev %s on thread %p\n", desc, bdev->name,

		      spdk_get_thread());



	assert(desc->thread == spdk_get_thread());
@@ -5785,7 +5785,7 @@ spdk_bdev_close(struct spdk_bdev_desc *desc) 


	/* If no more descriptors, kill QoS channel */

	if (bdev->internal.qos && TAILQ_EMPTY(&bdev->internal.open_descs)) {

		SPDK_DEBUGLOG(SPDK_LOG_BDEV, "Closed last descriptor for bdev %s on thread %p. Stopping QoS.\n",

		SPDK_DEBUGLOG(bdev, "Closed last descriptor for bdev %s on thread %p. Stopping QoS.\n",

			      bdev->name, spdk_get_thread());



		if (bdev_qos_destroy(bdev)) {
@@ -6815,7 +6815,7 @@ bdev_unlock_lba_range(struct spdk_bdev_desc *desc, struct spdk_io_channel *_ch, 
	return 0;

}



SPDK_LOG_REGISTER_COMPONENT("bdev", SPDK_LOG_BDEV)

SPDK_LOG_REGISTER_COMPONENT(bdev)



SPDK_TRACE_REGISTER_FN(bdev_trace, "bdev", TRACE_GROUP_BDEV)

{

lib/blob/blobstore.c

+32 −32
Original line number Diff line number Diff line
@@ -116,7 +116,7 @@ bs_claim_cluster(struct spdk_blob_store *bs) 
		return UINT32_MAX;

	}



	SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Claiming cluster %u\n", cluster_num);

	SPDK_DEBUGLOG(blob, "Claiming cluster %u\n", cluster_num);

	bs->num_free_clusters--;



	return cluster_num;
@@ -129,7 +129,7 @@ bs_release_cluster(struct spdk_blob_store *bs, uint32_t cluster_num) 
	assert(spdk_bit_pool_is_allocated(bs->used_clusters, cluster_num) == true);

	assert(bs->num_free_clusters < bs->total_clusters);



	SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Releasing cluster %u\n", cluster_num);

	SPDK_DEBUGLOG(blob, "Releasing cluster %u\n", cluster_num);



	spdk_bit_pool_free_bit(bs->used_clusters, cluster_num);

	bs->num_free_clusters++;
@@ -177,7 +177,7 @@ bs_allocate_cluster(struct spdk_blob *blob, uint32_t cluster_num, 
		}

	}



	SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Claiming cluster %lu for blob %lu\n", *cluster, blob->id);

	SPDK_DEBUGLOG(blob, "Claiming cluster %lu for blob %lu\n", *cluster, blob->id);



	if (update_map) {

		blob_insert_cluster(blob, cluster_num, *cluster);
@@ -2029,7 +2029,7 @@ blob_persist_generate_new_md(struct spdk_blob_persist_ctx *ctx) 
		ctx->pages[i - 1].crc = blob_md_page_calc_crc(&ctx->pages[i - 1]);

		blob->active.pages[i] = page_num;

		bs_claim_md_page(bs, page_num);

		SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Claiming page %u for blob %lu\n", page_num, blob->id);

		SPDK_DEBUGLOG(blob, "Claiming page %u for blob %lu\n", page_num, blob->id);

		page_num++;

	}

	ctx->pages[i - 1].crc = blob_md_page_calc_crc(&ctx->pages[i - 1]);
@@ -3177,7 +3177,7 @@ bs_alloc(struct spdk_bs_dev *dev, struct spdk_bs_opts *opts, struct spdk_blob_st 
	dev_size = dev->blocklen * dev->blockcnt;

	if (dev_size < opts->cluster_sz) {

		/* Device size cannot be smaller than cluster size of blobstore */

		SPDK_INFOLOG(SPDK_LOG_BLOB, "Device size %" PRIu64 " is smaller than cluster size %" PRIu32 "\n",

		SPDK_INFOLOG(blob, "Device size %" PRIu64 " is smaller than cluster size %" PRIu32 "\n",

			     dev_size, opts->cluster_sz);

		return -ENOSPC;

	}
@@ -4191,13 +4191,13 @@ bs_load_super_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno) 
	}



	if (memcmp(&ctx->bs->bstype, &ctx->super->bstype, SPDK_BLOBSTORE_TYPE_LENGTH) == 0) {

		SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Bstype matched - loading blobstore\n");

		SPDK_DEBUGLOG(blob, "Bstype matched - loading blobstore\n");

	} else if (memcmp(&ctx->bs->bstype, zeros, SPDK_BLOBSTORE_TYPE_LENGTH) == 0) {

		SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Bstype wildcard used - loading blobstore regardless bstype\n");

		SPDK_DEBUGLOG(blob, "Bstype wildcard used - loading blobstore regardless bstype\n");

	} else {

		SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Unexpected bstype\n");

		SPDK_LOGDUMP(SPDK_LOG_BLOB, "Expected:", ctx->bs->bstype.bstype, SPDK_BLOBSTORE_TYPE_LENGTH);

		SPDK_LOGDUMP(SPDK_LOG_BLOB, "Found:", ctx->super->bstype.bstype, SPDK_BLOBSTORE_TYPE_LENGTH);

		SPDK_DEBUGLOG(blob, "Unexpected bstype\n");

		SPDK_LOGDUMP(blob, "Expected:", ctx->bs->bstype.bstype, SPDK_BLOBSTORE_TYPE_LENGTH);

		SPDK_LOGDUMP(blob, "Found:", ctx->super->bstype.bstype, SPDK_BLOBSTORE_TYPE_LENGTH);

		bs_load_ctx_fail(ctx, -ENXIO);

		return;

	}
@@ -4255,10 +4255,10 @@ spdk_bs_load(struct spdk_bs_dev *dev, struct spdk_bs_opts *o, 
	struct spdk_bs_opts	opts = {};

	int err;



	SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Loading blobstore from dev %p\n", dev);

	SPDK_DEBUGLOG(blob, "Loading blobstore from dev %p\n", dev);



	if ((SPDK_BS_PAGE_SIZE % dev->blocklen) != 0) {

		SPDK_DEBUGLOG(SPDK_LOG_BLOB, "unsupported dev block length of %d\n", dev->blocklen);

		SPDK_DEBUGLOG(blob, "unsupported dev block length of %d\n", dev->blocklen);

		dev->destroy(dev);

		cb_fn(cb_arg, NULL, -EINVAL);

		return;
@@ -4521,7 +4521,7 @@ spdk_bs_dump(struct spdk_bs_dev *dev, FILE *fp, spdk_bs_dump_print_xattr print_x 
	struct spdk_bs_opts	opts = {};

	int err;



	SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Dumping blobstore from dev %p\n", dev);

	SPDK_DEBUGLOG(blob, "Dumping blobstore from dev %p\n", dev);



	spdk_bs_opts_init(&opts);
@@ -4598,7 +4598,7 @@ spdk_bs_init(struct spdk_bs_dev *dev, struct spdk_bs_opts *o, 
	int			rc;

	uint64_t		lba, lba_count;



	SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Initializing blobstore on dev %p\n", dev);

	SPDK_DEBUGLOG(blob, "Initializing blobstore on dev %p\n", dev);



	if ((SPDK_BS_PAGE_SIZE % dev->blocklen) != 0) {

		SPDK_ERRLOG("unsupported dev block length of %d\n",
@@ -4813,7 +4813,7 @@ spdk_bs_destroy(struct spdk_blob_store *bs, spdk_bs_op_complete cb_fn, 
	spdk_bs_sequence_t	*seq;

	struct spdk_bs_load_ctx *ctx;



	SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Destroying blobstore\n");

	SPDK_DEBUGLOG(blob, "Destroying blobstore\n");



	if (!TAILQ_EMPTY(&bs->blobs)) {

		SPDK_ERRLOG("Blobstore still has open blobs\n");
@@ -4948,7 +4948,7 @@ spdk_bs_unload(struct spdk_blob_store *bs, spdk_bs_op_complete cb_fn, void *cb_a 
	struct spdk_bs_cpl	cpl;

	struct spdk_bs_load_ctx *ctx;



	SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Syncing blobstore\n");

	SPDK_DEBUGLOG(blob, "Syncing blobstore\n");



	if (!TAILQ_EMPTY(&bs->blobs)) {

		SPDK_ERRLOG("Blobstore still has open blobs\n");
@@ -5039,7 +5039,7 @@ spdk_bs_set_super(struct spdk_blob_store *bs, spdk_blob_id blobid, 
	spdk_bs_sequence_t		*seq;

	struct spdk_bs_set_super_ctx	*ctx;



	SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Setting super blob id on blobstore\n");

	SPDK_DEBUGLOG(blob, "Setting super blob id on blobstore\n");



	ctx = calloc(1, sizeof(*ctx));

	if (!ctx) {
@@ -5237,7 +5237,7 @@ bs_create_blob(struct spdk_blob_store *bs, 


	id = bs_page_to_blobid(page_idx);



	SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Creating blob with id %lu at page %u\n", id, page_idx);

	SPDK_DEBUGLOG(blob, "Creating blob with id %lu at page %u\n", id, page_idx);



	blob = blob_alloc(bs, id);

	if (!blob) {
@@ -5654,7 +5654,7 @@ bs_snapshot_origblob_open_cpl(void *cb_arg, struct spdk_blob *_blob, int bserrno 
	ctx->original.blob = _blob;



	if (_blob->data_ro || _blob->md_ro) {

		SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Cannot create snapshot from read only blob with id %lu\n",

		SPDK_DEBUGLOG(blob, "Cannot create snapshot from read only blob with id %lu\n",

			      _blob->id);

		ctx->bserrno = -EINVAL;

		spdk_blob_close(_blob, bs_clone_snapshot_cleanup_finish, ctx);
@@ -5662,7 +5662,7 @@ bs_snapshot_origblob_open_cpl(void *cb_arg, struct spdk_blob *_blob, int bserrno 
	}



	if (_blob->locked_operation_in_progress) {

		SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Cannot create snapshot - another operation in progress\n");

		SPDK_DEBUGLOG(blob, "Cannot create snapshot - another operation in progress\n");

		ctx->bserrno = -EBUSY;

		spdk_blob_close(_blob, bs_clone_snapshot_cleanup_finish, ctx);

		return;
@@ -5766,14 +5766,14 @@ bs_clone_origblob_open_cpl(void *cb_arg, struct spdk_blob *_blob, int bserrno) 
	ctx->original.blob = _blob;



	if (!_blob->data_ro || !_blob->md_ro) {

		SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Clone not from read-only blob\n");

		SPDK_DEBUGLOG(blob, "Clone not from read-only blob\n");

		ctx->bserrno = -EINVAL;

		spdk_blob_close(_blob, bs_clone_snapshot_cleanup_finish, ctx);

		return;

	}



	if (_blob->locked_operation_in_progress) {

		SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Cannot create clone - another operation in progress\n");

		SPDK_DEBUGLOG(blob, "Cannot create clone - another operation in progress\n");

		ctx->bserrno = -EBUSY;

		spdk_blob_close(_blob, bs_clone_snapshot_cleanup_finish, ctx);

		return;
@@ -5955,7 +5955,7 @@ bs_inflate_blob_open_cpl(void *cb_arg, struct spdk_blob *_blob, int bserrno) 
	ctx->original.blob = _blob;



	if (_blob->locked_operation_in_progress) {

		SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Cannot inflate blob - another operation in progress\n");

		SPDK_DEBUGLOG(blob, "Cannot inflate blob - another operation in progress\n");

		ctx->bserrno = -EBUSY;

		spdk_blob_close(_blob, bs_clone_snapshot_cleanup_finish, ctx);

		return;
@@ -6085,7 +6085,7 @@ spdk_blob_resize(struct spdk_blob *blob, uint64_t sz, spdk_blob_op_complete cb_f 


	blob_verify_md_op(blob);



	SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Resizing blob %lu to %lu clusters\n", blob->id, sz);

	SPDK_DEBUGLOG(blob, "Resizing blob %lu to %lu clusters\n", blob->id, sz);



	if (blob->md_ro) {

		cb_fn(cb_arg, -EPERM);
@@ -6426,7 +6426,7 @@ delete_snapshot_open_clone_cb(void *cb_arg, struct spdk_blob *clone, int bserrno 
	ctx->clone = clone;



	if (clone->locked_operation_in_progress) {

		SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Cannot remove blob - another operation in progress on its clone\n");

		SPDK_DEBUGLOG(blob, "Cannot remove blob - another operation in progress on its clone\n");

		ctx->bserrno = -EBUSY;

		spdk_blob_close(ctx->clone, delete_snapshot_cleanup_snapshot, ctx);

		return;
@@ -6579,7 +6579,7 @@ bs_delete_open_cpl(void *cb_arg, struct spdk_blob *blob, int bserrno) 
	}



	if (blob->locked_operation_in_progress) {

		SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Cannot remove blob - another operation in progress\n");

		SPDK_DEBUGLOG(blob, "Cannot remove blob - another operation in progress\n");

		ctx->bserrno = -EBUSY;

		spdk_blob_close(blob, delete_blob_cleanup_finish, ctx);

		return;
@@ -6612,7 +6612,7 @@ spdk_bs_delete_blob(struct spdk_blob_store *bs, spdk_blob_id blobid, 
	struct spdk_bs_cpl	cpl;

	spdk_bs_sequence_t	*seq;



	SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Deleting blob %lu\n", blobid);

	SPDK_DEBUGLOG(blob, "Deleting blob %lu\n", blobid);



	assert(spdk_get_thread() == bs->md_thread);
@@ -6676,7 +6676,7 @@ bs_open_blob(struct spdk_blob_store *bs, 
	spdk_bs_sequence_t		*seq;

	uint32_t			page_num;



	SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Opening blob %lu\n", blobid);

	SPDK_DEBUGLOG(blob, "Opening blob %lu\n", blobid);

	assert(spdk_get_thread() == bs->md_thread);



	page_num = bs_blobid_to_page(blobid);
@@ -6786,7 +6786,7 @@ spdk_blob_sync_md(struct spdk_blob *blob, spdk_blob_op_complete cb_fn, void *cb_ 
{

	blob_verify_md_op(blob);



	SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Syncing blob %lu\n", blob->id);

	SPDK_DEBUGLOG(blob, "Syncing blob %lu\n", blob->id);



	if (blob->md_ro) {

		assert(blob->state == SPDK_BLOB_STATE_CLEAN);
@@ -6975,7 +6975,7 @@ void spdk_blob_close(struct spdk_blob *blob, spdk_blob_op_complete cb_fn, void * 


	blob_verify_md_op(blob);



	SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Closing blob %lu\n", blob->id);

	SPDK_DEBUGLOG(blob, "Closing blob %lu\n", blob->id);



	if (blob->open_ref == 0) {

		cb_fn(cb_arg, -EBADF);
@@ -7154,7 +7154,7 @@ blob_set_xattr(struct spdk_blob *blob, const char *name, const void *value, 


	desc_size = sizeof(struct spdk_blob_md_descriptor_xattr) + strlen(name) + value_len;

	if (desc_size > SPDK_BS_MAX_DESC_SIZE) {

		SPDK_DEBUGLOG(SPDK_LOG_BLOB, "Xattr '%s' of size %ld does not fix into single page %ld\n", name,

		SPDK_DEBUGLOG(blob, "Xattr '%s' of size %ld does not fix into single page %ld\n", name,

			      desc_size, SPDK_BS_MAX_DESC_SIZE);

		return -ENOMEM;

	}
@@ -7461,4 +7461,4 @@ spdk_blob_get_clones(struct spdk_blob_store *bs, spdk_blob_id blobid, spdk_blob_ 
	return 0;

}



SPDK_LOG_REGISTER_COMPONENT("blob", SPDK_LOG_BLOB)
 
SPDK_LOG_REGISTER_COMPONENT(blob)

lib/blob/request.c

+13 −13
Original line number Diff line number Diff line
@@ -133,7 +133,7 @@ bs_sequence_read_bs_dev(spdk_bs_sequence_t *seq, struct spdk_bs_dev *bs_dev, 
	struct spdk_bs_request_set      *set = (struct spdk_bs_request_set *)seq;

	struct spdk_bs_channel       *channel = set->channel;



	SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Reading %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,

	SPDK_DEBUGLOG(blob_rw, "Reading %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,

		      lba);



	set->u.sequence.cb_fn = cb_fn;
@@ -150,7 +150,7 @@ bs_sequence_read_dev(spdk_bs_sequence_t *seq, void *payload, 
	struct spdk_bs_request_set      *set = (struct spdk_bs_request_set *)seq;

	struct spdk_bs_channel       *channel = set->channel;



	SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Reading %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,

	SPDK_DEBUGLOG(blob_rw, "Reading %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,

		      lba);



	set->u.sequence.cb_fn = cb_fn;
@@ -167,7 +167,7 @@ bs_sequence_write_dev(spdk_bs_sequence_t *seq, void *payload, 
	struct spdk_bs_request_set      *set = (struct spdk_bs_request_set *)seq;

	struct spdk_bs_channel       *channel = set->channel;



	SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Writing %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,

	SPDK_DEBUGLOG(blob_rw, "Writing %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,

		      lba);



	set->u.sequence.cb_fn = cb_fn;
@@ -185,7 +185,7 @@ bs_sequence_readv_bs_dev(spdk_bs_sequence_t *seq, struct spdk_bs_dev *bs_dev, 
	struct spdk_bs_request_set      *set = (struct spdk_bs_request_set *)seq;

	struct spdk_bs_channel       *channel = set->channel;



	SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Reading %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,

	SPDK_DEBUGLOG(blob_rw, "Reading %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,

		      lba);



	set->u.sequence.cb_fn = cb_fn;
@@ -202,7 +202,7 @@ bs_sequence_readv_dev(spdk_bs_sequence_t *seq, struct iovec *iov, int iovcnt, 
	struct spdk_bs_request_set      *set = (struct spdk_bs_request_set *)seq;

	struct spdk_bs_channel       *channel = set->channel;



	SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Reading %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,

	SPDK_DEBUGLOG(blob_rw, "Reading %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,

		      lba);



	set->u.sequence.cb_fn = cb_fn;
@@ -219,7 +219,7 @@ bs_sequence_writev_dev(spdk_bs_sequence_t *seq, struct iovec *iov, int iovcnt, 
	struct spdk_bs_request_set      *set = (struct spdk_bs_request_set *)seq;

	struct spdk_bs_channel       *channel = set->channel;



	SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Writing %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,

	SPDK_DEBUGLOG(blob_rw, "Writing %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,

		      lba);



	set->u.sequence.cb_fn = cb_fn;
@@ -237,7 +237,7 @@ bs_sequence_write_zeroes_dev(spdk_bs_sequence_t *seq, 
	struct spdk_bs_request_set      *set = (struct spdk_bs_request_set *)seq;

	struct spdk_bs_channel       *channel = set->channel;



	SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "writing zeroes to %" PRIu32 " blocks at LBA %" PRIu64 "\n",

	SPDK_DEBUGLOG(blob_rw, "writing zeroes to %" PRIu32 " blocks at LBA %" PRIu64 "\n",

		      lba_count, lba);



	set->u.sequence.cb_fn = cb_fn;
@@ -323,7 +323,7 @@ bs_batch_read_bs_dev(spdk_bs_batch_t *batch, struct spdk_bs_dev *bs_dev, 
	struct spdk_bs_request_set	*set = (struct spdk_bs_request_set *)batch;

	struct spdk_bs_channel		*channel = set->channel;



	SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Reading %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,

	SPDK_DEBUGLOG(blob_rw, "Reading %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,

		      lba);



	set->u.batch.outstanding_ops++;
@@ -337,7 +337,7 @@ bs_batch_read_dev(spdk_bs_batch_t *batch, void *payload, 
	struct spdk_bs_request_set	*set = (struct spdk_bs_request_set *)batch;

	struct spdk_bs_channel		*channel = set->channel;



	SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Reading %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,

	SPDK_DEBUGLOG(blob_rw, "Reading %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,

		      lba);



	set->u.batch.outstanding_ops++;
@@ -351,7 +351,7 @@ bs_batch_write_dev(spdk_bs_batch_t *batch, void *payload, 
	struct spdk_bs_request_set	*set = (struct spdk_bs_request_set *)batch;

	struct spdk_bs_channel		*channel = set->channel;



	SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Writing %" PRIu32 " blocks to LBA %" PRIu64 "\n", lba_count, lba);

	SPDK_DEBUGLOG(blob_rw, "Writing %" PRIu32 " blocks to LBA %" PRIu64 "\n", lba_count, lba);



	set->u.batch.outstanding_ops++;

	channel->dev->write(channel->dev, channel->dev_channel, payload, lba, lba_count,
@@ -365,7 +365,7 @@ bs_batch_unmap_dev(spdk_bs_batch_t *batch, 
	struct spdk_bs_request_set	*set = (struct spdk_bs_request_set *)batch;

	struct spdk_bs_channel		*channel = set->channel;



	SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Unmapping %" PRIu32 " blocks at LBA %" PRIu64 "\n", lba_count,

	SPDK_DEBUGLOG(blob_rw, "Unmapping %" PRIu32 " blocks at LBA %" PRIu64 "\n", lba_count,

		      lba);



	set->u.batch.outstanding_ops++;
@@ -380,7 +380,7 @@ bs_batch_write_zeroes_dev(spdk_bs_batch_t *batch, 
	struct spdk_bs_request_set	*set = (struct spdk_bs_request_set *)batch;

	struct spdk_bs_channel		*channel = set->channel;



	SPDK_DEBUGLOG(SPDK_LOG_BLOB_RW, "Zeroing %" PRIu32 " blocks at LBA %" PRIu64 "\n", lba_count, lba);

	SPDK_DEBUGLOG(blob_rw, "Zeroing %" PRIu32 " blocks at LBA %" PRIu64 "\n", lba_count, lba);



	set->u.batch.outstanding_ops++;

	channel->dev->write_zeroes(channel->dev, channel->dev_channel, lba, lba_count,
@@ -518,4 +518,4 @@ bs_sequence_to_batch_completion(void *cb_arg, int bserrno) 
	}

}



SPDK_LOG_REGISTER_COMPONENT("blob_rw", SPDK_LOG_BLOB_RW)
 
SPDK_LOG_REGISTER_COMPONENT(blob_rw)

lib/blobfs/blobfs.c

+24 −24

File changed.

Preview size limit exceeded, changes collapsed.