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

lib: json-nbd remove spdk prefix from static functions.

Browse Source 
Signed-off-by: Seth Howell <seth.howell@intel.com>
Change-Id: Idbf8d37fbac4e3a9eff253095efb2525c9094d94
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/2364
Community-CI: Mellanox Build Bot
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Paul Luse <paul.e.luse@intel.com>
Reviewed-by: Aleksey Marchuk <alexeymar@mellanox.com>
Reviewed-by: Tomasz Zawadzki <tomasz.zawadzki@intel.com>
This commit is contained in:
Seth Howell 2020-05-10 16:18:51 -07:00 committed by Tomasz Zawadzki
parent a7592dbe13
commit 0be5557cad
8 changed files with 87 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
lib/json/json_util.c
View File

@ -104,7 +104,7 @@ struct spdk_json_num {
}; };
static int static int
spdk_json_number_split(const struct spdk_json_val *val, struct spdk_json_num *num) json_number_split(const struct spdk_json_val *val, struct spdk_json_num *num)
{ {
const char *iter; const char *iter;
size_t remaining; size_t remaining;
@ -210,7 +210,7 @@ spdk_json_number_to_uint16(const struct spdk_json_val *val, uint16_t *num)
struct spdk_json_num split_num; struct spdk_json_num split_num;
int rc; int rc;
rc = spdk_json_number_split(val, &split_num); rc = json_number_split(val, &split_num);
if (rc) { if (rc) {
return rc; return rc;
} }
@ -232,7 +232,7 @@ spdk_json_number_to_int32(const struct spdk_json_val *val, int32_t *num)
struct spdk_json_num split_num; struct spdk_json_num split_num;
int rc; int rc;
rc = spdk_json_number_split(val, &split_num); rc = json_number_split(val, &split_num);
if (rc) { if (rc) {
return rc; return rc;
} }
@ -263,7 +263,7 @@ spdk_json_number_to_uint32(const struct spdk_json_val *val, uint32_t *num)
struct spdk_json_num split_num; struct spdk_json_num split_num;
int rc; int rc;
rc = spdk_json_number_split(val, &split_num); rc = json_number_split(val, &split_num);
if (rc) { if (rc) {
return rc; return rc;
} }
@ -285,7 +285,7 @@ spdk_json_number_to_uint64(const struct spdk_json_val *val, uint64_t *num)
struct spdk_json_num split_num; struct spdk_json_num split_num;
int rc; int rc;
rc = spdk_json_number_split(val, &split_num); rc = json_number_split(val, &split_num);
if (rc) { if (rc) {
return rc; return rc;
} }
@ -460,7 +460,7 @@ spdk_json_decode_string(const struct spdk_json_val *val, void *out)
} }
static struct spdk_json_val * static struct spdk_json_val *
spdk_json_first(struct spdk_json_val *object, enum spdk_json_val_type type) json_first(struct spdk_json_val *object, enum spdk_json_val_type type)
{ {
/* 'object' must be JSON object or array. 'type' might be combination of these two. */ /* 'object' must be JSON object or array. 'type' might be combination of these two. */
assert((type & (SPDK_JSON_VAL_ARRAY_BEGIN | SPDK_JSON_VAL_OBJECT_BEGIN)) != 0); assert((type & (SPDK_JSON_VAL_ARRAY_BEGIN | SPDK_JSON_VAL_OBJECT_BEGIN)) != 0);
@ -480,7 +480,7 @@ spdk_json_first(struct spdk_json_val *object, enum spdk_json_val_type type)
} }
static struct spdk_json_val * static struct spdk_json_val *
spdk_json_value(struct spdk_json_val *key) json_value(struct spdk_json_val *key)
{ {
return key->type == SPDK_JSON_VAL_NAME ? key + 1 : NULL; return key->type == SPDK_JSON_VAL_NAME ? key + 1 : NULL;
} }
@ -495,7 +495,7 @@ spdk_json_find(struct spdk_json_val *object, const char *key_name, struct spdk_j
assert(object != NULL); assert(object != NULL);
for (it = spdk_json_first(object, SPDK_JSON_VAL_ARRAY_BEGIN | SPDK_JSON_VAL_OBJECT_BEGIN); for (it = json_first(object, SPDK_JSON_VAL_ARRAY_BEGIN | SPDK_JSON_VAL_OBJECT_BEGIN);
it != NULL; it != NULL;
it = spdk_json_next(it)) { it = spdk_json_next(it)) {
if (it->type != SPDK_JSON_VAL_NAME) { if (it->type != SPDK_JSON_VAL_NAME) {
@ -512,7 +512,7 @@ spdk_json_find(struct spdk_json_val *object, const char *key_name, struct spdk_j
} }
_key = it; _key = it;
_val = spdk_json_value(_key); _val = json_value(_key);
if (type != SPDK_JSON_VAL_INVALID && (_val->type & type) == 0) { if (type != SPDK_JSON_VAL_INVALID && (_val->type & type) == 0) {
SPDK_JSON_DEBUG("key '%s' type is %#x but expected one of %#x\n", key_name, _val->type, type); SPDK_JSON_DEBUG("key '%s' type is %#x but expected one of %#x\n", key_name, _val->type, type);
@ -548,7 +548,7 @@ spdk_json_find_array(struct spdk_json_val *object, const char *key_name,
struct spdk_json_val * struct spdk_json_val *
spdk_json_object_first(struct spdk_json_val *object) spdk_json_object_first(struct spdk_json_val *object)
{ {
struct spdk_json_val *first = spdk_json_first(object, SPDK_JSON_VAL_OBJECT_BEGIN); struct spdk_json_val *first = json_first(object, SPDK_JSON_VAL_OBJECT_BEGIN);
/* Empty object? */ /* Empty object? */
return first && first->type != SPDK_JSON_VAL_OBJECT_END ? first : NULL; return first && first->type != SPDK_JSON_VAL_OBJECT_END ? first : NULL;
@ -557,14 +557,14 @@ spdk_json_object_first(struct spdk_json_val *object)
struct spdk_json_val * struct spdk_json_val *
spdk_json_array_first(struct spdk_json_val *array_begin) spdk_json_array_first(struct spdk_json_val *array_begin)
{ {
struct spdk_json_val *first = spdk_json_first(array_begin, SPDK_JSON_VAL_ARRAY_BEGIN); struct spdk_json_val *first = json_first(array_begin, SPDK_JSON_VAL_ARRAY_BEGIN);
/* Empty array? */ /* Empty array? */
return first && first->type != SPDK_JSON_VAL_ARRAY_END ? first : NULL; return first && first->type != SPDK_JSON_VAL_ARRAY_END ? first : NULL;
} }
static struct spdk_json_val * static struct spdk_json_val *
spdk_json_skip_object_or_array(struct spdk_json_val *val) json_skip_object_or_array(struct spdk_json_val *val)
{ {
unsigned lvl; unsigned lvl;
enum spdk_json_val_type end_type; enum spdk_json_val_type end_type;
@ -605,7 +605,7 @@ spdk_json_next(struct spdk_json_val *it)
switch (it->type) { switch (it->type) {
case SPDK_JSON_VAL_NAME: case SPDK_JSON_VAL_NAME:
val = spdk_json_value(it); val = json_value(it);
next = spdk_json_next(val); next = spdk_json_next(val);
break; break;
@ -620,7 +620,7 @@ spdk_json_next(struct spdk_json_val *it)
case SPDK_JSON_VAL_ARRAY_BEGIN: case SPDK_JSON_VAL_ARRAY_BEGIN:
case SPDK_JSON_VAL_OBJECT_BEGIN: case SPDK_JSON_VAL_OBJECT_BEGIN:
next = spdk_json_skip_object_or_array(it); next = json_skip_object_or_array(it);
break; break;
/* Can't go to the next object if started from the end of array or object */ /* Can't go to the next object if started from the end of array or object */

6
lib/jsonrpc/jsonrpc_server.c
View File

@ -108,7 +108,7 @@ invalid:
} }
static int static int
spdk_jsonrpc_server_write_cb(void *cb_ctx, const void *data, size_t size) jsonrpc_server_write_cb(void *cb_ctx, const void *data, size_t size)
{ {
struct spdk_jsonrpc_request *request = cb_ctx; struct spdk_jsonrpc_request *request = cb_ctx;
size_t new_size = request->send_buf_size; size_t new_size = request->send_buf_size;
@ -200,7 +200,7 @@ jsonrpc_parse_request(struct spdk_jsonrpc_server_conn *conn, const void *json, s
return -1; return -1;
} }
request->response = spdk_json_write_begin(spdk_jsonrpc_server_write_cb, request, 0); request->response = spdk_json_write_begin(jsonrpc_server_write_cb, request, 0);
if (request->response == NULL) { if (request->response == NULL) {
SPDK_ERRLOG("Failed to allocate response JSON write context.\n"); SPDK_ERRLOG("Failed to allocate response JSON write context.\n");
jsonrpc_free_request(request); jsonrpc_free_request(request);
@ -283,7 +283,7 @@ end_response(struct spdk_jsonrpc_request *request)
spdk_json_write_end(request->response); spdk_json_write_end(request->response);
request->response = NULL; request->response = NULL;
spdk_jsonrpc_server_write_cb(request, "\n", 1); jsonrpc_server_write_cb(request, "\n", 1);
jsonrpc_server_send_response(request); jsonrpc_server_send_response(request);
} }

38
lib/jsonrpc/jsonrpc_server_tcp.c
View File

@ -99,7 +99,7 @@ spdk_jsonrpc_server_listen(int domain, int protocol,
} }
static struct spdk_jsonrpc_request * static struct spdk_jsonrpc_request *
spdk_jsonrpc_server_dequeue_request(struct spdk_jsonrpc_server_conn *conn) jsonrpc_server_dequeue_request(struct spdk_jsonrpc_server_conn *conn)
{ {
struct spdk_jsonrpc_request *request = NULL; struct spdk_jsonrpc_request *request = NULL;
@ -113,24 +113,24 @@ spdk_jsonrpc_server_dequeue_request(struct spdk_jsonrpc_server_conn *conn)
} }
static void static void
spdk_jsonrpc_server_free_conn_request(struct spdk_jsonrpc_server_conn *conn) jsonrpc_server_free_conn_request(struct spdk_jsonrpc_server_conn *conn)
{ {
struct spdk_jsonrpc_request *request; struct spdk_jsonrpc_request *request;
jsonrpc_free_request(conn->send_request); jsonrpc_free_request(conn->send_request);
conn->send_request = NULL ; conn->send_request = NULL ;
while ((request = spdk_jsonrpc_server_dequeue_request(conn)) != NULL) { while ((request = jsonrpc_server_dequeue_request(conn)) != NULL) {
jsonrpc_free_request(request); jsonrpc_free_request(request);
} }
} }
static void static void
spdk_jsonrpc_server_conn_close(struct spdk_jsonrpc_server_conn *conn) jsonrpc_server_conn_close(struct spdk_jsonrpc_server_conn *conn)
{ {
conn->closed = true; conn->closed = true;
if (conn->sockfd >= 0) { if (conn->sockfd >= 0) {
spdk_jsonrpc_server_free_conn_request(conn); jsonrpc_server_free_conn_request(conn);
close(conn->sockfd); close(conn->sockfd);
conn->sockfd = -1; conn->sockfd = -1;
@ -148,18 +148,18 @@ spdk_jsonrpc_server_shutdown(struct spdk_jsonrpc_server *server)
close(server->sockfd); close(server->sockfd);
TAILQ_FOREACH(conn, &server->conns, link) { TAILQ_FOREACH(conn, &server->conns, link) {
spdk_jsonrpc_server_conn_close(conn); jsonrpc_server_conn_close(conn);
} }
free(server); free(server);
} }
static void static void
spdk_jsonrpc_server_conn_remove(struct spdk_jsonrpc_server_conn *conn) jsonrpc_server_conn_remove(struct spdk_jsonrpc_server_conn *conn)
{ {
struct spdk_jsonrpc_server *server = conn->server; struct spdk_jsonrpc_server *server = conn->server;
spdk_jsonrpc_server_conn_close(conn); jsonrpc_server_conn_close(conn);
pthread_spin_destroy(&conn->queue_lock); pthread_spin_destroy(&conn->queue_lock);
assert(STAILQ_EMPTY(&conn->send_queue)); assert(STAILQ_EMPTY(&conn->send_queue));
@ -204,7 +204,7 @@ spdk_jsonrpc_conn_del_close_cb(struct spdk_jsonrpc_server_conn *conn,
} }
static int static int
spdk_jsonrpc_server_accept(struct spdk_jsonrpc_server *server) jsonrpc_server_accept(struct spdk_jsonrpc_server *server)
{ {
struct spdk_jsonrpc_server_conn *conn; struct spdk_jsonrpc_server_conn *conn;
int rc, flag; int rc, flag;
@ -285,7 +285,7 @@ jsonrpc_server_handle_error(struct spdk_jsonrpc_request *request, int error)
} }
static int static int
spdk_jsonrpc_server_conn_recv(struct spdk_jsonrpc_server_conn *conn) jsonrpc_server_conn_recv(struct spdk_jsonrpc_server_conn *conn)
{ {
ssize_t rc, offset; ssize_t rc, offset;
size_t recv_avail = SPDK_JSONRPC_RECV_BUF_SIZE - conn->recv_len; size_t recv_avail = SPDK_JSONRPC_RECV_BUF_SIZE - conn->recv_len;
@ -344,7 +344,7 @@ jsonrpc_server_send_response(struct spdk_jsonrpc_request *request)
static int static int
spdk_jsonrpc_server_conn_send(struct spdk_jsonrpc_server_conn *conn) jsonrpc_server_conn_send(struct spdk_jsonrpc_server_conn *conn)
{ {
struct spdk_jsonrpc_request *request; struct spdk_jsonrpc_request *request;
ssize_t rc; ssize_t rc;
@ -355,7 +355,7 @@ more:
} }
if (conn->send_request == NULL) { if (conn->send_request == NULL) {
conn->send_request = spdk_jsonrpc_server_dequeue_request(conn); conn->send_request = jsonrpc_server_dequeue_request(conn);
} }
request = conn->send_request; request = conn->send_request;
@ -402,17 +402,17 @@ spdk_jsonrpc_server_poll(struct spdk_jsonrpc_server *server)
TAILQ_FOREACH_SAFE(conn, &server->conns, link, conn_tmp) { TAILQ_FOREACH_SAFE(conn, &server->conns, link, conn_tmp) {
/* If we can't receive and there are no outstanding requests close the connection. */ /* If we can't receive and there are no outstanding requests close the connection. */
if (conn->closed == true && conn->outstanding_requests == 0) { if (conn->closed == true && conn->outstanding_requests == 0) {
spdk_jsonrpc_server_conn_close(conn); jsonrpc_server_conn_close(conn);
} }
if (conn->sockfd == -1 && conn->outstanding_requests == 0) { if (conn->sockfd == -1 && conn->outstanding_requests == 0) {
spdk_jsonrpc_server_conn_remove(conn); jsonrpc_server_conn_remove(conn);
} }
} }
/* Check listen socket */ /* Check listen socket */
if (!TAILQ_EMPTY(&server->free_conns)) { if (!TAILQ_EMPTY(&server->free_conns)) {
spdk_jsonrpc_server_accept(server); jsonrpc_server_accept(server);
} }
TAILQ_FOREACH(conn, &server->conns, link) { TAILQ_FOREACH(conn, &server->conns, link) {
@ -420,16 +420,16 @@ spdk_jsonrpc_server_poll(struct spdk_jsonrpc_server *server)
continue; continue;
} }
rc = spdk_jsonrpc_server_conn_send(conn); rc = jsonrpc_server_conn_send(conn);
if (rc != 0) { if (rc != 0) {
spdk_jsonrpc_server_conn_close(conn); jsonrpc_server_conn_close(conn);
continue; continue;
} }
if (!conn->closed) { if (!conn->closed) {
rc = spdk_jsonrpc_server_conn_recv(conn); rc = jsonrpc_server_conn_recv(conn);
if (rc != 0) { if (rc != 0) {
spdk_jsonrpc_server_conn_close(conn); jsonrpc_server_conn_close(conn);
} }
} }
} }

6
lib/log/log.c
View File

@ -72,7 +72,7 @@ spdk_log_close(void)
#ifdef SPDK_LOG_BACKTRACE_LVL #ifdef SPDK_LOG_BACKTRACE_LVL
static void static void
spdk_log_unwind_stack(FILE *fp, enum spdk_log_level level) log_unwind_stack(FILE *fp, enum spdk_log_level level)
{ {
unw_error_t err; unw_error_t err;
unw_cursor_t cursor; unw_cursor_t cursor;
@ -105,7 +105,7 @@ spdk_log_unwind_stack(FILE *fp, enum spdk_log_level level)
} }
#else #else
#define spdk_log_unwind_stack(fp, lvl) #define log_unwind_stack(fp, lvl)
#endif #endif
static void static void
@ -176,7 +176,7 @@ spdk_vlog(enum spdk_log_level level, const char *file, const int line, const cha
get_timestamp_prefix(timestamp, sizeof(timestamp)); get_timestamp_prefix(timestamp, sizeof(timestamp));
if (file) { if (file) {
fprintf(stderr, "%s%s:%4d:%s: *%s*: %s", timestamp, file, line, func, spdk_level_names[level], buf); fprintf(stderr, "%s%s:%4d:%s: *%s*: %s", timestamp, file, line, func, spdk_level_names[level], buf);
spdk_log_unwind_stack(stderr, level); log_unwind_stack(stderr, level);
} else { } else {
fprintf(stderr, "%s%s", timestamp, buf); fprintf(stderr, "%s%s", timestamp, buf);
} }

42
lib/log_rpc/log_rpc.c
View File

@ -99,8 +99,8 @@ _log_get_level_name(int level)
} }
static void static void
spdk_rpc_log_set_print_level(struct spdk_jsonrpc_request *request, rpc_log_set_print_level(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params) const struct spdk_json_val *params)
{ {
struct rpc_log_level req = {}; struct rpc_log_level req = {};
int level; int level;
@ -133,13 +133,13 @@ spdk_rpc_log_set_print_level(struct spdk_jsonrpc_request *request,
invalid: invalid:
free_rpc_log_level(&req); free_rpc_log_level(&req);
} }
SPDK_RPC_REGISTER("log_set_print_level", spdk_rpc_log_set_print_level, SPDK_RPC_REGISTER("log_set_print_level", rpc_log_set_print_level,
SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME) SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)
SPDK_RPC_REGISTER_ALIAS_DEPRECATED(log_set_print_level, set_log_print_level) SPDK_RPC_REGISTER_ALIAS_DEPRECATED(log_set_print_level, set_log_print_level)
static void static void
spdk_rpc_log_get_print_level(struct spdk_jsonrpc_request *request, rpc_log_get_print_level(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params) const struct spdk_json_val *params)
{ {
struct spdk_json_write_ctx *w; struct spdk_json_write_ctx *w;
int level; int level;
@ -164,13 +164,13 @@ spdk_rpc_log_get_print_level(struct spdk_jsonrpc_request *request,
spdk_jsonrpc_end_result(request, w); spdk_jsonrpc_end_result(request, w);
} }
SPDK_RPC_REGISTER("log_get_print_level", spdk_rpc_log_get_print_level, SPDK_RPC_REGISTER("log_get_print_level", rpc_log_get_print_level,
SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME) SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)
SPDK_RPC_REGISTER_ALIAS_DEPRECATED(log_get_print_level, get_log_print_level) SPDK_RPC_REGISTER_ALIAS_DEPRECATED(log_get_print_level, get_log_print_level)
static void static void
spdk_rpc_log_set_level(struct spdk_jsonrpc_request *request, rpc_log_set_level(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params) const struct spdk_json_val *params)
{ {
struct rpc_log_level req = {}; struct rpc_log_level req = {};
int level; int level;
@ -204,12 +204,12 @@ spdk_rpc_log_set_level(struct spdk_jsonrpc_request *request,
invalid: invalid:
free_rpc_log_level(&req); free_rpc_log_level(&req);
} }
SPDK_RPC_REGISTER("log_set_level", spdk_rpc_log_set_level, SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME) SPDK_RPC_REGISTER("log_set_level", rpc_log_set_level, SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)
SPDK_RPC_REGISTER_ALIAS_DEPRECATED(log_set_level, set_log_level) SPDK_RPC_REGISTER_ALIAS_DEPRECATED(log_set_level, set_log_level)
static void static void
spdk_rpc_log_get_level(struct spdk_jsonrpc_request *request, rpc_log_get_level(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params) const struct spdk_json_val *params)
{ {
struct spdk_json_write_ctx *w; struct spdk_json_write_ctx *w;
int level; int level;
@ -234,12 +234,12 @@ spdk_rpc_log_get_level(struct spdk_jsonrpc_request *request,
spdk_jsonrpc_end_result(request, w); spdk_jsonrpc_end_result(request, w);
} }
SPDK_RPC_REGISTER("log_get_level", spdk_rpc_log_get_level, SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME) SPDK_RPC_REGISTER("log_get_level", rpc_log_get_level, SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)
SPDK_RPC_REGISTER_ALIAS_DEPRECATED(log_get_level, get_log_level) SPDK_RPC_REGISTER_ALIAS_DEPRECATED(log_get_level, get_log_level)
static void static void
spdk_rpc_log_set_flag(struct spdk_jsonrpc_request *request, rpc_log_set_flag(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params) const struct spdk_json_val *params)
{ {
struct rpc_log_flag req = {}; struct rpc_log_flag req = {};
struct spdk_json_write_ctx *w; struct spdk_json_write_ctx *w;
@ -270,12 +270,12 @@ spdk_rpc_log_set_flag(struct spdk_jsonrpc_request *request,
invalid: invalid:
free_rpc_log_flag(&req); free_rpc_log_flag(&req);
} }
SPDK_RPC_REGISTER("log_set_flag", spdk_rpc_log_set_flag, SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME) SPDK_RPC_REGISTER("log_set_flag", rpc_log_set_flag, SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)
SPDK_RPC_REGISTER_ALIAS_DEPRECATED(log_set_flag, set_log_flag) SPDK_RPC_REGISTER_ALIAS_DEPRECATED(log_set_flag, set_log_flag)
static void static void
spdk_rpc_log_clear_flag(struct spdk_jsonrpc_request *request, rpc_log_clear_flag(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params) const struct spdk_json_val *params)
{ {
struct rpc_log_flag req = {}; struct rpc_log_flag req = {};
struct spdk_json_write_ctx *w; struct spdk_json_write_ctx *w;
@ -306,13 +306,13 @@ spdk_rpc_log_clear_flag(struct spdk_jsonrpc_request *request,
invalid: invalid:
free_rpc_log_flag(&req); free_rpc_log_flag(&req);
} }
SPDK_RPC_REGISTER("log_clear_flag", spdk_rpc_log_clear_flag, SPDK_RPC_REGISTER("log_clear_flag", rpc_log_clear_flag,
SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME) SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)
SPDK_RPC_REGISTER_ALIAS_DEPRECATED(log_clear_flag, clear_log_flag) SPDK_RPC_REGISTER_ALIAS_DEPRECATED(log_clear_flag, clear_log_flag)
static void static void
spdk_rpc_log_get_flags(struct spdk_jsonrpc_request *request, rpc_log_get_flags(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params) const struct spdk_json_val *params)
{ {
struct spdk_json_write_ctx *w; struct spdk_json_write_ctx *w;
struct spdk_log_flag *flag; struct spdk_log_flag *flag;
@ -334,7 +334,7 @@ spdk_rpc_log_get_flags(struct spdk_jsonrpc_request *request,
spdk_json_write_object_end(w); spdk_json_write_object_end(w);
spdk_jsonrpc_end_result(request, w); spdk_jsonrpc_end_result(request, w);
} }
SPDK_RPC_REGISTER("log_get_flags", spdk_rpc_log_get_flags, SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME) SPDK_RPC_REGISTER("log_get_flags", rpc_log_get_flags, SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)
SPDK_RPC_REGISTER_ALIAS_DEPRECATED(log_get_flags, get_log_flags) SPDK_RPC_REGISTER_ALIAS_DEPRECATED(log_get_flags, get_log_flags)
SPDK_LOG_REGISTER_COMPONENT("log_rpc", SPDK_LOG_LOG_RPC) SPDK_LOG_REGISTER_COMPONENT("log_rpc", SPDK_LOG_LOG_RPC)

16
lib/lvol/lvol.c
View File

@ -382,7 +382,7 @@ _spdk_lvs_load_cb(void *cb_arg, struct spdk_blob_store *bs, int lvolerrno)
} }
static void static void
spdk_lvs_bs_opts_init(struct spdk_bs_opts *opts) lvs_bs_opts_init(struct spdk_bs_opts *opts)
{ {
spdk_bs_opts_init(opts); spdk_bs_opts_init(opts);
opts->max_channel_ops = SPDK_LVOL_BLOB_OPTS_CHANNEL_OPS; opts->max_channel_ops = SPDK_LVOL_BLOB_OPTS_CHANNEL_OPS;
@ -413,7 +413,7 @@ spdk_lvs_load(struct spdk_bs_dev *bs_dev, spdk_lvs_op_with_handle_complete cb_fn
req->cb_arg = cb_arg; req->cb_arg = cb_arg;
req->bs_dev = bs_dev; req->bs_dev = bs_dev;
spdk_lvs_bs_opts_init(&opts); lvs_bs_opts_init(&opts);
snprintf(opts.bstype.bstype, sizeof(opts.bstype.bstype), "LVOLSTORE"); snprintf(opts.bstype.bstype, sizeof(opts.bstype.bstype), "LVOLSTORE");
spdk_bs_load(bs_dev, &opts, _spdk_lvs_load_cb, req); spdk_bs_load(bs_dev, &opts, _spdk_lvs_load_cb, req);
@ -566,7 +566,7 @@ static void
_spdk_setup_lvs_opts(struct spdk_bs_opts *bs_opts, struct spdk_lvs_opts *o) _spdk_setup_lvs_opts(struct spdk_bs_opts *bs_opts, struct spdk_lvs_opts *o)
{ {
assert(o != NULL); assert(o != NULL);
spdk_lvs_bs_opts_init(bs_opts); lvs_bs_opts_init(bs_opts);
bs_opts->cluster_sz = o->cluster_sz; bs_opts->cluster_sz = o->cluster_sz;
bs_opts->clear_method = (enum bs_clear_method)o->clear_method; bs_opts->clear_method = (enum bs_clear_method)o->clear_method;
} }
@ -967,8 +967,8 @@ _spdk_lvol_create_cb(void *cb_arg, spdk_blob_id blobid, int lvolerrno)
} }
static void static void
spdk_lvol_get_xattr_value(void *xattr_ctx, const char *name, lvol_get_xattr_value(void *xattr_ctx, const char *name,
const void **value, size_t *value_len) const void **value, size_t *value_len)
{ {
struct spdk_lvol *lvol = xattr_ctx; struct spdk_lvol *lvol = xattr_ctx;
@ -1069,7 +1069,7 @@ spdk_lvol_create(struct spdk_lvol_store *lvs, const char *name, uint64_t sz,
opts.xattrs.count = SPDK_COUNTOF(xattr_names); opts.xattrs.count = SPDK_COUNTOF(xattr_names);
opts.xattrs.names = xattr_names; opts.xattrs.names = xattr_names;
opts.xattrs.ctx = lvol; opts.xattrs.ctx = lvol;
opts.xattrs.get_value = spdk_lvol_get_xattr_value; opts.xattrs.get_value = lvol_get_xattr_value;
spdk_bs_create_blob_ext(lvs->blobstore, &opts, _spdk_lvol_create_cb, req); spdk_bs_create_blob_ext(lvs->blobstore, &opts, _spdk_lvol_create_cb, req);
@ -1131,7 +1131,7 @@ spdk_lvol_create_snapshot(struct spdk_lvol *origlvol, const char *snapshot_name,
snapshot_xattrs.count = SPDK_COUNTOF(xattr_names); snapshot_xattrs.count = SPDK_COUNTOF(xattr_names);
snapshot_xattrs.ctx = newlvol; snapshot_xattrs.ctx = newlvol;
snapshot_xattrs.names = xattr_names; snapshot_xattrs.names = xattr_names;
snapshot_xattrs.get_value = spdk_lvol_get_xattr_value; snapshot_xattrs.get_value = lvol_get_xattr_value;
req->lvol = newlvol; req->lvol = newlvol;
req->cb_fn = cb_fn; req->cb_fn = cb_fn;
req->cb_arg = cb_arg; req->cb_arg = cb_arg;
@ -1195,7 +1195,7 @@ spdk_lvol_create_clone(struct spdk_lvol *origlvol, const char *clone_name,
clone_xattrs.count = SPDK_COUNTOF(xattr_names); clone_xattrs.count = SPDK_COUNTOF(xattr_names);
clone_xattrs.ctx = newlvol; clone_xattrs.ctx = newlvol;
clone_xattrs.names = xattr_names; clone_xattrs.names = xattr_names;
clone_xattrs.get_value = spdk_lvol_get_xattr_value; clone_xattrs.get_value = lvol_get_xattr_value;
req->lvol = newlvol; req->lvol = newlvol;
req->cb_fn = cb_fn; req->cb_fn = cb_fn;
req->cb_arg = cb_arg; req->cb_arg = cb_arg;

32
lib/nbd/nbd_rpc.c
View File

@ -136,7 +136,7 @@ find_available_nbd_disk(int nbd_idx, int *next_nbd_idx)
} }
static void static void
spdk_rpc_start_nbd_done(void *cb_arg, struct spdk_nbd_disk *nbd, int rc) rpc_start_nbd_done(void *cb_arg, struct spdk_nbd_disk *nbd, int rc)
{ {
struct rpc_nbd_start_disk *req = cb_arg; struct rpc_nbd_start_disk *req = cb_arg;
struct spdk_jsonrpc_request *request = req->request; struct spdk_jsonrpc_request *request = req->request;
@ -149,7 +149,7 @@ spdk_rpc_start_nbd_done(void *cb_arg, struct spdk_nbd_disk *nbd, int rc)
req->nbd_device = find_available_nbd_disk(req->nbd_idx, &req->nbd_idx); req->nbd_device = find_available_nbd_disk(req->nbd_idx, &req->nbd_idx);
if (req->nbd_device != NULL) { if (req->nbd_device != NULL) {
spdk_nbd_start(req->bdev_name, req->nbd_device, spdk_nbd_start(req->bdev_name, req->nbd_device,
spdk_rpc_start_nbd_done, req); rpc_start_nbd_done, req);
return; return;
} }
@ -169,8 +169,8 @@ spdk_rpc_start_nbd_done(void *cb_arg, struct spdk_nbd_disk *nbd, int rc)
} }
static void static void
spdk_rpc_nbd_start_disk(struct spdk_jsonrpc_request *request, rpc_nbd_start_disk(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params) const struct spdk_json_val *params)
{ {
struct rpc_nbd_start_disk *req; struct rpc_nbd_start_disk *req;
int rc; int rc;
@ -223,7 +223,7 @@ spdk_rpc_nbd_start_disk(struct spdk_jsonrpc_request *request,
req->request = request; req->request = request;
spdk_nbd_start(req->bdev_name, req->nbd_device, spdk_nbd_start(req->bdev_name, req->nbd_device,
spdk_rpc_start_nbd_done, req); rpc_start_nbd_done, req);
return; return;
@ -231,7 +231,7 @@ invalid:
free_rpc_nbd_start_disk(req); free_rpc_nbd_start_disk(req);
} }
SPDK_RPC_REGISTER("nbd_start_disk", spdk_rpc_nbd_start_disk, SPDK_RPC_RUNTIME) SPDK_RPC_REGISTER("nbd_start_disk", rpc_nbd_start_disk, SPDK_RPC_RUNTIME)
SPDK_RPC_REGISTER_ALIAS_DEPRECATED(nbd_start_disk, start_nbd_disk) SPDK_RPC_REGISTER_ALIAS_DEPRECATED(nbd_start_disk, start_nbd_disk)
struct rpc_nbd_stop_disk { struct rpc_nbd_stop_disk {
@ -272,8 +272,8 @@ nbd_disconnect_thread(void *arg)
} }
static void static void
spdk_rpc_nbd_stop_disk(struct spdk_jsonrpc_request *request, rpc_nbd_stop_disk(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params) const struct spdk_json_val *params)
{ {
struct rpc_nbd_stop_disk req = {}; struct rpc_nbd_stop_disk req = {};
struct spdk_nbd_disk *nbd; struct spdk_nbd_disk *nbd;
@ -338,12 +338,12 @@ out:
free_rpc_nbd_stop_disk(&req); free_rpc_nbd_stop_disk(&req);
} }
SPDK_RPC_REGISTER("nbd_stop_disk", spdk_rpc_nbd_stop_disk, SPDK_RPC_RUNTIME) SPDK_RPC_REGISTER("nbd_stop_disk", rpc_nbd_stop_disk, SPDK_RPC_RUNTIME)
SPDK_RPC_REGISTER_ALIAS_DEPRECATED(nbd_stop_disk, stop_nbd_disk) SPDK_RPC_REGISTER_ALIAS_DEPRECATED(nbd_stop_disk, stop_nbd_disk)
static void static void
spdk_rpc_dump_nbd_info(struct spdk_json_write_ctx *w, rpc_dump_nbd_info(struct spdk_json_write_ctx *w,
struct spdk_nbd_disk *nbd) struct spdk_nbd_disk *nbd)
{ {
spdk_json_write_object_begin(w); spdk_json_write_object_begin(w);
@ -369,8 +369,8 @@ static const struct spdk_json_object_decoder rpc_nbd_get_disks_decoders[] = {
}; };
static void static void
spdk_rpc_nbd_get_disks(struct spdk_jsonrpc_request *request, rpc_nbd_get_disks(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params) const struct spdk_json_val *params)
{ {
struct rpc_nbd_get_disks req = {}; struct rpc_nbd_get_disks req = {};
struct spdk_json_write_ctx *w; struct spdk_json_write_ctx *w;
@ -402,10 +402,10 @@ spdk_rpc_nbd_get_disks(struct spdk_jsonrpc_request *request,
spdk_json_write_array_begin(w); spdk_json_write_array_begin(w);
if (nbd != NULL) { if (nbd != NULL) {
spdk_rpc_dump_nbd_info(w, nbd); rpc_dump_nbd_info(w, nbd);
} else { } else {
for (nbd = nbd_disk_first(); nbd != NULL; nbd = nbd_disk_next(nbd)) { for (nbd = nbd_disk_first(); nbd != NULL; nbd = nbd_disk_next(nbd)) {
spdk_rpc_dump_nbd_info(w, nbd); rpc_dump_nbd_info(w, nbd);
} }
} }
@ -418,5 +418,5 @@ spdk_rpc_nbd_get_disks(struct spdk_jsonrpc_request *request,
invalid: invalid:
free_rpc_nbd_get_disks(&req); free_rpc_nbd_get_disks(&req);
} }
SPDK_RPC_REGISTER("nbd_get_disks", spdk_rpc_nbd_get_disks, SPDK_RPC_RUNTIME) SPDK_RPC_REGISTER("nbd_get_disks", rpc_nbd_get_disks, SPDK_RPC_RUNTIME)
SPDK_RPC_REGISTER_ALIAS_DEPRECATED(nbd_get_disks, get_nbd_disks) SPDK_RPC_REGISTER_ALIAS_DEPRECATED(nbd_get_disks, get_nbd_disks)

6
test/unit/lib/json/json_util.c/json_util_ut.c
View File

@ -862,11 +862,11 @@ test_iterating(void)
CU_ASSERT(spdk_json_strequal(string_key, "string") == true); CU_ASSERT(spdk_json_strequal(string_key, "string") == true);
object_key = spdk_json_next(string_key); object_key = spdk_json_next(string_key);
object_val = spdk_json_value(object_key); object_val = json_value(object_key);
CU_ASSERT(spdk_json_strequal(object_key, "object") == true); CU_ASSERT(spdk_json_strequal(object_key, "object") == true);
array_key = spdk_json_next(object_key); array_key = spdk_json_next(object_key);
array_val = spdk_json_value(array_key); array_val = json_value(array_key);
CU_ASSERT(spdk_json_strequal(array_key, "array") == true); CU_ASSERT(spdk_json_strequal(array_key, "array") == true);
/* NULL '}' */ /* NULL '}' */
@ -877,7 +877,7 @@ test_iterating(void)
CU_ASSERT(spdk_json_strequal(another_string_key, "another_string") == true); CU_ASSERT(spdk_json_strequal(another_string_key, "another_string") == true);
array_name_with_space_key = spdk_json_next(another_string_key); array_name_with_space_key = spdk_json_next(another_string_key);
array_name_with_space_val = spdk_json_value(array_name_with_space_key); array_name_with_space_val = json_value(array_name_with_space_key);
CU_ASSERT(spdk_json_strequal(array_name_with_space_key, "array name with space") == true); CU_ASSERT(spdk_json_strequal(array_name_with_space_key, "array name with space") == true);
CU_ASSERT(spdk_json_next(array_name_with_space_key) == NULL); CU_ASSERT(spdk_json_next(array_name_with_space_key) == NULL);