LCOV - code coverage report
Current view: top level - lib/blob - request.c (source / functions) Hit Total Coverage
Test: ut_cov_unit.info Lines: 254 280 90.7 %
Date: 2024-07-12 09:11:09 Functions: 27 29 93.1 %

          Line data    Source code
       1             : /*   SPDX-License-Identifier: BSD-3-Clause
       2             :  *   Copyright (C) 2017 Intel Corporation.
       3             :  *   All rights reserved.
       4             :  *   Copyright (c) 2022-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
       5             :  */
       6             : 
       7             : #include "spdk/stdinc.h"
       8             : 
       9             : #include "blobstore.h"
      10             : #include "request.h"
      11             : 
      12             : #include "spdk/thread.h"
      13             : #include "spdk/queue.h"
      14             : #include "spdk/trace.h"
      15             : 
      16             : #include "spdk_internal/trace_defs.h"
      17             : #include "spdk/log.h"
      18             : 
      19             : void
      20       56230 : bs_call_cpl(struct spdk_bs_cpl *cpl, int bserrno)
      21             : {
      22       56230 :         switch (cpl->type) {
      23         698 :         case SPDK_BS_CPL_TYPE_BS_BASIC:
      24         698 :                 cpl->u.bs_basic.cb_fn(cpl->u.bs_basic.cb_arg,
      25             :                                       bserrno);
      26         698 :                 break;
      27         776 :         case SPDK_BS_CPL_TYPE_BS_HANDLE:
      28         776 :                 cpl->u.bs_handle.cb_fn(cpl->u.bs_handle.cb_arg,
      29             :                                        bserrno == 0 ? cpl->u.bs_handle.bs : NULL,
      30             :                                        bserrno);
      31         776 :                 break;
      32       48636 :         case SPDK_BS_CPL_TYPE_BLOB_BASIC:
      33       48636 :                 cpl->u.blob_basic.cb_fn(cpl->u.blob_basic.cb_arg,
      34             :                                         bserrno);
      35       48636 :                 break;
      36        1874 :         case SPDK_BS_CPL_TYPE_BLOBID:
      37        1874 :                 cpl->u.blobid.cb_fn(cpl->u.blobid.cb_arg,
      38             :                                     bserrno == 0 ? cpl->u.blobid.blobid : SPDK_BLOBID_INVALID,
      39             :                                     bserrno);
      40        1874 :                 break;
      41        3466 :         case SPDK_BS_CPL_TYPE_BLOB_HANDLE:
      42        3466 :                 cpl->u.blob_handle.cb_fn(cpl->u.blob_handle.cb_arg,
      43             :                                          bserrno == 0 ? cpl->u.blob_handle.blob : NULL,
      44             :                                          bserrno);
      45        3466 :                 break;
      46           0 :         case SPDK_BS_CPL_TYPE_NESTED_SEQUENCE:
      47           0 :                 cpl->u.nested_seq.cb_fn(cpl->u.nested_seq.cb_arg,
      48             :                                         cpl->u.nested_seq.parent,
      49             :                                         bserrno);
      50           0 :                 break;
      51         780 :         case SPDK_BS_CPL_TYPE_NONE:
      52             :                 /* this completion's callback is handled elsewhere */
      53         780 :                 break;
      54             :         }
      55       56230 : }
      56             : 
      57             : static void
      58       55450 : bs_request_set_complete(struct spdk_bs_request_set *set)
      59             : {
      60       55450 :         struct spdk_bs_cpl cpl = set->cpl;
      61       55450 :         int bserrno = set->bserrno;
      62             : 
      63       55450 :         spdk_trace_record(TRACE_BLOB_PROCESS_COMPLETE, 0, 0, (uintptr_t)&set->cb_args,
      64             :                           (uintptr_t)set->cpl.u.blob_basic.cb_arg);
      65             : 
      66       55450 :         TAILQ_INSERT_TAIL(&set->channel->reqs, set, link);
      67             : 
      68       55450 :         bs_call_cpl(&cpl, bserrno);
      69       55450 : }
      70             : 
      71             : static void
      72       24362 : bs_sequence_completion(struct spdk_io_channel *channel, void *cb_arg, int bserrno)
      73             : {
      74       24362 :         struct spdk_bs_request_set *set = cb_arg;
      75             : 
      76       24362 :         set->bserrno = bserrno;
      77       24362 :         set->u.sequence.cb_fn((spdk_bs_sequence_t *)set, set->u.sequence.cb_arg, bserrno);
      78       24362 : }
      79             : 
      80             : static inline spdk_bs_sequence_t *
      81       17960 : bs_sequence_start(struct spdk_io_channel *_channel, struct spdk_bs_cpl *cpl,
      82             :                   struct spdk_io_channel *back_channel)
      83             : {
      84             :         struct spdk_bs_channel          *channel;
      85             :         struct spdk_bs_request_set      *set;
      86             : 
      87       17960 :         channel = spdk_io_channel_get_ctx(_channel);
      88       17960 :         assert(channel != NULL);
      89       17960 :         set = TAILQ_FIRST(&channel->reqs);
      90       17960 :         if (!set) {
      91           0 :                 return NULL;
      92             :         }
      93       17960 :         TAILQ_REMOVE(&channel->reqs, set, link);
      94             : 
      95       17960 :         spdk_trace_record(TRACE_BLOB_PROCESS_START, 0, 0, (uintptr_t)&set->cb_args,
      96             :                           (uintptr_t)cpl->u.blob_basic.cb_arg);
      97             : 
      98       17960 :         set->cpl = *cpl;
      99       17960 :         set->bserrno = 0;
     100       17960 :         set->channel = channel;
     101       17960 :         set->back_channel = back_channel;
     102             : 
     103       17960 :         set->cb_args.cb_fn = bs_sequence_completion;
     104       17960 :         set->cb_args.cb_arg = set;
     105       17960 :         set->cb_args.channel = channel->dev_channel;
     106       17960 :         set->ext_io_opts = NULL;
     107             : 
     108       17960 :         return (spdk_bs_sequence_t *)set;
     109             : }
     110             : 
     111             : /* Use when performing IO directly on the blobstore (e.g. metadata - not a blob). */
     112             : spdk_bs_sequence_t *
     113       14610 : bs_sequence_start_bs(struct spdk_io_channel *_channel, struct spdk_bs_cpl *cpl)
     114             : {
     115       14610 :         return bs_sequence_start(_channel, cpl, _channel);
     116             : }
     117             : 
     118             : /* Use when performing IO on a blob. */
     119             : spdk_bs_sequence_t *
     120        3350 : bs_sequence_start_blob(struct spdk_io_channel *_channel, struct spdk_bs_cpl *cpl,
     121             :                        struct spdk_blob *blob)
     122             : {
     123        3350 :         struct spdk_io_channel  *esnap_ch = _channel;
     124             : 
     125        3350 :         if (spdk_blob_is_esnap_clone(blob)) {
     126        1500 :                 esnap_ch = blob_esnap_get_io_channel(_channel, blob);
     127        1500 :                 if (esnap_ch == NULL) {
     128             :                         /*
     129             :                          * The most likely reason we are here is because of some logic error
     130             :                          * elsewhere that caused channel allocations to fail. We could get here due
     131             :                          * to being out of memory as well. If we are out of memory, the process is
     132             :                          * this will be just one of many problems that this process will be having.
     133             :                          * Killing it off debug builds now due to logic errors is the right thing to
     134             :                          * do and killing it off due to ENOMEM is no big loss.
     135             :                          */
     136           0 :                         assert(false);
     137             :                         return NULL;
     138             :                 }
     139             :         }
     140        3350 :         return bs_sequence_start(_channel, cpl, esnap_ch);
     141             : }
     142             : 
     143             : void
     144         280 : bs_sequence_read_bs_dev(spdk_bs_sequence_t *seq, struct spdk_bs_dev *bs_dev,
     145             :                         void *payload, uint64_t lba, uint32_t lba_count,
     146             :                         spdk_bs_sequence_cpl cb_fn, void *cb_arg)
     147             : {
     148         280 :         struct spdk_bs_request_set      *set = (struct spdk_bs_request_set *)seq;
     149         280 :         struct spdk_io_channel          *back_channel = set->back_channel;
     150             : 
     151         280 :         SPDK_DEBUGLOG(blob_rw, "Reading %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,
     152             :                       lba);
     153             : 
     154         280 :         set->u.sequence.cb_fn = cb_fn;
     155         280 :         set->u.sequence.cb_arg = cb_arg;
     156             : 
     157         280 :         bs_dev->read(bs_dev, back_channel, payload, lba, lba_count, &set->cb_args);
     158         280 : }
     159             : 
     160             : void
     161       13054 : bs_sequence_read_dev(spdk_bs_sequence_t *seq, void *payload,
     162             :                      uint64_t lba, uint32_t lba_count,
     163             :                      spdk_bs_sequence_cpl cb_fn, void *cb_arg)
     164             : {
     165       13054 :         struct spdk_bs_request_set      *set = (struct spdk_bs_request_set *)seq;
     166       13054 :         struct spdk_bs_channel       *channel = set->channel;
     167             : 
     168       13054 :         SPDK_DEBUGLOG(blob_rw, "Reading %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,
     169             :                       lba);
     170             : 
     171       13054 :         set->u.sequence.cb_fn = cb_fn;
     172       13054 :         set->u.sequence.cb_arg = cb_arg;
     173             : 
     174       13054 :         channel->dev->read(channel->dev, channel->dev_channel, payload, lba, lba_count, &set->cb_args);
     175       13054 : }
     176             : 
     177             : void
     178        8536 : bs_sequence_write_dev(spdk_bs_sequence_t *seq, void *payload,
     179             :                       uint64_t lba, uint32_t lba_count,
     180             :                       spdk_bs_sequence_cpl cb_fn, void *cb_arg)
     181             : {
     182        8536 :         struct spdk_bs_request_set      *set = (struct spdk_bs_request_set *)seq;
     183        8536 :         struct spdk_bs_channel       *channel = set->channel;
     184             : 
     185        8536 :         SPDK_DEBUGLOG(blob_rw, "Writing %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,
     186             :                       lba);
     187             : 
     188        8536 :         set->u.sequence.cb_fn = cb_fn;
     189        8536 :         set->u.sequence.cb_arg = cb_arg;
     190             : 
     191        8536 :         channel->dev->write(channel->dev, channel->dev_channel, payload, lba, lba_count,
     192             :                             &set->cb_args);
     193        8536 : }
     194             : 
     195             : void
     196        1544 : bs_sequence_readv_bs_dev(spdk_bs_sequence_t *seq, struct spdk_bs_dev *bs_dev,
     197             :                          struct iovec *iov, int iovcnt, uint64_t lba, uint32_t lba_count,
     198             :                          spdk_bs_sequence_cpl cb_fn, void *cb_arg)
     199             : {
     200        1544 :         struct spdk_bs_request_set      *set = (struct spdk_bs_request_set *)seq;
     201        1544 :         struct spdk_io_channel          *back_channel = set->back_channel;
     202             : 
     203        1544 :         SPDK_DEBUGLOG(blob_rw, "Reading %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,
     204             :                       lba);
     205             : 
     206        1544 :         set->u.sequence.cb_fn = cb_fn;
     207        1544 :         set->u.sequence.cb_arg = cb_arg;
     208             : 
     209        1544 :         if (set->ext_io_opts) {
     210          72 :                 assert(bs_dev->readv_ext);
     211          72 :                 bs_dev->readv_ext(bs_dev, back_channel, iov, iovcnt, lba, lba_count,
     212             :                                   &set->cb_args, set->ext_io_opts);
     213             :         } else {
     214        1472 :                 bs_dev->readv(bs_dev, back_channel, iov, iovcnt, lba, lba_count, &set->cb_args);
     215             :         }
     216        1544 : }
     217             : 
     218             : void
     219         540 : bs_sequence_readv_dev(spdk_bs_sequence_t *seq, struct iovec *iov, int iovcnt,
     220             :                       uint64_t lba, uint32_t lba_count, spdk_bs_sequence_cpl cb_fn, void *cb_arg)
     221             : {
     222         540 :         struct spdk_bs_request_set      *set = (struct spdk_bs_request_set *)seq;
     223         540 :         struct spdk_bs_channel       *channel = set->channel;
     224             : 
     225         540 :         SPDK_DEBUGLOG(blob_rw, "Reading %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,
     226             :                       lba);
     227             : 
     228         540 :         set->u.sequence.cb_fn = cb_fn;
     229         540 :         set->u.sequence.cb_arg = cb_arg;
     230         540 :         if (set->ext_io_opts) {
     231         216 :                 assert(channel->dev->readv_ext);
     232         216 :                 channel->dev->readv_ext(channel->dev, channel->dev_channel, iov, iovcnt, lba, lba_count,
     233             :                                         &set->cb_args, set->ext_io_opts);
     234             :         } else {
     235         324 :                 channel->dev->readv(channel->dev, channel->dev_channel, iov, iovcnt, lba, lba_count, &set->cb_args);
     236             :         }
     237         540 : }
     238             : 
     239             : void
     240         276 : bs_sequence_writev_dev(spdk_bs_sequence_t *seq, struct iovec *iov, int iovcnt,
     241             :                        uint64_t lba, uint32_t lba_count,
     242             :                        spdk_bs_sequence_cpl cb_fn, void *cb_arg)
     243             : {
     244         276 :         struct spdk_bs_request_set      *set = (struct spdk_bs_request_set *)seq;
     245         276 :         struct spdk_bs_channel       *channel = set->channel;
     246             : 
     247         276 :         SPDK_DEBUGLOG(blob_rw, "Writing %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,
     248             :                       lba);
     249             : 
     250         276 :         set->u.sequence.cb_fn = cb_fn;
     251         276 :         set->u.sequence.cb_arg = cb_arg;
     252             : 
     253         276 :         if (set->ext_io_opts) {
     254          72 :                 assert(channel->dev->writev_ext);
     255          72 :                 channel->dev->writev_ext(channel->dev, channel->dev_channel, iov, iovcnt, lba, lba_count,
     256             :                                          &set->cb_args, set->ext_io_opts);
     257             :         } else {
     258         204 :                 channel->dev->writev(channel->dev, channel->dev_channel, iov, iovcnt, lba, lba_count,
     259             :                                      &set->cb_args);
     260             :         }
     261         276 : }
     262             : 
     263             : void
     264           4 : bs_sequence_write_zeroes_dev(spdk_bs_sequence_t *seq,
     265             :                              uint64_t lba, uint64_t lba_count,
     266             :                              spdk_bs_sequence_cpl cb_fn, void *cb_arg)
     267             : {
     268           4 :         struct spdk_bs_request_set      *set = (struct spdk_bs_request_set *)seq;
     269           4 :         struct spdk_bs_channel       *channel = set->channel;
     270             : 
     271           4 :         SPDK_DEBUGLOG(blob_rw, "writing zeroes to %" PRIu64 " blocks at LBA %" PRIu64 "\n",
     272             :                       lba_count, lba);
     273             : 
     274           4 :         set->u.sequence.cb_fn = cb_fn;
     275           4 :         set->u.sequence.cb_arg = cb_arg;
     276             : 
     277           4 :         channel->dev->write_zeroes(channel->dev, channel->dev_channel, lba, lba_count,
     278             :                                    &set->cb_args);
     279           4 : }
     280             : 
     281             : void
     282         128 : bs_sequence_copy_dev(spdk_bs_sequence_t *seq, uint64_t dst_lba, uint64_t src_lba,
     283             :                      uint64_t lba_count, spdk_bs_sequence_cpl cb_fn, void *cb_arg)
     284             : {
     285         128 :         struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq;
     286         128 :         struct spdk_bs_channel     *channel = set->channel;
     287             : 
     288         128 :         SPDK_DEBUGLOG(blob_rw, "Copying %" PRIu64 " blocks from LBA %" PRIu64 " to LBA %" PRIu64 "\n",
     289             :                       lba_count, src_lba, dst_lba);
     290             : 
     291         128 :         set->u.sequence.cb_fn = cb_fn;
     292         128 :         set->u.sequence.cb_arg = cb_arg;
     293             : 
     294         128 :         channel->dev->copy(channel->dev, channel->dev_channel, dst_lba, src_lba, lba_count, &set->cb_args);
     295         128 : }
     296             : 
     297             : void
     298       17960 : bs_sequence_finish(spdk_bs_sequence_t *seq, int bserrno)
     299             : {
     300       17960 :         if (bserrno != 0) {
     301         168 :                 seq->bserrno = bserrno;
     302             :         }
     303       17960 :         bs_request_set_complete((struct spdk_bs_request_set *)seq);
     304       17960 : }
     305             : 
     306             : void
     307           0 : bs_user_op_sequence_finish(void *cb_arg, int bserrno)
     308             : {
     309           0 :         spdk_bs_sequence_t *seq = cb_arg;
     310             : 
     311           0 :         bs_sequence_finish(seq, bserrno);
     312           0 : }
     313             : 
     314             : static void
     315       41998 : bs_batch_completion(struct spdk_io_channel *_channel,
     316             :                     void *cb_arg, int bserrno)
     317             : {
     318       41998 :         struct spdk_bs_request_set      *set = cb_arg;
     319             : 
     320       41998 :         set->u.batch.outstanding_ops--;
     321       41998 :         if (bserrno != 0) {
     322           4 :                 set->bserrno = bserrno;
     323             :         }
     324             : 
     325       41998 :         if (set->u.batch.outstanding_ops == 0 && set->u.batch.batch_closed) {
     326       40480 :                 if (set->u.batch.cb_fn) {
     327        3926 :                         set->cb_args.cb_fn = bs_sequence_completion;
     328        3926 :                         set->u.batch.cb_fn((spdk_bs_sequence_t *)set, set->u.batch.cb_arg, bserrno);
     329             :                 } else {
     330       36554 :                         bs_request_set_complete(set);
     331             :                 }
     332             :         }
     333       41998 : }
     334             : 
     335             : spdk_bs_batch_t *
     336       37490 : bs_batch_open(struct spdk_io_channel *_channel, struct spdk_bs_cpl *cpl, struct spdk_blob *blob)
     337             : {
     338             :         struct spdk_bs_channel          *channel;
     339             :         struct spdk_bs_request_set      *set;
     340       37490 :         struct spdk_io_channel          *back_channel = _channel;
     341             : 
     342       37490 :         if (spdk_blob_is_esnap_clone(blob)) {
     343        7340 :                 back_channel = blob_esnap_get_io_channel(_channel, blob);
     344        7340 :                 if (back_channel == NULL) {
     345           0 :                         return NULL;
     346             :                 }
     347             :         }
     348             : 
     349       37490 :         channel = spdk_io_channel_get_ctx(_channel);
     350       37490 :         assert(channel != NULL);
     351       37490 :         set = TAILQ_FIRST(&channel->reqs);
     352       37490 :         if (!set) {
     353           0 :                 return NULL;
     354             :         }
     355       37490 :         TAILQ_REMOVE(&channel->reqs, set, link);
     356             : 
     357       37490 :         set->cpl = *cpl;
     358       37490 :         set->bserrno = 0;
     359       37490 :         set->channel = channel;
     360       37490 :         set->back_channel = back_channel;
     361             : 
     362       37490 :         set->u.batch.cb_fn = NULL;
     363       37490 :         set->u.batch.cb_arg = NULL;
     364       37490 :         set->u.batch.outstanding_ops = 0;
     365       37490 :         set->u.batch.batch_closed = 0;
     366             : 
     367       37490 :         set->cb_args.cb_fn = bs_batch_completion;
     368       37490 :         set->cb_args.cb_arg = set;
     369       37490 :         set->cb_args.channel = channel->dev_channel;
     370             : 
     371       37490 :         return (spdk_bs_batch_t *)set;
     372             : }
     373             : 
     374             : void
     375        1088 : bs_batch_read_bs_dev(spdk_bs_batch_t *batch, struct spdk_bs_dev *bs_dev,
     376             :                      void *payload, uint64_t lba, uint32_t lba_count)
     377             : {
     378        1088 :         struct spdk_bs_request_set      *set = (struct spdk_bs_request_set *)batch;
     379        1088 :         struct spdk_io_channel          *back_channel = set->back_channel;
     380             : 
     381        1088 :         SPDK_DEBUGLOG(blob_rw, "Reading %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,
     382             :                       lba);
     383             : 
     384        1088 :         set->u.batch.outstanding_ops++;
     385        1088 :         bs_dev->read(bs_dev, back_channel, payload, lba, lba_count, &set->cb_args);
     386        1088 : }
     387             : 
     388             : void
     389       15851 : bs_batch_read_dev(spdk_bs_batch_t *batch, void *payload,
     390             :                   uint64_t lba, uint32_t lba_count)
     391             : {
     392       15851 :         struct spdk_bs_request_set      *set = (struct spdk_bs_request_set *)batch;
     393       15851 :         struct spdk_bs_channel          *channel = set->channel;
     394             : 
     395       15851 :         SPDK_DEBUGLOG(blob_rw, "Reading %" PRIu32 " blocks from LBA %" PRIu64 "\n", lba_count,
     396             :                       lba);
     397             : 
     398       15851 :         set->u.batch.outstanding_ops++;
     399       15851 :         channel->dev->read(channel->dev, channel->dev_channel, payload, lba, lba_count, &set->cb_args);
     400       15851 : }
     401             : 
     402             : void
     403       20563 : bs_batch_write_dev(spdk_bs_batch_t *batch, void *payload,
     404             :                    uint64_t lba, uint32_t lba_count)
     405             : {
     406       20563 :         struct spdk_bs_request_set      *set = (struct spdk_bs_request_set *)batch;
     407       20563 :         struct spdk_bs_channel          *channel = set->channel;
     408             : 
     409       20563 :         SPDK_DEBUGLOG(blob_rw, "Writing %" PRIu32 " blocks to LBA %" PRIu64 "\n", lba_count, lba);
     410             : 
     411       20563 :         set->u.batch.outstanding_ops++;
     412       20563 :         channel->dev->write(channel->dev, channel->dev_channel, payload, lba, lba_count,
     413             :                             &set->cb_args);
     414       20563 : }
     415             : 
     416             : void
     417        1810 : bs_batch_unmap_dev(spdk_bs_batch_t *batch,
     418             :                    uint64_t lba, uint64_t lba_count)
     419             : {
     420        1810 :         struct spdk_bs_request_set      *set = (struct spdk_bs_request_set *)batch;
     421        1810 :         struct spdk_bs_channel          *channel = set->channel;
     422             : 
     423        1810 :         SPDK_DEBUGLOG(blob_rw, "Unmapping %" PRIu64 " blocks at LBA %" PRIu64 "\n", lba_count,
     424             :                       lba);
     425             : 
     426        1810 :         set->u.batch.outstanding_ops++;
     427        1810 :         channel->dev->unmap(channel->dev, channel->dev_channel, lba, lba_count,
     428             :                             &set->cb_args);
     429        1810 : }
     430             : 
     431             : void
     432        2686 : bs_batch_write_zeroes_dev(spdk_bs_batch_t *batch,
     433             :                           uint64_t lba, uint64_t lba_count)
     434             : {
     435        2686 :         struct spdk_bs_request_set      *set = (struct spdk_bs_request_set *)batch;
     436        2686 :         struct spdk_bs_channel          *channel = set->channel;
     437             : 
     438        2686 :         SPDK_DEBUGLOG(blob_rw, "Zeroing %" PRIu64 " blocks at LBA %" PRIu64 "\n", lba_count, lba);
     439             : 
     440        2686 :         set->u.batch.outstanding_ops++;
     441        2686 :         channel->dev->write_zeroes(channel->dev, channel->dev_channel, lba, lba_count,
     442             :                                    &set->cb_args);
     443        2686 : }
     444             : 
     445             : void
     446       56734 : bs_batch_close(spdk_bs_batch_t *batch)
     447             : {
     448       56734 :         struct spdk_bs_request_set      *set = (struct spdk_bs_request_set *)batch;
     449             : 
     450       56734 :         set->u.batch.batch_closed = 1;
     451             : 
     452       56734 :         if (set->u.batch.outstanding_ops == 0) {
     453       16254 :                 if (set->u.batch.cb_fn) {
     454       15318 :                         set->cb_args.cb_fn = bs_sequence_completion;
     455       15318 :                         set->u.batch.cb_fn((spdk_bs_sequence_t *)set, set->u.batch.cb_arg, set->bserrno);
     456             :                 } else {
     457         936 :                         bs_request_set_complete(set);
     458             :                 }
     459             :         }
     460       56734 : }
     461             : 
     462             : spdk_bs_batch_t *
     463       19244 : bs_sequence_to_batch(spdk_bs_sequence_t *seq, spdk_bs_sequence_cpl cb_fn, void *cb_arg)
     464             : {
     465       19244 :         struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)seq;
     466             : 
     467       19244 :         set->u.batch.cb_fn = cb_fn;
     468       19244 :         set->u.batch.cb_arg = cb_arg;
     469       19244 :         set->u.batch.outstanding_ops = 0;
     470       19244 :         set->u.batch.batch_closed = 0;
     471             : 
     472       19244 :         set->cb_args.cb_fn = bs_batch_completion;
     473             : 
     474       19244 :         return set;
     475             : }
     476             : 
     477             : spdk_bs_user_op_t *
     478         816 : bs_user_op_alloc(struct spdk_io_channel *_channel, struct spdk_bs_cpl *cpl,
     479             :                  enum spdk_blob_op_type op_type, struct spdk_blob *blob,
     480             :                  void *payload, int iovcnt, uint64_t offset, uint64_t length)
     481             : {
     482             :         struct spdk_bs_channel          *channel;
     483             :         struct spdk_bs_request_set      *set;
     484             :         struct spdk_bs_user_op_args     *args;
     485             : 
     486         816 :         channel = spdk_io_channel_get_ctx(_channel);
     487         816 :         assert(channel != NULL);
     488         816 :         set = TAILQ_FIRST(&channel->reqs);
     489         816 :         if (!set) {
     490           0 :                 return NULL;
     491             :         }
     492         816 :         TAILQ_REMOVE(&channel->reqs, set, link);
     493             : 
     494         816 :         set->cpl = *cpl;
     495         816 :         set->channel = channel;
     496         816 :         set->back_channel = NULL;
     497         816 :         set->ext_io_opts = NULL;
     498             : 
     499         816 :         args = &set->u.user_op;
     500             : 
     501         816 :         args->type = op_type;
     502         816 :         args->iovcnt = iovcnt;
     503         816 :         args->blob = blob;
     504         816 :         args->offset = offset;
     505         816 :         args->length = length;
     506         816 :         args->payload = payload;
     507             : 
     508         816 :         return (spdk_bs_user_op_t *)set;
     509             : }
     510             : 
     511             : void
     512         816 : bs_user_op_execute(spdk_bs_user_op_t *op)
     513             : {
     514             :         struct spdk_bs_request_set      *set;
     515             :         struct spdk_bs_user_op_args     *args;
     516             :         struct spdk_io_channel          *ch;
     517             : 
     518         816 :         set = (struct spdk_bs_request_set *)op;
     519         816 :         args = &set->u.user_op;
     520         816 :         ch = spdk_io_channel_from_ctx(set->channel);
     521             : 
     522         816 :         switch (args->type) {
     523         452 :         case SPDK_BLOB_READ:
     524         452 :                 spdk_blob_io_read(args->blob, ch, args->payload, args->offset, args->length,
     525             :                                   set->cpl.u.blob_basic.cb_fn, set->cpl.u.blob_basic.cb_arg);
     526         452 :                 break;
     527         348 :         case SPDK_BLOB_WRITE:
     528         348 :                 spdk_blob_io_write(args->blob, ch, args->payload, args->offset, args->length,
     529             :                                    set->cpl.u.blob_basic.cb_fn, set->cpl.u.blob_basic.cb_arg);
     530         348 :                 break;
     531           0 :         case SPDK_BLOB_UNMAP:
     532           0 :                 spdk_blob_io_unmap(args->blob, ch, args->offset, args->length,
     533             :                                    set->cpl.u.blob_basic.cb_fn, set->cpl.u.blob_basic.cb_arg);
     534           0 :                 break;
     535           0 :         case SPDK_BLOB_WRITE_ZEROES:
     536           0 :                 spdk_blob_io_write_zeroes(args->blob, ch, args->offset, args->length,
     537             :                                           set->cpl.u.blob_basic.cb_fn, set->cpl.u.blob_basic.cb_arg);
     538           0 :                 break;
     539           0 :         case SPDK_BLOB_READV:
     540           0 :                 spdk_blob_io_readv_ext(args->blob, ch, args->payload, args->iovcnt,
     541             :                                        args->offset, args->length,
     542             :                                        set->cpl.u.blob_basic.cb_fn, set->cpl.u.blob_basic.cb_arg,
     543             :                                        set->ext_io_opts);
     544           0 :                 break;
     545          16 :         case SPDK_BLOB_WRITEV:
     546          16 :                 spdk_blob_io_writev_ext(args->blob, ch, args->payload, args->iovcnt,
     547             :                                         args->offset, args->length,
     548             :                                         set->cpl.u.blob_basic.cb_fn, set->cpl.u.blob_basic.cb_arg,
     549             :                                         set->ext_io_opts);
     550          16 :                 break;
     551             :         }
     552         816 :         TAILQ_INSERT_TAIL(&set->channel->reqs, set, link);
     553         816 : }
     554             : 
     555             : void
     556           0 : bs_user_op_abort(spdk_bs_user_op_t *op, int bserrno)
     557             : {
     558             :         struct spdk_bs_request_set      *set;
     559             : 
     560           0 :         set = (struct spdk_bs_request_set *)op;
     561             : 
     562           0 :         set->cpl.u.blob_basic.cb_fn(set->cpl.u.blob_basic.cb_arg, bserrno);
     563           0 :         TAILQ_INSERT_TAIL(&set->channel->reqs, set, link);
     564           0 : }
     565             : 
     566           3 : SPDK_LOG_REGISTER_COMPONENT(blob_rw)

Generated by: LCOV version 1.15