block/qed-table.c

   1 /*
   2  * QEMU Enhanced Disk Format Table I/O
   3  *
   4  * Copyright IBM, Corp. 2010
   5  *
   6  * Authors:
   7  *  Stefan Hajnoczi   <stefanha@linux.vnet.ibm.com>
   8  *  Anthony Liguori   <aliguori@us.ibm.com>
   9  *
  10  * This work is licensed under the terms of the GNU LGPL, version 2 or later.
  11  * See the COPYING.LIB file in the top-level directory.
  12  *
  13  */
  14
  15 #include "qemu/osdep.h"
  16 #include "trace.h"
  17 #include "qemu/sockets.h" /* for EINPROGRESS on Windows */
  18 #include "qed.h"
  19 #include "qemu/bswap.h"
  20
  21 /* Called with table_lock held.  */
  22 static int qed_read_table(BDRVQEDState *s, uint64_t offset, QEDTable *table)
  23 {
  24     unsigned int bytes = s->header.cluster_size * s->header.table_size;
  25
  26     int noffsets;
  27     int i, ret;
  28
  29     trace_qed_read_table(s, offset, table);
  30
  31     qemu_co_mutex_unlock(&s->table_lock);
  32     ret = bdrv_co_pread(s->bs->file, offset, bytes, table->offsets, 0);
  33     qemu_co_mutex_lock(&s->table_lock);
  34     if (ret < 0) {
  35         goto out;
  36     }
  37
  38     /* Byteswap offsets */
  39     noffsets = bytes / sizeof(uint64_t);
  40     for (i = 0; i < noffsets; i++) {
  41         table->offsets[i] = le64_to_cpu(table->offsets[i]);
  42     }
  43
  44     ret = 0;
  45 out:
  46     /* Completion */
  47     trace_qed_read_table_cb(s, table, ret);
  48     return ret;
  49 }
  50
  51 /**
  52  * Write out an updated part or all of a table
  53  *
  54  * @s:          QED state
  55  * @offset:     Offset of table in image file, in bytes
  56  * @table:      Table
  57  * @index:      Index of first element
  58  * @n:          Number of elements
  59  * @flush:      Whether or not to sync to disk
  60  *
  61  * Called with table_lock held.
  62  */
  63 static int qed_write_table(BDRVQEDState *s, uint64_t offset, QEDTable *table,
  64                            unsigned int index, unsigned int n, bool flush)
  65 {
  66     unsigned int sector_mask = BDRV_SECTOR_SIZE / sizeof(uint64_t) - 1;
  67     unsigned int start, end, i;
  68     QEDTable *new_table;
  69     size_t len_bytes;
  70     int ret;
  71
  72     trace_qed_write_table(s, offset, table, index, n);
  73
  74     /* Calculate indices of the first and one after last elements */
  75     start = index & ~sector_mask;
  76     end = (index + n + sector_mask) & ~sector_mask;
  77
  78     len_bytes = (end - start) * sizeof(uint64_t);
  79
  80     new_table = qemu_blockalign(s->bs, len_bytes);
  81
  82     /* Byteswap table */
  83     for (i = start; i < end; i++) {
  84         uint64_t le_offset = cpu_to_le64(table->offsets[i]);
  85         new_table->offsets[i - start] = le_offset;
  86     }
  87
  88     /* Adjust for offset into table */
  89     offset += start * sizeof(uint64_t);
  90
  91     qemu_co_mutex_unlock(&s->table_lock);
  92     ret = bdrv_co_pwrite(s->bs->file, offset, len_bytes, new_table->offsets, 0);
  93     qemu_co_mutex_lock(&s->table_lock);
  94     trace_qed_write_table_cb(s, table, flush, ret);
  95     if (ret < 0) {
  96         goto out;
  97     }
  98
  99     if (flush) {
 100         ret = bdrv_flush(s->bs);
 101         if (ret < 0) {
 102             goto out;
 103         }
 104     }
 105
 106     ret = 0;
 107 out:
 108     qemu_vfree(new_table);
 109     return ret;
 110 }
 111
 112 int qed_read_l1_table_sync(BDRVQEDState *s)
 113 {
 114     return qed_read_table(s, s->header.l1_table_offset, s->l1_table);
 115 }
 116
 117 /* Called with table_lock held.  */
 118 int qed_write_l1_table(BDRVQEDState *s, unsigned int index, unsigned int n)
 119 {
 120     BLKDBG_EVENT(s->bs->file, BLKDBG_L1_UPDATE);
 121     return qed_write_table(s, s->header.l1_table_offset,
 122                            s->l1_table, index, n, false);
 123 }
 124
 125 int qed_write_l1_table_sync(BDRVQEDState *s, unsigned int index,
 126                             unsigned int n)
 127 {
 128     return qed_write_l1_table(s, index, n);
 129 }
 130
 131 /* Called with table_lock held.  */
 132 int qed_read_l2_table(BDRVQEDState *s, QEDRequest *request, uint64_t offset)
 133 {
 134     int ret;
 135
 136     qed_unref_l2_cache_entry(request->l2_table);
 137
 138     /* Check for cached L2 entry */
 139     request->l2_table = qed_find_l2_cache_entry(&s->l2_cache, offset);
 140     if (request->l2_table) {
 141         return 0;
 142     }
 143
 144     request->l2_table = qed_alloc_l2_cache_entry(&s->l2_cache);
 145     request->l2_table->table = qed_alloc_table(s);
 146
 147     BLKDBG_EVENT(s->bs->file, BLKDBG_L2_LOAD);
 148     ret = qed_read_table(s, offset, request->l2_table->table);
 149
 150     if (ret) {
 151         /* can't trust loaded L2 table anymore */
 152         qed_unref_l2_cache_entry(request->l2_table);
 153         request->l2_table = NULL;
 154     } else {
 155         request->l2_table->offset = offset;
 156
 157         qed_commit_l2_cache_entry(&s->l2_cache, request->l2_table);
 158
 159         /* This is guaranteed to succeed because we just committed the entry
 160          * to the cache.
 161          */
 162         request->l2_table = qed_find_l2_cache_entry(&s->l2_cache, offset);
 163         assert(request->l2_table != NULL);
 164     }
 165
 166     return ret;
 167 }
 168
 169 int qed_read_l2_table_sync(BDRVQEDState *s, QEDRequest *request, uint64_t offset)
 170 {
 171     return qed_read_l2_table(s, request, offset);
 172 }
 173
 174 /* Called with table_lock held.  */
 175 int qed_write_l2_table(BDRVQEDState *s, QEDRequest *request,
 176                        unsigned int index, unsigned int n, bool flush)
 177 {
 178     BLKDBG_EVENT(s->bs->file, BLKDBG_L2_UPDATE);
 179     return qed_write_table(s, request->l2_table->offset,
 180                            request->l2_table->table, index, n, flush);
 181 }
 182
 183 int qed_write_l2_table_sync(BDRVQEDState *s, QEDRequest *request,
 184                             unsigned int index, unsigned int n, bool flush)
 185 {
 186     return qed_write_l2_table(s, request, index, n, flush);
 187 }