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             } else {
  91                 check->result->corruptions++;
  92             }
  93
  94             num_invalid++;
  95             continue;
  96         }
  97
  98         qed_set_used_clusters(check, offset, 1);
  99     }
 100
 101     return num_invalid;
 102 }
 103
 104 /**
 105  * Descend tables and check each cluster is referenced once only
 106  */
 107 static int qed_check_l1_table(QEDCheck *check, QEDTable *table)
 108 {
 109     BDRVQEDState *s = check->s;
 110     unsigned int i, num_invalid_l1 = 0;
 111     int ret, last_error = 0;
 112
 113     /* Mark L1 table clusters used */
 114     qed_set_used_clusters(check, s->header.l1_table_offset,
 115                           s->header.table_size);
 116
 117     for (i = 0; i < s->table_nelems; i++) {
 118         unsigned int num_invalid_l2;
 119         uint64_t offset = table->offsets[i];
 120
 121         if (qed_offset_is_unalloc_cluster(offset)) {
 122             continue;
 123         }
 124
 125         /* Detect invalid L2 offset */
 126         if (!qed_check_table_offset(s, offset)) {
 127             /* Clear invalid offset */
 128             if (check->fix) {
 129                 table->offsets[i] = 0;
 130             } else {
 131                 check->result->corruptions++;
 132             }
 133
 134             num_invalid_l1++;
 135             continue;
 136         }
 137
 138         if (!qed_set_used_clusters(check, offset, s->header.table_size)) {
 139             continue; /* skip an invalid table */
 140         }
 141
 142         ret = qed_read_l2_table_sync(s, &check->request, offset);
 143         if (ret) {
 144             check->result->check_errors++;
 145             last_error = ret;
 146             continue;
 147         }
 148
 149         num_invalid_l2 = qed_check_l2_table(check,
 150                                             check->request.l2_table->table);
 151
 152         /* Write out fixed L2 table */
 153         if (num_invalid_l2 > 0 && check->fix) {
 154             ret = qed_write_l2_table_sync(s, &check->request, 0,
 155                                           s->table_nelems, false);
 156             if (ret) {
 157                 check->result->check_errors++;
 158                 last_error = ret;
 159                 continue;
 160             }
 161         }
 162     }
 163
 164     /* Drop reference to final table */
 165     qed_unref_l2_cache_entry(check->request.l2_table);
 166     check->request.l2_table = NULL;
 167
 168     /* Write out fixed L1 table */
 169     if (num_invalid_l1 > 0 && check->fix) {
 170         ret = qed_write_l1_table_sync(s, 0, s->table_nelems);
 171         if (ret) {
 172             check->result->check_errors++;
 173             last_error = ret;
 174         }
 175     }
 176
 177     return last_error;
 178 }
 179
 180 /**
 181  * Check for unreferenced (leaked) clusters
 182  */
 183 static void qed_check_for_leaks(QEDCheck *check)
 184 {
 185     BDRVQEDState *s = check->s;
 186     uint64_t i;
 187
 188     for (i = s->header.header_size; i < check->nclusters; i++) {
 189         if (!qed_test_bit(check->used_clusters, i)) {
 190             check->result->leaks++;
 191         }
 192     }
 193 }
 194
 195 int qed_check(BDRVQEDState *s, BdrvCheckResult *result, bool fix)
 196 {
 197     QEDCheck check = {
 198         .s = s,
 199         .result = result,
 200         .nclusters = qed_bytes_to_clusters(s, s->file_size),
 201         .request = { .l2_table = NULL },
 202         .fix = fix,
 203     };
 204     int ret;
 205
 206     check.used_clusters = g_malloc0(((check.nclusters + 31) / 32) *
 207                                        sizeof(check.used_clusters[0]));
 208
 209     check.result->bfi.total_clusters =
 210         (s->header.image_size + s->header.cluster_size - 1) /
 211             s->header.cluster_size;
 212     ret = qed_check_l1_table(&check, s->l1_table);
 213     if (ret == 0) {
 214         /* Only check for leaks if entire image was scanned successfully */
 215         qed_check_for_leaks(&check);
 216     }
 217
 218     g_free(check.used_clusters);
 219     return ret;
 220 }