LCOV - code coverage report
Current view: top level - spdk/lib/event - log_rpc.c (source / functions) Hit Total Coverage
Test: Combined Lines: 41 152 27.0 %
Date: 2024-07-12 17:56:28 Functions: 13 21 61.9 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 10 108 9.3 %

           Branch data     Line data    Source code
       1                 :            : /*   SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  *   Copyright (C) 2016 Intel Corporation.
       3                 :            :  *   All rights reserved.
       4                 :            :  */
       5                 :            : 
       6                 :            : #include "spdk/rpc.h"
       7                 :            : #include "spdk/util.h"
       8                 :            : 
       9                 :            : #include "spdk/log.h"
      10                 :            : 
      11                 :            : struct rpc_log_flag {
      12                 :            :         char *flag;
      13                 :            : };
      14                 :            : 
      15                 :            : struct rpc_log_level {
      16                 :            :         char *level;
      17                 :            : };
      18                 :            : 
      19                 :            : static void
      20                 :         11 : free_rpc_log_flag(struct rpc_log_flag *p)
      21                 :            : {
      22                 :         11 :         free(p->flag);
      23                 :         11 : }
      24                 :            : 
      25                 :            : static void
      26                 :          0 : free_rpc_log_level(struct rpc_log_level *p)
      27                 :            : {
      28                 :          0 :         free(p->level);
      29                 :          0 : }
      30                 :            : 
      31                 :            : static const struct spdk_json_object_decoder rpc_log_flag_decoders[] = {
      32                 :            :         {"flag", offsetof(struct rpc_log_flag, flag), spdk_json_decode_string},
      33                 :            : };
      34                 :            : 
      35                 :            : static const struct spdk_json_object_decoder rpc_log_level_decoders[] = {
      36                 :            :         {"level", offsetof(struct rpc_log_level, level), spdk_json_decode_string},
      37                 :            : };
      38                 :            : 
      39                 :            : static int
      40                 :          0 : _parse_log_level(char *level)
      41                 :            : {
      42   [ #  #  #  # ]:          0 :         if (!strcasecmp(level, "ERROR")) {
      43                 :          0 :                 return SPDK_LOG_ERROR;
      44   [ #  #  #  # ]:          0 :         } else if (!strcasecmp(level, "WARNING")) {
      45                 :          0 :                 return SPDK_LOG_WARN;
      46   [ #  #  #  # ]:          0 :         } else if (!strcasecmp(level, "NOTICE")) {
      47                 :          0 :                 return SPDK_LOG_NOTICE;
      48   [ #  #  #  # ]:          0 :         } else if (!strcasecmp(level, "INFO")) {
      49                 :          0 :                 return SPDK_LOG_INFO;
      50   [ #  #  #  # ]:          0 :         } else if (!strcasecmp(level, "DEBUG")) {
      51                 :          0 :                 return SPDK_LOG_DEBUG;
      52                 :            :         }
      53                 :          0 :         return -1;
      54                 :            : }
      55                 :            : 
      56                 :            : static const char *
      57                 :          0 : _log_get_level_name(int level)
      58                 :            : {
      59         [ #  # ]:          0 :         if (level == SPDK_LOG_ERROR) {
      60                 :          0 :                 return "ERROR";
      61         [ #  # ]:          0 :         } else if (level == SPDK_LOG_WARN) {
      62                 :          0 :                 return "WARNING";
      63         [ #  # ]:          0 :         } else if (level == SPDK_LOG_NOTICE) {
      64                 :          0 :                 return "NOTICE";
      65         [ #  # ]:          0 :         } else if (level == SPDK_LOG_INFO) {
      66                 :          0 :                 return "INFO";
      67         [ #  # ]:          0 :         } else if (level == SPDK_LOG_DEBUG) {
      68                 :          0 :                 return "DEBUG";
      69                 :            :         }
      70                 :          0 :         return NULL;
      71                 :            : }
      72                 :            : 
      73                 :            : static void
      74                 :          0 : rpc_log_set_print_level(struct spdk_jsonrpc_request *request,
      75                 :            :                         const struct spdk_json_val *params)
      76                 :            : {
      77                 :          0 :         struct rpc_log_level req = {};
      78                 :            :         int level;
      79                 :            : 
      80         [ #  # ]:          0 :         if (spdk_json_decode_object(params, rpc_log_level_decoders,
      81                 :            :                                     SPDK_COUNTOF(rpc_log_level_decoders), &req)) {
      82   [ #  #  #  # ]:          0 :                 SPDK_DEBUGLOG(log_rpc, "spdk_json_decode_object failed\n");
      83                 :          0 :                 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
      84                 :            :                                                  "spdk_json_decode_object failed");
      85                 :          0 :                 goto end;
      86                 :            :         }
      87                 :            : 
      88                 :          0 :         level = _parse_log_level(req.level);
      89         [ #  # ]:          0 :         if (level == -1) {
      90   [ #  #  #  # ]:          0 :                 SPDK_DEBUGLOG(log_rpc, "tried to set invalid log level\n");
      91                 :          0 :                 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
      92                 :            :                                                  "invalid log level");
      93                 :          0 :                 goto end;
      94                 :            :         }
      95                 :            : 
      96                 :          0 :         spdk_log_set_print_level(level);
      97                 :          0 :         spdk_jsonrpc_send_bool_response(request, true);
      98                 :          0 : end:
      99                 :          0 :         free_rpc_log_level(&req);
     100                 :          0 : }
     101                 :       2987 : SPDK_RPC_REGISTER("log_set_print_level", rpc_log_set_print_level,
     102                 :            :                   SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)
     103                 :            : 
     104                 :            : static void
     105                 :          0 : rpc_log_get_print_level(struct spdk_jsonrpc_request *request,
     106                 :            :                         const struct spdk_json_val *params)
     107                 :            : {
     108                 :            :         struct spdk_json_write_ctx *w;
     109                 :            :         int level;
     110                 :            :         const char *name;
     111                 :            : 
     112         [ #  # ]:          0 :         if (params != NULL) {
     113                 :          0 :                 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
     114                 :            :                                                  "log_get_print_level requires no parameters");
     115                 :          0 :                 return;
     116                 :            :         }
     117                 :            : 
     118                 :          0 :         level = spdk_log_get_print_level();
     119                 :          0 :         name = _log_get_level_name(level);
     120         [ #  # ]:          0 :         if (name == NULL) {
     121                 :          0 :                 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
     122                 :            :                                                  "invalid log level");
     123                 :          0 :                 return;
     124                 :            :         }
     125                 :            : 
     126                 :          0 :         w = spdk_jsonrpc_begin_result(request);
     127                 :          0 :         spdk_json_write_string(w, name);
     128                 :            : 
     129                 :          0 :         spdk_jsonrpc_end_result(request, w);
     130                 :            : }
     131                 :       2987 : SPDK_RPC_REGISTER("log_get_print_level", rpc_log_get_print_level,
     132                 :            :                   SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)
     133                 :            : 
     134                 :            : static void
     135                 :          0 : rpc_log_set_level(struct spdk_jsonrpc_request *request,
     136                 :            :                   const struct spdk_json_val *params)
     137                 :            : {
     138                 :          0 :         struct rpc_log_level req = {};
     139                 :            :         int level;
     140                 :            : 
     141         [ #  # ]:          0 :         if (spdk_json_decode_object(params, rpc_log_level_decoders,
     142                 :            :                                     SPDK_COUNTOF(rpc_log_level_decoders), &req)) {
     143   [ #  #  #  # ]:          0 :                 SPDK_DEBUGLOG(log_rpc, "spdk_json_decode_object failed\n");
     144                 :          0 :                 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
     145                 :            :                                                  "spdk_json_decode_object failed");
     146                 :          0 :                 goto end;
     147                 :            :         }
     148                 :            : 
     149                 :          0 :         level = _parse_log_level(req.level);
     150         [ #  # ]:          0 :         if (level == -1) {
     151   [ #  #  #  # ]:          0 :                 SPDK_DEBUGLOG(log_rpc, "tried to set invalid log level\n");
     152                 :          0 :                 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
     153                 :            :                                                  "invalid log level");
     154                 :          0 :                 goto end;
     155                 :            :         }
     156                 :            : 
     157                 :            : 
     158                 :          0 :         spdk_log_set_level(level);
     159                 :          0 :         spdk_jsonrpc_send_bool_response(request, true);
     160                 :          0 : end:
     161                 :          0 :         free_rpc_log_level(&req);
     162                 :          0 : }
     163                 :       2987 : SPDK_RPC_REGISTER("log_set_level", rpc_log_set_level, SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)
     164                 :            : 
     165                 :            : static void
     166                 :          0 : rpc_log_get_level(struct spdk_jsonrpc_request *request,
     167                 :            :                   const struct spdk_json_val *params)
     168                 :            : {
     169                 :            :         struct spdk_json_write_ctx *w;
     170                 :            :         int level;
     171                 :            :         const char *name;
     172                 :            : 
     173         [ #  # ]:          0 :         if (params != NULL) {
     174                 :          0 :                 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
     175                 :            :                                                  "log_get_level requires no parameters");
     176                 :          0 :                 return;
     177                 :            :         }
     178                 :            : 
     179                 :          0 :         level = spdk_log_get_level();
     180                 :          0 :         name = _log_get_level_name(level);
     181         [ #  # ]:          0 :         if (name == NULL) {
     182                 :          0 :                 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
     183                 :            :                                                  "invalid log level");
     184                 :          0 :                 return;
     185                 :            :         }
     186                 :            : 
     187                 :          0 :         w = spdk_jsonrpc_begin_result(request);
     188                 :          0 :         spdk_json_write_string(w, name);
     189                 :            : 
     190                 :          0 :         spdk_jsonrpc_end_result(request, w);
     191                 :            : }
     192                 :       2987 : SPDK_RPC_REGISTER("log_get_level", rpc_log_get_level, SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)
     193                 :            : 
     194                 :            : static void
     195                 :          9 : rpc_log_set_flag(struct spdk_jsonrpc_request *request,
     196                 :            :                  const struct spdk_json_val *params)
     197                 :            : {
     198                 :          9 :         struct rpc_log_flag req = {};
     199                 :            : 
     200         [ -  + ]:          9 :         if (spdk_json_decode_object(params, rpc_log_flag_decoders,
     201                 :            :                                     SPDK_COUNTOF(rpc_log_flag_decoders), &req)) {
     202   [ #  #  #  # ]:          0 :                 SPDK_DEBUGLOG(log_rpc, "spdk_json_decode_object failed\n");
     203                 :          0 :                 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
     204                 :            :                                                  "spdk_json_decode_object failed");
     205                 :          0 :                 goto end;
     206                 :            :         }
     207                 :            : 
     208         [ -  + ]:          9 :         if (req.flag == 0) {
     209   [ #  #  #  # ]:          0 :                 SPDK_DEBUGLOG(log_rpc, "invalid flag 0\n");
     210                 :          0 :                 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
     211                 :            :                                                  "invalid flag 0");
     212                 :          0 :                 goto end;
     213                 :            :         }
     214                 :            : 
     215         [ -  + ]:          9 :         if (spdk_log_set_flag(req.flag) != 0) {
     216   [ #  #  #  # ]:          0 :                 SPDK_DEBUGLOG(log_rpc, "tried to set invalid log flag\n");
     217                 :          0 :                 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
     218                 :            :                                                  "invalid log flag");
     219                 :          0 :                 goto end;
     220                 :            :         }
     221                 :            : 
     222                 :          9 :         spdk_jsonrpc_send_bool_response(request, true);
     223                 :          9 : end:
     224                 :          9 :         free_rpc_log_flag(&req);
     225                 :          9 : }
     226                 :       2987 : SPDK_RPC_REGISTER("log_set_flag", rpc_log_set_flag, SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)
     227                 :            : 
     228                 :            : static void
     229                 :          2 : rpc_log_clear_flag(struct spdk_jsonrpc_request *request,
     230                 :            :                    const struct spdk_json_val *params)
     231                 :            : {
     232                 :          2 :         struct rpc_log_flag req = {};
     233                 :            : 
     234         [ -  + ]:          2 :         if (spdk_json_decode_object(params, rpc_log_flag_decoders,
     235                 :            :                                     SPDK_COUNTOF(rpc_log_flag_decoders), &req)) {
     236   [ #  #  #  # ]:          0 :                 SPDK_DEBUGLOG(log_rpc, "spdk_json_decode_object failed\n");
     237                 :          0 :                 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
     238                 :            :                                                  "spdk_json_decode_object failed");
     239                 :          0 :                 goto end;
     240                 :            :         }
     241                 :            : 
     242         [ -  + ]:          2 :         if (req.flag == 0) {
     243   [ #  #  #  # ]:          0 :                 SPDK_DEBUGLOG(log_rpc, "Invalid flag 0\n");
     244                 :          0 :                 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
     245                 :            :                                                  "invalid flag 0");
     246                 :          0 :                 goto end;
     247                 :            :         }
     248                 :            : 
     249         [ -  + ]:          2 :         if (spdk_log_clear_flag(req.flag) != 0) {
     250   [ #  #  #  # ]:          0 :                 SPDK_DEBUGLOG(log_rpc, "tried to clear invalid log flag\n");
     251                 :          0 :                 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
     252                 :            :                                                  "invalid log flag");
     253                 :          0 :                 goto end;
     254                 :            :         }
     255                 :            : 
     256                 :          2 :         spdk_jsonrpc_send_bool_response(request, true);
     257                 :          2 : end:
     258                 :          2 :         free_rpc_log_flag(&req);
     259                 :          2 : }
     260                 :       2987 : SPDK_RPC_REGISTER("log_clear_flag", rpc_log_clear_flag,
     261                 :            :                   SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)
     262                 :            : 
     263                 :            : static void
     264                 :          6 : rpc_log_get_flags(struct spdk_jsonrpc_request *request,
     265                 :            :                   const struct spdk_json_val *params)
     266                 :            : {
     267                 :            :         struct spdk_json_write_ctx *w;
     268                 :            :         struct spdk_log_flag *flag;
     269                 :            : 
     270         [ -  + ]:          6 :         if (params != NULL) {
     271                 :          0 :                 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
     272                 :            :                                                  "log_get_flags requires no parameters");
     273                 :          0 :                 return;
     274                 :            :         }
     275                 :            : 
     276                 :          6 :         w = spdk_jsonrpc_begin_result(request);
     277                 :          6 :         spdk_json_write_object_begin(w);
     278                 :          6 :         flag = spdk_log_get_first_flag();
     279         [ +  + ]:        408 :         while (flag) {
     280                 :        402 :                 spdk_json_write_name(w, flag->name);
     281         [ -  + ]:        402 :                 spdk_json_write_bool(w, flag->enabled);
     282                 :        402 :                 flag = spdk_log_get_next_flag(flag);
     283                 :            :         }
     284                 :          6 :         spdk_json_write_object_end(w);
     285                 :          6 :         spdk_jsonrpc_end_result(request, w);
     286                 :            : }
     287                 :       2987 : SPDK_RPC_REGISTER("log_get_flags", rpc_log_get_flags, SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)
     288                 :            : 
     289                 :            : struct rpc_log_enable_timestamps {
     290                 :            :         bool enabled;
     291                 :            : };
     292                 :            : 
     293                 :            : static const struct spdk_json_object_decoder rpc_log_enable_timestamps_decoders[] = {
     294                 :            :         {"enabled", offsetof(struct rpc_log_enable_timestamps, enabled), spdk_json_decode_bool},
     295                 :            : };
     296                 :            : 
     297                 :            : static void
     298                 :          0 : rpc_log_enable_timestamps(struct spdk_jsonrpc_request *request,
     299                 :            :                           const struct spdk_json_val *params)
     300                 :            : {
     301                 :          0 :         struct rpc_log_enable_timestamps req = {};
     302                 :            : 
     303         [ #  # ]:          0 :         if (spdk_json_decode_object(params, rpc_log_enable_timestamps_decoders,
     304                 :            :                                     SPDK_COUNTOF(rpc_log_enable_timestamps_decoders),
     305                 :            :                                     &req)) {
     306                 :          0 :                 SPDK_ERRLOG("spdk_json_decode_object failed\n");
     307                 :          0 :                 spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
     308                 :            :                                                  "spdk_json_decode_object failed");
     309                 :          0 :                 return;
     310                 :            :         }
     311                 :            : 
     312         [ #  # ]:          0 :         spdk_log_enable_timestamps(req.enabled);
     313                 :            : 
     314                 :          0 :         spdk_jsonrpc_send_bool_response(request, true);
     315                 :            : }
     316                 :       2987 : SPDK_RPC_REGISTER("log_enable_timestamps", rpc_log_enable_timestamps, SPDK_RPC_RUNTIME)
     317                 :       2987 : SPDK_LOG_REGISTER_COMPONENT(log_rpc)

Generated by: LCOV version 1.14