block/qed-check.c

   1 /*
   2  * QEMU Enhanced Disk Format Consistency Check
   3  *
   4  * Copyright IBM, Corp. 2010
   5  *
   6  * Authors:
   7  *  Stefan Hajnoczi   <stefanha@linux.vnet.ibm.com>
   8  *
   9  * This work is licensed under the terms of the GNU LGPL, version 2 or later.
  10  * See the COPYING.LIB file in the top-level directory.
  11  *
  12  */
  13
  14 #include "qed.h"
  15
  16 typedef struct {
  17     BDRVQEDState *s;
  18     BdrvCheckResult *result;
  19     bool fix;                           /* whether to fix invalid offsets */
  20
  21     uint64_t nclusters;
  22     uint32_t *used_clusters;            /* referenced cluster bitmap */
  23
  24     QEDRequest request;
  25 } QEDCheck;
  26
  27 static bool qed_test_bit(uint32_t *bitmap, uint64_t n) {
  28     return !!(bitmap[n / 32] & (1 << (n % 32)));
  29 }
  30
  31 static void qed_set_bit(uint32_t *bitmap, uint64_t n) {
  32     bitmap[n / 32] |= 1 << (n % 32);
  33 }
  34
  35 /**
  36  * Set bitmap bits for clusters
  37  *
  38  * @check:          Check structure
  39  * @offset:         Starting offset in bytes
  40  * @n:              Number of clusters
  41  */
  42 static bool qed_set_used_clusters(QEDCheck *check, uint64_t offset,
  43                                   unsigned int n)
  44 {
  45     uint64_t cluster = qed_bytes_to_clusters(check->s, offset);
  46     unsigned int corruptions = 0;
  47
  48     while (n-- != 0) {
  49         /* Clusters should only be referenced once */
  50         if (qed_test_bit(check->used_clusters, cluster)) {
  51             corruptions++;
  52         }
  53
  54         qed_set_bit(check->used_clusters, cluster);
  55         cluster++;
  56     }
  57
  58     check->result->corruptions += corruptions;
  59     return corruptions == 0;
  60 }
  61
  62 /**
  63  * Check an L2 table
  64  *
  65  * @ret:            Number of invalid cluster offsets
  66  */
  67 static unsigned int qed_check_l2_table(QEDCheck *check, QEDTable *table)
  68 {
  69     BDRVQEDState *s = check->s;
  70     unsigned int i, num_invalid = 0;
  71     uint64_t last_offset = 0;
  72
  73     for (i = 0; i < s->table_nelems; i++) {
  74         uint64_t offset = table->offsets[i];
  75
  76         if (qed_offset_is_unalloc_cluster(offset) ||
  77             qed_offset_is_zero_cluster(offset)) {
  78             continue;
  79         }
  80         check->result->bfi.allocated_clusters++;
  81         if (last_offset && (last_offset + s->header.cluster_size != offset)) {
  82             check->result->bfi.fragmented_clusters++;
  83         }
  84         last_offset = offset;
  85
  86         /* Detect invalid cluster offset */
  87         if (!qed_check_cluster_offset(s, offset)) {
  88             if (check->fix) {
  89                 table->offsets[i] = 0;
  90                 check->result->corruptions_fixed++;
  91             } else {
  92                 check->result->corruptions++;
  93             }
  94
  95             num_invalid++;
  96             continue;
  97         }
  98
  99         qed_set_used_clusters(check, offset, 1);
 100     }
 101
 102     return num_invalid;
 103 }
 104
 105 /**
 106  * Descend tables and check each cluster is referenced once only
 107  */
 108 static int qed_check_l1_table(QEDCheck *check, QEDTable *table)
 109 {
 110     BDRVQEDState *s = check->s;
 111     unsigned int i, num_invalid_l1 = 0;
 112     int ret, last_error = 0;
 113
 114     /* Mark L1 table clusters used */
 115     qed_set_used_clusters(check, s->header.l1_table_offset,
 116                           s->header.table_size);
 117
 118     for (i = 0; i < s->table_nelems; i++) {
 119         unsigned int num_invalid_l2;
 120         uint64_t offset = table->offsets[i];
 121
 122         if (qed_offset_is_unalloc_cluster(offset)) {
 123             continue;
 124         }
 125
 126         /* Detect invalid L2 offset */
 127         if (!qed_check_table_offset(s, offset)) {
 128             /* Clear invalid offset */
 129             if (check->fix) {
 130                 table->offsets[i] = 0;
 131                 check->result->corruptions_fixed++;
 132             } else {
 133                 check->result->corruptions++;
 134             }
 135
 136             num_invalid_l1++;
 137             continue;
 138         }
 139
 140         if (!qed_set_used_clusters(check, offset, s->header.table_size)) {
 141             continue; /* skip an invalid table */
 142         }
 143
 144         ret = qed_read_l2_table_sync(s, &check->request, offset);
 145         if (ret) {
 146             check->result->check_errors++;
 147             last_error = ret;
 148             continue;
 149         }
 150
 151         num_invalid_l2 = qed_check_l2_table(check,
 152                                             check->request.l2_table->table);
 153
 154         /* Write out fixed L2 table */
 155         if (num_invalid_l2 > 0 && check->fix) {
 156             ret = qed_write_l2_table_sync(s, &check->request, 0,
 157                                           s->table_nelems, false);
 158             if (ret) {
 159                 check->result->check_errors++;
 160                 last_error = ret;
 161                 continue;
 162             }
 163         }
 164     }
 165
 166     /* Drop reference to final table */
 167     qed_unref_l2_cache_entry(check->request.l2_table);
 168     check->request.l2_table = NULL;
 169
 170     /* Write out fixed L1 table */
 171     if (num_invalid_l1 > 0 && check->fix) {
 172         ret = qed_write_l1_table_sync(s, 0, s->table_nelems);
 173         if (ret) {
 174             check->result->check_errors++;
 175             last_error = ret;
 176         }
 177     }
 178
 179     return last_error;
 180 }
 181
 182 /**
 183  * Check for unreferenced (leaked) clusters
 184  */
 185 static void qed_check_for_leaks(QEDCheck *check)
 186 {
 187     BDRVQEDState *s = check->s;
 188     uint64_t i;
 189
 190     for (i = s->header.header_size; i < check->nclusters; i++) {
 191         if (!qed_test_bit(check->used_clusters, i)) {
 192             check->result->leaks++;
 193         }
 194     }
 195 }
 196
 197 /**
 198  * Mark an image clean once it passes check or has been repaired
 199  */
 200 static void qed_check_mark_clean(BDRVQEDState *s, BdrvCheckResult *result)
 201 {
 202     /* Skip if there were unfixable corruptions or I/O errors */
 203     if (result->corruptions > 0 || result->check_errors > 0) {
 204         return;
 205     }
 206
 207     /* Skip if image is already marked clean */
 208     if (!(s->header.features & QED_F_NEED_CHECK)) {
 209         return;
 210     }
 211
 212     /* Ensure fixes reach storage before clearing check bit */
 213     bdrv_flush(s->bs);
 214
 215     s->header.features &= ~QED_F_NEED_CHECK;
 216     qed_write_header_sync(s);
 217 }
 218
 219 int qed_check(BDRVQEDState *s, BdrvCheckResult *result, bool fix)
 220 {
 221     QEDCheck check = {
 222         .s = s,
 223         .result = result,
 224         .nclusters = qed_bytes_to_clusters(s, s->file_size),
 225         .request = { .l2_table = NULL },
 226         .fix = fix,
 227     };
 228     int ret;
 229
 230     check.used_clusters = g_malloc0(((check.nclusters + 31) / 32) *
 231                                        sizeof(check.used_clusters[0]));
 232
 233     check.result->bfi.total_clusters =
 234         (s->header.image_size + s->header.cluster_size - 1) /
 235             s->header.cluster_size;
 236     ret = qed_check_l1_table(&check, s->l1_table);
 237     if (ret == 0) {
 238         /* Only check for leaks if entire image was scanned successfully */
 239         qed_check_for_leaks(&check);
 240
 241         if (fix) {
 242             qed_check_mark_clean(s, result);
 243         }
 244     }
 245
 246     g_free(check.used_clusters);
 247     return ret;
 248 }