Commit 0b0f0c54 authored by Shuhei Matsumoto's avatar Shuhei Matsumoto Committed by Tomasz Zawadzki
Browse files

rpc: Add thread_get_pollers RPC 



Add an new JSON RPC thread_get_pollers to retrieve pollers of all
the threads. By adding a helper function spdk_poller_state_str(),
output poller state as string to improve readability. Most of the
code of thread_get_stats and thread_get_pollers are common and so
unify these two RPCs as possible as we can.

Sample output of thread_get_stats RPC in doc/jsonrpc.md was wrong
because thread_get_stats doesn't output ticks. Fix this together.

Signed-off-by: default avatarShuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Change-Id: I003ffe569d3c0651ae65c5858eff8287f7e9031d
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/604


Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarJim Harris <james.r.harris@intel.com>
Reviewed-by: default avatarAleksey Marchuk <alexeymar@mellanox.com>
parent c40f35b7

doc/jsonrpc.md

+48 −1
Original line number Diff line number Diff line
@@ -560,7 +560,6 @@ Example response: 
  "id": 1,

  "result": {

    "tick_rate": 2400000000,

    "ticks": 2523538189523655,

    "threads": [

      {

        "name": "app_thread",
@@ -616,6 +615,54 @@ Example response: 
}

~~~



## thread_get_pollers {#rpc_thread_get_pollers}



Retrieve current pollers of all the threads.



### Parameters



This method has no parameters.



### Response



The response is an array of objects containing pollers of all the threads.



### Example



Example request:

~~~

{

  "jsonrpc": "2.0",

  "method": "thread_get_pollers",

  "id": 1

}

~~~



Example response:

~~~

{

  "jsonrpc": "2.0",

  "id": 1,

  "result": {

    "tick_rate": 2500000000,

    "threads": [

      {

        "name": "app_thread",

        "active_pollers": [],

        "timed_pollers": [

          {

            "name": "spdk_rpc_subsystem_poll",

            "state": "waiting",

            "period_ticks": 10000000

          }

        ],

        "paused_pollers": []

      }

    ]

  }

}

~~~



# Block Device Abstraction Layer {#jsonrpc_components_bdev}



## bdev_set_options {#rpc_bdev_set_options}

include/spdk_internal/thread.h

+2 −0
Original line number Diff line number Diff line
@@ -111,4 +111,6 @@ struct spdk_thread { 
	uint8_t				ctx[0];

};



const char *spdk_poller_state_str(enum spdk_poller_state state);



#endif /* SPDK_THREAD_INTERNAL_H_ */

lib/thread/thread.c

+19 −0
Original line number Diff line number Diff line
@@ -993,6 +993,25 @@ spdk_poller_resume(struct spdk_poller *poller) 
	poller->state = SPDK_POLLER_STATE_WAITING;

}



const char *

spdk_poller_state_str(enum spdk_poller_state state)

{

	switch (state) {

	case SPDK_POLLER_STATE_WAITING:

		return "waiting";

	case SPDK_POLLER_STATE_RUNNING:

		return "running";

	case SPDK_POLLER_STATE_UNREGISTERED:

		return "unregistered";

	case SPDK_POLLER_STATE_PAUSING:

		return "pausing";

	case SPDK_POLLER_STATE_PAUSED:

		return "paused";

	default:

		return NULL;

	}

}



struct call_thread {

	struct spdk_thread *cur_thread;

	spdk_msg_fn fn;

module/event/rpc/app_rpc.c

+78 −13
Original line number Diff line number Diff line
@@ -42,6 +42,7 @@ 


#include "spdk_internal/log.h"

#include "spdk_internal/event.h"

#include "spdk_internal/thread.h"



struct rpc_spdk_kill_instance {

	char *sig_name;
@@ -170,6 +171,27 @@ rpc_thread_get_stats_done(void *arg) 
	free(ctx);

}



static void

rpc_thread_get_stats_for_each(struct spdk_jsonrpc_request *request, spdk_msg_fn fn)

{

	struct rpc_get_stats_ctx *ctx;



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

	if (!ctx) {

		spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,

						 "Memory allocation error");

		return;

	}

	ctx->request = request;



	ctx->w = spdk_jsonrpc_begin_result(ctx->request);

	spdk_json_write_object_begin(ctx->w);

	spdk_json_write_named_uint64(ctx->w, "tick_rate", spdk_get_ticks_hz());

	spdk_json_write_named_array_begin(ctx->w, "threads");



	spdk_for_each_thread(fn, ctx, rpc_thread_get_stats_done);

}



static void

rpc_thread_get_stats(void *arg)

{
@@ -193,31 +215,74 @@ static void 
spdk_rpc_thread_get_stats(struct spdk_jsonrpc_request *request,

			  const struct spdk_json_val *params)

{

	struct rpc_get_stats_ctx *ctx;



	if (params) {

		spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,

						 "'thread_get_stats' requires no arguments");

		return;

	}



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

	if (!ctx) {

		spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,

						 "Memory allocation error");

		return;

	rpc_thread_get_stats_for_each(request, rpc_thread_get_stats);

}

	ctx->request = request;



	ctx->w = spdk_jsonrpc_begin_result(ctx->request);

SPDK_RPC_REGISTER("thread_get_stats", spdk_rpc_thread_get_stats, SPDK_RPC_RUNTIME)



static void

rpc_get_poller(struct spdk_poller *poller, struct spdk_json_write_ctx *w)

{

	spdk_json_write_object_begin(w);

	spdk_json_write_named_string(w, "name", poller->name);

	spdk_json_write_named_string(w, "state", spdk_poller_state_str(poller->state));

	if (poller->period_ticks) {

		spdk_json_write_named_uint64(w, "period_ticks", poller->period_ticks);

	}

	spdk_json_write_object_end(w);

}



static void

rpc_thread_get_pollers(void *arg)

{

	struct rpc_get_stats_ctx *ctx = arg;

	struct spdk_thread *thread = spdk_get_thread();

	struct spdk_poller *poller;



	spdk_json_write_object_begin(ctx->w);

	spdk_json_write_named_uint64(ctx->w, "tick_rate", spdk_get_ticks_hz());

	spdk_json_write_named_array_begin(ctx->w, "threads");

	spdk_json_write_named_string(ctx->w, "name", spdk_thread_get_name(thread));



	spdk_json_write_named_array_begin(ctx->w, "active_pollers");

	TAILQ_FOREACH(poller, &thread->active_pollers, tailq) {

		rpc_get_poller(poller, ctx->w);

	}

	spdk_json_write_array_end(ctx->w);



	spdk_for_each_thread(rpc_thread_get_stats, ctx, rpc_thread_get_stats_done);

	spdk_json_write_named_array_begin(ctx->w, "timed_pollers");

	TAILQ_FOREACH(poller, &thread->timed_pollers, tailq) {

		rpc_get_poller(poller, ctx->w);

	}

	spdk_json_write_array_end(ctx->w);



SPDK_RPC_REGISTER("thread_get_stats", spdk_rpc_thread_get_stats, SPDK_RPC_RUNTIME)

	spdk_json_write_named_array_begin(ctx->w, "paused_pollers");

	TAILQ_FOREACH(poller, &thread->paused_pollers, tailq) {

		rpc_get_poller(poller, ctx->w);

	}

	spdk_json_write_array_end(ctx->w);



	spdk_json_write_object_end(ctx->w);

}



static void

spdk_rpc_thread_get_pollers(struct spdk_jsonrpc_request *request,

			    const struct spdk_json_val *params)

{

	if (params) {

		spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,

						 "'thread_get_pollers' requires no arguments");

		return;

	}



	rpc_thread_get_stats_for_each(request, rpc_thread_get_pollers);

}



SPDK_RPC_REGISTER("thread_get_pollers", spdk_rpc_thread_get_pollers, SPDK_RPC_RUNTIME)



static void

rpc_framework_get_reactors_done(void *arg1, void *arg2)

scripts/rpc.py

+7 −0
Original line number Diff line number Diff line
@@ -2283,6 +2283,13 @@ Format: 'user:u1 secret:s1 muser:mu1 msecret:ms1,user:u2 secret:s2 muser:mu2 mse 
    p.add_argument('-m', '--cpumask', help='cpumask for this thread')

    p.set_defaults(func=thread_set_cpumask)



    def thread_get_pollers(args):

        print_dict(rpc.app.thread_get_pollers(args.client))



    p = subparsers.add_parser(

        'thread_get_pollers', help='Display current pollers of all the threads')

    p.set_defaults(func=thread_get_pollers)



    def env_dpdk_get_mem_stats(args):

        print_dict(rpc.env_dpdk.env_dpdk_get_mem_stats(args.client))