LCOV - code coverage report
Current view: top level - spdk/module/bdev/passthru - vbdev_passthru.c (source / functions) Hit Total Coverage
Test: Combined Lines: 240 374 64.2 %
Date: 2024-12-17 10:11:24 Functions: 24 30 80.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 357 1234 28.9 %

           Branch data     Line data    Source code
       1                 :            : /*   SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  *   Copyright (C) 2018 Intel Corporation.
       3                 :            :  *   All rights reserved.
       4                 :            :  *   Copyright (c) 2021 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
       5                 :            :  */
       6                 :            : 
       7                 :            : /*
       8                 :            :  * This is a simple example of a virtual block device module that passes IO
       9                 :            :  * down to a bdev (or bdevs) that its configured to attach to.
      10                 :            :  */
      11                 :            : 
      12                 :            : #include "spdk/stdinc.h"
      13                 :            : 
      14                 :            : #include "vbdev_passthru.h"
      15                 :            : #include "spdk/rpc.h"
      16                 :            : #include "spdk/env.h"
      17                 :            : #include "spdk/endian.h"
      18                 :            : #include "spdk/string.h"
      19                 :            : #include "spdk/thread.h"
      20                 :            : #include "spdk/util.h"
      21                 :            : 
      22                 :            : #include "spdk/bdev_module.h"
      23                 :            : #include "spdk/log.h"
      24                 :            : 
      25                 :            : /* This namespace UUID was generated using uuid_generate() method. */
      26                 :            : #define BDEV_PASSTHRU_NAMESPACE_UUID "7e25812e-c8c0-4d3f-8599-16d790555b85"
      27                 :            : 
      28                 :            : static int vbdev_passthru_init(void);
      29                 :            : static int vbdev_passthru_get_ctx_size(void);
      30                 :            : static void vbdev_passthru_examine(struct spdk_bdev *bdev);
      31                 :            : static void vbdev_passthru_finish(void);
      32                 :            : static int vbdev_passthru_config_json(struct spdk_json_write_ctx *w);
      33                 :            : 
      34                 :            : static struct spdk_bdev_module passthru_if = {
      35                 :            :         .name = "passthru",
      36                 :            :         .module_init = vbdev_passthru_init,
      37                 :            :         .get_ctx_size = vbdev_passthru_get_ctx_size,
      38                 :            :         .examine_config = vbdev_passthru_examine,
      39                 :            :         .module_fini = vbdev_passthru_finish,
      40                 :            :         .config_json = vbdev_passthru_config_json
      41                 :            : };
      42                 :            : 
      43                 :       2315 : SPDK_BDEV_MODULE_REGISTER(passthru, &passthru_if)
      44                 :            : 
      45                 :            : /* List of pt_bdev names and their base bdevs via configuration file.
      46                 :            :  * Used so we can parse the conf once at init and use this list in examine().
      47                 :            :  */
      48                 :            : struct bdev_names {
      49                 :            :         char                    *vbdev_name;
      50                 :            :         char                    *bdev_name;
      51                 :            :         struct spdk_uuid        uuid;
      52                 :            :         TAILQ_ENTRY(bdev_names) link;
      53                 :            : };
      54                 :            : static TAILQ_HEAD(, bdev_names) g_bdev_names = TAILQ_HEAD_INITIALIZER(g_bdev_names);
      55                 :            : 
      56                 :            : /* List of virtual bdevs and associated info for each. */
      57                 :            : struct vbdev_passthru {
      58                 :            :         struct spdk_bdev                *base_bdev; /* the thing we're attaching to */
      59                 :            :         struct spdk_bdev_desc           *base_desc; /* its descriptor we get from open */
      60                 :            :         struct spdk_bdev                pt_bdev;    /* the PT virtual bdev */
      61                 :            :         TAILQ_ENTRY(vbdev_passthru)     link;
      62                 :            :         struct spdk_thread              *thread;    /* thread where base device is opened */
      63                 :            : };
      64                 :            : static TAILQ_HEAD(, vbdev_passthru) g_pt_nodes = TAILQ_HEAD_INITIALIZER(g_pt_nodes);
      65                 :            : 
      66                 :            : /* The pt vbdev channel struct. It is allocated and freed on my behalf by the io channel code.
      67                 :            :  * If this vbdev needed to implement a poller or a queue for IO, this is where those things
      68                 :            :  * would be defined. This passthru bdev doesn't actually need to allocate a channel, it could
      69                 :            :  * simply pass back the channel of the bdev underneath it but for example purposes we will
      70                 :            :  * present its own to the upper layers.
      71                 :            :  */
      72                 :            : struct pt_io_channel {
      73                 :            :         struct spdk_io_channel  *base_ch; /* IO channel of base device */
      74                 :            : };
      75                 :            : 
      76                 :            : /* Just for fun, this pt_bdev module doesn't need it but this is essentially a per IO
      77                 :            :  * context that we get handed by the bdev layer.
      78                 :            :  */
      79                 :            : struct passthru_bdev_io {
      80                 :            :         uint8_t test;
      81                 :            : 
      82                 :            :         /* bdev related */
      83                 :            :         struct spdk_io_channel *ch;
      84                 :            : 
      85                 :            :         /* for bdev_io_wait */
      86                 :            :         struct spdk_bdev_io_wait_entry bdev_io_wait;
      87                 :            : };
      88                 :            : 
      89                 :            : static void vbdev_passthru_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io);
      90                 :            : 
      91                 :            : 
      92                 :            : /* Callback for unregistering the IO device. */
      93                 :            : static void
      94                 :        361 : _device_unregister_cb(void *io_device)
      95                 :            : {
      96                 :        361 :         struct vbdev_passthru *pt_node  = io_device;
      97                 :            : 
      98                 :            :         /* Done with this pt_node. */
      99   [ +  -  +  -  :        361 :         free(pt_node->pt_bdev.name);
                   +  - ]
     100                 :        361 :         free(pt_node);
     101                 :        361 : }
     102                 :            : 
     103                 :            : /* Wrapper for the bdev close operation. */
     104                 :            : static void
     105                 :          0 : _vbdev_passthru_destruct(void *ctx)
     106                 :            : {
     107                 :          0 :         struct spdk_bdev_desc *desc = ctx;
     108                 :            : 
     109                 :          0 :         spdk_bdev_close(desc);
     110                 :          0 : }
     111                 :            : 
     112                 :            : /* Called after we've unregistered following a hot remove callback.
     113                 :            :  * Our finish entry point will be called next.
     114                 :            :  */
     115                 :            : static int
     116                 :        361 : vbdev_passthru_destruct(void *ctx)
     117                 :            : {
     118                 :        361 :         struct vbdev_passthru *pt_node = (struct vbdev_passthru *)ctx;
     119                 :            : 
     120                 :            :         /* It is important to follow this exact sequence of steps for destroying
     121                 :            :          * a vbdev...
     122                 :            :          */
     123                 :            : 
     124   [ +  +  +  -  :        361 :         TAILQ_REMOVE(&g_pt_nodes, pt_node, link);
          +  -  +  -  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
             +  -  +  - ]
     125                 :            : 
     126                 :            :         /* Unclaim the underlying bdev. */
     127   [ +  -  +  - ]:        361 :         spdk_bdev_module_release_bdev(pt_node->base_bdev);
     128                 :            : 
     129                 :            :         /* Close the underlying bdev on its same opened thread. */
     130   [ +  -  +  +  :        361 :         if (pt_node->thread && pt_node->thread != spdk_get_thread()) {
          +  -  +  -  +  
                -  +  - ]
     131   [ #  #  #  #  :          0 :                 spdk_thread_send_msg(pt_node->thread, _vbdev_passthru_destruct, pt_node->base_desc);
             #  #  #  # ]
     132                 :          0 :         } else {
     133   [ +  -  +  - ]:        361 :                 spdk_bdev_close(pt_node->base_desc);
     134                 :            :         }
     135                 :            : 
     136                 :            :         /* Unregister the io_device. */
     137                 :        361 :         spdk_io_device_unregister(pt_node, _device_unregister_cb);
     138                 :            : 
     139                 :        361 :         return 0;
     140                 :            : }
     141                 :            : 
     142                 :            : /* Completion callback for IO that were issued from this bdev. The original bdev_io
     143                 :            :  * is passed in as an arg so we'll complete that one with the appropriate status
     144                 :            :  * and then free the one that this module issued.
     145                 :            :  */
     146                 :            : static void
     147                 :    3516330 : _pt_complete_io(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg)
     148                 :            : {
     149                 :    3516330 :         struct spdk_bdev_io *orig_io = cb_arg;
     150         [ +  + ]:    3516330 :         int status = success ? SPDK_BDEV_IO_STATUS_SUCCESS : SPDK_BDEV_IO_STATUS_FAILED;
     151         [ +  - ]:    3516330 :         struct passthru_bdev_io *io_ctx = (struct passthru_bdev_io *)orig_io->driver_ctx;
     152                 :            : 
     153                 :            :         /* We setup this value in the submission routine, just showing here that it is
     154                 :            :          * passed back to us.
     155                 :            :          */
     156   [ +  +  +  -  :    3516330 :         if (io_ctx->test != 0x5a) {
                   +  - ]
     157   [ #  #  #  # ]:          0 :                 SPDK_ERRLOG("Error, original IO device_ctx is wrong! 0x%x\n",
     158                 :            :                             io_ctx->test);
     159                 :          0 :         }
     160                 :            : 
     161                 :            :         /* Complete the original IO and then free the one that we created here
     162                 :            :          * as a result of issuing an IO via submit_request.
     163                 :            :          */
     164                 :    3516330 :         spdk_bdev_io_complete(orig_io, status);
     165                 :    3516330 :         spdk_bdev_free_io(bdev_io);
     166                 :    3516330 : }
     167                 :            : 
     168                 :            : static void
     169                 :          0 : _pt_complete_zcopy_io(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg)
     170                 :            : {
     171                 :          0 :         struct spdk_bdev_io *orig_io = cb_arg;
     172         [ #  # ]:          0 :         int status = success ? SPDK_BDEV_IO_STATUS_SUCCESS : SPDK_BDEV_IO_STATUS_FAILED;
     173         [ #  # ]:          0 :         struct passthru_bdev_io *io_ctx = (struct passthru_bdev_io *)orig_io->driver_ctx;
     174                 :            : 
     175                 :            :         /* We setup this value in the submission routine, just showing here that it is
     176                 :            :          * passed back to us.
     177                 :            :          */
     178   [ #  #  #  #  :          0 :         if (io_ctx->test != 0x5a) {
                   #  # ]
     179   [ #  #  #  # ]:          0 :                 SPDK_ERRLOG("Error, original IO device_ctx is wrong! 0x%x\n",
     180                 :            :                             io_ctx->test);
     181                 :          0 :         }
     182                 :            : 
     183                 :            :         /* Complete the original IO and then free the one that we created here
     184                 :            :          * as a result of issuing an IO via submit_request.
     185                 :            :          */
     186   [ #  #  #  #  :          0 :         spdk_bdev_io_set_buf(orig_io, bdev_io->u.bdev.iovs[0].iov_base, bdev_io->u.bdev.iovs[0].iov_len);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
     187                 :          0 :         spdk_bdev_io_complete(orig_io, status);
     188                 :          0 :         spdk_bdev_free_io(bdev_io);
     189                 :          0 : }
     190                 :            : 
     191                 :            : static void
     192                 :          0 : vbdev_passthru_resubmit_io(void *arg)
     193                 :            : {
     194                 :          0 :         struct spdk_bdev_io *bdev_io = (struct spdk_bdev_io *)arg;
     195         [ #  # ]:          0 :         struct passthru_bdev_io *io_ctx = (struct passthru_bdev_io *)bdev_io->driver_ctx;
     196                 :            : 
     197   [ #  #  #  # ]:          0 :         vbdev_passthru_submit_request(io_ctx->ch, bdev_io);
     198                 :          0 : }
     199                 :            : 
     200                 :            : static void
     201                 :          0 : vbdev_passthru_queue_io(struct spdk_bdev_io *bdev_io)
     202                 :            : {
     203         [ #  # ]:          0 :         struct passthru_bdev_io *io_ctx = (struct passthru_bdev_io *)bdev_io->driver_ctx;
     204   [ #  #  #  # ]:          0 :         struct pt_io_channel *pt_ch = spdk_io_channel_get_ctx(io_ctx->ch);
     205                 :            :         int rc;
     206                 :            : 
     207   [ #  #  #  #  :          0 :         io_ctx->bdev_io_wait.bdev = bdev_io->bdev;
          #  #  #  #  #  
                      # ]
     208   [ #  #  #  #  :          0 :         io_ctx->bdev_io_wait.cb_fn = vbdev_passthru_resubmit_io;
                   #  # ]
     209   [ #  #  #  #  :          0 :         io_ctx->bdev_io_wait.cb_arg = bdev_io;
                   #  # ]
     210                 :            : 
     211                 :            :         /* Queue the IO using the channel of the base device. */
     212   [ #  #  #  #  :          0 :         rc = spdk_bdev_queue_io_wait(bdev_io->bdev, pt_ch->base_ch, &io_ctx->bdev_io_wait);
          #  #  #  #  #  
                      # ]
     213         [ #  # ]:          0 :         if (rc != 0) {
     214                 :          0 :                 SPDK_ERRLOG("Queue io failed in vbdev_passthru_queue_io, rc=%d.\n", rc);
     215                 :          0 :                 spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
     216                 :          0 :         }
     217                 :          0 : }
     218                 :            : 
     219                 :            : static void
     220                 :    2911349 : pt_init_ext_io_opts(struct spdk_bdev_io *bdev_io, struct spdk_bdev_ext_io_opts *opts)
     221                 :            : {
     222         [ +  + ]:    2911349 :         memset(opts, 0, sizeof(*opts));
     223   [ +  -  +  - ]:    2911349 :         opts->size = sizeof(*opts);
     224   [ +  -  +  -  :    2911349 :         opts->memory_domain = bdev_io->u.bdev.memory_domain;
          +  -  +  -  +  
                -  +  - ]
     225   [ +  -  +  -  :    2911349 :         opts->memory_domain_ctx = bdev_io->u.bdev.memory_domain_ctx;
          +  -  +  -  +  
                -  +  - ]
     226   [ +  -  +  -  :    2911349 :         opts->metadata = bdev_io->u.bdev.md_buf;
          +  -  +  -  +  
                -  +  - ]
     227   [ +  -  +  -  :    2911349 :         opts->dif_check_flags_exclude_mask = ~bdev_io->u.bdev.dif_check_flags;
          +  -  +  -  +  
                -  +  - ]
     228                 :    2911349 : }
     229                 :            : 
     230                 :            : /* Callback for getting a buf from the bdev pool in the event that the caller passed
     231                 :            :  * in NULL, we need to own the buffer so it doesn't get freed by another vbdev module
     232                 :            :  * beneath us before we're done with it. That won't happen in this example but it could
     233                 :            :  * if this example were used as a template for something more complex.
     234                 :            :  */
     235                 :            : static void
     236                 :     722237 : pt_read_get_buf_cb(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io, bool success)
     237                 :            : {
     238   [ +  -  +  - ]:     722237 :         struct vbdev_passthru *pt_node = SPDK_CONTAINEROF(bdev_io->bdev, struct vbdev_passthru,
     239                 :            :                                          pt_bdev);
     240                 :     722237 :         struct pt_io_channel *pt_ch = spdk_io_channel_get_ctx(ch);
     241         [ +  - ]:     722237 :         struct passthru_bdev_io *io_ctx = (struct passthru_bdev_io *)bdev_io->driver_ctx;
     242                 :     639858 :         struct spdk_bdev_ext_io_opts io_opts;
     243                 :            :         int rc;
     244                 :            : 
     245   [ +  +  +  - ]:     722237 :         if (!success) {
     246                 :          0 :                 spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
     247                 :          0 :                 return;
     248                 :            :         }
     249                 :            : 
     250                 :     722237 :         pt_init_ext_io_opts(bdev_io, &io_opts);
     251   [ +  -  +  -  :     804616 :         rc = spdk_bdev_readv_blocks_ext(pt_node->base_desc, pt_ch->base_ch, bdev_io->u.bdev.iovs,
          +  -  +  -  +  
          -  +  -  +  -  
                   +  - ]
     252   [ +  -  +  -  :      82379 :                                         bdev_io->u.bdev.iovcnt, bdev_io->u.bdev.offset_blocks,
          +  -  +  -  +  
          -  +  -  +  -  
                   +  - ]
     253   [ +  -  +  -  :      82379 :                                         bdev_io->u.bdev.num_blocks, _pt_complete_io,
             +  -  +  - ]
     254                 :      82379 :                                         bdev_io, &io_opts);
     255         [ +  + ]:     722237 :         if (rc != 0) {
     256         [ #  # ]:          0 :                 if (rc == -ENOMEM) {
     257                 :          0 :                         SPDK_ERRLOG("No memory, start to queue io for passthru.\n");
     258   [ #  #  #  # ]:          0 :                         io_ctx->ch = ch;
     259                 :          0 :                         vbdev_passthru_queue_io(bdev_io);
     260                 :          0 :                 } else {
     261                 :          0 :                         SPDK_ERRLOG("ERROR on bdev_io submission!\n");
     262                 :          0 :                         spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
     263                 :            :                 }
     264                 :          0 :         }
     265                 :      82379 : }
     266                 :            : 
     267                 :            : /* Called when someone above submits IO to this pt vbdev. We're simply passing it on here
     268                 :            :  * via SPDK IO calls which in turn allocate another bdev IO and call our cpl callback provided
     269                 :            :  * below along with the original bdev_io so that we can complete it once this IO completes.
     270                 :            :  */
     271                 :            : static void
     272                 :    3516333 : vbdev_passthru_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
     273                 :            : {
     274   [ +  -  +  - ]:    3516333 :         struct vbdev_passthru *pt_node = SPDK_CONTAINEROF(bdev_io->bdev, struct vbdev_passthru, pt_bdev);
     275                 :    3516333 :         struct pt_io_channel *pt_ch = spdk_io_channel_get_ctx(ch);
     276         [ +  - ]:    3516333 :         struct passthru_bdev_io *io_ctx = (struct passthru_bdev_io *)bdev_io->driver_ctx;
     277                 :    2982840 :         struct spdk_bdev_ext_io_opts io_opts;
     278                 :    3516333 :         int rc = 0;
     279                 :            : 
     280                 :            :         /* Setup a per IO context value; we don't do anything with it in the vbdev other
     281                 :            :          * than confirm we get the same thing back in the completion callback just to
     282                 :            :          * demonstrate.
     283                 :            :          */
     284   [ +  -  +  - ]:    3516333 :         io_ctx->test = 0x5a;
     285                 :            : 
     286   [ +  +  +  +  :    3516333 :         switch (bdev_io->type) {
          +  +  +  -  +  
             +  -  -  -  
                      - ]
     287                 :     639858 :         case SPDK_BDEV_IO_TYPE_READ:
     288                 :     804614 :                 spdk_bdev_io_get_buf(bdev_io, pt_read_get_buf_cb,
     289   [ +  -  +  -  :     722236 :                                      bdev_io->u.bdev.num_blocks * bdev_io->bdev->blocklen);
          +  -  +  -  +  
          -  +  -  +  -  
                   +  - ]
     290                 :     722236 :                 break;
     291                 :    1933404 :         case SPDK_BDEV_IO_TYPE_WRITE:
     292                 :    2189117 :                 pt_init_ext_io_opts(bdev_io, &io_opts);
     293   [ #  #  #  #  :    2444830 :                 rc = spdk_bdev_writev_blocks_ext(pt_node->base_desc, pt_ch->base_ch, bdev_io->u.bdev.iovs,
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     294   [ #  #  #  #  :     255713 :                                                  bdev_io->u.bdev.iovcnt, bdev_io->u.bdev.offset_blocks,
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     295   [ #  #  #  #  :     255713 :                                                  bdev_io->u.bdev.num_blocks, _pt_complete_io,
             #  #  #  # ]
     296                 :     255713 :                                                  bdev_io, &io_opts);
     297                 :    2189117 :                 break;
     298                 :      24978 :         case SPDK_BDEV_IO_TYPE_WRITE_ZEROES:
     299   [ #  #  #  #  :      76186 :                 rc = spdk_bdev_write_zeroes_blocks(pt_node->base_desc, pt_ch->base_ch,
             #  #  #  # ]
     300   [ #  #  #  #  :      25604 :                                                    bdev_io->u.bdev.offset_blocks,
             #  #  #  # ]
     301   [ #  #  #  #  :      25604 :                                                    bdev_io->u.bdev.num_blocks,
             #  #  #  # ]
     302                 :      25604 :                                                    _pt_complete_io, bdev_io);
     303                 :      50582 :                 break;
     304                 :     384592 :         case SPDK_BDEV_IO_TYPE_UNMAP:
     305   [ #  #  #  #  :     724184 :                 rc = spdk_bdev_unmap_blocks(pt_node->base_desc, pt_ch->base_ch,
             #  #  #  # ]
     306   [ #  #  #  #  :     169796 :                                             bdev_io->u.bdev.offset_blocks,
             #  #  #  # ]
     307   [ #  #  #  #  :     169796 :                                             bdev_io->u.bdev.num_blocks,
             #  #  #  # ]
     308                 :     169796 :                                             _pt_complete_io, bdev_io);
     309                 :     554388 :                 break;
     310                 :          0 :         case SPDK_BDEV_IO_TYPE_FLUSH:
     311   [ #  #  #  #  :          0 :                 rc = spdk_bdev_flush_blocks(pt_node->base_desc, pt_ch->base_ch,
             #  #  #  # ]
     312   [ #  #  #  #  :          0 :                                             bdev_io->u.bdev.offset_blocks,
             #  #  #  # ]
     313   [ #  #  #  #  :          0 :                                             bdev_io->u.bdev.num_blocks,
             #  #  #  # ]
     314                 :          0 :                                             _pt_complete_io, bdev_io);
     315                 :          0 :                 break;
     316                 :          4 :         case SPDK_BDEV_IO_TYPE_RESET:
     317   [ #  #  #  #  :          6 :                 rc = spdk_bdev_reset(pt_node->base_desc, pt_ch->base_ch,
             #  #  #  # ]
     318                 :          1 :                                      _pt_complete_io, bdev_io);
     319                 :          5 :                 break;
     320                 :          0 :         case SPDK_BDEV_IO_TYPE_ZCOPY:
     321   [ #  #  #  #  :          0 :                 rc = spdk_bdev_zcopy_start(pt_node->base_desc, pt_ch->base_ch, NULL, 0,
             #  #  #  # ]
     322   [ #  #  #  #  :          0 :                                            bdev_io->u.bdev.offset_blocks,
             #  #  #  # ]
     323   [ #  #  #  #  :          0 :                                            bdev_io->u.bdev.num_blocks, bdev_io->u.bdev.zcopy.populate,
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     324                 :          0 :                                            _pt_complete_zcopy_io, bdev_io);
     325                 :          0 :                 break;
     326                 :          0 :         case SPDK_BDEV_IO_TYPE_ABORT:
     327   [ #  #  #  #  :          0 :                 rc = spdk_bdev_abort(pt_node->base_desc, pt_ch->base_ch, bdev_io->u.abort.bio_to_abort,
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     328                 :          0 :                                      _pt_complete_io, bdev_io);
     329                 :          0 :                 break;
     330                 :          4 :         case SPDK_BDEV_IO_TYPE_COPY:
     331   [ #  #  #  #  :          6 :                 rc = spdk_bdev_copy_blocks(pt_node->base_desc, pt_ch->base_ch,
             #  #  #  # ]
     332   [ #  #  #  #  :          1 :                                            bdev_io->u.bdev.offset_blocks,
             #  #  #  # ]
     333   [ #  #  #  #  :          1 :                                            bdev_io->u.bdev.copy.src_offset_blocks,
          #  #  #  #  #  
                      # ]
     334   [ #  #  #  #  :          1 :                                            bdev_io->u.bdev.num_blocks,
             #  #  #  # ]
     335                 :          1 :                                            _pt_complete_io, bdev_io);
     336                 :          5 :                 break;
     337                 :          0 :         default:
     338   [ #  #  #  # ]:          0 :                 SPDK_ERRLOG("passthru: unknown I/O type %d\n", bdev_io->type);
     339                 :          0 :                 spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
     340                 :          0 :                 return;
     341                 :            :         }
     342         [ +  + ]:    3516333 :         if (rc != 0) {
     343         [ #  # ]:          0 :                 if (rc == -ENOMEM) {
     344                 :          0 :                         SPDK_ERRLOG("No memory, start to queue io for passthru.\n");
     345   [ #  #  #  # ]:          0 :                         io_ctx->ch = ch;
     346                 :          0 :                         vbdev_passthru_queue_io(bdev_io);
     347                 :          0 :                 } else {
     348                 :          0 :                         SPDK_ERRLOG("ERROR on bdev_io submission!\n");
     349                 :          0 :                         spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
     350                 :            :                 }
     351                 :          0 :         }
     352                 :     533493 : }
     353                 :            : 
     354                 :            : /* We'll just call the base bdev and let it answer however if we were more
     355                 :            :  * restrictive for some reason (or less) we could get the response back
     356                 :            :  * and modify according to our purposes.
     357                 :            :  */
     358                 :            : static bool
     359                 :     105838 : vbdev_passthru_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type)
     360                 :            : {
     361                 :     105838 :         struct vbdev_passthru *pt_node = (struct vbdev_passthru *)ctx;
     362                 :            : 
     363   [ +  -  +  - ]:     105838 :         return spdk_bdev_io_type_supported(pt_node->base_bdev, io_type);
     364                 :            : }
     365                 :            : 
     366                 :            : /* We supplied this as an entry point for upper layers who want to communicate to this
     367                 :            :  * bdev.  This is how they get a channel. We are passed the same context we provided when
     368                 :            :  * we created our PT vbdev in examine() which, for this bdev, is the address of one of
     369                 :            :  * our context nodes. From here we'll ask the SPDK channel code to fill out our channel
     370                 :            :  * struct and we'll keep it in our PT node.
     371                 :            :  */
     372                 :            : static struct spdk_io_channel *
     373                 :        858 : vbdev_passthru_get_io_channel(void *ctx)
     374                 :            : {
     375                 :        858 :         struct vbdev_passthru *pt_node = (struct vbdev_passthru *)ctx;
     376                 :        858 :         struct spdk_io_channel *pt_ch = NULL;
     377                 :            : 
     378                 :            :         /* The IO channel code will allocate a channel for us which consists of
     379                 :            :          * the SPDK channel structure plus the size of our pt_io_channel struct
     380                 :            :          * that we passed in when we registered our IO device. It will then call
     381                 :            :          * our channel create callback to populate any elements that we need to
     382                 :            :          * update.
     383                 :            :          */
     384                 :        858 :         pt_ch = spdk_get_io_channel(pt_node);
     385                 :            : 
     386                 :        858 :         return pt_ch;
     387                 :            : }
     388                 :            : 
     389                 :            : /* This is the output for bdev_get_bdevs() for this vbdev */
     390                 :            : static int
     391                 :        138 : vbdev_passthru_dump_info_json(void *ctx, struct spdk_json_write_ctx *w)
     392                 :            : {
     393                 :        138 :         struct vbdev_passthru *pt_node = (struct vbdev_passthru *)ctx;
     394                 :            : 
     395                 :        138 :         spdk_json_write_name(w, "passthru");
     396                 :        138 :         spdk_json_write_object_begin(w);
     397         [ +  - ]:        138 :         spdk_json_write_named_string(w, "name", spdk_bdev_get_name(&pt_node->pt_bdev));
     398   [ +  -  +  - ]:        138 :         spdk_json_write_named_string(w, "base_bdev_name", spdk_bdev_get_name(pt_node->base_bdev));
     399                 :        138 :         spdk_json_write_object_end(w);
     400                 :            : 
     401                 :        138 :         return 0;
     402                 :            : }
     403                 :            : 
     404                 :            : /* This is used to generate JSON that can configure this module to its current state. */
     405                 :            : static int
     406                 :        206 : vbdev_passthru_config_json(struct spdk_json_write_ctx *w)
     407                 :            : {
     408                 :            :         struct vbdev_passthru *pt_node;
     409                 :            : 
     410   [ +  +  #  #  :        231 :         TAILQ_FOREACH(pt_node, &g_pt_nodes, link) {
             #  #  #  # ]
     411         [ #  # ]:         25 :                 const struct spdk_uuid *uuid = spdk_bdev_get_uuid(&pt_node->pt_bdev);
     412                 :            : 
     413                 :         25 :                 spdk_json_write_object_begin(w);
     414                 :         25 :                 spdk_json_write_named_string(w, "method", "bdev_passthru_create");
     415                 :         25 :                 spdk_json_write_named_object_begin(w, "params");
     416   [ #  #  #  # ]:         25 :                 spdk_json_write_named_string(w, "base_bdev_name", spdk_bdev_get_name(pt_node->base_bdev));
     417         [ #  # ]:         25 :                 spdk_json_write_named_string(w, "name", spdk_bdev_get_name(&pt_node->pt_bdev));
     418         [ +  + ]:         25 :                 if (!spdk_uuid_is_null(uuid)) {
     419                 :         25 :                         spdk_json_write_named_uuid(w, "uuid", uuid);
     420                 :          5 :                 }
     421                 :         25 :                 spdk_json_write_object_end(w);
     422                 :         25 :                 spdk_json_write_object_end(w);
     423                 :          5 :         }
     424                 :        206 :         return 0;
     425                 :            : }
     426                 :            : 
     427                 :            : /* We provide this callback for the SPDK channel code to create a channel using
     428                 :            :  * the channel struct we provided in our module get_io_channel() entry point. Here
     429                 :            :  * we get and save off an underlying base channel of the device below us so that
     430                 :            :  * we can communicate with the base bdev on a per channel basis.  If we needed
     431                 :            :  * our own poller for this vbdev, we'd register it here.
     432                 :            :  */
     433                 :            : static int
     434                 :        858 : pt_bdev_ch_create_cb(void *io_device, void *ctx_buf)
     435                 :            : {
     436                 :        858 :         struct pt_io_channel *pt_ch = ctx_buf;
     437                 :        858 :         struct vbdev_passthru *pt_node = io_device;
     438                 :            : 
     439   [ +  -  +  -  :        858 :         pt_ch->base_ch = spdk_bdev_get_io_channel(pt_node->base_desc);
             +  -  +  - ]
     440                 :            : 
     441                 :        858 :         return 0;
     442                 :            : }
     443                 :            : 
     444                 :            : /* We provide this callback for the SPDK channel code to destroy a channel
     445                 :            :  * created with our create callback. We just need to undo anything we did
     446                 :            :  * when we created. If this bdev used its own poller, we'd unregister it here.
     447                 :            :  */
     448                 :            : static void
     449                 :        858 : pt_bdev_ch_destroy_cb(void *io_device, void *ctx_buf)
     450                 :            : {
     451                 :        858 :         struct pt_io_channel *pt_ch = ctx_buf;
     452                 :            : 
     453   [ +  -  +  - ]:        858 :         spdk_put_io_channel(pt_ch->base_ch);
     454                 :        858 : }
     455                 :            : 
     456                 :            : /* Create the passthru association from the bdev and vbdev name and insert
     457                 :            :  * on the global list. */
     458                 :            : static int
     459                 :        361 : vbdev_passthru_insert_name(const char *bdev_name, const char *vbdev_name,
     460                 :            :                            const struct spdk_uuid *uuid)
     461                 :            : {
     462                 :            :         struct bdev_names *name;
     463                 :            : 
     464   [ +  +  #  #  :        700 :         TAILQ_FOREACH(name, &g_bdev_names, link) {
             #  #  #  # ]
     465   [ -  +  -  +  :        339 :                 if (strcmp(vbdev_name, name->vbdev_name) == 0) {
          -  +  #  #  #  
                      # ]
     466                 :          0 :                         SPDK_ERRLOG("passthru bdev %s already exists\n", vbdev_name);
     467                 :          0 :                         return -EEXIST;
     468                 :            :                 }
     469                 :          0 :         }
     470                 :            : 
     471                 :        361 :         name = calloc(1, sizeof(struct bdev_names));
     472         [ +  + ]:        361 :         if (!name) {
     473                 :          0 :                 SPDK_ERRLOG("could not allocate bdev_names\n");
     474                 :          0 :                 return -ENOMEM;
     475                 :            :         }
     476                 :            : 
     477   [ +  +  +  -  :        361 :         name->bdev_name = strdup(bdev_name);
                   +  - ]
     478   [ +  +  +  -  :        361 :         if (!name->bdev_name) {
                   +  - ]
     479                 :          0 :                 SPDK_ERRLOG("could not allocate name->bdev_name\n");
     480                 :          0 :                 free(name);
     481                 :          0 :                 return -ENOMEM;
     482                 :            :         }
     483                 :            : 
     484   [ +  +  +  -  :        361 :         name->vbdev_name = strdup(vbdev_name);
                   +  - ]
     485   [ +  +  +  -  :        361 :         if (!name->vbdev_name) {
                   +  - ]
     486                 :          0 :                 SPDK_ERRLOG("could not allocate name->vbdev_name\n");
     487   [ #  #  #  # ]:          0 :                 free(name->bdev_name);
     488                 :          0 :                 free(name);
     489                 :          0 :                 return -ENOMEM;
     490                 :            :         }
     491                 :            : 
     492         [ +  - ]:        361 :         spdk_uuid_copy(&name->uuid, uuid);
     493   [ +  -  +  -  :        361 :         TAILQ_INSERT_TAIL(&g_bdev_names, name, link);
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
             -  +  -  +  
                      - ]
     494                 :            : 
     495                 :        361 :         return 0;
     496                 :         14 : }
     497                 :            : 
     498                 :            : /* On init, just perform bdev module specific initialization. */
     499                 :            : static int
     500                 :       2122 : vbdev_passthru_init(void)
     501                 :            : {
     502                 :       2122 :         return 0;
     503                 :            : }
     504                 :            : 
     505                 :            : /* Called when the entire module is being torn down. */
     506                 :            : static void
     507                 :       2122 : vbdev_passthru_finish(void)
     508                 :            : {
     509                 :            :         struct bdev_names *name;
     510                 :            : 
     511         [ +  + ]:       2318 :         while ((name = TAILQ_FIRST(&g_bdev_names))) {
     512   [ +  +  #  #  :        196 :                 TAILQ_REMOVE(&g_bdev_names, name, link);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
     513   [ #  #  #  # ]:        196 :                 free(name->bdev_name);
     514   [ #  #  #  # ]:        196 :                 free(name->vbdev_name);
     515                 :        196 :                 free(name);
     516                 :            :         }
     517                 :       2122 : }
     518                 :            : 
     519                 :            : /* During init we'll be asked how much memory we'd like passed to us
     520                 :            :  * in bev_io structures as context. Here's where we specify how
     521                 :            :  * much context we want per IO.
     522                 :            :  */
     523                 :            : static int
     524                 :       2125 : vbdev_passthru_get_ctx_size(void)
     525                 :            : {
     526                 :       2125 :         return sizeof(struct passthru_bdev_io);
     527                 :            : }
     528                 :            : 
     529                 :            : /* Where vbdev_passthru_config_json() is used to generate per module JSON config data, this
     530                 :            :  * function is called to output any per bdev specific methods. For the PT module, there are
     531                 :            :  * none.
     532                 :            :  */
     533                 :            : static void
     534                 :         25 : vbdev_passthru_write_config_json(struct spdk_bdev *bdev, struct spdk_json_write_ctx *w)
     535                 :            : {
     536                 :            :         /* No config per bdev needed */
     537                 :         25 : }
     538                 :            : 
     539                 :            : static int
     540                 :       4303 : vbdev_passthru_get_memory_domains(void *ctx, struct spdk_memory_domain **domains, int array_size)
     541                 :            : {
     542                 :       4303 :         struct vbdev_passthru *pt_node = (struct vbdev_passthru *)ctx;
     543                 :            : 
     544                 :            :         /* Passthru bdev doesn't work with data buffers, so it supports any memory domain used by base_bdev */
     545   [ +  -  +  - ]:       4303 :         return spdk_bdev_get_memory_domains(pt_node->base_bdev, domains, array_size);
     546                 :            : }
     547                 :            : 
     548                 :            : /* When we register our bdev this is how we specify our entry points. */
     549                 :            : static const struct spdk_bdev_fn_table vbdev_passthru_fn_table = {
     550                 :            :         .destruct               = vbdev_passthru_destruct,
     551                 :            :         .submit_request         = vbdev_passthru_submit_request,
     552                 :            :         .io_type_supported      = vbdev_passthru_io_type_supported,
     553                 :            :         .get_io_channel         = vbdev_passthru_get_io_channel,
     554                 :            :         .dump_info_json         = vbdev_passthru_dump_info_json,
     555                 :            :         .write_config_json      = vbdev_passthru_write_config_json,
     556                 :            :         .get_memory_domains     = vbdev_passthru_get_memory_domains,
     557                 :            : };
     558                 :            : 
     559                 :            : static void
     560                 :          0 : vbdev_passthru_base_bdev_hotremove_cb(struct spdk_bdev *bdev_find)
     561                 :            : {
     562                 :            :         struct vbdev_passthru *pt_node, *tmp;
     563                 :            : 
     564   [ #  #  #  #  :          0 :         TAILQ_FOREACH_SAFE(pt_node, &g_pt_nodes, link, tmp) {
          #  #  #  #  #  
                      # ]
     565   [ #  #  #  #  :          0 :                 if (bdev_find == pt_node->base_bdev) {
                   #  # ]
     566         [ #  # ]:          0 :                         spdk_bdev_unregister(&pt_node->pt_bdev, NULL, NULL);
     567                 :          0 :                 }
     568                 :          0 :         }
     569                 :          0 : }
     570                 :            : 
     571                 :            : /* Called when the underlying base bdev triggers asynchronous event such as bdev removal. */
     572                 :            : static void
     573                 :          0 : vbdev_passthru_base_bdev_event_cb(enum spdk_bdev_event_type type, struct spdk_bdev *bdev,
     574                 :            :                                   void *event_ctx)
     575                 :            : {
     576         [ #  # ]:          0 :         switch (type) {
     577                 :          0 :         case SPDK_BDEV_EVENT_REMOVE:
     578                 :          0 :                 vbdev_passthru_base_bdev_hotremove_cb(bdev);
     579                 :          0 :                 break;
     580                 :          0 :         default:
     581                 :          0 :                 SPDK_NOTICELOG("Unsupported bdev event: type %d\n", type);
     582                 :          0 :                 break;
     583                 :            :         }
     584                 :          0 : }
     585                 :            : 
     586                 :            : /* Create and register the passthru vbdev if we find it in our list of bdev names.
     587                 :            :  * This can be called either by the examine path or RPC method.
     588                 :            :  */
     589                 :            : static int
     590                 :       6752 : vbdev_passthru_register(const char *bdev_name)
     591                 :            : {
     592                 :            :         struct bdev_names *name;
     593                 :            :         struct vbdev_passthru *pt_node;
     594                 :            :         struct spdk_bdev *bdev;
     595                 :       6421 :         struct spdk_uuid ns_uuid;
     596                 :       6752 :         int rc = 0;
     597                 :            : 
     598                 :       6752 :         spdk_uuid_parse(&ns_uuid, BDEV_PASSTHRU_NAMESPACE_UUID);
     599                 :            : 
     600                 :            :         /* Check our list of names from config versus this bdev and if
     601                 :            :          * there's a match, create the pt_node & bdev accordingly.
     602                 :            :          */
     603   [ +  +  +  -  :       9792 :         TAILQ_FOREACH(name, &g_bdev_names, link) {
             +  -  +  - ]
     604   [ +  +  +  +  :       3084 :                 if (strcmp(name->bdev_name, bdev_name) != 0) {
          +  +  +  -  +  
                      + ]
     605                 :       2679 :                         continue;
     606                 :            :                 }
     607                 :            : 
     608                 :        405 :                 SPDK_NOTICELOG("Match on %s\n", bdev_name);
     609                 :        405 :                 pt_node = calloc(1, sizeof(struct vbdev_passthru));
     610         [ +  + ]:        405 :                 if (!pt_node) {
     611                 :          0 :                         rc = -ENOMEM;
     612                 :          0 :                         SPDK_ERRLOG("could not allocate pt_node\n");
     613                 :          0 :                         break;
     614                 :            :                 }
     615                 :            : 
     616   [ +  +  +  -  :        405 :                 pt_node->pt_bdev.name = strdup(name->vbdev_name);
          +  -  +  -  +  
                -  +  - ]
     617   [ +  +  +  -  :        405 :                 if (!pt_node->pt_bdev.name) {
             +  -  +  - ]
     618                 :          0 :                         rc = -ENOMEM;
     619                 :          0 :                         SPDK_ERRLOG("could not allocate pt_bdev name\n");
     620                 :          0 :                         free(pt_node);
     621                 :          0 :                         break;
     622                 :            :                 }
     623   [ +  -  +  -  :        405 :                 pt_node->pt_bdev.product_name = "passthru";
                   +  - ]
     624                 :            : 
     625                 :            :                 /* The base bdev that we're attaching to. */
     626                 :        425 :                 rc = spdk_bdev_open_ext(bdev_name, true, vbdev_passthru_base_bdev_event_cb,
     627         [ +  - ]:         22 :                                         NULL, &pt_node->base_desc);
     628         [ +  + ]:        405 :                 if (rc) {
     629         [ +  + ]:         44 :                         if (rc != -ENODEV) {
     630                 :          0 :                                 SPDK_ERRLOG("could not open bdev %s\n", bdev_name);
     631                 :          0 :                         }
     632   [ #  #  #  #  :         44 :                         free(pt_node->pt_bdev.name);
                   #  # ]
     633                 :         44 :                         free(pt_node);
     634                 :         44 :                         break;
     635                 :            :                 }
     636                 :        361 :                 SPDK_NOTICELOG("base bdev opened\n");
     637                 :            : 
     638   [ +  -  +  - ]:        361 :                 bdev = spdk_bdev_desc_get_bdev(pt_node->base_desc);
     639   [ +  -  +  - ]:        361 :                 pt_node->base_bdev = bdev;
     640                 :            : 
     641   [ +  +  +  - ]:        361 :                 if (!spdk_uuid_is_null(&name->uuid)) {
     642                 :            :                         /* Use the configured UUID */
     643   [ #  #  #  #  :        158 :                         spdk_uuid_copy(&pt_node->pt_bdev.uuid, &name->uuid);
                   #  # ]
     644                 :          8 :                 } else {
     645                 :            :                         /* Generate UUID based on namespace UUID + base bdev UUID. */
     646   [ +  -  +  - ]:        209 :                         rc = spdk_uuid_generate_sha1(&pt_node->pt_bdev.uuid, &ns_uuid,
     647   [ +  -  +  -  :        203 :                                                      (const char *)&pt_node->base_bdev->uuid, sizeof(struct spdk_uuid));
                   +  - ]
     648         [ +  + ]:        203 :                         if (rc) {
     649                 :          0 :                                 SPDK_ERRLOG("Unable to generate new UUID for passthru bdev\n");
     650   [ #  #  #  # ]:          0 :                                 spdk_bdev_close(pt_node->base_desc);
     651   [ #  #  #  #  :          0 :                                 free(pt_node->pt_bdev.name);
                   #  # ]
     652                 :          0 :                                 free(pt_node);
     653                 :          0 :                                 break;
     654                 :            :                         }
     655                 :            :                 }
     656                 :            : 
     657                 :            :                 /* Copy some properties from the underlying base bdev. */
     658   [ +  -  +  -  :        361 :                 pt_node->pt_bdev.write_cache = bdev->write_cache;
          +  -  +  -  +  
                      - ]
     659   [ +  -  +  -  :        361 :                 pt_node->pt_bdev.required_alignment = bdev->required_alignment;
          +  -  +  -  +  
                      - ]
     660   [ +  -  +  -  :        361 :                 pt_node->pt_bdev.optimal_io_boundary = bdev->optimal_io_boundary;
          +  -  +  -  +  
                      - ]
     661   [ +  -  +  -  :        361 :                 pt_node->pt_bdev.blocklen = bdev->blocklen;
          +  -  +  -  +  
                      - ]
     662   [ +  -  +  -  :        361 :                 pt_node->pt_bdev.blockcnt = bdev->blockcnt;
          +  -  +  -  +  
                      - ]
     663                 :            : 
     664   [ +  +  +  -  :        361 :                 pt_node->pt_bdev.md_interleave = bdev->md_interleave;
          +  -  +  -  +  
                -  +  - ]
     665   [ +  -  +  -  :        361 :                 pt_node->pt_bdev.md_len = bdev->md_len;
          +  -  +  -  +  
                      - ]
     666   [ +  -  +  -  :        361 :                 pt_node->pt_bdev.dif_type = bdev->dif_type;
          +  -  +  -  +  
                      - ]
     667   [ +  +  +  -  :        361 :                 pt_node->pt_bdev.dif_is_head_of_md = bdev->dif_is_head_of_md;
          +  -  +  -  +  
                -  +  - ]
     668   [ +  -  +  -  :        361 :                 pt_node->pt_bdev.dif_check_flags = bdev->dif_check_flags;
          +  -  +  -  +  
                      - ]
     669   [ +  -  +  -  :        361 :                 pt_node->pt_bdev.dif_pi_format = bdev->dif_pi_format;
          +  -  +  -  +  
                      - ]
     670                 :            : 
     671                 :            :                 /* This is the context that is passed to us when the bdev
     672                 :            :                  * layer calls in so we'll save our pt_bdev node here.
     673                 :            :                  */
     674   [ +  -  +  -  :        361 :                 pt_node->pt_bdev.ctxt = pt_node;
                   +  - ]
     675   [ +  -  +  -  :        361 :                 pt_node->pt_bdev.fn_table = &vbdev_passthru_fn_table;
                   +  - ]
     676   [ +  -  +  -  :        361 :                 pt_node->pt_bdev.module = &passthru_if;
                   +  - ]
     677   [ +  -  +  -  :        361 :                 TAILQ_INSERT_TAIL(&g_pt_nodes, pt_node, link);
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
             -  +  -  +  
                      - ]
     678                 :            : 
     679                 :        375 :                 spdk_io_device_register(pt_node, pt_bdev_ch_create_cb, pt_bdev_ch_destroy_cb,
     680                 :            :                                         sizeof(struct pt_io_channel),
     681   [ +  -  +  - ]:        361 :                                         name->vbdev_name);
     682                 :        361 :                 SPDK_NOTICELOG("io_device created at: 0x%p\n", pt_node);
     683                 :            : 
     684                 :            :                 /* Save the thread where the base device is opened */
     685   [ +  -  +  - ]:        361 :                 pt_node->thread = spdk_get_thread();
     686                 :            : 
     687   [ +  -  +  -  :        361 :                 rc = spdk_bdev_module_claim_bdev(bdev, pt_node->base_desc, pt_node->pt_bdev.module);
          +  -  +  -  +  
                      - ]
     688         [ +  + ]:        361 :                 if (rc) {
     689                 :          0 :                         SPDK_ERRLOG("could not claim bdev %s\n", bdev_name);
     690   [ #  #  #  # ]:          0 :                         spdk_bdev_close(pt_node->base_desc);
     691   [ #  #  #  #  :          0 :                         TAILQ_REMOVE(&g_pt_nodes, pt_node, link);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
     692                 :          0 :                         spdk_io_device_unregister(pt_node, NULL);
     693   [ #  #  #  #  :          0 :                         free(pt_node->pt_bdev.name);
                   #  # ]
     694                 :          0 :                         free(pt_node);
     695                 :          0 :                         break;
     696                 :            :                 }
     697                 :        361 :                 SPDK_NOTICELOG("bdev claimed\n");
     698                 :            : 
     699         [ +  - ]:        361 :                 rc = spdk_bdev_register(&pt_node->pt_bdev);
     700         [ +  + ]:        361 :                 if (rc) {
     701                 :          0 :                         SPDK_ERRLOG("could not register pt_bdev\n");
     702         [ #  # ]:          0 :                         spdk_bdev_module_release_bdev(&pt_node->pt_bdev);
     703   [ #  #  #  # ]:          0 :                         spdk_bdev_close(pt_node->base_desc);
     704   [ #  #  #  #  :          0 :                         TAILQ_REMOVE(&g_pt_nodes, pt_node, link);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
     705                 :          0 :                         spdk_io_device_unregister(pt_node, NULL);
     706   [ #  #  #  #  :          0 :                         free(pt_node->pt_bdev.name);
                   #  # ]
     707                 :          0 :                         free(pt_node);
     708                 :          0 :                         break;
     709                 :            :                 }
     710                 :        361 :                 SPDK_NOTICELOG("pt_bdev registered\n");
     711   [ +  -  +  - ]:        361 :                 SPDK_NOTICELOG("created pt_bdev for: %s\n", name->vbdev_name);
     712                 :         14 :         }
     713                 :            : 
     714                 :       6752 :         return rc;
     715                 :            : }
     716                 :            : 
     717                 :            : /* Create the passthru disk from the given bdev and vbdev name. */
     718                 :            : int
     719                 :        361 : bdev_passthru_create_disk(const char *bdev_name, const char *vbdev_name,
     720                 :            :                           const struct spdk_uuid *uuid)
     721                 :            : {
     722                 :            :         int rc;
     723                 :            : 
     724                 :            :         /* Insert the bdev name into our global name list even if it doesn't exist yet,
     725                 :            :          * it may show up soon...
     726                 :            :          */
     727                 :        361 :         rc = vbdev_passthru_insert_name(bdev_name, vbdev_name, uuid);
     728         [ -  + ]:        361 :         if (rc) {
     729                 :          0 :                 return rc;
     730                 :            :         }
     731                 :            : 
     732                 :        361 :         rc = vbdev_passthru_register(bdev_name);
     733         [ +  + ]:        361 :         if (rc == -ENODEV) {
     734                 :            :                 /* This is not an error, we tracked the name above and it still
     735                 :            :                  * may show up later.
     736                 :            :                  */
     737                 :         44 :                 SPDK_NOTICELOG("vbdev creation deferred pending base bdev arrival\n");
     738                 :         44 :                 rc = 0;
     739                 :          8 :         }
     740                 :            : 
     741                 :        361 :         return rc;
     742                 :         14 : }
     743                 :            : 
     744                 :            : void
     745                 :        165 : bdev_passthru_delete_disk(const char *bdev_name, spdk_bdev_unregister_cb cb_fn, void *cb_arg)
     746                 :            : {
     747                 :            :         struct bdev_names *name;
     748                 :            :         int rc;
     749                 :            : 
     750                 :            :         /* Some cleanup happens in the destruct callback. */
     751                 :        165 :         rc = spdk_bdev_unregister_by_name(bdev_name, &passthru_if, cb_fn, cb_arg);
     752         [ +  + ]:        165 :         if (rc == 0) {
     753                 :            :                 /* Remove the association (vbdev, bdev) from g_bdev_names. This is required so that the
     754                 :            :                  * vbdev does not get re-created if the same bdev is constructed at some other time,
     755                 :            :                  * unless the underlying bdev was hot-removed.
     756                 :            :                  */
     757   [ +  +  #  #  :        254 :                 TAILQ_FOREACH(name, &g_bdev_names, link) {
             #  #  #  # ]
     758   [ +  +  +  +  :        254 :                         if (strcmp(name->vbdev_name, bdev_name) == 0) {
          +  +  +  -  -  
                      + ]
     759   [ +  +  +  -  :        165 :                                 TAILQ_REMOVE(&g_bdev_names, name, link);
          +  -  -  +  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  -  +  -  
          +  -  +  -  +  
          +  -  +  -  +  
          -  +  -  +  -  
             +  -  +  - ]
     760   [ +  -  +  - ]:        165 :                                 free(name->bdev_name);
     761   [ +  -  +  - ]:        165 :                                 free(name->vbdev_name);
     762                 :        165 :                                 free(name);
     763                 :        165 :                                 break;
     764                 :            :                         }
     765                 :          0 :                 }
     766                 :          5 :         } else {
     767   [ #  #  #  # ]:          0 :                 cb_fn(cb_arg, rc);
     768                 :            :         }
     769                 :        165 : }
     770                 :            : 
     771                 :            : /* Because we specified this function in our pt bdev function table when we
     772                 :            :  * registered our pt bdev, we'll get this call anytime a new bdev shows up.
     773                 :            :  * Here we need to decide if we care about it and if so what to do. We
     774                 :            :  * parsed the config file at init so we check the new bdev against the list
     775                 :            :  * we built up at that time and if the user configured us to attach to this
     776                 :            :  * bdev, here's where we do it.
     777                 :            :  */
     778                 :            : static void
     779                 :       6391 : vbdev_passthru_examine(struct spdk_bdev *bdev)
     780                 :            : {
     781   [ +  -  +  - ]:       6391 :         vbdev_passthru_register(bdev->name);
     782                 :            : 
     783                 :       6391 :         spdk_bdev_module_examine_done(&passthru_if);
     784                 :       6391 : }
     785                 :            : 
     786                 :       2315 : SPDK_LOG_REGISTER_COMPONENT(vbdev_passthru)

Generated by: LCOV version 1.15