LCOV - code coverage report
Current view: top level - spdk/lib/ftl/mngt - ftl_mngt_misc.c (source / functions) Hit Total Coverage
Test: Combined Lines: 193 230 83.9 %
Date: 2024-07-11 11:43:24 Functions: 30 30 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 42 88 47.7 %

           Branch data     Line data    Source code
       1                 :            : /*   SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  *   Copyright (C) 2022 Intel Corporation.
       3                 :            :  *   All rights reserved.
       4                 :            :  */
       5                 :            : 
       6                 :            : #include "ftl_core.h"
       7                 :            : #include "ftl_utils.h"
       8                 :            : #include "ftl_mngt.h"
       9                 :            : #include "ftl_mngt_steps.h"
      10                 :            : #include "ftl_band.h"
      11                 :            : #include "ftl_internal.h"
      12                 :            : #include "ftl_nv_cache.h"
      13                 :            : #include "ftl_debug.h"
      14                 :            : #include "ftl_utils.h"
      15                 :            : 
      16                 :            : void
      17                 :         27 : ftl_mngt_check_conf(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
      18                 :            : {
      19         [ +  - ]:         27 :         if (ftl_conf_is_valid(&dev->conf)) {
      20                 :         27 :                 ftl_mngt_next_step(mngt);
      21                 :            :         } else {
      22                 :          0 :                 ftl_mngt_fail_step(mngt);
      23                 :            :         }
      24                 :         27 : }
      25                 :            : 
      26                 :            : static int
      27                 :         27 : init_p2l_map_pool(struct spdk_ftl_dev *dev)
      28                 :            : {
      29                 :         27 :         size_t p2l_pool_el_blks = spdk_divide_round_up(ftl_p2l_map_pool_elem_size(dev), FTL_BLOCK_SIZE);
      30                 :         27 :         size_t p2l_pool_buf_blks = P2L_MEMPOOL_SIZE * p2l_pool_el_blks;
      31                 :            :         void *p2l_pool_buf;
      32                 :            : 
      33                 :         27 :         dev->p2l_pool_md = ftl_md_create(dev, p2l_pool_buf_blks, 0, "p2l_pool",
      34                 :            :                                          ftl_md_create_shm_flags(dev), NULL);
      35         [ -  + ]:         27 :         if (!dev->p2l_pool_md) {
      36                 :          0 :                 return -ENOMEM;
      37                 :            :         }
      38                 :            : 
      39                 :         27 :         p2l_pool_buf = ftl_md_get_buffer(dev->p2l_pool_md);
      40                 :         27 :         dev->p2l_pool = ftl_mempool_create_ext(p2l_pool_buf, P2L_MEMPOOL_SIZE,
      41                 :         27 :                                                p2l_pool_el_blks * FTL_BLOCK_SIZE,
      42                 :            :                                                FTL_BLOCK_SIZE);
      43         [ -  + ]:         27 :         if (!dev->p2l_pool) {
      44                 :          0 :                 return -ENOMEM;
      45                 :            :         }
      46                 :            : 
      47         [ +  + ]:         27 :         if (!ftl_fast_startup(dev)) {
      48                 :         24 :                 ftl_mempool_initialize_ext(dev->p2l_pool);
      49                 :            :         }
      50                 :            : 
      51                 :         27 :         return 0;
      52                 :            : }
      53                 :            : 
      54                 :            : static int
      55                 :         27 : init_band_md_pool(struct spdk_ftl_dev *dev)
      56                 :            : {
      57                 :         27 :         dev->band_md_pool = ftl_mempool_create(P2L_MEMPOOL_SIZE,
      58                 :            :                                                sizeof(struct ftl_band_md),
      59                 :            :                                                FTL_BLOCK_SIZE,
      60                 :            :                                                SPDK_ENV_SOCKET_ID_ANY);
      61         [ -  + ]:         27 :         if (!dev->band_md_pool) {
      62                 :          0 :                 return -ENOMEM;
      63                 :            :         }
      64                 :            : 
      65                 :         27 :         return 0;
      66                 :            : }
      67                 :            : 
      68                 :            : void
      69                 :         27 : ftl_mngt_init_mem_pools(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
      70                 :            : {
      71         [ -  + ]:         27 :         if (init_p2l_map_pool(dev)) {
      72                 :          0 :                 ftl_mngt_fail_step(mngt);
      73                 :          0 :                 return;
      74                 :            :         }
      75                 :            : 
      76         [ -  + ]:         27 :         if (init_band_md_pool(dev)) {
      77                 :          0 :                 ftl_mngt_fail_step(mngt);
      78                 :          0 :                 return;
      79                 :            :         }
      80                 :            : 
      81                 :         27 :         ftl_mngt_next_step(mngt);
      82                 :            : }
      83                 :            : 
      84                 :            : void
      85                 :         27 : ftl_mngt_deinit_mem_pools(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
      86                 :            : {
      87         [ +  - ]:         27 :         if (dev->p2l_pool) {
      88                 :         27 :                 ftl_mempool_destroy_ext(dev->p2l_pool);
      89                 :         27 :                 dev->p2l_pool = NULL;
      90                 :            :         }
      91                 :            : 
      92         [ +  - ]:         27 :         if (dev->p2l_pool_md) {
      93                 :         27 :                 ftl_md_destroy(dev->p2l_pool_md, ftl_md_destroy_shm_flags(dev));
      94                 :         27 :                 dev->p2l_pool_md = NULL;
      95                 :            :         }
      96                 :            : 
      97         [ +  - ]:         27 :         if (dev->band_md_pool) {
      98                 :         27 :                 ftl_mempool_destroy(dev->band_md_pool);
      99                 :         27 :                 dev->band_md_pool = NULL;
     100                 :            :         }
     101                 :            : 
     102                 :         27 :         ftl_mngt_next_step(mngt);
     103                 :         27 : }
     104                 :            : 
     105                 :            : void
     106                 :         27 : ftl_mngt_init_reloc(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
     107                 :            : {
     108                 :         27 :         dev->reloc = ftl_reloc_init(dev);
     109         [ -  + ]:         27 :         if (!dev->reloc) {
     110         [ #  # ]:          0 :                 FTL_ERRLOG(dev, "Unable to initialize reloc structures\n");
     111                 :          0 :                 ftl_mngt_fail_step(mngt);
     112                 :          0 :                 return;
     113                 :            :         }
     114                 :            : 
     115                 :         27 :         ftl_mngt_next_step(mngt);
     116                 :            : }
     117                 :            : 
     118                 :            : void
     119                 :         27 : ftl_mngt_deinit_reloc(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
     120                 :            : {
     121                 :         27 :         ftl_reloc_free(dev->reloc);
     122                 :         27 :         ftl_mngt_next_step(mngt);
     123                 :         27 : }
     124                 :            : 
     125                 :            : void
     126                 :         27 : ftl_mngt_init_nv_cache(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
     127                 :            : {
     128         [ -  + ]:         27 :         if (ftl_nv_cache_init(dev)) {
     129         [ #  # ]:          0 :                 FTL_ERRLOG(dev, "Unable to initialize persistent cache\n");
     130                 :          0 :                 ftl_mngt_fail_step(mngt);
     131                 :          0 :                 return;
     132                 :            :         }
     133                 :            : 
     134                 :         27 :         ftl_mngt_next_step(mngt);
     135                 :            : }
     136                 :            : 
     137                 :            : void
     138                 :         27 : ftl_mngt_deinit_nv_cache(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
     139                 :            : {
     140                 :         27 :         ftl_nv_cache_deinit(dev);
     141                 :         27 :         ftl_mngt_next_step(mngt);
     142                 :         27 : }
     143                 :            : 
     144                 :            : static void
     145                 :          6 : user_clear_cb(struct spdk_ftl_dev *dev, void *cb_ctx, int status)
     146                 :            : {
     147                 :          6 :         struct ftl_mngt_process *mngt = cb_ctx;
     148                 :            : 
     149         [ -  + ]:          6 :         if (status) {
     150         [ #  # ]:          0 :                 FTL_ERRLOG(ftl_mngt_get_dev(mngt), "FTL NV Cache: ERROR of clearing user cache data\n");
     151                 :          0 :                 ftl_mngt_fail_step(mngt);
     152                 :            :         } else {
     153                 :          6 :                 ftl_mngt_next_step(mngt);
     154                 :            :         }
     155                 :          6 : }
     156                 :            : 
     157                 :            : void
     158                 :         27 : ftl_mngt_scrub_nv_cache(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
     159                 :            : {
     160                 :         27 :         bool is_first_start = (dev->conf.mode & SPDK_FTL_MODE_CREATE) != 0;
     161   [ +  +  -  +  :         44 :         bool is_major_upgrade = dev->sb->clean == 1 && dev->sb_shm->shm_clean == 0 &&
                   +  + ]
     162         [ -  + ]:         17 :                                 dev->sb->upgrade_ready == 1;
     163                 :            : 
     164   [ +  +  -  + ]:         27 :         if (is_first_start || is_major_upgrade) {
     165         [ +  - ]:          6 :                 FTL_NOTICELOG(dev, "NV cache data region needs scrubbing, this may take a while.\n");
     166         [ +  - ]:          6 :                 FTL_NOTICELOG(dev, "Scrubbing %"PRIu64" chunks\n", dev->layout.nvc.chunk_count);
     167                 :            : 
     168                 :            :                 /* Need to scrub user data, so in case of dirty shutdown the recovery won't
     169                 :            :                  * pull in data during open chunks recovery from any previous instance (since during short
     170                 :            :                  * tests it's very likely that chunks seq_id will be in line between new head md and old VSS)
     171                 :            :                  */
     172                 :          6 :                 ftl_nv_cache_scrub(dev, user_clear_cb, mngt);
     173                 :            :         } else {
     174                 :         21 :                 ftl_mngt_skip_step(mngt);
     175                 :            :         }
     176                 :         27 : }
     177                 :            : 
     178                 :            : void
     179                 :         27 : ftl_mngt_finalize_startup(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
     180                 :            : {
     181         [ -  + ]:         27 :         if (ftl_bitmap_find_first_set(dev->trim_map, 0, UINT64_MAX) != UINT64_MAX) {
     182                 :          0 :                 dev->trim_in_progress = true;
     183                 :            :         }
     184                 :            : 
     185                 :         27 :         ftl_property_register(dev, "superblock_version", &dev->sb->header.version,
     186                 :            :                               sizeof(dev->sb->header.version), NULL, NULL,
     187                 :            :                               ftl_property_dump_uint64, NULL, NULL, false);
     188                 :            : 
     189                 :            :         /* Clear the limit applications as they're incremented incorrectly by
     190                 :            :          * the initialization code.
     191                 :            :          */
     192         [ -  + ]:         27 :         memset(dev->stats.limits, 0, sizeof(dev->stats.limits));
     193                 :         27 :         dev->initialized = 1;
     194                 :         27 :         dev->sb_shm->shm_ready = true;
     195                 :            : 
     196                 :         27 :         ftl_l2p_resume(dev);
     197                 :         27 :         ftl_reloc_resume(dev->reloc);
     198                 :         27 :         ftl_writer_resume(&dev->writer_user);
     199                 :         27 :         ftl_writer_resume(&dev->writer_gc);
     200                 :         27 :         ftl_nv_cache_resume(&dev->nv_cache);
     201                 :            : 
     202                 :         27 :         ftl_mngt_next_step(mngt);
     203                 :         27 : }
     204                 :            : 
     205                 :            : void
     206                 :         27 : ftl_mngt_start_core_poller(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
     207                 :            : {
     208                 :         27 :         dev->core_poller = SPDK_POLLER_REGISTER(ftl_core_poller, dev, 0);
     209         [ -  + ]:         27 :         if (!dev->core_poller) {
     210         [ #  # ]:          0 :                 FTL_ERRLOG(dev, "Unable to register core poller\n");
     211                 :          0 :                 ftl_mngt_fail_step(mngt);
     212                 :          0 :                 return;
     213                 :            :         }
     214                 :            : 
     215                 :         27 :         ftl_mngt_next_step(mngt);
     216                 :            : }
     217                 :            : 
     218                 :            : void
     219                 :     146575 : ftl_mngt_stop_core_poller(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
     220                 :            : {
     221                 :     146575 :         dev->halt = true;
     222                 :            : 
     223         [ +  + ]:     146575 :         if (dev->core_poller) {
     224                 :     146548 :                 ftl_mngt_continue_step(mngt);
     225                 :            :         } else {
     226                 :         27 :                 ftl_mngt_next_step(mngt);
     227                 :            :         }
     228                 :     146575 : }
     229                 :            : 
     230                 :            : void
     231                 :         27 : ftl_mngt_dump_stats(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
     232                 :            : {
     233                 :         27 :         ftl_dev_dump_bands(dev);
     234                 :         27 :         ftl_dev_dump_stats(dev);
     235                 :         27 :         ftl_mngt_next_step(mngt);
     236                 :         27 : }
     237                 :            : 
     238                 :            : void
     239                 :         27 : ftl_mngt_init_vld_map(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
     240                 :            : {
     241                 :         27 :         struct ftl_md *valid_map_md = dev->layout.md[FTL_LAYOUT_REGION_TYPE_VALID_MAP];
     242                 :            : 
     243                 :         27 :         dev->valid_map = ftl_bitmap_create(ftl_md_get_buffer(valid_map_md),
     244                 :            :                                            ftl_md_get_buffer_size(valid_map_md));
     245         [ -  + ]:         27 :         if (!dev->valid_map) {
     246         [ #  # ]:          0 :                 FTL_ERRLOG(dev, "Failed to create valid map\n");
     247                 :          0 :                 ftl_mngt_fail_step(mngt);
     248                 :          0 :                 return;
     249                 :            :         }
     250                 :            : 
     251                 :         27 :         ftl_mngt_next_step(mngt);
     252                 :            : }
     253                 :            : 
     254                 :            : void
     255                 :         27 : ftl_mngt_deinit_vld_map(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
     256                 :            : {
     257         [ +  - ]:         27 :         if (dev->valid_map) {
     258                 :         27 :                 ftl_bitmap_destroy(dev->valid_map);
     259                 :         27 :                 dev->valid_map = NULL;
     260                 :            :         }
     261                 :            : 
     262                 :         27 :         ftl_mngt_next_step(mngt);
     263                 :         27 : }
     264                 :            : void
     265                 :         27 : ftl_mngt_init_trim_map(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
     266                 :            : {
     267                 :         27 :         uint64_t num_l2p_pages = spdk_divide_round_up(dev->num_lbas, dev->layout.l2p.lbas_in_page);
     268                 :         27 :         uint64_t map_blocks = ftl_bitmap_bits_to_blocks(num_l2p_pages);
     269                 :            : 
     270                 :         27 :         dev->trim_map_md = ftl_md_create(dev,
     271                 :            :                                          map_blocks,
     272                 :            :                                          0,
     273                 :            :                                          "trim_bitmap",
     274                 :            :                                          ftl_md_create_shm_flags(dev), NULL);
     275                 :            : 
     276         [ -  + ]:         27 :         if (!dev->trim_map_md) {
     277         [ #  # ]:          0 :                 FTL_ERRLOG(dev, "Failed to create trim bitmap md\n");
     278                 :          0 :                 ftl_mngt_fail_step(mngt);
     279                 :          0 :                 return;
     280                 :            :         }
     281                 :            : 
     282                 :         27 :         dev->trim_map = ftl_bitmap_create(ftl_md_get_buffer(dev->trim_map_md),
     283                 :            :                                           ftl_md_get_buffer_size(dev->trim_map_md));
     284                 :            : 
     285         [ -  + ]:         27 :         if (!dev->trim_map) {
     286         [ #  # ]:          0 :                 FTL_ERRLOG(dev, "Failed to create trim map\n");
     287                 :          0 :                 ftl_mngt_fail_step(mngt);
     288                 :          0 :                 return;
     289                 :            :         }
     290                 :            : 
     291                 :         27 :         ftl_mngt_next_step(mngt);
     292                 :            : }
     293                 :            : 
     294                 :            : static void
     295                 :         12 : trim_clear_cb(struct spdk_ftl_dev *dev, struct ftl_md *md, int status)
     296                 :            : {
     297                 :         12 :         struct ftl_mngt_process *mngt = md->owner.cb_ctx;
     298                 :            : 
     299         [ -  + ]:         12 :         if (status) {
     300                 :          0 :                 ftl_mngt_fail_step(mngt);
     301                 :            :         } else {
     302                 :         12 :                 ftl_mngt_next_step(mngt);
     303                 :            :         }
     304                 :         12 : }
     305                 :            : 
     306                 :            : void
     307                 :          6 : ftl_mngt_trim_metadata_clear(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
     308                 :            : {
     309                 :          6 :         struct ftl_md *md = dev->layout.md[FTL_LAYOUT_REGION_TYPE_TRIM_MD];
     310                 :            : 
     311                 :          6 :         md->cb = trim_clear_cb;
     312                 :          6 :         md->owner.cb_ctx = mngt;
     313                 :          6 :         ftl_md_clear(md, 0, NULL);
     314                 :          6 : }
     315                 :            : 
     316                 :            : void
     317                 :          6 : ftl_mngt_trim_log_clear(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
     318                 :            : {
     319                 :          6 :         struct ftl_md *md = dev->layout.md[FTL_LAYOUT_REGION_TYPE_TRIM_LOG];
     320                 :            : 
     321                 :          6 :         md->cb = trim_clear_cb;
     322                 :          6 :         md->owner.cb_ctx = mngt;
     323                 :          6 :         ftl_md_clear(md, 0, NULL);
     324                 :          6 : }
     325                 :            : 
     326                 :            : void
     327                 :         27 : ftl_mngt_deinit_trim_map(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
     328                 :            : {
     329                 :         27 :         ftl_bitmap_destroy(dev->trim_map);
     330                 :         27 :         dev->trim_map = NULL;
     331                 :            : 
     332                 :         27 :         ftl_md_destroy(dev->trim_map_md, ftl_md_destroy_shm_flags(dev));
     333                 :         27 :         dev->trim_map_md = NULL;
     334                 :            : 
     335                 :         27 :         ftl_mngt_next_step(mngt);
     336                 :         27 : }
     337                 :            : 
     338                 :            : struct ftl_mngt_property_caller_ctx {
     339                 :            :         struct spdk_ftl_dev *dev;
     340                 :            :         struct spdk_jsonrpc_request *request;
     341                 :            :         spdk_ftl_fn cb_fn;
     342                 :            :         void *cb_arg;
     343                 :            :         struct spdk_thread *cb_thread;
     344                 :            :         const char *property;
     345                 :            :         const char *value;
     346                 :            :         size_t value_size;
     347                 :            : };
     348                 :            : 
     349                 :            : static void
     350                 :          3 : ftl_get_properties_cb(void *arg)
     351                 :            : {
     352                 :          3 :         struct ftl_mngt_property_caller_ctx *cctx = arg;
     353                 :            : 
     354                 :          3 :         cctx->cb_fn(cctx->cb_arg, 0);
     355                 :          3 :         free(cctx);
     356                 :          3 : }
     357                 :            : 
     358                 :            : static void
     359                 :          3 : ftl_get_properties_msg(void *arg)
     360                 :            : {
     361                 :          3 :         struct ftl_mngt_property_caller_ctx *cctx = arg;
     362                 :            :         int rc;
     363                 :            : 
     364                 :          3 :         ftl_property_dump(cctx->dev, cctx->request);
     365                 :          3 :         rc = spdk_thread_send_msg(cctx->cb_thread, ftl_get_properties_cb, cctx);
     366         [ -  + ]:          3 :         ftl_bug(rc);
     367                 :          3 : }
     368                 :            : 
     369                 :            : int
     370                 :          3 : spdk_ftl_get_properties(struct spdk_ftl_dev *dev, struct spdk_jsonrpc_request *request,
     371                 :            :                         spdk_ftl_fn cb_fn, void *cb_arg)
     372                 :            : {
     373                 :            :         int rc;
     374                 :          3 :         struct ftl_mngt_property_caller_ctx *ctx = calloc(1, sizeof(*ctx));
     375                 :            : 
     376         [ -  + ]:          3 :         if (ctx == NULL) {
     377                 :          0 :                 return -ENOMEM;
     378                 :            :         }
     379                 :          3 :         ctx->dev = dev;
     380                 :          3 :         ctx->request = request;
     381                 :          3 :         ctx->cb_fn = cb_fn;
     382                 :          3 :         ctx->cb_arg = cb_arg;
     383                 :          3 :         ctx->cb_thread = spdk_get_thread();
     384                 :            : 
     385                 :          3 :         rc = spdk_thread_send_msg(dev->core_thread, ftl_get_properties_msg, ctx);
     386         [ -  + ]:          3 :         if (rc) {
     387                 :          0 :                 free(ctx);
     388                 :          0 :                 return rc;
     389                 :            :         }
     390                 :            : 
     391                 :          3 :         return 0;
     392                 :            : }
     393                 :            : 
     394                 :            : struct ftl_set_property_process_ctx {
     395                 :            :         void *value;
     396                 :            :         size_t value_size;
     397                 :            : };
     398                 :            : 
     399                 :            : static void
     400                 :          3 : ftl_mngt_set_property_decode(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
     401                 :            : {
     402                 :          3 :         struct ftl_set_property_process_ctx *pctx = ftl_mngt_get_process_ctx(mngt);
     403                 :          3 :         struct ftl_mngt_property_caller_ctx *cctx = ftl_mngt_get_caller_ctx(mngt);
     404                 :            : 
     405         [ -  + ]:          3 :         if (ftl_property_decode(dev, cctx->property, cctx->value, cctx->value_size,
     406                 :            :                                 &pctx->value, &pctx->value_size)) {
     407                 :          0 :                 ftl_mngt_fail_step(mngt);
     408                 :            :         } else {
     409                 :          3 :                 ftl_mngt_next_step(mngt);
     410                 :            :         }
     411                 :          3 : }
     412                 :            : 
     413                 :            : static void
     414                 :          3 : ftl_mngt_set_property(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
     415                 :            : {
     416                 :          3 :         struct ftl_set_property_process_ctx *pctx = ftl_mngt_get_process_ctx(mngt);
     417                 :          3 :         struct ftl_mngt_property_caller_ctx *cctx = ftl_mngt_get_caller_ctx(mngt);
     418                 :            : 
     419         [ -  + ]:          3 :         if (ftl_property_set(dev, mngt, cctx->property, pctx->value, pctx->value_size)) {
     420                 :          0 :                 ftl_mngt_fail_step(mngt);
     421                 :            :         }
     422                 :          3 : }
     423                 :            : 
     424                 :            : static void
     425                 :          3 : ftl_mngt_set_property_cleanup(struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt)
     426                 :            : {
     427                 :          3 :         struct ftl_set_property_process_ctx *pctx = ftl_mngt_get_process_ctx(mngt);
     428                 :          3 :         free(pctx->value);
     429                 :          3 :         pctx->value = NULL;
     430                 :          3 :         pctx->value_size = 0;
     431                 :          3 :         ftl_mngt_next_step(mngt);
     432                 :          3 : }
     433                 :            : 
     434                 :            : static const struct ftl_mngt_process_desc desc_set_property = {
     435                 :            :         .name = "Set FTL property",
     436                 :            :         .ctx_size = sizeof(struct ftl_set_property_process_ctx),
     437                 :            :         .steps = {
     438                 :            :                 {
     439                 :            :                         .name = "Decode property",
     440                 :            :                         .action = ftl_mngt_set_property_decode,
     441                 :            :                         .cleanup = ftl_mngt_set_property_cleanup
     442                 :            :                 },
     443                 :            :                 {
     444                 :            :                         .name = "Set property",
     445                 :            :                         .action = ftl_mngt_set_property,
     446                 :            :                         .cleanup = ftl_mngt_set_property_cleanup
     447                 :            :                 },
     448                 :            :                 {
     449                 :            :                         .name = "Property setting cleanup",
     450                 :            :                         .action = ftl_mngt_set_property_cleanup,
     451                 :            :                 },
     452                 :            :                 {}
     453                 :            :         }
     454                 :            : };
     455                 :            : 
     456                 :            : static void
     457                 :          3 : ftl_mngt_property_caller_cb(struct spdk_ftl_dev *dev, void *ctx, int status)
     458                 :            : {
     459                 :          3 :         struct ftl_mngt_property_caller_ctx *cctx = ctx;
     460                 :            : 
     461                 :          3 :         cctx->cb_fn(cctx->cb_arg, status);
     462                 :          3 :         free(cctx);
     463                 :          3 : }
     464                 :            : 
     465                 :            : int
     466                 :          3 : spdk_ftl_set_property(struct spdk_ftl_dev *dev,
     467                 :            :                       const char *property, const char *value, size_t value_size,
     468                 :            :                       spdk_ftl_fn cb_fn, void *cb_arg)
     469                 :            : {
     470                 :            :         int rc;
     471                 :          3 :         struct ftl_mngt_property_caller_ctx *cctx = calloc(1, sizeof(*cctx));
     472                 :            : 
     473         [ -  + ]:          3 :         if (cctx == NULL) {
     474                 :          0 :                 return -EAGAIN;
     475                 :            :         }
     476                 :          3 :         cctx->cb_fn = cb_fn;
     477                 :          3 :         cctx->cb_arg = cb_arg;
     478                 :          3 :         cctx->property = property;
     479                 :          3 :         cctx->value = value;
     480                 :          3 :         cctx->value_size = value_size;
     481                 :            : 
     482                 :          3 :         rc = ftl_mngt_process_execute(dev, &desc_set_property, ftl_mngt_property_caller_cb, cctx);
     483         [ -  + ]:          3 :         if (rc) {
     484                 :          0 :                 free(cctx);
     485                 :            :         }
     486                 :            : 
     487                 :          3 :         return rc;
     488                 :            : }

Generated by: LCOV version 1.14