qemu

FORK: QEMU emulator
git clone https://git.neptards.moe/neptards/qemu.git
Log | Files | Refs | Submodules | LICENSE

qed-cluster.c (4664B)

      1 /*
      2  * QEMU Enhanced Disk Format Cluster functions
      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 "qed.h"
     17 
     18 /**
     19  * Count the number of contiguous data clusters
     20  *
     21  * @s:              QED state
     22  * @table:          L2 table
     23  * @index:          First cluster index
     24  * @n:              Maximum number of clusters
     25  * @offset:         Set to first cluster offset
     26  *
     27  * This function scans tables for contiguous clusters.  A contiguous run of
     28  * clusters may be allocated, unallocated, or zero.
     29  */
     30 static unsigned int qed_count_contiguous_clusters(BDRVQEDState *s,
     31                                                   QEDTable *table,
     32                                                   unsigned int index,
     33                                                   unsigned int n,
     34                                                   uint64_t *offset)
     35 {
     36     unsigned int end = MIN(index + n, s->table_nelems);
     37     uint64_t last = table->offsets[index];
     38     unsigned int i;
     39 
     40     *offset = last;
     41 
     42     for (i = index + 1; i < end; i++) {
     43         if (qed_offset_is_unalloc_cluster(last)) {
     44             /* Counting unallocated clusters */
     45             if (!qed_offset_is_unalloc_cluster(table->offsets[i])) {
     46                 break;
     47             }
     48         } else if (qed_offset_is_zero_cluster(last)) {
     49             /* Counting zero clusters */
     50             if (!qed_offset_is_zero_cluster(table->offsets[i])) {
     51                 break;
     52             }
     53         } else {
     54             /* Counting allocated clusters */
     55             if (table->offsets[i] != last + s->header.cluster_size) {
     56                 break;
     57             }
     58             last = table->offsets[i];
     59         }
     60     }
     61     return i - index;
     62 }
     63 
     64 /**
     65  * Find the offset of a data cluster
     66  *
     67  * @s:          QED state
     68  * @request:    L2 cache entry
     69  * @pos:        Byte position in device
     70  * @len:        Number of bytes (may be shortened on return)
     71  * @img_offset: Contains offset in the image file on success
     72  *
     73  * This function translates a position in the block device to an offset in the
     74  * image file. The translated offset or unallocated range in the image file is
     75  * reported back in *img_offset and *len.
     76  *
     77  * If the L2 table exists, request->l2_table points to the L2 table cache entry
     78  * and the caller must free the reference when they are finished.  The cache
     79  * entry is exposed in this way to avoid callers having to read the L2 table
     80  * again later during request processing.  If request->l2_table is non-NULL it
     81  * will be unreferenced before taking on the new cache entry.
     82  *
     83  * On success QED_CLUSTER_FOUND is returned and img_offset/len are a contiguous
     84  * range in the image file.
     85  *
     86  * On failure QED_CLUSTER_L2 or QED_CLUSTER_L1 is returned for missing L2 or L1
     87  * table offset, respectively. len is number of contiguous unallocated bytes.
     88  *
     89  * Called with table_lock held.
     90  */
     91 int coroutine_fn qed_find_cluster(BDRVQEDState *s, QEDRequest *request,
     92                                   uint64_t pos, size_t *len,
     93                                   uint64_t *img_offset)
     94 {
     95     uint64_t l2_offset;
     96     uint64_t offset = 0;
     97     unsigned int index;
     98     unsigned int n;
     99     int ret;
    100 
    101     /* Limit length to L2 boundary.  Requests are broken up at the L2 boundary
    102      * so that a request acts on one L2 table at a time.
    103      */
    104     *len = MIN(*len, (((pos >> s->l1_shift) + 1) << s->l1_shift) - pos);
    105 
    106     l2_offset = s->l1_table->offsets[qed_l1_index(s, pos)];
    107     if (qed_offset_is_unalloc_cluster(l2_offset)) {
    108         *img_offset = 0;
    109         return QED_CLUSTER_L1;
    110     }
    111     if (!qed_check_table_offset(s, l2_offset)) {
    112         *img_offset = *len = 0;
    113         return -EINVAL;
    114     }
    115 
    116     ret = qed_read_l2_table(s, request, l2_offset);
    117     if (ret) {
    118         goto out;
    119     }
    120 
    121     index = qed_l2_index(s, pos);
    122     n = qed_bytes_to_clusters(s, qed_offset_into_cluster(s, pos) + *len);
    123     n = qed_count_contiguous_clusters(s, request->l2_table->table,
    124                                       index, n, &offset);
    125 
    126     if (qed_offset_is_unalloc_cluster(offset)) {
    127         ret = QED_CLUSTER_L2;
    128     } else if (qed_offset_is_zero_cluster(offset)) {
    129         ret = QED_CLUSTER_ZERO;
    130     } else if (qed_check_cluster_offset(s, offset)) {
    131         ret = QED_CLUSTER_FOUND;
    132     } else {
    133         ret = -EINVAL;
    134     }
    135 
    136     *len = MIN(*len,
    137                n * s->header.cluster_size - qed_offset_into_cluster(s, pos));
    138 
    139 out:
    140     *img_offset = offset;
    141     return ret;
    142 }