LCOV - code coverage report
Current view: top level - spdk/lib/ftl/mngt - ftl_mngt_misc.c (source / functions) Hit Total Coverage
Test: Combined Lines: 189 227 83.3 %
Date: 2024-07-15 05:31:22 Functions: 29 29 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 32 78 41.0 %

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

Generated by: LCOV version 1.14