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