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

lib/thread: Use function name as poller name by using macro SPDK_POLLER_REGISTER

Browse Source 
We will be create fine name for each poller but it will need large
effort. Replacing spdk_poller_register by the macro SPDK_POLLER_REGISTER
will provide better name than function address with minimum effort.

Following patches may improve function name for clarification.

Signed-off-by: Shuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Change-Id: If862a274c5879065c3f7cb04dcb5ca7844523e68
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/1781
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
Reviewed-by: Paul Luse <paul.e.luse@intel.com>
Reviewed-by: Aleksey Marchuk <alexeymar@mellanox.com>
Reviewed-by: Maciej Szwed <maciej.szwed@intel.com>
Community-CI: Broadcom CI
This commit is contained in:
Shuhei Matsumoto 2020-04-14 15:49:46 +09:00 committed by Tomasz Zawadzki
parent 2eabc71518
commit ab0bc5c254
49 changed files with 100 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
examples/accel/perf/accel_perf.c
View File

@ -262,7 +262,7 @@ _worker_stop(void *arg)
/* now let the worker drain and check it's outstanding IO with a poller */
worker->is_draining = true;
worker->is_draining_poller = spdk_poller_register(_check_draining, worker, 0);
worker->is_draining_poller = SPDK_POLLER_REGISTER(_check_draining, worker, 0);
return 0;
}
@ -311,7 +311,7 @@ _init_thread(void *arg1)
}
/* Register a poller that will stop the worker at time elapsed */
worker->stop_poller = spdk_poller_register(_worker_stop, worker,
worker->stop_poller = SPDK_POLLER_REGISTER(_worker_stop, worker,
g_time_in_sec * 1000000ULL);
g_workers = worker;

2
examples/nvmf/nvmf/nvmf.c
View File

@ -730,7 +730,7 @@ nvmf_target_advance_state(void)
nvmf_tgt_start_subsystems(&g_nvmf_tgt);
break;
case NVMF_INIT_START_ACCEPTOR:
g_acceptor_poller = spdk_poller_register(nvmf_tgt_acceptor_poll, &g_nvmf_tgt,
g_acceptor_poller = SPDK_POLLER_REGISTER(nvmf_tgt_acceptor_poll, &g_nvmf_tgt,
g_acceptor_poll_rate);
fprintf(stdout, "Acceptor running\n");
g_target_state = NVMF_RUNNING;

10
examples/sock/hello_world/hello_sock.c
View File

@ -143,7 +143,7 @@ hello_sock_quit(struct hello_context_t *ctx, int rc)
ctx->rc = rc;
spdk_poller_unregister(&ctx->poller_out);
if (!ctx->time_out) {
ctx->time_out = spdk_poller_register(hello_sock_close_timeout_poll, ctx,
ctx->time_out = SPDK_POLLER_REGISTER(hello_sock_close_timeout_poll, ctx,
CLOSE_TIMEOUT_US);
}
return 0;
@ -238,8 +238,8 @@ hello_sock_connect(struct hello_context_t *ctx)
fcntl(STDIN_FILENO, F_SETFL, fcntl(STDIN_FILENO, F_GETFL) | O_NONBLOCK);
g_is_running = true;
ctx->poller_in = spdk_poller_register(hello_sock_recv_poll, ctx, 0);
ctx->poller_out = spdk_poller_register(hello_sock_writev_poll, ctx, 0);
ctx->poller_in = SPDK_POLLER_REGISTER(hello_sock_recv_poll, ctx, 0);
ctx->poller_out = SPDK_POLLER_REGISTER(hello_sock_writev_poll, ctx, 0);
return 0;
}
@ -366,9 +366,9 @@ hello_sock_listen(struct hello_context_t *ctx)
/*
* Start acceptor and group poller
*/
ctx->poller_in = spdk_poller_register(hello_sock_accept_poll, ctx,
ctx->poller_in = SPDK_POLLER_REGISTER(hello_sock_accept_poll, ctx,
ACCEPT_TIMEOUT_US);
ctx->poller_out = spdk_poller_register(hello_sock_group_poll, ctx, 0);
ctx->poller_out = SPDK_POLLER_REGISTER(hello_sock_group_poll, ctx, 0);
return 0;
}

8
lib/bdev/bdev.c
View File

@ -2317,7 +2317,7 @@ bdev_enable_qos(struct spdk_bdev *bdev, struct spdk_bdev_channel *ch)
qos->timeslice_size =
SPDK_BDEV_QOS_TIMESLICE_IN_USEC * spdk_get_ticks_hz() / SPDK_SEC_TO_USEC;
qos->last_timeslice = spdk_get_ticks();
qos->poller = spdk_poller_register(bdev_channel_poll_qos,
qos->poller = SPDK_POLLER_REGISTER(bdev_channel_poll_qos,
qos,
SPDK_BDEV_QOS_TIMESLICE_IN_USEC);
}
@ -2437,7 +2437,7 @@ spdk_bdev_set_timeout(struct spdk_bdev_desc *desc, uint64_t timeout_in_sec,
if (timeout_in_sec) {
assert(cb_fn != NULL);
desc->io_timeout_poller = spdk_poller_register(bdev_poll_timeout_io,
desc->io_timeout_poller = SPDK_POLLER_REGISTER(bdev_poll_timeout_io,
desc,
SPDK_BDEV_IO_POLL_INTERVAL_IN_MSEC * SPDK_SEC_TO_USEC /
1000);
@ -3044,7 +3044,7 @@ spdk_bdev_set_qd_sampling_period(struct spdk_bdev *bdev, uint64_t period)
}
if (period != 0) {
bdev->internal.qd_poller = spdk_poller_register(bdev_calculate_measured_queue_depth, bdev,
bdev->internal.qd_poller = SPDK_POLLER_REGISTER(bdev_calculate_measured_queue_depth, bdev,
period);
}
}
@ -6144,7 +6144,7 @@ bdev_lock_lba_range_check_io(void *_i)
*/
TAILQ_FOREACH(bdev_io, &ch->io_submitted, internal.ch_link) {
if (bdev_io_range_is_locked(bdev_io, range)) {
ctx->poller = spdk_poller_register(bdev_lock_lba_range_check_io, i, 100);
ctx->poller = SPDK_POLLER_REGISTER(bdev_lock_lba_range_check_io, i, 100);
return 1;
}
}

2
lib/blobfs/blobfs.c
View File

@ -297,7 +297,7 @@ __start_cache_pool_mgmt(void *ctx)
pthread_spin_init(&g_caches_lock, 0);
assert(g_cache_pool_mgmt_poller == NULL);
g_cache_pool_mgmt_poller = spdk_poller_register(_blobfs_cache_pool_reclaim, NULL,
g_cache_pool_mgmt_poller = SPDK_POLLER_REGISTER(_blobfs_cache_pool_reclaim, NULL,
BLOBFS_CACHE_POOL_POLL_PERIOD_IN_US);
}

2
lib/event/app.c
View File

@ -1134,7 +1134,7 @@ spdk_rpc_framework_wait_init(struct spdk_jsonrpc_request *request,
return;
}
ctx->request = request;
ctx->init_poller = spdk_poller_register(spdk_rpc_subsystem_init_poller_ctx, ctx, 0);
ctx->init_poller = SPDK_POLLER_REGISTER(spdk_rpc_subsystem_init_poller_ctx, ctx, 0);
}
}
SPDK_RPC_REGISTER("framework_wait_init", spdk_rpc_framework_wait_init,

4
lib/event/json_config.c
View File

@ -219,7 +219,7 @@ rpc_client_connect_poller(void *_ctx)
if (rc != -ENOTCONN) {
/* We are connected. Start regular poller and issue first request */
spdk_poller_unregister(&ctx->client_conn_poller);
ctx->client_conn_poller = spdk_poller_register(rpc_client_poller, ctx, 100);
ctx->client_conn_poller = SPDK_POLLER_REGISTER(rpc_client_poller, ctx, 100);
spdk_app_json_config_load_subsystem(ctx);
} else {
rc = rpc_client_check_timeout(ctx);
@ -589,7 +589,7 @@ spdk_app_json_config_load(const char *json_config_file, const char *rpc_addr,
}
rpc_client_set_timeout(ctx, RPC_CLIENT_CONNECT_TIMEOUT_US);
ctx->client_conn_poller = spdk_poller_register(rpc_client_connect_poller, ctx, 100);
ctx->client_conn_poller = SPDK_POLLER_REGISTER(rpc_client_connect_poller, ctx, 100);
return;
fail:

2
lib/event/rpc.c
View File

@ -76,7 +76,7 @@ spdk_rpc_initialize(const char *listen_addr)
spdk_rpc_set_state(SPDK_RPC_STARTUP);
/* Register a poller to periodically check for RPCs */
g_rpc_poller = spdk_poller_register(spdk_rpc_subsystem_poll, NULL, RPC_SELECT_INTERVAL);
g_rpc_poller = SPDK_POLLER_REGISTER(spdk_rpc_subsystem_poll, NULL, RPC_SELECT_INTERVAL);
}
void

6
lib/ftl/ftl_init.c
View File

@ -512,7 +512,7 @@ _ftl_dev_init_core_thread(void *ctx)
{
struct spdk_ftl_dev *dev = ctx;
dev->core_poller = spdk_poller_register(ftl_task_core, dev, 0);
dev->core_poller = SPDK_POLLER_REGISTER(ftl_task_core, dev, 0);
if (!dev->core_poller) {
SPDK_ERRLOG("Unable to register core poller\n");
assert(0);
@ -1140,7 +1140,7 @@ ftl_io_channel_create_cb(void *io_device, void *ctx)
TAILQ_INIT(&ioch->write_cmpl_queue);
TAILQ_INIT(&ioch->retry_queue);
ioch->poller = spdk_poller_register(ftl_io_channel_poll, ioch, 0);
ioch->poller = SPDK_POLLER_REGISTER(ftl_io_channel_poll, ioch, 0);
if (!ioch->poller) {
SPDK_ERRLOG("Failed to register IO channel poller\n");
goto fail_poller;
@ -1637,7 +1637,7 @@ ftl_add_halt_poller(void *ctx)
_ftl_halt_defrag(dev);
assert(!fini_ctx->poller);
fini_ctx->poller = spdk_poller_register(ftl_halt_poller, fini_ctx, 100);
fini_ctx->poller = SPDK_POLLER_REGISTER(ftl_halt_poller, fini_ctx, 100);
}
static int

12
lib/iscsi/conn.c
View File

@ -535,7 +535,7 @@ _iscsi_conn_hotremove_lun(void *ctx)
spdk_clear_all_transfer_task(conn, lun, NULL);
iscsi_lun->remove_poller = spdk_poller_register(iscsi_conn_remove_lun, iscsi_lun,
iscsi_lun->remove_poller = SPDK_POLLER_REGISTER(iscsi_conn_remove_lun, iscsi_lun,
1000);
}
@ -674,7 +674,7 @@ _iscsi_conn_destruct(struct spdk_iscsi_conn *conn)
rc = iscsi_conn_free_tasks(conn);
if (rc < 0) {
/* The connection cannot be freed yet. Check back later. */
conn->shutdown_timer = spdk_poller_register(_iscsi_conn_check_shutdown, conn, 1000);
conn->shutdown_timer = SPDK_POLLER_REGISTER(_iscsi_conn_check_shutdown, conn, 1000);
} else {
iscsi_conn_stop(conn);
iscsi_conn_free(conn);
@ -744,7 +744,7 @@ spdk_iscsi_conn_destruct(struct spdk_iscsi_conn *conn)
if (conn->dev != NULL &&
spdk_scsi_dev_has_pending_tasks(conn->dev, conn->initiator_port)) {
conn->shutdown_timer = spdk_poller_register(_iscsi_conn_check_pending_tasks, conn, 1000);
conn->shutdown_timer = SPDK_POLLER_REGISTER(_iscsi_conn_check_pending_tasks, conn, 1000);
} else {
_iscsi_conn_destruct(conn);
}
@ -844,7 +844,7 @@ _iscsi_conn_request_logout(void *ctx)
iscsi_send_logout_request(conn);
conn->logout_request_timer = spdk_poller_register(logout_request_timeout,
conn->logout_request_timer = SPDK_POLLER_REGISTER(logout_request_timeout,
conn, ISCSI_LOGOUT_REQUEST_TIMEOUT * 1000000);
}
@ -892,7 +892,7 @@ spdk_shutdown_iscsi_conns(void)
{
spdk_iscsi_conns_request_logout(NULL);
g_shutdown_timer = spdk_poller_register(iscsi_conn_check_shutdown, NULL, 1000);
g_shutdown_timer = SPDK_POLLER_REGISTER(iscsi_conn_check_shutdown, NULL, 1000);
}
int
@ -1638,7 +1638,7 @@ void
spdk_iscsi_conn_logout(struct spdk_iscsi_conn *conn)
{
conn->is_logged_out = true;
conn->logout_timer = spdk_poller_register(logout_timeout, conn, ISCSI_LOGOUT_TIMEOUT * 1000000);
conn->logout_timer = SPDK_POLLER_REGISTER(logout_timeout, conn, ISCSI_LOGOUT_TIMEOUT * 1000000);
}
SPDK_TRACE_REGISTER_FN(iscsi_conn_trace, "iscsi_conn", TRACE_GROUP_ISCSI)

4
lib/iscsi/iscsi.c
View File

@ -3606,7 +3606,7 @@ iscsi_op_abort_task(struct spdk_iscsi_task *task, uint32_t ref_task_tag)
{
task->scsi.abort_id = ref_task_tag;
task->scsi.function = SPDK_SCSI_TASK_FUNC_ABORT_TASK;
task->mgmt_poller = spdk_poller_register(_iscsi_op_abort_task, task, 10);
task->mgmt_poller = SPDK_POLLER_REGISTER(_iscsi_op_abort_task, task, 10);
}
static int
@ -3630,7 +3630,7 @@ void
spdk_iscsi_op_abort_task_set(struct spdk_iscsi_task *task, uint8_t function)
{
task->scsi.function = function;
task->mgmt_poller = spdk_poller_register(_iscsi_op_abort_task_set, task, 10);
task->mgmt_poller = SPDK_POLLER_REGISTER(_iscsi_op_abort_task_set, task, 10);
}
static int

4
lib/iscsi/iscsi_subsystem.c
View File

@ -1228,9 +1228,9 @@ iscsi_poll_group_create(void *io_device, void *ctx_buf)
pg->sock_group = spdk_sock_group_create(NULL);
assert(pg->sock_group != NULL);
pg->poller = spdk_poller_register(iscsi_poll_group_poll, pg, 0);
pg->poller = SPDK_POLLER_REGISTER(iscsi_poll_group_poll, pg, 0);
/* set the period to 1 sec */
pg->nop_poller = spdk_poller_register(iscsi_poll_group_handle_nop, pg, 1000000);
pg->nop_poller = SPDK_POLLER_REGISTER(iscsi_poll_group_handle_nop, pg, 1000000);
return 0;
}

2
lib/iscsi/portal_grp.c
View File

@ -198,7 +198,7 @@ iscsi_portal_open(struct spdk_iscsi_portal *p)
* the requests will be queued by the nonzero backlog of the socket
* or resend by TCP.
*/
p->acceptor_poller = spdk_poller_register(iscsi_portal_accept, p, ACCEPT_TIMEOUT_US);
p->acceptor_poller = SPDK_POLLER_REGISTER(iscsi_portal_accept, p, ACCEPT_TIMEOUT_US);
return 0;
}

2
lib/iscsi/tgt_node.c
View File

@ -692,7 +692,7 @@ iscsi_tgt_node_destruct(struct spdk_iscsi_tgt_node *target,
spdk_iscsi_conns_request_logout(target);
if (spdk_iscsi_get_active_conns(target) != 0) {
target->destruct_poller = spdk_poller_register(iscsi_tgt_node_check_active_conns,
target->destruct_poller = SPDK_POLLER_REGISTER(iscsi_tgt_node_check_active_conns,
target, 10);
} else {
spdk_scsi_dev_destruct(target->dev, _iscsi_tgt_node_destruct, target);

4
lib/nbd/nbd.c
View File

@ -911,7 +911,7 @@ spdk_nbd_start_complete(struct spdk_nbd_start_ctx *ctx)
goto err;
}
ctx->nbd->nbd_poller = spdk_poller_register(spdk_nbd_poll, ctx->nbd, 0);
ctx->nbd->nbd_poller = SPDK_POLLER_REGISTER(spdk_nbd_poll, ctx->nbd, 0);
if (ctx->cb_fn) {
ctx->cb_fn(ctx->cb_arg, ctx->nbd, 0);
@ -939,7 +939,7 @@ spdk_nbd_enable_kernel(void *arg)
if (rc == -1) {
if (errno == EBUSY && ctx->polling_count-- > 0) {
if (ctx->poller == NULL) {
ctx->poller = spdk_poller_register(spdk_nbd_enable_kernel, ctx,
ctx->poller = SPDK_POLLER_REGISTER(spdk_nbd_enable_kernel, ctx,
NBD_BUSY_POLLING_INTERVAL_US);
}
/* If the kernel is busy, check back later */

4
lib/nvmf/ctrlr.c
View File

@ -196,7 +196,7 @@ spdk_nvmf_ctrlr_start_keep_alive_timer(struct spdk_nvmf_ctrlr *ctrlr)
ctrlr->last_keep_alive_tick = spdk_get_ticks();
SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Ctrlr add keep alive poller\n");
ctrlr->keep_alive_poller = spdk_poller_register(spdk_nvmf_ctrlr_keep_alive_poll, ctrlr,
ctrlr->keep_alive_poller = SPDK_POLLER_REGISTER(spdk_nvmf_ctrlr_keep_alive_poll, ctrlr,
ctrlr->feat.keep_alive_timer.bits.kato * 1000);
}
}
@ -1371,7 +1371,7 @@ spdk_nvmf_ctrlr_set_features_keep_alive_timer(struct spdk_nvmf_request *req)
if (ctrlr->keep_alive_poller != NULL) {
spdk_poller_unregister(&ctrlr->keep_alive_poller);
}
ctrlr->keep_alive_poller = spdk_poller_register(spdk_nvmf_ctrlr_keep_alive_poll, ctrlr,
ctrlr->keep_alive_poller = SPDK_POLLER_REGISTER(spdk_nvmf_ctrlr_keep_alive_poll, ctrlr,
ctrlr->feat.keep_alive_timer.bits.kato * 1000);
}

2
lib/nvmf/nvmf.c
View File

@ -142,7 +142,7 @@ spdk_nvmf_tgt_create_poll_group(void *io_device, void *ctx_buf)
}
}
group->poller = spdk_poller_register(spdk_nvmf_poll_group_poll, group, 0);
group->poller = SPDK_POLLER_REGISTER(spdk_nvmf_poll_group_poll, group, 0);
group->thread = spdk_get_thread();
return 0;

2
lib/nvmf/rdma.c
View File

@ -3650,7 +3650,7 @@ spdk_nvmf_rdma_close_qpair(struct spdk_nvmf_qpair *qpair)
spdk_nvmf_rdma_set_ibv_state(rqpair, IBV_QPS_ERR);
}
rqpair->destruct_poller = spdk_poller_register(spdk_nvmf_rdma_destroy_defunct_qpair, (void *)rqpair,
rqpair->destruct_poller = SPDK_POLLER_REGISTER(spdk_nvmf_rdma_destroy_defunct_qpair, (void *)rqpair,
NVMF_RDMA_QPAIR_DESTROY_TIMEOUT_US);
}

2
lib/nvmf/tcp.c
View File

@ -1064,7 +1064,7 @@ spdk_nvmf_tcp_send_c2h_term_req_complete(void *cb_arg)
struct spdk_nvmf_tcp_qpair *tqpair = (struct spdk_nvmf_tcp_qpair *)cb_arg;
if (!tqpair->timeout_poller) {
tqpair->timeout_poller = spdk_poller_register(spdk_nvmf_tcp_qpair_handle_timeout, tqpair,
tqpair->timeout_poller = SPDK_POLLER_REGISTER(spdk_nvmf_tcp_qpair_handle_timeout, tqpair,
SPDK_NVME_TCP_QPAIR_EXIT_TIMEOUT * 1000000);
}
}

6
lib/scsi/lun.c
View File

@ -110,7 +110,7 @@ spdk_scsi_lun_complete_reset_task(struct spdk_scsi_lun *lun, struct spdk_scsi_ta
if (task->status == SPDK_SCSI_STATUS_GOOD) {
if (scsi_lun_has_outstanding_tasks(lun)) {
lun->reset_poller =
spdk_poller_register(scsi_lun_reset_check_outstanding_tasks,
SPDK_POLLER_REGISTER(scsi_lun_reset_check_outstanding_tasks,
task, 10);
return;
}
@ -311,7 +311,7 @@ scsi_lun_notify_hot_remove(struct spdk_scsi_lun *lun)
}
if (lun->io_channel) {
lun->hotremove_poller = spdk_poller_register(scsi_lun_check_io_channel,
lun->hotremove_poller = SPDK_POLLER_REGISTER(scsi_lun_check_io_channel,
lun, 10);
} else {
scsi_lun_remove(lun);
@ -348,7 +348,7 @@ _scsi_lun_hot_remove(void *arg1)
*/
if (scsi_lun_has_outstanding_tasks(lun) ||
scsi_lun_has_outstanding_mgmt_tasks(lun)) {
lun->hotremove_poller = spdk_poller_register(scsi_lun_check_outstanding_tasks,
lun->hotremove_poller = SPDK_POLLER_REGISTER(scsi_lun_check_outstanding_tasks,
lun, 10);
} else {
scsi_lun_notify_hot_remove(lun);

6
lib/vhost/vhost_blk.c
View File

@ -831,7 +831,7 @@ vhost_session_bdev_remove_cb(struct spdk_vhost_dev *vdev,
bvsession = (struct spdk_vhost_blk_session *)vsession;
if (bvsession->requestq_poller) {
spdk_poller_unregister(&bvsession->requestq_poller);
bvsession->requestq_poller = spdk_poller_register(no_bdev_vdev_worker, bvsession, 0);
bvsession->requestq_poller = SPDK_POLLER_REGISTER(no_bdev_vdev_worker, bvsession, 0);
}
return 0;
@ -954,7 +954,7 @@ vhost_blk_start_cb(struct spdk_vhost_dev *vdev,
}
}
bvsession->requestq_poller = spdk_poller_register(bvdev->bdev ? vdev_worker : no_bdev_vdev_worker,
bvsession->requestq_poller = SPDK_POLLER_REGISTER(bvdev->bdev ? vdev_worker : no_bdev_vdev_worker,
bvsession, 0);
SPDK_INFOLOG(SPDK_LOG_VHOST, "%s: started poller on lcore %d\n",
vsession->name, spdk_env_get_current_core());
@ -1013,7 +1013,7 @@ vhost_blk_stop_cb(struct spdk_vhost_dev *vdev,
struct spdk_vhost_blk_session *bvsession = to_blk_session(vsession);
spdk_poller_unregister(&bvsession->requestq_poller);
bvsession->stop_poller = spdk_poller_register(destroy_session_poller_cb,
bvsession->stop_poller = SPDK_POLLER_REGISTER(destroy_session_poller_cb,
bvsession, 1000);
return 0;
}

4
lib/vhost/vhost_nvme.c
View File

@ -1053,7 +1053,7 @@ spdk_vhost_nvme_start_cb(struct spdk_vhost_dev *vdev,
nvme->vsession = vsession;
/* Start the NVMe Poller */
nvme->requestq_poller = spdk_poller_register(nvme_worker, nvme, 0);
nvme->requestq_poller = SPDK_POLLER_REGISTER(nvme_worker, nvme, 0);
out:
vhost_session_start_done(vsession, rc);
@ -1147,7 +1147,7 @@ spdk_vhost_nvme_stop_cb(struct spdk_vhost_dev *vdev,
SPDK_NOTICELOG("Stopping Device %u, Path %s\n", vsession->vid, vdev->path);
spdk_poller_unregister(&nvme->requestq_poller);
nvme->stop_poller = spdk_poller_register(destroy_device_poller_cb, nvme, 1000);
nvme->stop_poller = SPDK_POLLER_REGISTER(destroy_device_poller_cb, nvme, 1000);
return 0;
}

6
lib/vhost/vhost_scsi.c
View File

@ -1332,10 +1332,10 @@ vhost_scsi_start_cb(struct spdk_vhost_dev *vdev,
SPDK_INFOLOG(SPDK_LOG_VHOST, "%s: started poller on lcore %d\n",
vsession->name, spdk_env_get_current_core());
svsession->requestq_poller = spdk_poller_register(vdev_worker, svsession, 0);
svsession->requestq_poller = SPDK_POLLER_REGISTER(vdev_worker, svsession, 0);
if (vsession->virtqueue[VIRTIO_SCSI_CONTROLQ].vring.desc &&
vsession->virtqueue[VIRTIO_SCSI_EVENTQ].vring.desc) {
svsession->mgmt_poller = spdk_poller_register(vdev_mgmt_worker, svsession,
svsession->mgmt_poller = SPDK_POLLER_REGISTER(vdev_mgmt_worker, svsession,
MGMT_POLL_PERIOD_US);
}
out:
@ -1431,7 +1431,7 @@ vhost_scsi_stop_cb(struct spdk_vhost_dev *vdev,
/* Wait for all pending I/Os to complete, then process all the
* remaining hotremove events one last time.
*/
svsession->stop_poller = spdk_poller_register(destroy_session_poller_cb,
svsession->stop_poller = SPDK_POLLER_REGISTER(destroy_session_poller_cb,
svsession, 1000);
return 0;

2
module/accel/ioat/accel_engine_ioat.c
View File

@ -210,7 +210,7 @@ ioat_create_cb(void *io_device, void *ctx_buf)
ch->ioat_dev = ioat_dev;
ch->ioat_ch = ioat_dev->ioat;
ch->poller = spdk_poller_register(ioat_poll, ch->ioat_ch, 0);
ch->poller = SPDK_POLLER_REGISTER(ioat_poll, ch->ioat_ch, 0);
return 0;
}

4
module/bdev/aio/bdev_aio.c
View File

@ -363,7 +363,7 @@ _bdev_aio_get_io_inflight_done(struct spdk_io_channel_iter *i, int status)
struct file_disk *fdisk = spdk_io_channel_iter_get_ctx(i);
if (status == -1) {
fdisk->reset_retry_timer = spdk_poller_register(bdev_aio_reset_retry_timer, fdisk, 500);
fdisk->reset_retry_timer = SPDK_POLLER_REGISTER(bdev_aio_reset_retry_timer, fdisk, 500);
return;
}
@ -566,7 +566,7 @@ bdev_aio_group_create_cb(void *io_device, void *ctx_buf)
return -1;
}
ch->poller = spdk_poller_register(bdev_aio_group_poll, ch, 0);
ch->poller = SPDK_POLLER_REGISTER(bdev_aio_group_poll, ch, 0);
return 0;
}

2
module/bdev/compress/vbdev_compress.c
View File

@ -1393,7 +1393,7 @@ comp_bdev_ch_create_cb(void *io_device, void *ctx_buf)
comp_bdev->base_ch = spdk_bdev_get_io_channel(comp_bdev->base_desc);
comp_bdev->reduce_thread = spdk_get_thread();
comp_bdev->poller = spdk_poller_register(comp_dev_poller, comp_bdev, 0);
comp_bdev->poller = SPDK_POLLER_REGISTER(comp_dev_poller, comp_bdev, 0);
/* Now assign a q pair */
pthread_mutex_lock(&g_comp_device_qp_lock);
TAILQ_FOREACH(device_qp, &g_comp_device_qp, link) {

2
module/bdev/crypto/vbdev_crypto.c
View File

@ -1363,7 +1363,7 @@ crypto_bdev_ch_create_cb(void *io_device, void *ctx_buf)
struct device_qp *device_qp = NULL;
crypto_ch->base_ch = spdk_bdev_get_io_channel(crypto_bdev->base_desc);
crypto_ch->poller = spdk_poller_register(crypto_dev_poller, crypto_ch, 0);
crypto_ch->poller = SPDK_POLLER_REGISTER(crypto_dev_poller, crypto_ch, 0);
crypto_ch->device_qp = NULL;
/* Assign a device/qp combination that is unique per channel per PMD. */

2
module/bdev/delay/vbdev_delay.c
View File

@ -443,7 +443,7 @@ delay_bdev_ch_create_cb(void *io_device, void *ctx_buf)
STAILQ_INIT(&delay_ch->avg_write_io);
STAILQ_INIT(&delay_ch->p99_write_io);
delay_ch->io_poller = spdk_poller_register(_delay_finish_io, delay_ch, 0);
delay_ch->io_poller = SPDK_POLLER_REGISTER(_delay_finish_io, delay_ch, 0);
delay_ch->base_ch = spdk_bdev_get_io_channel(delay_node->base_desc);
delay_ch->rand_seed = time(NULL);

6
module/bdev/iscsi/bdev_iscsi.c
View File

@ -511,7 +511,7 @@ bdev_iscsi_create_cb(void *io_device, void *ctx_buf)
if (lun->ch_count == 0) {
assert(lun->master_td == NULL);
lun->master_td = spdk_get_thread();
lun->poller = spdk_poller_register(bdev_iscsi_poll_lun, lun, 0);
lun->poller = SPDK_POLLER_REGISTER(bdev_iscsi_poll_lun, lun, 0);
ch->lun = lun;
}
lun->ch_count++;
@ -663,7 +663,7 @@ create_iscsi_lun(struct iscsi_context *context, int lun_id, char *url, char *ini
}
lun->no_master_ch_poller_td = spdk_get_thread();
lun->no_master_ch_poller = spdk_poller_register(bdev_iscsi_no_master_ch_poll, lun,
lun->no_master_ch_poller = SPDK_POLLER_REGISTER(bdev_iscsi_no_master_ch_poll, lun,
BDEV_ISCSI_NO_MASTER_CH_POLL_US);
*bdev = &lun->bdev;
@ -845,7 +845,7 @@ create_iscsi_disk(const char *bdev_name, const char *url, const char *initiator_
req->status = -1;
TAILQ_INSERT_TAIL(&g_iscsi_conn_req, req, link);
if (!g_conn_poller) {
g_conn_poller = spdk_poller_register(iscsi_bdev_conn_poll, NULL, BDEV_ISCSI_CONNECTION_POLL_US);
g_conn_poller = SPDK_POLLER_REGISTER(iscsi_bdev_conn_poll, NULL, BDEV_ISCSI_CONNECTION_POLL_US);
}
return 0;

2
module/bdev/null/bdev_null.c
View File

@ -362,7 +362,7 @@ null_bdev_create_cb(void *io_device, void *ctx_buf)
struct null_io_channel *ch = ctx_buf;
TAILQ_INIT(&ch->io);
ch->poller = spdk_poller_register(null_io_poll, ch, 0);
ch->poller = SPDK_POLLER_REGISTER(null_io_poll, ch, 0);
return 0;
}

8
module/bdev/nvme/bdev_nvme.c
View File

@ -708,7 +708,7 @@ bdev_nvme_create_cb(void *io_device, void *ctx_buf)
}
}
ch->poller = spdk_poller_register(bdev_nvme_poll, ch, g_opts.nvme_ioq_poll_period_us);
ch->poller = SPDK_POLLER_REGISTER(bdev_nvme_poll, ch, g_opts.nvme_ioq_poll_period_us);
TAILQ_INIT(&ch->pending_resets);
return 0;
@ -1318,7 +1318,7 @@ create_ctrlr(struct spdk_nvme_ctrlr *ctrlr,
sizeof(struct nvme_io_channel),
name);
nvme_bdev_ctrlr->adminq_timer_poller = spdk_poller_register(bdev_nvme_poll_adminq, ctrlr,
nvme_bdev_ctrlr->adminq_timer_poller = SPDK_POLLER_REGISTER(bdev_nvme_poll_adminq, ctrlr,
g_opts.nvme_adminq_poll_period_us);
TAILQ_INSERT_TAIL(&g_nvme_bdev_ctrlrs, nvme_bdev_ctrlr, tailq);
@ -1483,7 +1483,7 @@ set_nvme_hotplug_period_cb(void *_ctx)
spdk_poller_unregister(&g_hotplug_poller);
if (ctx->enabled) {
g_hotplug_poller = spdk_poller_register(bdev_nvme_hotplug, NULL, ctx->period_us);
g_hotplug_poller = SPDK_POLLER_REGISTER(bdev_nvme_hotplug, NULL, ctx->period_us);
}
g_nvme_hotplug_poll_period_us = ctx->period_us;
@ -1676,7 +1676,7 @@ spdk_bdev_nvme_create(struct spdk_nvme_transport_id *trid,
free(ctx);
return -ENODEV;
}
ctx->poller = spdk_poller_register(bdev_nvme_async_poll, ctx, 1000);
ctx->poller = SPDK_POLLER_REGISTER(bdev_nvme_async_poll, ctx, 1000);
return 0;
}

4
module/bdev/nvme/bdev_ocssd.c
View File

@ -1441,7 +1441,7 @@ bdev_ocssd_create_io_channel(struct nvme_io_channel *ioch)
return -ENOMEM;
}
ocssd_ioch->pending_poller = spdk_poller_register(bdev_ocssd_poll_pending,
ocssd_ioch->pending_poller = SPDK_POLLER_REGISTER(bdev_ocssd_poll_pending,
spdk_io_channel_from_ctx(ioch), 0);
if (ocssd_ioch->pending_poller == NULL) {
SPDK_ERRLOG("Failed to register pending requests poller\n");
@ -1475,7 +1475,7 @@ bdev_ocssd_init_ctrlr(struct nvme_bdev_ctrlr *nvme_bdev_ctrlr)
return -ENOMEM;
}
ocssd_ctrlr->mm_poller = spdk_poller_register(bdev_ocssd_poll_mm, nvme_bdev_ctrlr,
ocssd_ctrlr->mm_poller = SPDK_POLLER_REGISTER(bdev_ocssd_poll_mm, nvme_bdev_ctrlr,
10000ULL);
if (!ocssd_ctrlr->mm_poller) {
free(ocssd_ctrlr);

2
module/bdev/nvme/common.c
View File

@ -154,7 +154,7 @@ nvme_bdev_ctrlr_destruct(struct nvme_bdev_ctrlr *nvme_bdev_ctrlr)
if (nvme_bdev_ctrlr->resetting) {
nvme_bdev_ctrlr->destruct_poller =
spdk_poller_register((spdk_poller_fn)nvme_bdev_ctrlr_destruct, nvme_bdev_ctrlr, 1000);
SPDK_POLLER_REGISTER((spdk_poller_fn)nvme_bdev_ctrlr_destruct, nvme_bdev_ctrlr, 1000);
pthread_mutex_unlock(&g_bdev_nvme_mutex);
return 1;
}

2
module/bdev/ocf/ctx.c
View File

@ -429,7 +429,7 @@ vbdev_ocf_ctx_cleaner_kick(ocf_cleaner_t cleaner)
/* We start cleaner poller at the same thread where cache was created
* TODO: allow user to specify core at which cleaner should run */
priv->poller = spdk_poller_register(cleaner_poll, cleaner, 0);
priv->poller = SPDK_POLLER_REGISTER(cleaner_poll, cleaner, 0);
}
static void

6
module/bdev/ocf/vbdev_ocf.c
View File

@ -828,7 +828,7 @@ io_device_create_cb(void *io_device, void *ctx_buf)
qctx->vbdev = vbdev;
qctx->cache_ch = spdk_bdev_get_io_channel(vbdev->cache.desc);
qctx->core_ch = spdk_bdev_get_io_channel(vbdev->core.desc);
qctx->poller = spdk_poller_register(queue_poll, qctx, 0);
qctx->poller = SPDK_POLLER_REGISTER(queue_poll, qctx, 0);
return rc;
}
@ -846,7 +846,7 @@ io_device_destroy_cb(void *io_device, void *ctx_buf)
ocf_queue_set_priv(qctx->queue, copy);
memcpy(copy, qctx, sizeof(*copy));
spdk_poller_unregister(&qctx->poller);
copy->poller = spdk_poller_register(queue_poll, copy, 0);
copy->poller = SPDK_POLLER_REGISTER(queue_poll, copy, 0);
copy->allocated = true;
} else {
SPDK_ERRLOG("Unable to stop OCF queue properly: %s\n",
@ -1013,7 +1013,7 @@ create_management_queue(struct vbdev_ocf *vbdev)
return rc;
}
mngt_poller = spdk_poller_register(mngt_queue_poll, vbdev->cache_ctx->mngt_queue, 100);
mngt_poller = SPDK_POLLER_REGISTER(mngt_queue_poll, vbdev->cache_ctx->mngt_queue, 100);
if (mngt_poller == NULL) {
SPDK_ERRLOG("Unable to initiate mngt request: %s", spdk_strerror(ENOMEM));
return -ENOMEM;

4
module/bdev/rbd/bdev_rbd.c
View File

@ -357,7 +357,7 @@ bdev_rbd_reset(struct bdev_rbd *disk, struct spdk_bdev_io *bdev_io)
*/
assert(disk->reset_bdev_io == NULL);
disk->reset_bdev_io = bdev_io;
disk->reset_timer = spdk_poller_register(bdev_rbd_reset_timer, disk, 1 * 1000 * 1000);
disk->reset_timer = SPDK_POLLER_REGISTER(bdev_rbd_reset_timer, disk, 1 * 1000 * 1000);
return 0;
}
@ -580,7 +580,7 @@ bdev_rbd_create_cb(void *io_device, void *ctx_buf)
goto err;
}
ch->poller = spdk_poller_register(bdev_rbd_io_poll, ch, BDEV_RBD_POLL_US);
ch->poller = SPDK_POLLER_REGISTER(bdev_rbd_io_poll, ch, BDEV_RBD_POLL_US);
return 0;

2
module/bdev/uring/bdev_uring.c
View File

@ -427,7 +427,7 @@ bdev_uring_group_create_cb(void *io_device, void *ctx_buf)
return -1;
}
ch->poller = spdk_poller_register(bdev_uring_group_poll, ch, 0);
ch->poller = SPDK_POLLER_REGISTER(bdev_uring_group_poll, ch, 0);
return 0;
}

2
module/bdev/virtio/bdev_virtio_blk.c
View File

@ -390,7 +390,7 @@ bdev_virtio_blk_ch_create_cb(void *io_device, void *ctx_buf)
ch->vdev = vdev;
ch->vq = vq;
ch->poller = spdk_poller_register(bdev_virtio_poll, ch, 0);
ch->poller = SPDK_POLLER_REGISTER(bdev_virtio_poll, ch, 0);
return 0;
}

4
module/bdev/virtio/bdev_virtio_scsi.c
View File

@ -286,7 +286,7 @@ virtio_scsi_dev_init(struct virtio_scsi_dev *svdev, uint16_t max_queues)
svdev->ctrlq_ring = ctrlq_ring;
svdev->mgmt_poller = spdk_poller_register(bdev_virtio_mgmt_poll, svdev,
svdev->mgmt_poller = SPDK_POLLER_REGISTER(bdev_virtio_mgmt_poll, svdev,
MGMT_POLL_PERIOD_US);
TAILQ_INIT(&svdev->luns);
@ -1017,7 +1017,7 @@ bdev_virtio_scsi_ch_create_cb(void *io_device, void *ctx_buf)
ch->svdev = svdev;
ch->vq = vq;
ch->poller = spdk_poller_register(bdev_virtio_poll, ch, 0);
ch->poller = SPDK_POLLER_REGISTER(bdev_virtio_poll, ch, 0);
return 0;
}

2
module/event/subsystems/nvmf/nvmf_tgt.c
View File

@ -596,7 +596,7 @@ nvmf_tgt_advance_state(void)
break;
}
case NVMF_TGT_INIT_START_ACCEPTOR:
g_acceptor_poller = spdk_poller_register(acceptor_poll, g_spdk_nvmf_tgt,
g_acceptor_poller = SPDK_POLLER_REGISTER(acceptor_poll, g_spdk_nvmf_tgt,
g_spdk_nvmf_tgt_conf->acceptor_poll_rate);
SPDK_INFOLOG(SPDK_LOG_NVMF, "Acceptor running\n");
g_tgt_state = NVMF_TGT_RUNNING;

2
module/event/subsystems/vmd/vmd.c
View File

@ -68,7 +68,7 @@ vmd_subsystem_init(void)
assert(g_hotplug_poller == NULL);
g_hotplug_poller = spdk_poller_register(vmd_hotplug_monitor, NULL, 1000000ULL);
g_hotplug_poller = SPDK_POLLER_REGISTER(vmd_hotplug_monitor, NULL, 1000000ULL);
if (g_hotplug_poller == NULL) {
SPDK_ERRLOG("Failed to register hotplug monitor poller\n");
return -ENOMEM;

6
module/sock/vpp/vpp.c
View File

@ -1351,7 +1351,7 @@ _spdk_vpp_application_attached(void *arg)
SPDK_NOTICELOG("VPP net framework initialized.\n");
g_svm.vpp_state = VPP_STATE_ATTACHED;
g_svm.vpp_initialized = true;
g_svm.app_queue_poller = spdk_poller_register(app_queue_poller, NULL, 100);
g_svm.app_queue_poller = SPDK_POLLER_REGISTER(app_queue_poller, NULL, 100);
spdk_net_framework_init_next(0);
}
@ -1487,7 +1487,7 @@ _spdk_vpp_app_detach(void)
bmp->context = ntohl(0xfeedface);
vl_msg_api_send_shmem(g_svm.vl_input_queue, (u8 *)&bmp);
g_svm.timeout_poller = spdk_poller_register(_spdk_vpp_application_detached_timeout,
g_svm.timeout_poller = SPDK_POLLER_REGISTER(_spdk_vpp_application_detached_timeout,
NULL, 10000000);
return 0;
@ -1576,7 +1576,7 @@ spdk_vpp_net_framework_init(void)
g_svm.init_thread = spdk_get_thread();
SPDK_NOTICELOG("Enable VPP session\n");
g_svm.vpp_queue_poller = spdk_poller_register(vpp_queue_poller, NULL, 100);
g_svm.vpp_queue_poller = SPDK_POLLER_REGISTER(vpp_queue_poller, NULL, 100);
_spdk_vpp_session_enable(1);

4
test/app/fuzz/iscsi_fuzz/iscsi_fuzz.c
View File

@ -968,7 +968,7 @@ start_io(void *ctx)
dev_ctx->random_seed = spdk_get_ticks();
}
dev_ctx->poller = spdk_poller_register(poll_dev, dev_ctx, 0);
dev_ctx->poller = SPDK_POLLER_REGISTER(poll_dev, dev_ctx, 0);
if (dev_ctx->poller == NULL) {
return;
}
@ -1012,7 +1012,7 @@ begin_iscsi_fuzz(void *ctx)
__sync_add_and_fetch(&g_num_active_threads, 1);
}
g_app_completion_poller = spdk_poller_register(check_app_completion, NULL, 1000000);
g_app_completion_poller = SPDK_POLLER_REGISTER(check_app_completion, NULL, 1000000);
if (g_app_completion_poller == NULL) {
fprintf(stderr, "Failed to register a poller for test completion checking.\n");
goto out;

4
test/app/fuzz/nvme_fuzz/nvme_fuzz.c
View File

@ -687,7 +687,7 @@ start_ns_poller(void *ctx)
{
struct nvme_fuzz_ns *ns_entry = ctx;
ns_entry->req_poller = spdk_poller_register(poll_for_completions, ns_entry, 0);
ns_entry->req_poller = SPDK_POLLER_REGISTER(poll_for_completions, ns_entry, 0);
submit_ns_cmds(ns_entry);
}
@ -765,7 +765,7 @@ begin_fuzz(void *ctx)
__sync_add_and_fetch(&g_num_active_threads, 1);
}
g_app_completion_poller = spdk_poller_register(check_app_completion, NULL, 1000000);
g_app_completion_poller = SPDK_POLLER_REGISTER(check_app_completion, NULL, 1000000);
return;
out:
printf("Shutting down the fuzz application\n");

4
test/app/fuzz/vhost_fuzz/vhost_fuzz.c
View File

@ -1010,7 +1010,7 @@ start_io(void *ctx)
dev_ctx->timeout_tsc = fuzz_refresh_timeout();
dev_ctx->poller = spdk_poller_register(poll_dev, dev_ctx, 0);
dev_ctx->poller = SPDK_POLLER_REGISTER(poll_dev, dev_ctx, 0);
if (dev_ctx->poller == NULL) {
return;
}
@ -1041,7 +1041,7 @@ begin_fuzz(void *ctx)
goto out;
}
g_run_poller = spdk_poller_register(end_fuzz, NULL, 0);
g_run_poller = SPDK_POLLER_REGISTER(end_fuzz, NULL, 0);
if (g_run_poller == NULL) {
fprintf(stderr, "Failed to register a poller for test completion checking.\n");
}

2
test/app/stub/stub.c
View File

@ -129,7 +129,7 @@ stub_start(void *arg1)
exit(1);
}
g_poller = spdk_poller_register(stub_sleep, NULL, 0);
g_poller = SPDK_POLLER_REGISTER(stub_sleep, NULL, 0);
}
static void

8
test/bdev/bdevperf/bdevperf.c
View File

@ -789,7 +789,7 @@ reset_cb(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg)
TAILQ_INSERT_TAIL(&job->task_list, task, link);
spdk_bdev_free_io(bdev_io);
job->reset_timer = spdk_poller_register(reset_job, job,
job->reset_timer = SPDK_POLLER_REGISTER(reset_job, job,
10 * 1000000);
}
@ -825,9 +825,9 @@ bdevperf_job_run(struct bdevperf_job *job)
* completes, another will be submitted. */
/* Start a timer to stop this I/O chain when the run is over */
job->run_timer = spdk_poller_register(bdevperf_job_drain, job, g_time_in_usec);
job->run_timer = SPDK_POLLER_REGISTER(bdevperf_job_drain, job, g_time_in_usec);
if (g_reset) {
job->reset_timer = spdk_poller_register(reset_job, job,
job->reset_timer = SPDK_POLLER_REGISTER(reset_job, job,
10 * 1000000);
}
@ -1000,7 +1000,7 @@ bdevperf_test(void)
/* Start a timer to dump performance numbers */
g_shutdown_tsc = spdk_get_ticks();
if (g_show_performance_real_time) {
g_perf_timer = spdk_poller_register(performance_statistics_thread, NULL,
g_perf_timer = SPDK_POLLER_REGISTER(performance_statistics_thread, NULL,
g_show_performance_period_in_usec);
}

12
test/event/reactor/reactor.c
View File

@ -90,14 +90,14 @@ test_start(void *arg1)
printf("test_start\n");
/* Register a poller that will stop the test after the time has elapsed. */
test_end_poller = spdk_poller_register(test_end, NULL, g_time_in_sec * 1000000ULL);
test_end_poller = SPDK_POLLER_REGISTER(test_end, NULL, g_time_in_sec * 1000000ULL);
poller_100ms = spdk_poller_register(tick, (void *)100, 100000);
poller_250ms = spdk_poller_register(tick, (void *)250, 250000);
poller_500ms = spdk_poller_register(tick, (void *)500, 500000);
poller_oneshot = spdk_poller_register(oneshot, NULL, 0);
poller_100ms = SPDK_POLLER_REGISTER(tick, (void *)100, 100000);
poller_250ms = SPDK_POLLER_REGISTER(tick, (void *)250, 250000);
poller_500ms = SPDK_POLLER_REGISTER(tick, (void *)500, 500000);
poller_oneshot = SPDK_POLLER_REGISTER(oneshot, NULL, 0);
poller_unregister = spdk_poller_register(nop, NULL, 0);
poller_unregister = SPDK_POLLER_REGISTER(nop, NULL, 0);
spdk_poller_unregister(&poller_unregister);
}

2
test/event/reactor_perf/reactor_perf.c
View File

@ -72,7 +72,7 @@ test_start(void *arg1)
printf("test_start\n");
/* Register a poller that will stop the test after the time has elapsed. */
g_test_end_poller = spdk_poller_register(__test_end, NULL,
g_test_end_poller = SPDK_POLLER_REGISTER(__test_end, NULL,
g_time_in_sec * 1000000ULL);
for (i = 0; i < g_queue_depth; i++) {