LCOV - code coverage report
Current view: top level - drivers - tapdisk-vbd.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 86 770 11.2 %
Date: 2025-07-10 10:47:11 Functions: 6 62 9.7 %
Branches: 21 442 4.8 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * Copyright (c) 2016, Citrix Systems, Inc.
       3                 :            :  *
       4                 :            :  * All rights reserved.
       5                 :            :  *
       6                 :            :  * Redistribution and use in source and binary forms, with or without
       7                 :            :  * modification, are permitted provided that the following conditions are met:
       8                 :            :  * 
       9                 :            :  *  1. Redistributions of source code must retain the above copyright
      10                 :            :  *     notice, this list of conditions and the following disclaimer.
      11                 :            :  *  2. Redistributions in binary form must reproduce the above copyright
      12                 :            :  *     notice, this list of conditions and the following disclaimer in the
      13                 :            :  *     documentation and/or other materials provided with the distribution.
      14                 :            :  *  3. Neither the name of the copyright holder nor the names of its 
      15                 :            :  *     contributors may be used to endorse or promote products derived from 
      16                 :            :  *     this software without specific prior written permission.
      17                 :            :  *
      18                 :            :  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
      19                 :            :  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
      20                 :            :  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
      21                 :            :  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
      22                 :            :  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
      23                 :            :  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
      24                 :            :  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
      25                 :            :  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
      26                 :            :  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
      27                 :            :  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
      28                 :            :  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      29                 :            :  */
      30                 :            : 
      31                 :            : #ifdef HAVE_CONFIG_H
      32                 :            : #include "config.h"
      33                 :            : #endif
      34                 :            : 
      35                 :            : #include <stdio.h>
      36                 :            : #include <errno.h>
      37                 :            : #include <fcntl.h>
      38                 :            : #include <regex.h>
      39                 :            : #include <unistd.h>
      40                 :            : #include <stdlib.h>
      41                 :            : #include <libgen.h>
      42                 :            : #include <sys/mman.h>
      43                 :            : #include <sys/ioctl.h>
      44                 :            : #include <sys/stat.h>
      45                 :            : #include <sys/types.h>
      46                 :            : 
      47                 :            : #include "debug.h"
      48                 :            : #include "libvhd.h"
      49                 :            : #include "tapdisk-blktap.h"
      50                 :            : #include "tapdisk-image.h"
      51                 :            : #include "tapdisk-driver.h"
      52                 :            : #include "tapdisk-server.h"
      53                 :            : #include "tapdisk-vbd.h"
      54                 :            : #include "tapdisk-metrics.h"
      55                 :            : #include "tapdisk-disktype.h"
      56                 :            : #include "tapdisk-interface.h"
      57                 :            : #include "tapdisk-stats.h"
      58                 :            : #include "tapdisk-storage.h"
      59                 :            : #include "tapdisk-nbdserver.h"
      60                 :            : #include "td-stats.h"
      61                 :            : #include "tapdisk-utils.h"
      62                 :            : 
      63                 :            : #define DBG(_level, _f, _a...) tlog_write(_level, _f, ##_a)
      64                 :            : #define ERR(_err, _f, _a...) tlog_error(_err, _f, ##_a)
      65                 :            : 
      66                 :            : #define INFO(_f, _a...)            tlog_syslog(TLOG_INFO, "vbd: " _f, ##_a)
      67                 :            : #define ERROR(_f, _a...)           tlog_syslog(TLOG_WARN, "vbd: " _f, ##_a)
      68                 :            : 
      69                 :            : #define TD_VBD_EIO_RETRIES          10
      70                 :            : #define TD_VBD_EIO_SLEEP            1
      71                 :            : #define TD_VBD_WATCHDOG_TIMEOUT     10
      72                 :            : 
      73                 :            : char* op_strings[TD_OPS_END] ={"read", "write", "block_status"};
      74                 :            : 
      75                 :            : static void tapdisk_vbd_complete_vbd_request(td_vbd_t *, td_vbd_request_t *);
      76                 :            : static int  tapdisk_vbd_queue_ready(td_vbd_t *);
      77                 :            : static void tapdisk_vbd_check_complete_requests(td_vbd_t *);
      78                 :            : static void tapdisk_vbd_check_requests_for_issue(td_vbd_t *);
      79                 :            : 
      80                 :            : static bool log=true;
      81                 :            : 
      82                 :            : /*
      83                 :            :  * initialization
      84                 :            :  */
      85                 :            : 
      86                 :            : static void
      87                 :            : tapdisk_vbd_mark_progress(td_vbd_t *vbd)
      88                 :            : {
      89                 :          2 :         gettimeofday(&vbd->ts, NULL);
      90                 :            : }
      91                 :            : 
      92                 :            : td_vbd_t*
      93                 :          0 : tapdisk_vbd_create(uint16_t uuid)
      94                 :            : {
      95                 :            :         td_vbd_t *vbd;
      96                 :            : 
      97                 :          0 :         vbd = calloc(1, sizeof(td_vbd_t));
      98         [ #  # ]:          0 :         if (!vbd) {
      99                 :            :                 EPRINTF("failed to allocate tapdisk state\n");
     100                 :          0 :                 return NULL;
     101                 :            :         }
     102                 :            : 
     103                 :          0 :         shm_init(&vbd->rrd.shm);
     104                 :            : 
     105                 :          0 :         vbd->uuid        = uuid;
     106                 :          0 :         vbd->req_timeout = TD_VBD_REQUEST_TIMEOUT;
     107                 :          0 :         vbd->watchdog_warned = false;
     108                 :            : 
     109                 :          0 :         INIT_LIST_HEAD(&vbd->images);
     110                 :          0 :         INIT_LIST_HEAD(&vbd->new_requests);
     111                 :          0 :         INIT_LIST_HEAD(&vbd->pending_requests);
     112                 :          0 :         INIT_LIST_HEAD(&vbd->failed_requests);
     113                 :          0 :         INIT_LIST_HEAD(&vbd->completed_requests);
     114                 :          0 :         INIT_LIST_HEAD(&vbd->next);
     115                 :          0 :         INIT_LIST_HEAD(&vbd->rings);
     116                 :          0 :         INIT_LIST_HEAD(&vbd->dead_rings);
     117                 :            :         tapdisk_vbd_mark_progress(vbd);
     118                 :            : 
     119                 :          0 :         return vbd;
     120                 :            : }
     121                 :            : 
     122                 :            : int
     123                 :          0 : tapdisk_vbd_initialize(int rfd, int wfd, uint16_t uuid)
     124                 :            : {
     125                 :            :         td_vbd_t *vbd;
     126                 :            : 
     127                 :          0 :         vbd = tapdisk_server_get_vbd(uuid);
     128         [ #  # ]:          0 :         if (vbd) {
     129                 :          0 :                 EPRINTF("duplicate vbds! %u\n", uuid);
     130                 :          0 :                 return -EEXIST;
     131                 :            :         }
     132                 :            : 
     133                 :          0 :         vbd = tapdisk_vbd_create(uuid);
     134         [ #  # ]:          0 :         if (!vbd) {
     135                 :            :                 EPRINTF("failed to create vbd\n");
     136                 :          0 :                 return -ENOMEM;
     137                 :            :         }
     138                 :            : 
     139                 :          0 :         tapdisk_server_add_vbd(vbd);
     140                 :            : 
     141                 :          0 :         return 0;
     142                 :            : }
     143                 :            : 
     144                 :            : static inline void
     145                 :            : tapdisk_vbd_add_image(td_vbd_t *vbd, td_image_t *image)
     146                 :            : {
     147                 :            :         list_add_tail(&image->next, &vbd->images);
     148                 :            : }
     149                 :            : 
     150                 :            : static inline int
     151                 :            : tapdisk_vbd_is_last_image(td_vbd_t *vbd, td_image_t *image)
     152                 :            : {
     153                 :          0 :         return list_is_last(&image->next, &vbd->images);
     154                 :            : }
     155                 :            : 
     156                 :            : static inline td_image_t *
     157                 :            : tapdisk_vbd_first_image(td_vbd_t *vbd)
     158                 :            : {
     159                 :          1 :         td_image_t *image = NULL;
     160 [ #  # ][ +  - ]:          1 :         if (!list_empty(&vbd->images))
         [ #  # ][ #  # ]
           [ #  #  #  # ]
         [ #  # ][ #  # ]
     161                 :          1 :                 image = list_entry(vbd->images.next, td_image_t, next);
     162                 :            :         return image;
     163                 :            : }
     164                 :            : 
     165                 :            : static inline td_image_t *
     166                 :            : tapdisk_vbd_last_image(td_vbd_t *vbd)
     167                 :            : {
     168                 :            :         td_image_t *image = NULL;
     169                 :            :         if (!list_empty(&vbd->images))
     170                 :            :                 image = list_entry(vbd->images.prev, td_image_t, next);
     171                 :            :         return image;
     172                 :            : }
     173                 :            : 
     174                 :            : static inline td_image_t *
     175                 :          0 : tapdisk_vbd_next_image(td_image_t *image)
     176                 :            : {
     177                 :          0 :         return list_entry(image->next.next, td_image_t, next);
     178                 :            : }
     179                 :            : 
     180                 :            : static int
     181                 :            : tapdisk_vbd_validate_chain(td_vbd_t *vbd)
     182                 :            : {
     183                 :          0 :         return tapdisk_image_validate_chain(&vbd->images);
     184                 :            : }
     185                 :            : 
     186                 :            : static int
     187                 :          0 : vbd_stats_destroy(td_vbd_t *vbd) {
     188                 :            : 
     189                 :          0 :     int err = 0;
     190                 :            : 
     191         [ #  # ]:          0 :     ASSERT(vbd);
     192                 :            : 
     193                 :          0 :     err = shm_destroy(&vbd->rrd.shm);
     194         [ #  # ]:          0 :     if (unlikely(err)) {
     195                 :          0 :         EPRINTF("failed to destroy RRD file: %s\n", strerror(err));
     196                 :            :         goto out;
     197                 :            :     }
     198                 :            : 
     199                 :          0 :     free(vbd->rrd.shm.path);
     200                 :          0 :     vbd->rrd.shm.path = NULL;
     201                 :            : 
     202                 :            : out:
     203                 :          0 :     return -err;
     204                 :            : }
     205                 :            : 
     206                 :            : static int
     207                 :          0 : vbd_stats_create(td_vbd_t *vbd) {
     208                 :            : 
     209                 :            :     int err;
     210                 :            : 
     211         [ #  # ]:          0 :     ASSERT(vbd);
     212                 :            : 
     213                 :          0 :         err = mkdir("/dev/shm/metrics", S_IRUSR | S_IWUSR);
     214         [ #  # ]:          0 :         if (likely(err)) {
     215                 :          0 :         err = errno;
     216         [ #  # ]:          0 :         if (unlikely(err != EEXIST))
     217                 :            :                 goto out;
     218                 :            :         else
     219                 :            :             err = 0;
     220                 :            :     }
     221                 :            : 
     222                 :            :     /*
     223                 :            :      * FIXME Rename this to something like "vbd3-domid-devid". Consider
     224                 :            :      * consolidating this with the io_ring shared memory file. Check if blkback
     225                 :            :      * exports the same information in some sysfs file and if so move this to
     226                 :            :      * the ring location.
     227                 :            :      */
     228                 :          0 :     err = asprintf(&vbd->rrd.shm.path, "/dev/shm/metrics/tap-%d-%d", getpid(),
     229                 :          0 :             vbd->uuid);
     230         [ #  # ]:          0 :     if (err == -1) {
     231                 :          0 :         err = errno;
     232                 :          0 :         vbd->rrd.shm.path = NULL;
     233                 :          0 :         EPRINTF("failed to create metric file: %s\n", strerror(err));
     234                 :            :         goto out;
     235                 :            :     }
     236                 :          0 :     err = 0;
     237                 :            : 
     238                 :          0 :     vbd->rrd.shm.size = PAGE_SIZE;
     239                 :          0 :     err = shm_create(&vbd->rrd.shm);
     240         [ #  # ]:          0 :     if (err)
     241                 :          0 :         EPRINTF("failed to create RRD: %s\n", strerror(err));
     242                 :            : 
     243                 :            : out:
     244         [ #  # ]:          0 :     if (err) {
     245                 :          0 :         int err2 = vbd_stats_destroy(vbd);
     246         [ #  # ]:          0 :         if (err2)
     247                 :          0 :             EPRINTF("failed to clean up failed RRD shared memory creation: "
     248                 :            :                     "%s (error ignored)\n", strerror(-err2));
     249                 :            :     }
     250                 :          0 :     return -err;
     251                 :            : }
     252                 :            : 
     253                 :            : void
     254                 :          0 : tapdisk_vbd_close_vdi(td_vbd_t *vbd)
     255                 :            : {
     256                 :            :     int err;
     257                 :            : 
     258                 :          0 :     err = vbd_stats_destroy(vbd);
     259         [ #  # ]:          0 :     if (err) {
     260                 :          0 :         EPRINTF("failed to destroy RRD stats file: %s (error ignored)\n",
     261                 :            :                 strerror(-err));
     262                 :            :     }
     263                 :            : 
     264                 :          0 :     err = td_metrics_vdi_stop(&vbd->vdi_stats);
     265         [ #  # ]:          0 :     if (err) {
     266                 :          0 :         EPRINTF("failed to destroy stats file: %s\n", strerror(-err));
     267                 :            :     }
     268                 :            : 
     269                 :          0 :         tapdisk_image_close_chain(&vbd->images);
     270                 :            : 
     271 [ #  # ][ #  # ]:          0 :         if (vbd->secondary &&
     272                 :          0 :             vbd->secondary_mode != TD_VBD_SECONDARY_MIRROR) {
     273                 :          0 :                 tapdisk_image_close(vbd->secondary);
     274                 :          0 :                 vbd->secondary = NULL;
     275                 :            :         }
     276                 :            : 
     277         [ #  # ]:          0 :         if (vbd->retired) {
     278                 :          0 :                 tapdisk_image_close(vbd->retired);
     279                 :          0 :                 vbd->retired = NULL;
     280                 :            :         }
     281                 :            : 
     282                 :          0 :         td_flag_set(vbd->state, TD_VBD_CLOSED);
     283                 :          0 : }
     284                 :            : 
     285                 :            : static int
     286                 :          0 : tapdisk_vbd_add_block_cache(td_vbd_t *vbd)
     287                 :            : {
     288                 :            :         td_image_t *cache, *image, *target, *tmp;
     289                 :            :         int err;
     290                 :            : 
     291                 :          0 :         target = NULL;
     292                 :            : 
     293         [ #  # ]:          0 :         tapdisk_vbd_for_each_image(vbd, image, tmp)
     294         [ #  # ]:          0 :                 if (td_flag_test(image->flags, TD_OPEN_RDONLY) &&
     295                 :            :                     td_flag_test(image->flags, TD_OPEN_SHAREABLE)) {
     296                 :            :                         target = image;
     297                 :            :                         break;
     298                 :            :                 }
     299                 :            : 
     300         [ #  # ]:          0 :         if (!target)
     301                 :            :                 return 0;
     302                 :            : 
     303                 :          0 :         cache = tapdisk_image_allocate(target->name,
     304                 :            :                                        DISK_TYPE_BLOCK_CACHE,
     305                 :            :                                        target->flags);
     306         [ #  # ]:          0 :         if (!cache)
     307                 :            :                 return -ENOMEM;
     308                 :            : 
     309                 :            :         /* try to load existing cache */
     310                 :          0 :         err = td_load(cache);
     311         [ #  # ]:          0 :         if (!err)
     312                 :            :                 goto done;
     313                 :            : 
     314                 :            :         /* hack driver to send open() correct image size */
     315         [ #  # ]:          0 :         if (!target->driver) {
     316                 :            :                 err = -ENODEV;
     317                 :            :                 goto fail;
     318                 :            :         }
     319                 :            : 
     320                 :          0 :         cache->driver = tapdisk_driver_allocate(cache->type,
     321                 :          0 :                                                 cache->name,
     322                 :            :                                                 cache->flags);
     323         [ #  # ]:          0 :         if (!cache->driver) {
     324                 :            :                 err = -ENOMEM;
     325                 :            :                 goto fail;
     326                 :            :         }
     327                 :            : 
     328                 :          0 :         cache->driver->info = target->driver->info;
     329                 :            : 
     330                 :            :         /* try to open new cache */
     331                 :          0 :         err = td_open(cache, &vbd->encryption);
     332         [ #  # ]:          0 :         if (!err)
     333                 :            :                 goto done;
     334                 :            : 
     335                 :            : fail:
     336                 :            :         /* give up */
     337                 :          0 :         tapdisk_image_free(target);
     338                 :          0 :         tapdisk_image_free(cache);
     339                 :          0 :         return err;
     340                 :            : 
     341                 :            : done:
     342                 :            :         /* insert cache before image */
     343                 :          0 :         list_add(&cache->next, target->next.prev);
     344                 :          0 :         return 0;
     345                 :            : }
     346                 :            : 
     347                 :            : static int
     348                 :          0 : tapdisk_vbd_add_local_cache(td_vbd_t *vbd)
     349                 :            : {
     350                 :            :         td_image_t *cache, *parent;
     351                 :            :         int err;
     352                 :            : 
     353                 :          0 :         parent = tapdisk_vbd_first_image(vbd);
     354         [ #  # ]:          0 :         if (tapdisk_vbd_is_last_image(vbd, parent)) {
     355                 :            :                 DPRINTF("Single-image chain, nothing to cache");
     356                 :          0 :                 return 0;
     357                 :            :         }
     358                 :            : 
     359                 :          0 :         cache = tapdisk_image_allocate(parent->name,
     360                 :            :                                        DISK_TYPE_LCACHE,
     361                 :            :                                        parent->flags);
     362                 :            : 
     363         [ #  # ]:          0 :         if (!cache)
     364                 :            :                 return -ENOMEM;
     365                 :            : 
     366                 :            :         /* try to load existing cache */
     367                 :          0 :         err = td_load(cache);
     368         [ #  # ]:          0 :         if (!err)
     369                 :            :                 goto done;
     370                 :            : 
     371                 :          0 :         cache->driver = tapdisk_driver_allocate(cache->type,
     372                 :          0 :                                                 cache->name,
     373                 :            :                                                 cache->flags);
     374         [ #  # ]:          0 :         if (!cache->driver) {
     375                 :            :                 err = -ENOMEM;
     376                 :            :                 goto fail;
     377                 :            :         }
     378                 :            : 
     379                 :          0 :         cache->driver->info = parent->driver->info;
     380                 :            : 
     381                 :            :         /* try to open new cache */
     382                 :          0 :         err = td_open(cache, &vbd->encryption);
     383         [ #  # ]:          0 :         if (!err)
     384                 :            :                 goto done;
     385                 :            : 
     386                 :            : fail:
     387                 :          0 :         tapdisk_image_free(cache);
     388                 :          0 :         return err;
     389                 :            : 
     390                 :            : done:
     391                 :            :         /* insert cache right above leaf image */
     392                 :          0 :         list_add(&cache->next, &parent->next);
     393                 :            : 
     394                 :            :         DPRINTF("Added local_cache driver\n");
     395                 :          0 :         return 0;
     396                 :            : }
     397                 :            : 
     398                 :            : int
     399                 :          0 : tapdisk_vbd_add_secondary(td_vbd_t *vbd)
     400                 :            : {
     401                 :          0 :         td_image_t *leaf, *second = NULL;
     402                 :            :         const char *path;
     403                 :            :         int type, err;
     404                 :            : 
     405         [ #  # ]:          0 :         if (strcmp(vbd->secondary_name, "null") == 0) {
     406                 :            :                 DPRINTF("Removing secondary image\n");
     407                 :          0 :                 vbd->secondary_mode = TD_VBD_SECONDARY_DISABLED;
     408                 :          0 :                 vbd->secondary = NULL;
     409                 :          0 :                 vbd->nbd_mirror_failed = 0;
     410                 :          0 :                 return 0;
     411                 :            :         }
     412                 :            : 
     413                 :          0 :         DPRINTF("Adding secondary image: %s\n", vbd->secondary_name);
     414                 :            : 
     415                 :          0 :         type = tapdisk_disktype_parse_params(vbd->secondary_name, &path);
     416         [ #  # ]:          0 :         if (type < 0)
     417                 :            :                 return type;
     418                 :            : 
     419                 :          0 :         leaf = tapdisk_vbd_first_image(vbd);
     420         [ #  # ]:          0 :         if (!leaf) {
     421                 :            :                 err = -EINVAL;
     422                 :            :                 goto fail;
     423                 :            :         }
     424                 :            : 
     425                 :          0 :         err = tapdisk_image_open(type, path, leaf->flags, &vbd->encryption, &second);
     426         [ #  # ]:          0 :         if (err) {
     427         [ #  # ]:          0 :                 if (type == DISK_TYPE_NBD)
     428                 :          0 :                         vbd->nbd_mirror_failed = 1;
     429                 :            : 
     430                 :          0 :                 vbd->secondary=NULL;
     431                 :          0 :                 vbd->secondary_mode=TD_VBD_SECONDARY_DISABLED;
     432                 :            :                 
     433                 :          0 :                 goto fail;
     434                 :            :         }
     435                 :            : 
     436         [ #  # ]:          0 :         if (second->info.size != leaf->info.size) {
     437                 :          0 :                 EPRINTF("Secondary image size %"PRIu64" != image size %"PRIu64"\n",
     438                 :            :                         second->info.size, leaf->info.size);
     439                 :            :                 err = -EINVAL;
     440                 :            :                 goto fail;
     441                 :            :         }
     442                 :            : 
     443                 :          0 :         vbd->secondary = second;
     444                 :          0 :         leaf->flags |= TD_IGNORE_ENOSPC;
     445         [ #  # ]:          0 :         if (td_flag_test(vbd->flags, TD_OPEN_STANDBY)) {
     446                 :            :                 DPRINTF("In standby mode\n");
     447                 :          0 :                 vbd->secondary_mode = TD_VBD_SECONDARY_STANDBY;
     448                 :            :         } else {
     449                 :            :                 DPRINTF("In mirror mode\n");
     450                 :          0 :                 vbd->secondary_mode = TD_VBD_SECONDARY_MIRROR;
     451                 :            :                 /*
     452                 :            :                  * we actually need this image to also be part of the chain, 
     453                 :            :                  * since it may already contain data
     454                 :            :                  */
     455                 :          0 :                 list_add(&second->next, &leaf->next);
     456                 :            :         }
     457                 :            : 
     458                 :            :         DPRINTF("Added secondary image\n");
     459                 :            :         return 0;
     460                 :            : 
     461                 :            : fail:
     462         [ #  # ]:          0 :         if (second)
     463                 :          0 :                 tapdisk_image_close(second);
     464                 :          0 :         return err;
     465                 :            : }
     466                 :            : 
     467                 :          0 : static void signal_enospc(td_vbd_t *vbd)
     468                 :            : {
     469                 :            :         int fd, err;
     470                 :            :         char *fn;
     471                 :            : 
     472                 :          0 :         err = asprintf(&fn, BLKTAP2_ENOSPC_SIGNAL_FILE"%d", vbd->tap->minor);
     473         [ #  # ]:          0 :         if (err == -1) {
     474                 :            :                 EPRINTF("Failed to signal ENOSPC condition\n");
     475                 :          0 :                 return;
     476                 :            :         }
     477                 :            : 
     478                 :          0 :         fd = open(fn, O_WRONLY | O_CREAT | O_NONBLOCK, 0666);
     479         [ #  # ]:          0 :         if (fd == -1)
     480                 :            :                 EPRINTF("Failed to open file to signal ENOSPC condition\n");
     481                 :            :         else
     482                 :          0 :                 close(fd);
     483                 :            : 
     484                 :          0 :         free(fn);
     485                 :            : }
     486                 :            : 
     487                 :            : #if 0
     488                 :            : static int
     489                 :            : tapdisk_vbd_open_index(td_vbd_t *vbd)
     490                 :            : {
     491                 :            :         int err;
     492                 :            :         char *path;
     493                 :            :         td_flag_t flags;
     494                 :            :         td_image_t *last, *image;
     495                 :            : 
     496                 :            :         last = tapdisk_vbd_last_image(vbd);
     497                 :            :         err  = asprintf(&path, "%s.bat", last->name);
     498                 :            :         if (err == -1)
     499                 :            :                 return -errno;
     500                 :            : 
     501                 :            :         err = access(path, R_OK);
     502                 :            :         if (err == -1) {
     503                 :            :                 free(path);
     504                 :            :                 return -errno;
     505                 :            :         }
     506                 :            : 
     507                 :            :         flags = vbd->flags | TD_OPEN_RDONLY | TD_OPEN_SHAREABLE;
     508                 :            :         image = tapdisk_image_allocate(path, DISK_TYPE_VINDEX, flags);
     509                 :            :         if (!image) {
     510                 :            :                 err = -ENOMEM;
     511                 :            :                 goto fail;
     512                 :            :         }
     513                 :            : 
     514                 :            :         err = td_open(image);
     515                 :            :         if (err)
     516                 :            :                 goto fail;
     517                 :            : 
     518                 :            :         tapdisk_vbd_add_image(vbd, image);
     519                 :            :         return 0;
     520                 :            : 
     521                 :            : fail:
     522                 :            :         if (image)
     523                 :            :                 tapdisk_image_free(image);
     524                 :            :         free(path);
     525                 :            :         return err;
     526                 :            : }
     527                 :            : #endif
     528                 :            : 
     529                 :          0 : static int tapdisk_vbd_add_dirty_log(td_vbd_t *vbd)
     530                 :            : {
     531                 :            :         int err;
     532                 :            :         td_driver_t *driver;
     533                 :            :         td_image_t *log, *parent;
     534                 :            : 
     535                 :          0 :         driver = NULL;
     536                 :          0 :         log    = NULL;
     537                 :            : 
     538                 :          0 :         DPRINTF("CBT:tapdisk_vbd_add_dirty_log called for %s with log file %s\n",
     539                 :            :                         vbd->name, vbd->logpath);
     540                 :            : 
     541                 :          0 :         parent = tapdisk_vbd_first_image(vbd);
     542                 :            : 
     543                 :          0 :         DPRINTF("CBT: Size in Image: %"PRIu64" sectors\n", parent->info.size);
     544                 :            : 
     545                 :          0 :         log = tapdisk_image_allocate(vbd->logpath,
     546                 :            :                                         DISK_TYPE_LOG,
     547                 :            :                                         parent->flags);
     548         [ #  # ]:          0 :         if (!log)
     549                 :            :                 return -ENOMEM;
     550                 :            : 
     551                 :          0 :         driver = tapdisk_driver_allocate(log->type,
     552                 :          0 :                                          log->name,
     553                 :            :                                          log->flags);
     554         [ #  # ]:          0 :         if (!driver) {
     555                 :            :                 err = -ENOMEM;
     556                 :            :                 goto fail;
     557                 :            :         }
     558                 :            : 
     559                 :          0 :         driver->info = parent->driver->info;
     560                 :          0 :         log->driver  = driver;
     561                 :            : 
     562                 :          0 :         err = td_open(log, &vbd->encryption);
     563         [ #  # ]:          0 :         if (err)
     564                 :            :                 goto fail;
     565                 :            : 
     566                 :            :         /* insert log before image */
     567                 :          0 :         list_add(&log->next, parent->next.prev);
     568                 :          0 :         return 0;
     569                 :            : 
     570                 :            : fail:
     571                 :          0 :         tapdisk_image_free(log);
     572                 :          0 :         return err;
     573                 :            : }
     574                 :            : 
     575                 :            : int 
     576                 :          0 : tapdisk_vbd_open_vdi(td_vbd_t *vbd, const char *name, td_flag_t flags, int prt_devnum)
     577                 :            : {
     578                 :          0 :         char *tmp = vbd->name;
     579                 :            :         int err;
     580                 :            : 
     581         [ #  # ]:          0 :         if (!list_empty(&vbd->images)) {
     582                 :            :                 err = -EBUSY;
     583                 :            :                 goto fail;
     584                 :            :         }
     585                 :            : 
     586 [ #  # ][ #  # ]:          0 :         if (!name && !vbd->name) {
     587                 :            :                 err = -EINVAL;
     588                 :            :                 goto fail;
     589                 :            :         }
     590                 :            : 
     591         [ #  # ]:          0 :         if (name) {
     592                 :          0 :                 vbd->name = strdup(name);
     593         [ #  # ]:          0 :                 if (!vbd->name) {
     594                 :          0 :                         err = -errno;
     595                 :          0 :                         goto fail;
     596                 :            :                 }
     597                 :            :         }
     598                 :            : 
     599                 :          0 :         err = tapdisk_image_open_chain(vbd->name, flags, prt_devnum, &vbd->encryption, &vbd->images);
     600         [ #  # ]:          0 :         if (err)
     601                 :            :                 goto fail;
     602                 :            : 
     603                 :          0 :         td_flag_clear(vbd->state, TD_VBD_CLOSED);
     604                 :          0 :         vbd->flags = flags;
     605                 :            : 
     606         [ #  # ]:          0 :         if (td_flag_test(vbd->flags, TD_OPEN_ADD_LOG)) {
     607         [ #  # ]:          0 :                 if (!vbd->logpath) {
     608                 :            :                         err = -EINVAL;
     609                 :            :                         goto fail;
     610                 :            :                 }
     611                 :          0 :                 err = tapdisk_vbd_add_dirty_log(vbd);
     612         [ #  # ]:          0 :                 if (err)
     613                 :            :                         goto fail;
     614                 :            :         }
     615                 :            : 
     616         [ #  # ]:          0 :         if (td_flag_test(vbd->flags, TD_OPEN_ADD_CACHE)) {
     617                 :          0 :                 err = tapdisk_vbd_add_block_cache(vbd);
     618         [ #  # ]:          0 :                 if (err)
     619                 :            :                         goto fail;
     620                 :            :         }
     621                 :            : 
     622                 :          0 :         err = tapdisk_vbd_validate_chain(vbd);
     623         [ #  # ]:          0 :         if (err)
     624                 :            :                 goto fail;
     625                 :            : 
     626         [ #  # ]:          0 :         if (td_flag_test(vbd->flags, TD_OPEN_SECONDARY)) {
     627                 :          0 :                 err = tapdisk_vbd_add_secondary(vbd);
     628         [ #  # ]:          0 :                 if (err) {
     629         [ #  # ]:          0 :                         if (vbd->nbd_mirror_failed != 1)
     630                 :            :                                 goto fail;
     631                 :          0 :                         INFO("Ignoring failed NBD secondary attach\n");
     632                 :          0 :                         err = 0;
     633                 :            :                 }
     634                 :            :         }
     635                 :            : 
     636         [ #  # ]:          0 :         if (td_flag_test(vbd->flags, TD_OPEN_LOCAL_CACHE)) {
     637                 :          0 :                 err = tapdisk_vbd_add_local_cache(vbd);
     638         [ #  # ]:          0 :                 if (err)
     639                 :            :                         goto fail;
     640                 :            :         }
     641                 :            : 
     642                 :          0 :         err = vbd_stats_create(vbd);
     643         [ #  # ]:          0 :         if (err)
     644                 :            :                 goto fail;
     645                 :            : 
     646                 :          0 :         err = td_metrics_vdi_start(vbd->tap->minor, &vbd->vdi_stats);
     647         [ #  # ]:          0 :         if (err)
     648                 :            :                 goto fail;
     649         [ #  # ]:          0 :         if (tmp != vbd->name)
     650                 :          0 :                 free(tmp);
     651                 :            : 
     652                 :          0 :         return err;
     653                 :            : 
     654                 :            : fail:
     655         [ #  # ]:          0 :         if (vbd->name != tmp) {
     656                 :          0 :                 free(vbd->name);
     657                 :          0 :                 vbd->name = tmp;
     658                 :            :         }
     659                 :            : 
     660         [ #  # ]:          0 :         if (!list_empty(&vbd->images))
     661                 :          0 :                 tapdisk_image_close_chain(&vbd->images);
     662                 :            : 
     663                 :          0 :         vbd->flags = 0;
     664                 :            : 
     665                 :          0 :         return err;
     666                 :            : }
     667                 :            : 
     668                 :            : void
     669                 :          0 : tapdisk_vbd_detach(td_vbd_t *vbd)
     670                 :            : {
     671                 :          0 :         td_blktap_t *tap = vbd->tap;
     672                 :            : 
     673         [ #  # ]:          0 :         if (tap) {
     674                 :          0 :                 tapdisk_blktap_close(tap);
     675                 :          0 :                 vbd->tap = NULL;
     676                 :            :         }
     677                 :          0 : }
     678                 :            : 
     679                 :            : int
     680                 :          0 : tapdisk_vbd_attach(td_vbd_t *vbd, const char *devname, int minor)
     681                 :            : {
     682                 :            : 
     683         [ #  # ]:          0 :         if (vbd->tap)
     684                 :            :                 return -EALREADY;
     685                 :            : 
     686                 :          0 :         return tapdisk_blktap_open(devname, vbd, &vbd->tap);
     687                 :            : }
     688                 :            : 
     689                 :            : /*
     690                 :            : int
     691                 :            : tapdisk_vbd_open(td_vbd_t *vbd, const char *name,
     692                 :            :                  int minor, const char *ring, td_flag_t flags)
     693                 :            : {
     694                 :            :         int err;
     695                 :            : 
     696                 :            :         err = tapdisk_vbd_open_vdi(vbd, name, flags, -1);
     697                 :            :         if (err)
     698                 :            :                 goto out;
     699                 :            : 
     700                 :            :         err = tapdisk_vbd_attach(vbd, ring, minor);
     701                 :            :         if (err)
     702                 :            :                 goto out;
     703                 :            : 
     704                 :            :         return 0;
     705                 :            : 
     706                 :            : out:
     707                 :            :         tapdisk_vbd_detach(vbd);
     708                 :            :         tapdisk_vbd_close_vdi(vbd);
     709                 :            :         free(vbd->name);
     710                 :            :         vbd->name = NULL;
     711                 :            :         return err;
     712                 :            : }
     713                 :            : */
     714                 :            : 
     715                 :            : static void
     716                 :          0 : tapdisk_vbd_queue_count(td_vbd_t *vbd, int *new,
     717                 :            :                         int *pending, int *failed, int *completed)
     718                 :            : {
     719                 :            :         int n, p, f, c;
     720                 :            :         td_vbd_request_t *vreq, *tvreq;
     721                 :            : 
     722                 :          0 :         n = 0;
     723                 :          0 :         p = 0;
     724                 :          0 :         f = 0;
     725                 :          0 :         c = 0;
     726                 :            : 
     727         [ #  # ]:          0 :         tapdisk_vbd_for_each_request(vreq, tvreq, &vbd->new_requests)
     728                 :          0 :                 n++;
     729                 :            : 
     730         [ #  # ]:          0 :         tapdisk_vbd_for_each_request(vreq, tvreq, &vbd->pending_requests)
     731                 :          0 :                 p++;
     732                 :            : 
     733         [ #  # ]:          0 :         tapdisk_vbd_for_each_request(vreq, tvreq, &vbd->failed_requests)
     734                 :          0 :                 f++;
     735                 :            : 
     736         [ #  # ]:          0 :         tapdisk_vbd_for_each_request(vreq, tvreq, &vbd->completed_requests)
     737                 :          0 :                 c++;
     738                 :            : 
     739                 :          0 :         *new       = n;
     740                 :          0 :         *pending   = p;
     741                 :          0 :         *failed    = f;
     742                 :          0 :         *completed = c;
     743                 :          0 : }
     744                 :            : 
     745                 :            : static int
     746                 :          0 : tapdisk_vbd_shutdown(td_vbd_t *vbd)
     747                 :            : {
     748                 :            :         int new, pending, failed, completed;
     749                 :            : 
     750         [ #  # ]:          0 :         if (!list_empty(&vbd->pending_requests))
     751                 :          0 :                 return -EAGAIN;
     752                 :            : 
     753                 :          0 :         tapdisk_vbd_queue_count(vbd, &new, &pending, &failed, &completed);
     754                 :            : 
     755                 :          0 :         DPRINTF("%s: state: 0x%08x, new: 0x%02x, pending: 0x%02x, "
     756                 :            :                 "failed: 0x%02x, completed: 0x%02x\n", 
     757                 :            :                 vbd->name, vbd->state, new, pending, failed, completed);
     758                 :          0 :         DPRINTF("last activity: %010ld.%06ld, errors: 0x%04"PRIx64", "
     759                 :            :                 "retries: 0x%04"PRIx64", received: 0x%08"PRIx64", "
     760                 :            :                 "returned: 0x%08"PRIx64", kicked: 0x%08"PRIx64"\n",
     761                 :            :                 vbd->ts.tv_sec, vbd->ts.tv_usec,
     762                 :            :                 vbd->errors, vbd->retries, vbd->received, vbd->returned,
     763                 :            :                 vbd->kicked);
     764                 :            : 
     765                 :          0 :         tapdisk_vbd_close_vdi(vbd);
     766                 :          0 :         tapdisk_vbd_detach(vbd);
     767                 :          0 :         tapdisk_server_remove_vbd(vbd);
     768                 :          0 :         tapdisk_vbd_free(vbd);
     769                 :            : 
     770                 :          0 :         return 0;
     771                 :            : }
     772                 :            : 
     773                 :            : void
     774                 :          0 : tapdisk_vbd_free(td_vbd_t *vbd)
     775                 :            : {
     776                 :          0 :         free(vbd->name);
     777                 :          0 :         free(vbd->encryption.encryption_key);
     778                 :          0 :         free(vbd);
     779                 :          0 : }
     780                 :            : 
     781                 :            : int
     782                 :          0 : tapdisk_vbd_close(td_vbd_t *vbd)
     783                 :            : {
     784                 :            :         /*
     785                 :            :          * don't close if any requests are pending in the aio layer
     786                 :            :          */
     787         [ #  # ]:          0 :         if (!list_empty(&vbd->pending_requests))
     788                 :            :                 goto fail;
     789                 :            : 
     790                 :            :         /* 
     791                 :            :          * if the queue is still active and we have more
     792                 :            :          * requests, try to complete them before closing.
     793                 :            :          */
     794 [ #  # ][ #  # ]:          0 :         if (tapdisk_vbd_queue_ready(vbd) &&
     795         [ #  # ]:          0 :             (!list_empty(&vbd->new_requests) ||
     796         [ #  # ]:          0 :              !list_empty(&vbd->failed_requests) ||
     797                 :          0 :              !list_empty(&vbd->completed_requests)))
     798                 :            :                 goto fail;
     799                 :            : 
     800                 :          0 :         return tapdisk_vbd_shutdown(vbd);
     801                 :            : 
     802                 :            : fail:
     803                 :          0 :         td_flag_set(vbd->state, TD_VBD_SHUTDOWN_REQUESTED);
     804                 :          0 :         DBG(TLOG_WARN, "%s: requests pending\n", vbd->name);
     805                 :          0 :         return -EAGAIN;
     806                 :            : }
     807                 :            : 
     808                 :            : /*
     809                 :            :  * control operations
     810                 :            :  */
     811                 :            : 
     812                 :            : void
     813                 :          0 : tapdisk_vbd_debug(td_vbd_t *vbd)
     814                 :            : {
     815                 :            :         td_image_t *image, *tmp;
     816                 :            :         int new, pending, failed, completed;
     817                 :            : 
     818                 :          0 :         tapdisk_vbd_queue_count(vbd, &new, &pending, &failed, &completed);
     819                 :            : 
     820                 :          0 :         DBG(TLOG_WARN, "%s: state: 0x%08x, new: 0x%02x, pending: 0x%02x, "
     821                 :            :             "failed: 0x%02x, completed: 0x%02x, last activity: %010ld.%06ld, "
     822                 :            :             "errors: 0x%04"PRIx64", retries: 0x%04"PRIx64", "
     823                 :            :             "received: 0x%08"PRIx64", returned: 0x%08"PRIx64", "
     824                 :            :             "kicked: 0x%08"PRIx64"\n",
     825                 :            :             vbd->name, vbd->state, new, pending, failed, completed,
     826                 :            :             vbd->ts.tv_sec, vbd->ts.tv_usec, vbd->errors, vbd->retries,
     827                 :            :             vbd->received, vbd->returned, vbd->kicked);
     828                 :            : 
     829         [ #  # ]:          0 :         tapdisk_vbd_for_each_image(vbd, image, tmp)
     830                 :          0 :                 td_debug(image);
     831                 :          0 : }
     832                 :            : 
     833                 :            : static void
     834                 :          0 : tapdisk_vbd_drop_log(td_vbd_t *vbd)
     835                 :            : {
     836         [ #  # ]:          0 :         if (td_flag_test(vbd->state, TD_VBD_LOG_DROPPED))
     837                 :          0 :                 return;
     838                 :            : 
     839                 :          0 :         tapdisk_vbd_debug(vbd);
     840                 :          0 :         tlog_precious(0);
     841                 :          0 :         td_flag_set(vbd->state, TD_VBD_LOG_DROPPED);
     842                 :            : }
     843                 :            : 
     844                 :            : int
     845                 :          0 : tapdisk_vbd_get_disk_info(td_vbd_t *vbd, td_disk_info_t *info)
     846                 :            : {
     847         [ #  # ]:          0 :         if (list_empty(&vbd->images))
     848                 :            :                 return -EINVAL;
     849                 :            : 
     850                 :          0 :         *info = tapdisk_vbd_first_image(vbd)->info;
     851                 :          0 :         return 0;
     852                 :            : }
     853                 :            : 
     854                 :            : static int
     855                 :            : tapdisk_vbd_queue_ready(td_vbd_t *vbd)
     856                 :            : {
     857                 :            :         return (!td_flag_test(vbd->state, TD_VBD_DEAD) &&
     858                 :            :                 !td_flag_test(vbd->state, TD_VBD_CLOSED) &&
     859                 :          1 :                 !td_flag_test(vbd->state, TD_VBD_QUIESCED) &&
     860                 :            :                 !td_flag_test(vbd->state, TD_VBD_QUIESCE_REQUESTED));
     861                 :            : }
     862                 :            : 
     863                 :            : int
     864                 :          0 : tapdisk_vbd_retry_needed(td_vbd_t *vbd)
     865                 :            : {
     866 [ #  # ][ #  # ]:          0 :         return !(list_empty(&vbd->failed_requests) &&
     867                 :          0 :                  list_empty(&vbd->new_requests));
     868                 :            : }
     869                 :            : 
     870                 :            : int
     871                 :          0 : tapdisk_vbd_lock(td_vbd_t *vbd)
     872                 :            : {
     873                 :          0 :         return 0;
     874                 :            : }
     875                 :            : 
     876                 :            : int
     877                 :          0 : tapdisk_vbd_quiesce_queue(td_vbd_t *vbd)
     878                 :            : {
     879         [ #  # ]:          0 :         if (!list_empty(&vbd->pending_requests)) {
     880                 :          0 :                 td_flag_set(vbd->state, TD_VBD_QUIESCE_REQUESTED);
     881                 :          0 :                 return -EAGAIN;
     882                 :            :         }
     883                 :            : 
     884                 :          0 :         td_flag_clear(vbd->state, TD_VBD_QUIESCE_REQUESTED);
     885                 :          0 :         td_flag_set(vbd->state, TD_VBD_QUIESCED);
     886                 :          0 :         return 0;
     887                 :            : }
     888                 :            : 
     889                 :            : int
     890                 :          0 : tapdisk_vbd_start_queue(td_vbd_t *vbd)
     891                 :            : {
     892                 :          0 :         td_flag_clear(vbd->state, TD_VBD_QUIESCED);
     893                 :          0 :         td_flag_clear(vbd->state, TD_VBD_QUIESCE_REQUESTED);
     894                 :            :         tapdisk_vbd_mark_progress(vbd);
     895                 :          0 :         return 0;
     896                 :            : }
     897                 :            : 
     898                 :            : int
     899                 :          0 : tapdisk_vbd_kill_queue(td_vbd_t *vbd)
     900                 :            : {
     901                 :          0 :         tapdisk_vbd_quiesce_queue(vbd);
     902                 :          0 :         td_flag_set(vbd->state, TD_VBD_DEAD);
     903                 :          0 :         return 0;
     904                 :            : }
     905                 :            : 
     906                 :            : #if 0
     907                 :            : static int
     908                 :            : tapdisk_vbd_open_image(td_vbd_t *vbd, td_image_t *image)
     909                 :            : {
     910                 :            :         int err;
     911                 :            :         td_image_t *parent;
     912                 :            : 
     913                 :            :         err = td_open(image);
     914                 :            :         if (err)
     915                 :            :                 return err;
     916                 :            : 
     917                 :            :         if (!tapdisk_vbd_is_last_image(vbd, image)) {
     918                 :            :                 parent = tapdisk_vbd_next_image(image);
     919                 :            :                 err    = td_validate_parent(image, parent);
     920                 :            :                 if (err) {
     921                 :            :                         td_close(image);
     922                 :            :                         return err;
     923                 :            :                 }
     924                 :            :         }
     925                 :            : 
     926                 :            :         return 0;
     927                 :            : }
     928                 :            : #endif
     929                 :            : 
     930                 :            : /*
     931                 :            :  * Pausing a tapdisk can produce a lot of logging if the storage is not available
     932                 :            :  * and there are inflight data requests. All the caller to squash the logging 
     933                 :            :  * when entering a retry process.
     934                 :            :  */
     935                 :          0 : void tapdisk_vbd_squash_pause_logging(bool squash)
     936                 :            : {
     937                 :          0 :         log = !squash;
     938                 :          0 : }
     939                 :            : 
     940                 :            : int
     941                 :          0 : tapdisk_vbd_pause(td_vbd_t *vbd)
     942                 :            : {
     943                 :            :         int err;
     944                 :            :         struct td_xenblkif *blkif;
     945                 :            : 
     946         [ #  # ]:          0 :         if (log) {
     947                 :          0 :                 INFO("pause requested\n");
     948                 :            :         }
     949                 :            : 
     950                 :          0 :         td_flag_set(vbd->state, TD_VBD_PAUSE_REQUESTED);
     951                 :            : 
     952         [ #  # ]:          0 :         if (vbd->nbdserver)
     953                 :          0 :                 tapdisk_nbdserver_pause(vbd->nbdserver, log);
     954         [ #  # ]:          0 :         if (vbd->nbdserver_new)
     955                 :          0 :                 tapdisk_nbdserver_pause(vbd->nbdserver_new, log);
     956                 :            : 
     957         [ #  # ]:          0 :         list_for_each_entry(blkif, &vbd->rings, entry)
     958                 :          0 :                 tapdisk_xenblkif_suspend(blkif);
     959                 :            : 
     960                 :          0 :         err = tapdisk_vbd_quiesce_queue(vbd);
     961         [ #  # ]:          0 :         if (err)
     962                 :            :                 return err;
     963                 :            : 
     964                 :            : 
     965                 :          0 :         tapdisk_vbd_close_vdi(vbd);
     966                 :            : 
     967                 :            :         /* Don't guard this one as at this point the pause operation is complete */
     968                 :          0 :         INFO("pause completed\n");
     969                 :            : 
     970         [ #  # ]:          0 :         if (!list_empty(&vbd->failed_requests))
     971                 :          0 :                 INFO("warning: failed requests pending\n");
     972                 :            : 
     973                 :          0 :         td_flag_clear(vbd->state, TD_VBD_PAUSE_REQUESTED);
     974                 :          0 :         td_flag_set(vbd->state, TD_VBD_PAUSED);
     975                 :            : 
     976                 :          0 :         return 0;
     977                 :            : }
     978                 :            : 
     979                 :            : int
     980                 :          0 : tapdisk_vbd_resume(td_vbd_t *vbd, const char *name)
     981                 :            : {
     982                 :            :         int i, err;
     983                 :            :     struct td_xenblkif *blkif;
     984                 :            : 
     985                 :          0 :         DBG(TLOG_DBG, "resume requested\n");
     986                 :            : 
     987         [ #  # ]:          0 :         if (!td_flag_test(vbd->state, TD_VBD_PAUSED)) {
     988                 :          0 :                 EPRINTF("resume request for unpaused vbd %s\n", vbd->name);
     989                 :          0 :                 return -EINVAL;
     990                 :            :         }
     991                 :            : 
     992         [ #  # ]:          0 :         for (i = 0; i < TD_VBD_EIO_RETRIES; i++) {
     993                 :          0 :                 err = tapdisk_vbd_open_vdi(vbd, name, vbd->flags | TD_OPEN_STRICT, -1);
     994         [ #  # ]:          0 :                 if (!err)
     995                 :            :                         break;
     996                 :            : 
     997                 :          0 :                 sleep(TD_VBD_EIO_SLEEP);
     998                 :            :         }
     999                 :            : 
    1000         [ #  # ]:          0 :         if (!err) {
    1001                 :            :                 td_disk_info_t disk_info;
    1002                 :          0 :                 err = tapdisk_vbd_get_disk_info(vbd, &disk_info);
    1003         [ #  # ]:          0 :                 if (err) {
    1004                 :          0 :                         EPRINTF("VBD %d failed to get disk info: %s\n", vbd->uuid,
    1005                 :            :                                         strerror(-err));
    1006                 :          0 :                         goto resume_failed;
    1007                 :            :                 }
    1008         [ #  # ]:          0 :                 if (vbd->disk_info.size != disk_info.size
    1009         [ #  # ]:          0 :                                 || vbd->disk_info.sector_size != disk_info.sector_size
    1010         [ #  # ]:          0 :                                 || vbd->disk_info.info != disk_info.info) {
    1011                 :          0 :                         EPRINTF("VBD %d cannot change disk info\n", vbd->uuid);
    1012                 :            :                         err = -EMEDIUMTYPE;
    1013                 :            :                         goto resume_failed;
    1014                 :            :                 }
    1015                 :            :         }
    1016                 :            : resume_failed:
    1017         [ #  # ]:          0 :         if (err) {
    1018                 :          0 :                 td_flag_set(vbd->state, TD_VBD_RESUME_FAILED);
    1019                 :          0 :                 tapdisk_vbd_close_vdi(vbd);
    1020                 :          0 :                 return err;
    1021                 :            :         }
    1022                 :          0 :         td_flag_clear(vbd->state, TD_VBD_RESUME_FAILED);
    1023                 :            : 
    1024                 :          0 :         DBG(TLOG_DBG, "resume completed\n");
    1025                 :            : 
    1026                 :          0 :         tapdisk_vbd_start_queue(vbd);
    1027                 :          0 :         td_flag_clear(vbd->state, TD_VBD_PAUSED);
    1028                 :          0 :         td_flag_clear(vbd->state, TD_VBD_PAUSE_REQUESTED);
    1029                 :          0 :         tapdisk_vbd_check_state(vbd);
    1030                 :            : 
    1031         [ #  # ]:          0 :         if (vbd->nbdserver)
    1032                 :          0 :                 tapdisk_nbdserver_unpause(vbd->nbdserver);
    1033         [ #  # ]:          0 :         if (vbd->nbdserver_new)
    1034                 :          0 :                 tapdisk_nbdserver_unpause(vbd->nbdserver_new);
    1035                 :            : 
    1036         [ #  # ]:          0 :     list_for_each_entry(blkif, &vbd->rings, entry)
    1037                 :          0 :                 tapdisk_xenblkif_resume(blkif);
    1038                 :            : 
    1039                 :            : 
    1040                 :          0 :         DBG(TLOG_DBG, "state checked\n");
    1041                 :            : 
    1042                 :          0 :         return 0;
    1043                 :            : }
    1044                 :            : 
    1045                 :            : static int
    1046                 :            : tapdisk_vbd_request_ttl(td_vbd_request_t *vreq,
    1047                 :            :                         const struct timeval *now)
    1048                 :            : {
    1049                 :            :         struct timeval delta;
    1050         [ #  # ]:          0 :         timersub(now, &vreq->ts, &delta);
    1051                 :          0 :         return vreq->vbd->req_timeout - delta.tv_sec;
    1052                 :            : }
    1053                 :            : 
    1054                 :            : static int
    1055                 :          0 : __tapdisk_vbd_request_timeout(td_vbd_request_t *vreq,
    1056                 :            :                               const struct timeval *now)
    1057                 :            : {
    1058                 :            :         int timeout;
    1059                 :            : 
    1060                 :          0 :         timeout = tapdisk_vbd_request_ttl(vreq, now) < 0;
    1061         [ #  # ]:          0 :         if (timeout)
    1062                 :          0 :                 ERR(vreq->error,
    1063                 :            :                     "req %s timed out, retried %d times\n",
    1064                 :            :                     vreq->name, vreq->num_retries);
    1065                 :            : 
    1066                 :          0 :         return timeout;
    1067                 :            : }
    1068                 :            : 
    1069                 :            : static int
    1070                 :          0 : tapdisk_vbd_request_timeout(td_vbd_request_t *vreq)
    1071                 :            : {
    1072                 :            :         struct timeval now;
    1073                 :          0 :         gettimeofday(&now, NULL);
    1074                 :          0 :         return __tapdisk_vbd_request_timeout(vreq, &now);
    1075                 :            : }
    1076                 :            : 
    1077                 :            : static void
    1078                 :          0 : tapdisk_vbd_check_complete_requests(td_vbd_t *vbd)
    1079                 :            : {
    1080                 :            :         td_vbd_request_t *vreq, *tmp;
    1081                 :            :         struct timeval now;
    1082                 :            : 
    1083                 :          0 :         gettimeofday(&now, NULL);
    1084         [ #  # ]:          0 :         tapdisk_vbd_for_each_request(vreq, tmp, &vbd->failed_requests)
    1085         [ #  # ]:          0 :                 if (__tapdisk_vbd_request_timeout(vreq, &now))
    1086                 :          0 :                         tapdisk_vbd_complete_vbd_request(vbd, vreq);
    1087                 :          0 : }
    1088                 :            : 
    1089                 :            : static void
    1090                 :            : tapdisk_vbd_check_requests_for_issue(td_vbd_t *vbd)
    1091                 :            : {
    1092 [ #  # ][ #  # ]:          0 :         if (!list_empty(&vbd->new_requests) ||
    1093                 :          0 :             !list_empty(&vbd->failed_requests))
    1094                 :          0 :                 tapdisk_vbd_issue_requests(vbd);
    1095                 :            : }
    1096                 :            : 
    1097                 :            : void
    1098                 :          0 : tapdisk_vbd_check_state(td_vbd_t *vbd)
    1099                 :            : {
    1100                 :            :         struct td_xenblkif *blkif;
    1101                 :            : 
    1102                 :            :         /* Don't check if we're already quiesced */
    1103         [ #  # ]:          0 :         if (td_flag_test(vbd->state, TD_VBD_QUIESCED))
    1104                 :          0 :                 return;
    1105                 :            : 
    1106                 :            :         /*
    1107                 :            :          * TODO don't ignore return value
    1108                 :            :          */
    1109         [ #  # ]:          0 :         list_for_each_entry(blkif, &vbd->rings, entry)
    1110                 :          0 :                 tapdisk_xenblkif_ring_stats_update(blkif);
    1111                 :            : 
    1112                 :          0 :         tapdisk_vbd_check_complete_requests(vbd);
    1113                 :            : 
    1114         [ #  # ]:          0 :         if (!td_flag_test(vbd->state, TD_VBD_QUIESCE_REQUESTED) &&
    1115                 :            :               !td_flag_test(vbd->state, TD_VBD_PAUSE_REQUESTED))
    1116                 :            :                 tapdisk_vbd_check_requests_for_issue(vbd);
    1117                 :            : 
    1118         [ #  # ]:          0 :         if (td_flag_test(vbd->state, TD_VBD_QUIESCE_REQUESTED))
    1119                 :          0 :                 tapdisk_vbd_quiesce_queue(vbd);
    1120                 :            : 
    1121         [ #  # ]:          0 :         if (td_flag_test(vbd->state, TD_VBD_PAUSE_REQUESTED))
    1122                 :          0 :                 tapdisk_vbd_pause(vbd);
    1123                 :            : 
    1124         [ #  # ]:          0 :         if (td_flag_test(vbd->state, TD_VBD_SHUTDOWN_REQUESTED))
    1125                 :          0 :                 tapdisk_vbd_close(vbd);
    1126                 :            : }
    1127                 :            : 
    1128                 :          0 : void watchdog_cleared(td_vbd_t *vbd)
    1129                 :            : {
    1130         [ #  # ]:          0 :         if (vbd->watchdog_warned) {
    1131                 :          0 :                 DBG(TLOG_WARN, "%s: watchdog timeout: requests were blocked\n", vbd->name);
    1132                 :            :                 /* Ideally want a direct way to flush the log */
    1133                 :          0 :                 tlog_precious(1);
    1134                 :            :         }
    1135                 :          0 :         vbd->watchdog_warned = false;
    1136                 :          0 : }
    1137                 :            : 
    1138                 :            : void
    1139                 :          0 : tapdisk_vbd_check_progress(td_vbd_t *vbd)
    1140                 :            : {
    1141                 :            :         time_t diff;
    1142                 :            :         struct timeval now, delta;
    1143                 :            : 
    1144         [ #  # ]:          0 :         if (list_empty(&vbd->pending_requests)) {
    1145                 :          0 :                 watchdog_cleared(vbd);
    1146                 :          0 :                 return;
    1147                 :            :         }
    1148                 :            : 
    1149                 :          0 :         gettimeofday(&now, NULL);
    1150         [ #  # ]:          0 :         timersub(&now, &vbd->ts, &delta);
    1151                 :          0 :         diff = delta.tv_sec;
    1152                 :            : 
    1153         [ #  # ]:          0 :         if (diff >= TD_VBD_WATCHDOG_TIMEOUT)
    1154                 :            :         {
    1155         [ #  # ]:          0 :                 if(tapdisk_vbd_queue_ready(vbd))
    1156                 :            :                 {
    1157         [ #  # ]:          0 :                         if (!vbd->watchdog_warned) {
    1158                 :          0 :                                 DBG(TLOG_WARN, "%s: watchdog timeout: pending requests "
    1159                 :            :                                     "idle for %ld seconds\n", vbd->name, diff);
    1160                 :          0 :                                 vbd->watchdog_warned = true;
    1161                 :            :                         }
    1162                 :          0 :                         tapdisk_vbd_drop_log(vbd);
    1163                 :            :                 }
    1164                 :            :                 return;
    1165                 :            :         }
    1166                 :            : 
    1167                 :          0 :         watchdog_cleared(vbd);
    1168                 :            : 
    1169                 :          0 :         tapdisk_server_set_max_timeout(TD_VBD_WATCHDOG_TIMEOUT - diff);
    1170                 :            : }
    1171                 :            : 
    1172                 :            : /*
    1173                 :            :  * request submission 
    1174                 :            :  */
    1175                 :            : 
    1176                 :            : static int
    1177                 :            : tapdisk_vbd_check_queue(td_vbd_t *vbd)
    1178                 :            : {
    1179         [ +  - ]:          1 :         if (list_empty(&vbd->images))
    1180                 :            :                 return -ENOSYS;
    1181                 :            : 
    1182         [ +  - ]:          1 :         if (!tapdisk_vbd_queue_ready(vbd))
    1183                 :            :                 return -EAGAIN;
    1184                 :            : 
    1185                 :            :         return 0;
    1186                 :            : }
    1187                 :            : 
    1188                 :            : static int
    1189                 :          0 : tapdisk_vbd_request_should_retry(td_vbd_t *vbd, td_vbd_request_t *vreq)
    1190                 :            : {
    1191         [ #  # ]:          0 :         if (td_flag_test(vbd->state, TD_VBD_DEAD) ||
    1192                 :            :             td_flag_test(vbd->state, TD_VBD_SHUTDOWN_REQUESTED))
    1193                 :            :                 return 0;
    1194                 :            : 
    1195         [ #  # ]:          0 :         if (tapdisk_vbd_request_timeout(vreq))
    1196                 :            :                 return 0;
    1197                 :            : 
    1198 [ #  # ][ #  # ]:          0 :         switch (abs(vreq->error)) {
    1199                 :            :         case EAGAIN:
    1200                 :            :         case EBUSY:
    1201                 :            :         case EINTR:
    1202                 :            :                 return 1;
    1203                 :            :         }
    1204                 :            : 
    1205                 :          0 :         return 0;
    1206                 :            : }
    1207                 :            : 
    1208                 :            : static void
    1209                 :          1 : tapdisk_vbd_complete_vbd_request(td_vbd_t *vbd, td_vbd_request_t *vreq)
    1210                 :            : {
    1211         [ -  + ]:          1 :         if (!vreq->submitting && !vreq->secs_pending) {
    1212   [ #  #  #  # ]:          0 :                 if (vreq->error &&
    1213                 :          0 :                     tapdisk_vbd_request_should_retry(vbd, vreq))
    1214                 :          0 :                         tapdisk_vbd_move_request(vreq, &vbd->failed_requests);
    1215                 :            :                 else
    1216                 :          0 :                         tapdisk_vbd_move_request(vreq, &vbd->completed_requests);
    1217                 :            :         }
    1218                 :          1 : }
    1219                 :            : 
    1220                 :            : static void
    1221                 :          0 : FIXME_maybe_count_enospc_redirect(td_vbd_t *vbd, td_request_t treq)
    1222                 :            : {
    1223                 :          1 :         int write = treq.op == TD_OP_WRITE;
    1224 [ -  + ][ #  # ]:          1 :         if (write &&
    1225         [ #  # ]:          0 :             treq.image == tapdisk_vbd_first_image(vbd) &&
    1226                 :          0 :             vbd->FIXME_enospc_redirect_count_enabled)
    1227                 :          0 :                 vbd->FIXME_enospc_redirect_count += treq.secs;
    1228                 :          0 : }
    1229                 :            : 
    1230                 :            : static void
    1231                 :          2 : __tapdisk_vbd_complete_td_request(td_vbd_t *vbd, td_vbd_request_t *vreq,
    1232                 :            :                                   td_request_t treq, int res)
    1233                 :            : {
    1234                 :          1 :         td_image_t *image = treq.image;
    1235                 :            :         int err;
    1236                 :            : 
    1237                 :            :         long long interval;
    1238                 :            : 
    1239                 :          1 :         err = (res <= 0 ? res : -res);
    1240                 :          1 :         vbd->secs_pending  -= treq.secs;
    1241                 :          1 :         vreq->secs_pending -= treq.secs;
    1242                 :            : 
    1243         [ +  - ]:          1 :         if (err != -EBUSY) {
    1244                 :          1 :                 int write = treq.op == TD_OP_WRITE;
    1245                 :          1 :                 td_sector_count_add(&image->stats.hits, treq.secs, write);
    1246         [ -  + ]:          1 :                 if (err)
    1247                 :          0 :                         td_sector_count_add(&image->stats.fail,
    1248                 :            :                                             treq.secs, write);
    1249                 :            : 
    1250                 :          1 :                 FIXME_maybe_count_enospc_redirect(vbd, treq);
    1251                 :            :         }
    1252                 :            : 
    1253         [ -  + ]:          1 :         if (err) {
    1254         [ #  # ]:          0 :                 if (err != -EBUSY) {
    1255 [ #  # ][ #  # ]:          0 :                         if (!vreq->error &&
    1256                 :          0 :                             err != vreq->prev_error)
    1257         [ #  # ]:          0 :                                 tlog_drv_error(image->driver, err,
    1258                 :            :                                                "req %s: %s 0x%04x secs @ 0x%08"PRIx64" - %s",
    1259                 :            :                                                vreq->name,
    1260                 :            :                                                op_strings[treq.op],
    1261                 :            :                                                treq.secs, treq.sec, strerror(abs(err)));
    1262                 :          0 :                         vbd->errors++;
    1263                 :            :                 }
    1264         [ #  # ]:          0 :                 vreq->error = (vreq->error ? : err);
    1265                 :            :         }
    1266                 :            : 
    1267                 :          3 :         interval = timeval_to_us(&vbd->ts) - timeval_to_us(&vreq->ts);
    1268                 :            : 
    1269         [ -  + ]:          1 :         if(treq.op == TD_OP_READ) {
    1270                 :          0 :             vbd->vdi_stats.stats->read_reqs_completed++;
    1271                 :          0 :             vbd->vdi_stats.stats->read_sectors += treq.secs;
    1272                 :          0 :             vbd->vdi_stats.stats->read_total_ticks += interval;
    1273                 :            :         }
    1274                 :            : 
    1275         [ -  + ]:          1 :         if(treq.op == TD_OP_WRITE) {
    1276                 :          0 :             vbd->vdi_stats.stats->write_reqs_completed++;
    1277                 :          0 :             vbd->vdi_stats.stats->write_sectors += treq.secs;
    1278                 :          0 :             vbd->vdi_stats.stats->write_total_ticks += interval;
    1279                 :            :         }
    1280                 :            : 
    1281                 :          1 :         tapdisk_vbd_complete_vbd_request(vbd, vreq);
    1282                 :          1 : }
    1283                 :            : 
    1284                 :            : static void
    1285                 :          0 : __tapdisk_vbd_reissue_td_request(td_vbd_t *vbd,
    1286                 :            :                                  td_image_t *image, td_request_t treq)
    1287                 :            : {
    1288                 :            :         td_image_t *parent;
    1289                 :            :         td_vbd_request_t *vreq;
    1290                 :            : 
    1291                 :          0 :         vreq = treq.vreq;
    1292                 :          0 :         gettimeofday(&vreq->last_try, NULL);
    1293                 :            : 
    1294                 :          0 :         vreq->submitting++;
    1295                 :            : 
    1296         [ #  # ]:          0 :         if (tapdisk_vbd_is_last_image(vbd, image)) {
    1297         [ #  # ]:          0 :                 if (unlikely(treq.op == TD_OP_BLOCK_STATUS)) {
    1298                 :          0 :                         treq.status = TD_BLOCK_STATE_HOLE;
    1299                 :            :                 } else {
    1300                 :          0 :                         memset(treq.buf, 0, (size_t)treq.secs << SECTOR_SHIFT);
    1301                 :            :                 }
    1302                 :          0 :                 td_complete_request(treq, 0);
    1303                 :          0 :                 goto done;
    1304                 :            :         }
    1305                 :            :         /*
    1306                 :            :          * If intellicache is enabled, check to confirm  mirroring
    1307                 :            :          * is disabled due to out of space.
    1308                 :            :          */
    1309 [ #  # ][ #  # ]:          0 :         if (unlikely(vbd->retired && vbd->retired == image))
    1310                 :          0 :                 parent = tapdisk_vbd_first_image(vbd);
    1311                 :            :         else
    1312                 :          0 :                 parent = tapdisk_vbd_next_image(image);
    1313                 :            : 
    1314                 :          0 :         treq.image = parent;
    1315                 :            : 
    1316                 :            :         /* return zeros for requests that extend beyond end of parent image */
    1317         [ #  # ]:          0 :         if (treq.sec + treq.secs > parent->info.size) {
    1318                 :          0 :                 td_request_t clone  = treq;
    1319                 :            : 
    1320         [ #  # ]:          0 :                 if (parent->info.size > treq.sec) {
    1321                 :          0 :                         int secs    = parent->info.size - treq.sec;
    1322                 :          0 :                         clone.sec  += secs;
    1323                 :          0 :                         clone.secs -= secs;
    1324                 :          0 :                         clone.buf  += (secs << SECTOR_SHIFT);
    1325                 :          0 :                         treq.secs   = secs;
    1326                 :            :                 } else
    1327                 :          0 :                         treq.secs   = 0;
    1328                 :            : 
    1329                 :          0 :                 memset(clone.buf, 0, (size_t)clone.secs << SECTOR_SHIFT);
    1330                 :          0 :                 td_complete_request(clone, 0);
    1331                 :            : 
    1332         [ #  # ]:          0 :                 if (!treq.secs)
    1333                 :            :                         goto done;
    1334                 :            :         }
    1335                 :            : 
    1336   [ #  #  #  # ]:          0 :         switch (treq.op) {
    1337                 :            :         case TD_OP_WRITE:
    1338                 :          0 :                 td_queue_write(parent, treq);
    1339                 :          0 :                 break;
    1340                 :            : 
    1341                 :            :         case TD_OP_READ:
    1342                 :          0 :                 td_queue_read(parent, treq);
    1343                 :          0 :                 break;
    1344                 :            :         case TD_OP_BLOCK_STATUS:
    1345                 :          0 :                 td_queue_block_status(parent, &treq);
    1346                 :          0 :                 break;
    1347                 :            :         }
    1348                 :            : 
    1349                 :            : done:
    1350                 :          0 :         vreq->submitting--;
    1351         [ #  # ]:          0 :         if (!vreq->secs_pending)
    1352                 :          0 :                 tapdisk_vbd_complete_vbd_request(vbd, vreq);
    1353                 :          0 : }
    1354                 :            : 
    1355                 :            : void
    1356                 :          0 : tapdisk_vbd_forward_request(td_request_t treq)
    1357                 :            : {
    1358                 :            :         td_vbd_t *vbd;
    1359                 :            :         td_image_t *image;
    1360                 :            :         td_vbd_request_t *vreq;
    1361                 :            : 
    1362                 :          0 :         image = treq.image;
    1363                 :          0 :         vreq  = treq.vreq;
    1364                 :          0 :         vbd   = vreq->vbd;
    1365                 :            : 
    1366                 :            :         tapdisk_vbd_mark_progress(vbd);
    1367                 :            : 
    1368         [ #  # ]:          0 :         if (tapdisk_vbd_queue_ready(vbd))
    1369                 :          0 :                 __tapdisk_vbd_reissue_td_request(vbd, image, treq);
    1370                 :            :         else
    1371                 :          0 :                 td_complete_request(treq, -EBUSY);
    1372                 :          0 : }
    1373                 :            : 
    1374                 :            : int
    1375                 :          2 : add_extent(tapdisk_extents_t *extents, td_request_t *vreq)
    1376                 :            : {
    1377                 :            :         tapdisk_extent_t *extent;
    1378                 :          2 :         extent  = (tapdisk_extent_t*)malloc(sizeof(*extent));
    1379         [ +  - ]:          2 :         if(extent == NULL)
    1380                 :            :                 return -1;
    1381                 :            : 
    1382                 :          2 :         extent->start = vreq->sec;
    1383                 :          2 :         extent->length = vreq->secs;
    1384                 :          2 :         extent->flag = vreq->status;
    1385                 :          2 :         extent->next = NULL;
    1386                 :            : 
    1387 [ -  + ][ #  # ]:          2 :         if(extents->head != NULL && extents->tail != NULL) {
    1388                 :          0 :                 extents->tail->next = extent;
    1389                 :          0 :                 extents->tail = extent;
    1390                 :            :         } else {
    1391                 :          2 :                 extents->tail = extent;
    1392                 :          2 :                 extents->head = extent;
    1393                 :            :         }
    1394                 :            : 
    1395                 :          2 :         extents->count += 1;
    1396                 :          2 :         return 0;
    1397                 :            : }
    1398                 :            : 
    1399                 :            : int
    1400                 :          1 : block_status_add_extent(tapdisk_extents_t *extents, td_request_t *vreq)
    1401                 :            : {
    1402                 :          1 :         int ret  = 0;
    1403         [ +  - ]:          1 :         if(extents->tail == NULL) {
    1404                 :          1 :                 ret = add_extent(extents, vreq);
    1405                 :            :         } else {
    1406         [ #  # ]:          0 :                 if(extents->tail->flag == vreq->status) {
    1407                 :          0 :                         extents->tail->length += vreq->secs;
    1408                 :            :                 } else {
    1409                 :          0 :                         ret = add_extent(extents, vreq);
    1410                 :            :                 }
    1411                 :            :         }
    1412                 :          1 :         return ret;
    1413                 :            : }
    1414                 :            : 
    1415                 :            : void
    1416                 :          1 : tapdisk_vbd_complete_block_status_request(td_request_t treq, int res)
    1417                 :            : {
    1418                 :            :         td_vbd_t *vbd;
    1419                 :            :         td_image_t *image;
    1420                 :            :         td_vbd_request_t *vreq;
    1421                 :            : 
    1422                 :          1 :         image = treq.image;
    1423                 :          1 :         vreq  = treq.vreq;
    1424                 :          1 :         vbd   = vreq->vbd;
    1425                 :            :         tapdisk_vbd_mark_progress(vbd);
    1426                 :            : 
    1427                 :            :         /* Record this extents in the vreqs data */
    1428                 :          1 :         tapdisk_extents_t* extents = (tapdisk_extents_t*)vreq->data;
    1429         [ -  + ]:          1 :         if( block_status_add_extent(extents, &treq) != 0) {
    1430                 :          0 :                 ERROR("Could not allocate extent structure");
    1431                 :            :                 /* Propagate the ENOMEM */
    1432                 :          0 :                 res = -ENOMEM;
    1433                 :            :         }
    1434                 :            : 
    1435                 :          1 :         DBG(TLOG_DBG, "%s: req %s seg %d sec 0x%08"PRIx64
    1436                 :            :             " secs 0x%04x buf %p op %d res %d\n", image->name,
    1437                 :            :             vreq->name, treq.sidx, treq.sec, treq.secs,
    1438                 :            :             treq.buf, vreq->op, res);
    1439                 :            : 
    1440                 :          1 :         __tapdisk_vbd_complete_td_request(vbd, vreq, treq, res);
    1441                 :          1 : }
    1442                 :            : 
    1443                 :            : void
    1444                 :          0 : tapdisk_vbd_complete_td_request(td_request_t treq, int res)
    1445                 :            : {
    1446                 :          0 :         td_vbd_t *vbd;
    1447                 :            :         td_image_t *image, *leaf;
    1448                 :            :         td_vbd_request_t *vreq;
    1449                 :            : 
    1450                 :          0 :         image = treq.image;
    1451                 :          0 :         vreq  = treq.vreq;
    1452                 :          0 :         vbd   = vreq->vbd;
    1453                 :            : 
    1454                 :            :         tapdisk_vbd_mark_progress(vbd);
    1455                 :            : 
    1456 [ #  # ][ #  # ]:          0 :         if (abs(res) == ENOSPC && td_flag_test(image->flags,
    1457                 :            :                                 TD_IGNORE_ENOSPC)) {
    1458                 :          0 :                 res = 0;
    1459                 :          0 :                 leaf = tapdisk_vbd_first_image(vbd);
    1460         [ #  # ]:          0 :                 if (vbd->secondary_mode == TD_VBD_SECONDARY_MIRROR) {
    1461                 :            :                         DPRINTF("ENOSPC: disabling mirroring\n");
    1462                 :          0 :                         list_del_init(&leaf->next);
    1463                 :          0 :                         vbd->retired = leaf;
    1464         [ #  # ]:          0 :                 } else if (vbd->secondary_mode == TD_VBD_SECONDARY_STANDBY) {
    1465                 :            :                         DPRINTF("ENOSPC: failing over to secondary image\n");
    1466                 :          0 :                         list_add(&vbd->secondary->next, leaf->next.prev);
    1467                 :          0 :                         vbd->FIXME_enospc_redirect_count_enabled = 1;
    1468                 :            :                 }
    1469         [ #  # ]:          0 :                 if (vbd->secondary_mode != TD_VBD_SECONDARY_DISABLED) {
    1470                 :          0 :                         vbd->secondary = NULL;
    1471                 :          0 :                         vbd->secondary_mode = TD_VBD_SECONDARY_DISABLED;
    1472                 :          0 :                         signal_enospc(vbd);
    1473                 :            :                 }
    1474                 :            :         }
    1475                 :            : 
    1476 [ #  # ][ #  # ]:          0 :         if (res != 0 && image->type == DISK_TYPE_NBD && 
                 [ #  # ]
    1477         [ #  # ]:          0 :                         ((image == vbd->secondary) || 
    1478                 :          0 :                          (image == vbd->retired))) {
    1479                 :          0 :                 ERROR("Got non-zero res %d for NBD secondary - disabling "
    1480                 :            :                       "mirroring: %s", res, vreq->name);
    1481                 :          0 :                 vbd->nbd_mirror_failed = 1;
    1482                 :          0 :                 res = 0; /* Pretend the writes have completed successfully */
    1483                 :            : 
    1484                 :            :                 /* It was the secondary that timed out - disable secondary */
    1485                 :          0 :                 list_del_init(&image->next);
    1486                 :          0 :                 vbd->retired = image;
    1487         [ #  # ]:          0 :                 if (vbd->secondary_mode != TD_VBD_SECONDARY_DISABLED) {
    1488                 :          0 :                         vbd->secondary = NULL;
    1489                 :          0 :                         vbd->secondary_mode = TD_VBD_SECONDARY_DISABLED;
    1490                 :            :                 }
    1491                 :            :         }
    1492                 :            : 
    1493                 :          0 :         DBG(TLOG_DBG, "%s: req %s seg %d sec 0x%08"PRIx64
    1494                 :            :             " secs 0x%04x buf %p op %d res %d\n", image->name,
    1495                 :            :             vreq->name, treq.sidx, treq.sec, treq.secs,
    1496                 :            :             treq.buf, vreq->op, res);
    1497                 :            : 
    1498                 :          0 :         __tapdisk_vbd_complete_td_request(vbd, vreq, treq, res);
    1499                 :          0 : }
    1500                 :            : 
    1501                 :            : static inline void
    1502                 :          0 : queue_mirror_req(td_vbd_t *vbd, td_request_t clone)
    1503                 :            : {
    1504                 :          0 :         clone.image = vbd->secondary;
    1505                 :          0 :         td_queue_write(vbd->secondary, clone);
    1506                 :          0 : }
    1507                 :            : 
    1508                 :            : int
    1509                 :          1 : tapdisk_vbd_issue_request(td_vbd_t *vbd, td_vbd_request_t *vreq)
    1510                 :            : {
    1511                 :            :         td_image_t *image;
    1512                 :            :         td_request_t treq;
    1513                 :            :         bzero(&treq, sizeof(treq));
    1514                 :            :         td_sector_t sec;
    1515                 :            :         int i, err;
    1516                 :            : 
    1517                 :          1 :         sec    = vreq->sec;
    1518                 :          1 :         image  = tapdisk_vbd_first_image(vbd);
    1519                 :            : 
    1520                 :          1 :         vreq->submitting = 1;
    1521                 :            : 
    1522                 :            :         tapdisk_vbd_mark_progress(vbd);
    1523                 :          1 :         vreq->last_try = vbd->ts;
    1524                 :            : 
    1525                 :          1 :         tapdisk_vbd_move_request(vreq, &vbd->pending_requests);
    1526                 :            : 
    1527                 :          1 :         err = tapdisk_vbd_check_queue(vbd);
    1528         [ -  + ]:          1 :         if (err) {
    1529                 :          0 :                 vreq->error = err;
    1530                 :          0 :                 goto fail;
    1531                 :            :         }
    1532                 :            : 
    1533                 :          1 :         err = tapdisk_image_check_request(image, vreq);
    1534         [ +  - ]:          1 :         if (err) {
    1535                 :          0 :                 vreq->error = err;
    1536                 :          0 :                 goto fail;
    1537                 :            :         }
    1538                 :            : 
    1539         [ +  + ]:          2 :         for (i = 0; i < vreq->iovcnt; i++) {
    1540                 :          1 :                 struct td_iovec *iov = &vreq->iov[i];
    1541                 :            : 
    1542                 :          1 :                 treq.sidx           = i;
    1543                 :          1 :                 treq.buf            = iov->base;
    1544                 :          1 :                 treq.sec            = sec;
    1545                 :          1 :                 treq.secs           = iov->secs;
    1546                 :          1 :                 treq.image          = image;
    1547                 :          1 :                 treq.cb             = tapdisk_vbd_complete_td_request;
    1548                 :          1 :                 treq.cb_data        = NULL;
    1549                 :          1 :                 treq.vreq           = vreq;
    1550                 :            : 
    1551                 :            : 
    1552                 :          1 :                 vreq->secs_pending += iov->secs;
    1553                 :          1 :                 vbd->secs_pending  += iov->secs;
    1554 [ -  + ][ #  # ]:          1 :                 if (vbd->secondary_mode == TD_VBD_SECONDARY_MIRROR &&
    1555         [ #  # ]:          0 :                     vreq->op == TD_OP_WRITE &&
    1556                 :          0 :                         likely(vreq->skip_mirror == false))
    1557                 :            :                 {
    1558                 :          0 :                         vreq->secs_pending += iov->secs;
    1559                 :          0 :                         vbd->secs_pending  += iov->secs;
    1560                 :            :                 }
    1561                 :            : 
    1562   [ -  -  +  - ]:          1 :                 switch (vreq->op) {
    1563                 :            :                 case TD_OP_WRITE:
    1564                 :          0 :                         treq.op = TD_OP_WRITE;
    1565                 :          0 :                         vbd->vdi_stats.stats->write_reqs_submitted++;
    1566                 :            :                         /*
    1567                 :            :                          * it's important to queue the mirror request before
    1568                 :            :                          * queuing the main one. If the main image runs into
    1569                 :            :                          * ENOSPC, the mirroring could be disabled before
    1570                 :            :                          * td_queue_write returns, so if the mirror request was
    1571                 :            :                          * queued after (which would then not happen), we'd
    1572                 :            :                          * lose that write and cause the process to hang with
    1573                 :            :                          * unacknowledged writes.
    1574                 :            :                          *
    1575                 :            :                          * Skip when lcache is storing a read-through.
    1576                 :            :                          */
    1577 [ #  # ][ #  # ]:          0 :                         if (vbd->secondary_mode == TD_VBD_SECONDARY_MIRROR &&
    1578                 :          0 :                                 likely(vreq->skip_mirror == false)) {
    1579                 :          0 :                                         queue_mirror_req(vbd, treq);
    1580                 :            :                         }
    1581                 :            : 
    1582                 :          0 :                         td_queue_write(treq.image, treq);
    1583                 :            :                         break;
    1584                 :            : 
    1585                 :            :                 case TD_OP_READ:
    1586                 :          0 :                         treq.op = TD_OP_READ;
    1587                 :          0 :                         vbd->vdi_stats.stats->read_reqs_submitted++;
    1588                 :          0 :                         td_queue_read(treq.image, treq);
    1589                 :            :                         break;
    1590                 :            :                 case TD_OP_BLOCK_STATUS:
    1591                 :          1 :                         treq.op = TD_OP_BLOCK_STATUS;
    1592                 :          1 :                         treq.cb = tapdisk_vbd_complete_block_status_request;
    1593                 :          1 :                         td_queue_block_status(treq.image, &treq);
    1594                 :            :                         break;
    1595                 :            :                 }
    1596                 :            : 
    1597                 :          1 :                 DBG(TLOG_DBG, "%s: req %s seg %d sec 0x%08"PRIx64" secs 0x%04x "
    1598                 :            :                     "buf %p op %d\n", image->name, vreq->name, i, treq.sec, treq.secs,
    1599                 :            :                     treq.buf, vreq->op);
    1600                 :          1 :                 sec += iov->secs;
    1601                 :            :         }
    1602                 :            : 
    1603                 :            :         err = 0;
    1604                 :            : 
    1605                 :            : out:
    1606                 :          1 :         vreq->submitting--;
    1607         [ -  + ]:          1 :         if (!vreq->secs_pending) {
    1608         [ #  # ]:          0 :                 err = (err ? : vreq->error);
    1609                 :          0 :                 tapdisk_vbd_complete_vbd_request(vbd, vreq);
    1610                 :            :         }
    1611                 :            : 
    1612                 :          1 :         return err;
    1613                 :            : 
    1614                 :            : fail:
    1615                 :          0 :         vreq->error = err;
    1616                 :          0 :         goto out;
    1617                 :            : }
    1618                 :            : 
    1619                 :            : static int
    1620                 :          0 : tapdisk_vbd_request_completed(td_vbd_t *vbd, td_vbd_request_t *vreq)
    1621                 :            : {
    1622                 :          0 :         return vreq->list_head == &vbd->completed_requests;
    1623                 :            : }
    1624                 :            : 
    1625                 :            : static int
    1626                 :          0 : tapdisk_vbd_reissue_failed_requests(td_vbd_t *vbd)
    1627                 :            : {
    1628                 :            :         int err;
    1629                 :            :         struct timeval now;
    1630                 :          0 :         td_vbd_request_t *vreq, *tmp;
    1631                 :            : 
    1632                 :          0 :         err = 0;
    1633                 :          0 :         gettimeofday(&now, NULL);
    1634                 :            : 
    1635         [ #  # ]:          0 :         tapdisk_vbd_for_each_request(vreq, tmp, &vbd->failed_requests) {
    1636         [ #  # ]:          0 :                 if (vreq->secs_pending)
    1637                 :          0 :                         continue;
    1638                 :            : 
    1639         [ #  # ]:          0 :                 if (td_flag_test(vbd->state, TD_VBD_SHUTDOWN_REQUESTED)) {
    1640                 :          0 :                         tapdisk_vbd_complete_vbd_request(vbd, vreq);
    1641                 :          0 :                         continue;
    1642                 :            :                 }
    1643                 :            : 
    1644 [ #  # ][ #  # ]:          0 :                 if (vreq->error != -EBUSY &&
    1645                 :          0 :                     now.tv_sec - vreq->last_try.tv_sec < TD_VBD_RETRY_INTERVAL)
    1646                 :          0 :                         continue;
    1647                 :            : 
    1648                 :          0 :                 vbd->retries++;
    1649                 :          0 :                 vreq->num_retries++;
    1650                 :            : 
    1651                 :          0 :                 vreq->prev_error = vreq->error;
    1652                 :          0 :                 vreq->error      = 0;
    1653                 :            : 
    1654                 :          0 :                 DBG(TLOG_DBG, "retry #%d of req %s, "
    1655                 :            :                     "sec 0x%08"PRIx64", iovcnt: %d\n", vreq->num_retries,
    1656                 :            :                     vreq->name, vreq->sec, vreq->iovcnt);
    1657                 :            : 
    1658                 :          0 :                 err = tapdisk_vbd_issue_request(vbd, vreq);
    1659                 :            :                 /*
    1660                 :            :                  * if this request failed, but was not completed,
    1661                 :            :                  * we'll back off for a while.
    1662                 :            :                  */
    1663 [ #  # ][ #  # ]:          0 :                 if (err && !tapdisk_vbd_request_completed(vbd, vreq))
    1664                 :            :                         break;
    1665                 :            :         }
    1666                 :            : 
    1667                 :          0 :         return 0;
    1668                 :            : }
    1669                 :            : 
    1670                 :            : static void
    1671                 :          0 : tapdisk_vbd_count_new_request(td_vbd_t *vbd, td_vbd_request_t *vreq)
    1672                 :            : {
    1673                 :            :         struct td_iovec *iov;
    1674                 :            :         int write;
    1675                 :            : 
    1676                 :          0 :         write = vreq->op == TD_OP_WRITE;
    1677                 :            : 
    1678         [ #  # ]:          0 :         for (iov = &vreq->iov[0]; iov < &vreq->iov[vreq->iovcnt]; iov++)
    1679                 :          0 :                 td_sector_count_add(&vbd->secs, iov->secs, write);
    1680                 :          0 : }
    1681                 :            : 
    1682                 :            : static int
    1683                 :          0 : tapdisk_vbd_issue_new_requests(td_vbd_t *vbd)
    1684                 :            : {
    1685                 :            :         int err;
    1686                 :          0 :         td_vbd_request_t *vreq, *tmp;
    1687                 :            : 
    1688         [ #  # ]:          0 :         tapdisk_vbd_for_each_request(vreq, tmp, &vbd->new_requests) {
    1689                 :          0 :                 err = tapdisk_vbd_issue_request(vbd, vreq);
    1690                 :            :                 /*
    1691                 :            :                  * if this request failed, but was not completed,
    1692                 :            :                  * we'll back off for a while.
    1693                 :            :                  */
    1694   [ #  #  #  # ]:          0 :                 if (err && !tapdisk_vbd_request_completed(vbd, vreq))
    1695                 :            :                         return err;
    1696                 :            : 
    1697                 :          0 :                 tapdisk_vbd_count_new_request(vbd, vreq);
    1698                 :            :         }
    1699                 :            : 
    1700                 :            :         return 0;
    1701                 :            : }
    1702                 :            : 
    1703                 :            : int
    1704                 :          0 : tapdisk_vbd_recheck_state(td_vbd_t *vbd)
    1705                 :            : {
    1706                 :          0 :         int err = 0;
    1707                 :            : 
    1708         [ #  # ]:          0 :         if (list_empty(&vbd->new_requests))
    1709                 :            :                 return 0;
    1710                 :            : 
    1711         [ #  # ]:          0 :         if (td_flag_test(vbd->state, TD_VBD_QUIESCED) ||
    1712                 :            :             td_flag_test(vbd->state, TD_VBD_QUIESCE_REQUESTED))
    1713                 :            :                 return 0;
    1714                 :            : 
    1715                 :          0 :         err = tapdisk_vbd_issue_requests(vbd);
    1716                 :            : 
    1717                 :            :         /* If we have errors stop checking in this cycle */
    1718                 :          0 :         return err ? 0 : 1;
    1719                 :            : }
    1720                 :            : 
    1721                 :            : static int
    1722                 :          0 : tapdisk_vbd_kill_requests(td_vbd_t *vbd)
    1723                 :            : {
    1724                 :            :         td_vbd_request_t *vreq, *tmp;
    1725                 :            : 
    1726         [ #  # ]:          0 :         tapdisk_vbd_for_each_request(vreq, tmp, &vbd->new_requests) {
    1727                 :          0 :                 vreq->error = -ESHUTDOWN;
    1728                 :          0 :                 tapdisk_vbd_move_request(vreq, &vbd->completed_requests);
    1729                 :            :         }
    1730                 :            : 
    1731         [ #  # ]:          0 :         tapdisk_vbd_for_each_request(vreq, tmp, &vbd->failed_requests) {
    1732                 :          0 :                 vreq->error = -ESHUTDOWN;
    1733                 :          0 :                 tapdisk_vbd_move_request(vreq, &vbd->completed_requests);
    1734                 :            :         }
    1735                 :            : 
    1736                 :          0 :         return 0;
    1737                 :            : }
    1738                 :            : 
    1739                 :            : int
    1740                 :          0 : tapdisk_vbd_issue_requests(td_vbd_t *vbd)
    1741                 :            : {
    1742                 :            :         int err;
    1743                 :            : 
    1744         [ #  # ]:          0 :         if (td_flag_test(vbd->state, TD_VBD_DEAD))
    1745                 :          0 :                 return tapdisk_vbd_kill_requests(vbd);
    1746                 :            : 
    1747         [ #  # ]:          0 :         if (td_flag_test(vbd->state, TD_VBD_QUIESCED) ||
    1748                 :            :             td_flag_test(vbd->state, TD_VBD_QUIESCE_REQUESTED)) {
    1749                 :            : 
    1750         [ #  # ]:          0 :                 if (td_flag_test(vbd->state, TD_VBD_RESUME_FAILED))
    1751                 :          0 :                         return tapdisk_vbd_kill_requests(vbd);
    1752                 :            :                 else
    1753                 :            :                         return -EAGAIN;
    1754                 :            :         }
    1755                 :            : 
    1756                 :          0 :         err = tapdisk_vbd_reissue_failed_requests(vbd);
    1757         [ #  # ]:          0 :         if (err)
    1758                 :            :                 return err;
    1759                 :            : 
    1760                 :          0 :         return tapdisk_vbd_issue_new_requests(vbd);
    1761                 :            : }
    1762                 :            : 
    1763                 :            : int
    1764                 :          0 : tapdisk_vbd_queue_request(td_vbd_t *vbd, td_vbd_request_t *vreq)
    1765                 :            : {
    1766                 :          0 :         gettimeofday(&vreq->ts, NULL);
    1767                 :          0 :         vreq->vbd = vbd;
    1768                 :            : 
    1769                 :          0 :         list_add_tail(&vreq->next, &vbd->new_requests);
    1770                 :          0 :         vbd->received++;
    1771                 :            : 
    1772                 :          0 :         return 0;
    1773                 :            : }
    1774                 :            : 
    1775                 :            : void
    1776                 :          0 : tapdisk_vbd_kick(td_vbd_t *vbd)
    1777                 :            : {
    1778                 :          0 :         const struct list_head *list = &vbd->completed_requests;
    1779                 :            :         td_vbd_request_t *vreq, *prev, *next;
    1780                 :            : 
    1781                 :          0 :         vbd->kicked++;
    1782                 :            : 
    1783         [ #  # ]:          0 :         while (!list_empty(list)) {
    1784                 :            : 
    1785                 :            :                 /*
    1786                 :            :                  * Take one request off the completed requests list, and then look for
    1787                 :            :                  * other requests in the same list that have the same token and
    1788                 :            :                  * complete them. This way we complete requests against the same token
    1789                 :            :                  * in one go before we proceed to completing requests with other
    1790                 :            :                  * tokens. The token is usually used to point back to some other
    1791                 :            :                  * structure, e.g. a blktap or a tapdisk3 connexion. Once all requests
    1792                 :            :                  * with a specific token have been completed, proceed to the next one
    1793                 :            :                  * until the list is empty.
    1794                 :            :                  */
    1795                 :          0 :                 prev = list_entry(list->next, td_vbd_request_t, next);
    1796                 :          0 :                 list_del(&prev->next);
    1797                 :            : 
    1798         [ #  # ]:          0 :                 tapdisk_vbd_for_each_request(vreq, next, list) {
    1799         [ #  # ]:          0 :                         if (vreq->token == prev->token) {
    1800                 :            : 
    1801                 :          0 :                                 prev->cb(prev, prev->error, prev->token, 0);
    1802                 :          0 :                                 vbd->returned++;
    1803                 :            : 
    1804                 :          0 :                                 list_del(&vreq->next);
    1805                 :          0 :                                 prev = vreq;
    1806                 :            :                         }
    1807                 :            :                 }
    1808                 :            : 
    1809                 :          0 :                 prev->cb(prev, prev->error, prev->token, 1);
    1810                 :          0 :                 vbd->returned++;
    1811                 :            :         }
    1812                 :          0 : }
    1813                 :            : 
    1814                 :            : int
    1815                 :          0 : tapdisk_vbd_start_nbdservers(td_vbd_t *vbd)
    1816                 :            : {
    1817                 :            :         td_disk_info_t info;
    1818                 :            :         int err;
    1819                 :            : 
    1820                 :          0 :         err = tapdisk_vbd_get_disk_info(vbd, &info);
    1821                 :            : 
    1822         [ #  # ]:          0 :         if (err)
    1823                 :          0 :                 return err;
    1824                 :            : 
    1825                 :          0 :         vbd->nbdserver = tapdisk_nbdserver_alloc(vbd, info, TAPDISK_NBD_PROTOCOL_OLD);
    1826         [ #  # ]:          0 :         if (!vbd->nbdserver) {
    1827                 :            :                 EPRINTF("Error starting nbd server");
    1828                 :            :                 return -1;
    1829                 :            :         }
    1830                 :          0 :         err = tapdisk_nbdserver_listen_unix(vbd->nbdserver);
    1831         [ #  # ]:          0 :         if (err) {
    1832                 :          0 :                 tapdisk_nbdserver_free(vbd->nbdserver);
    1833                 :          0 :                 EPRINTF("failed to listen on the UNIX domain socket: %s\n",
    1834                 :            :                                 strerror(-err));
    1835                 :            :                 return err;
    1836                 :            :         }
    1837                 :            : 
    1838                 :          0 :         vbd->nbdserver_new = tapdisk_nbdserver_alloc(vbd, info, TAPDISK_NBD_PROTOCOL_NEW);
    1839         [ #  # ]:          0 :         if (!vbd->nbdserver_new) {
    1840                 :            :                 EPRINTF("Error starting new-style nbd server");
    1841                 :            :                 return -1;
    1842                 :            :         }
    1843                 :          0 :         err = tapdisk_nbdserver_listen_unix(vbd->nbdserver_new);
    1844         [ #  # ]:          0 :         if (err) {
    1845                 :          0 :                 tapdisk_nbdserver_free(vbd->nbdserver_new);
    1846                 :          0 :                 EPRINTF("failed to listen on the UNIX domain socket: %s\n",
    1847                 :            :                                 strerror(-err));
    1848                 :            :                 return err;
    1849                 :            :         }
    1850                 :            : 
    1851                 :            :         return 0;
    1852                 :            : }
    1853                 :            : 
    1854                 :            : 
    1855                 :            : static int
    1856                 :          0 : tapdisk_vbd_reqs_outstanding(td_vbd_t *vbd)
    1857                 :            : {
    1858                 :            :         int new, pending, failed, completed;
    1859                 :            : 
    1860         [ #  # ]:          0 :         ASSERT(vbd);
    1861                 :            : 
    1862                 :          0 :         tapdisk_vbd_queue_count(vbd, &new, &pending, &failed, &completed);
    1863                 :            : 
    1864                 :          0 :         return new + pending + failed + completed;
    1865                 :            : }
    1866                 :            : 
    1867                 :            : 
    1868                 :            : void
    1869                 :          0 : tapdisk_vbd_stats(td_vbd_t *vbd, td_stats_t *st)
    1870                 :            : {
    1871                 :            :         td_image_t *image, *next;
    1872                 :            :     struct td_xenblkif *blkif;
    1873                 :          0 :         const bool read_caching =
    1874                 :          0 :                 TD_OPEN_NO_O_DIRECT == (vbd->flags & TD_OPEN_NO_O_DIRECT);
    1875                 :            : 
    1876                 :          0 :         tapdisk_stats_enter(st, '{');
    1877                 :          0 :         tapdisk_stats_field(st, "name", "s", vbd->name);
    1878                 :            : 
    1879                 :          0 :         tapdisk_stats_field(st, "secs", "[");
    1880                 :          0 :         tapdisk_stats_val(st, "llu", vbd->secs.rd);
    1881                 :          0 :         tapdisk_stats_val(st, "llu", vbd->secs.wr);
    1882                 :          0 :         tapdisk_stats_leave(st, ']');
    1883                 :            : 
    1884                 :          0 :         tapdisk_stats_field(st, "images", "[");
    1885         [ #  # ]:          0 :         tapdisk_vbd_for_each_image(vbd, image, next)
    1886                 :          0 :                 tapdisk_image_stats(image, st);
    1887                 :          0 :         tapdisk_stats_leave(st, ']');
    1888                 :            : 
    1889         [ #  # ]:          0 :         if (vbd->tap) {
    1890                 :          0 :                 tapdisk_stats_field(st, "tap", "{");
    1891                 :          0 :                 tapdisk_blktap_stats(vbd->tap, st);
    1892                 :          0 :                 tapdisk_stats_leave(st, '}');
    1893                 :            :         }
    1894                 :            : 
    1895                 :            :     /*
    1896                 :            :      * TODO Is this used by any one?
    1897                 :            :      */
    1898         [ #  # ]:          0 :     if (!list_empty(&vbd->rings)) {
    1899                 :          0 :             tapdisk_stats_field(st, "xenbus", "{");
    1900         [ #  # ]:          0 :         list_for_each_entry(blkif, &vbd->rings, entry)
    1901                 :          0 :                     tapdisk_xenblkif_stats(blkif, st);
    1902                 :          0 :         tapdisk_stats_leave(st, '}');
    1903                 :            :     }
    1904                 :            : 
    1905                 :          0 :         tapdisk_stats_field(st,
    1906                 :            :                         "FIXME_enospc_redirect_count",
    1907                 :            :                         "llu", vbd->FIXME_enospc_redirect_count);
    1908                 :            : 
    1909                 :          0 :         tapdisk_stats_field(st,
    1910                 :            :                         "nbd_mirror_failed",
    1911                 :            :                         "d", vbd->nbd_mirror_failed);
    1912                 :            : 
    1913                 :          0 :         tapdisk_stats_field(st,
    1914                 :            :                         "reqs_outstanding",
    1915                 :            :                         "d", tapdisk_vbd_reqs_outstanding(vbd));
    1916                 :            : 
    1917         [ #  # ]:          0 :         tapdisk_stats_field(st,
    1918                 :            :                         "read_caching",
    1919                 :            :                         "s",  read_caching ? "true": "false");
    1920                 :            : 
    1921                 :          0 :         tapdisk_stats_leave(st, '}');
    1922                 :          0 : }
    1923                 :            : 
    1924                 :            : 
    1925                 :            : bool
    1926                 :          0 : tapdisk_vbd_contains_dead_rings(td_vbd_t * vbd)
    1927                 :            : {
    1928                 :          0 :     return !list_empty(&vbd->dead_rings);
    1929                 :            : }

Generated by: LCOV version 1.13