1 /* 2 * QEMU SPAPR Architecture Option Vector Helper Functions 3 * 4 * Copyright IBM Corp. 2016 5 * 6 * Authors: 7 * Bharata B Rao <bharata@linux.vnet.ibm.com> 8 * Michael Roth <mdroth@linux.vnet.ibm.com> 9 * 10 * This work is licensed under the terms of the GNU GPL, version 2 or later. 11 * See the COPYING file in the top-level directory. 12 */ 13 14 #include "qemu/osdep.h" 15 #include "hw/ppc/spapr_ovec.h" 16 #include "qemu/bitmap.h" 17 #include "exec/address-spaces.h" 18 #include "qemu/error-report.h" 19 #include <libfdt.h> 20 21 /* #define DEBUG_SPAPR_OVEC */ 22 23 #ifdef DEBUG_SPAPR_OVEC 24 #define DPRINTFN(fmt, ...) \ 25 do { fprintf(stderr, fmt "\n", ## __VA_ARGS__); } while (0) 26 #else 27 #define DPRINTFN(fmt, ...) \ 28 do { } while (0) 29 #endif 30 31 #define OV_MAXBYTES 256 /* not including length byte */ 32 #define OV_MAXBITS (OV_MAXBYTES * BITS_PER_BYTE) 33 34 /* we *could* work with bitmaps directly, but handling the bitmap privately 35 * allows us to more safely make assumptions about the bitmap size and 36 * simplify the calling code somewhat 37 */ 38 struct sPAPROptionVector { 39 unsigned long *bitmap; 40 int32_t bitmap_size; /* only used for migration */ 41 }; 42 43 const VMStateDescription vmstate_spapr_ovec = { 44 .name = "spapr_option_vector", 45 .version_id = 1, 46 .minimum_version_id = 1, 47 .fields = (VMStateField[]) { 48 VMSTATE_BITMAP(bitmap, sPAPROptionVector, 1, bitmap_size), 49 VMSTATE_END_OF_LIST() 50 } 51 }; 52 53 sPAPROptionVector *spapr_ovec_new(void) 54 { 55 sPAPROptionVector *ov; 56 57 ov = g_new0(sPAPROptionVector, 1); 58 ov->bitmap = bitmap_new(OV_MAXBITS); 59 ov->bitmap_size = OV_MAXBITS; 60 61 return ov; 62 } 63 64 sPAPROptionVector *spapr_ovec_clone(sPAPROptionVector *ov_orig) 65 { 66 sPAPROptionVector *ov; 67 68 g_assert(ov_orig); 69 70 ov = spapr_ovec_new(); 71 bitmap_copy(ov->bitmap, ov_orig->bitmap, OV_MAXBITS); 72 73 return ov; 74 } 75 76 void spapr_ovec_intersect(sPAPROptionVector *ov, 77 sPAPROptionVector *ov1, 78 sPAPROptionVector *ov2) 79 { 80 g_assert(ov); 81 g_assert(ov1); 82 g_assert(ov2); 83 84 bitmap_and(ov->bitmap, ov1->bitmap, ov2->bitmap, OV_MAXBITS); 85 } 86 87 /* returns true if options bits were removed, false otherwise */ 88 bool spapr_ovec_diff(sPAPROptionVector *ov, 89 sPAPROptionVector *ov_old, 90 sPAPROptionVector *ov_new) 91 { 92 unsigned long *change_mask = bitmap_new(OV_MAXBITS); 93 unsigned long *removed_bits = bitmap_new(OV_MAXBITS); 94 bool bits_were_removed = false; 95 96 g_assert(ov); 97 g_assert(ov_old); 98 g_assert(ov_new); 99 100 bitmap_xor(change_mask, ov_old->bitmap, ov_new->bitmap, OV_MAXBITS); 101 bitmap_and(ov->bitmap, ov_new->bitmap, change_mask, OV_MAXBITS); 102 bitmap_and(removed_bits, ov_old->bitmap, change_mask, OV_MAXBITS); 103 104 if (!bitmap_empty(removed_bits, OV_MAXBITS)) { 105 bits_were_removed = true; 106 } 107 108 g_free(change_mask); 109 g_free(removed_bits); 110 111 return bits_were_removed; 112 } 113 114 void spapr_ovec_cleanup(sPAPROptionVector *ov) 115 { 116 if (ov) { 117 g_free(ov->bitmap); 118 g_free(ov); 119 } 120 } 121 122 void spapr_ovec_set(sPAPROptionVector *ov, long bitnr) 123 { 124 g_assert(ov); 125 g_assert_cmpint(bitnr, <, OV_MAXBITS); 126 127 set_bit(bitnr, ov->bitmap); 128 } 129 130 void spapr_ovec_clear(sPAPROptionVector *ov, long bitnr) 131 { 132 g_assert(ov); 133 g_assert_cmpint(bitnr, <, OV_MAXBITS); 134 135 clear_bit(bitnr, ov->bitmap); 136 } 137 138 bool spapr_ovec_test(sPAPROptionVector *ov, long bitnr) 139 { 140 g_assert(ov); 141 g_assert_cmpint(bitnr, <, OV_MAXBITS); 142 143 return test_bit(bitnr, ov->bitmap) ? true : false; 144 } 145 146 static void guest_byte_to_bitmap(uint8_t entry, unsigned long *bitmap, 147 long bitmap_offset) 148 { 149 int i; 150 151 for (i = 0; i < BITS_PER_BYTE; i++) { 152 if (entry & (1 << (BITS_PER_BYTE - 1 - i))) { 153 bitmap_set(bitmap, bitmap_offset + i, 1); 154 } 155 } 156 } 157 158 static uint8_t guest_byte_from_bitmap(unsigned long *bitmap, long bitmap_offset) 159 { 160 uint8_t entry = 0; 161 int i; 162 163 for (i = 0; i < BITS_PER_BYTE; i++) { 164 if (test_bit(bitmap_offset + i, bitmap)) { 165 entry |= (1 << (BITS_PER_BYTE - 1 - i)); 166 } 167 } 168 169 return entry; 170 } 171 172 static target_ulong vector_addr(target_ulong table_addr, int vector) 173 { 174 uint16_t vector_count, vector_len; 175 int i; 176 177 vector_count = ldub_phys(&address_space_memory, table_addr) + 1; 178 if (vector > vector_count) { 179 return 0; 180 } 181 table_addr++; /* skip nr option vectors */ 182 183 for (i = 0; i < vector - 1; i++) { 184 vector_len = ldub_phys(&address_space_memory, table_addr) + 1; 185 table_addr += vector_len + 1; /* bit-vector + length byte */ 186 } 187 return table_addr; 188 } 189 190 sPAPROptionVector *spapr_ovec_parse_vector(target_ulong table_addr, int vector) 191 { 192 sPAPROptionVector *ov; 193 target_ulong addr; 194 uint16_t vector_len; 195 int i; 196 197 g_assert(table_addr); 198 g_assert_cmpint(vector, >=, 1); /* vector numbering starts at 1 */ 199 200 addr = vector_addr(table_addr, vector); 201 if (!addr) { 202 /* specified vector isn't present */ 203 return NULL; 204 } 205 206 vector_len = ldub_phys(&address_space_memory, addr++) + 1; 207 g_assert_cmpint(vector_len, <=, OV_MAXBYTES); 208 ov = spapr_ovec_new(); 209 210 for (i = 0; i < vector_len; i++) { 211 uint8_t entry = ldub_phys(&address_space_memory, addr + i); 212 if (entry) { 213 DPRINTFN("read guest vector %2d, byte %3d / %3d: 0x%.2x", 214 vector, i + 1, vector_len, entry); 215 guest_byte_to_bitmap(entry, ov->bitmap, i * BITS_PER_BYTE); 216 } 217 } 218 219 return ov; 220 } 221 222 int spapr_ovec_populate_dt(void *fdt, int fdt_offset, 223 sPAPROptionVector *ov, const char *name) 224 { 225 uint8_t vec[OV_MAXBYTES + 1]; 226 uint16_t vec_len; 227 unsigned long lastbit; 228 int i; 229 230 g_assert(ov); 231 232 lastbit = find_last_bit(ov->bitmap, OV_MAXBITS); 233 /* if no bits are set, include at least 1 byte of the vector so we can 234 * still encoded this in the device tree while abiding by the same 235 * encoding/sizing expected in ibm,client-architecture-support 236 */ 237 vec_len = (lastbit == OV_MAXBITS) ? 1 : lastbit / BITS_PER_BYTE + 1; 238 g_assert_cmpint(vec_len, <=, OV_MAXBYTES); 239 /* guest expects vector len encoded as vec_len - 1, since the length byte 240 * is assumed and not included, and the first byte of the vector 241 * is assumed as well 242 */ 243 vec[0] = vec_len - 1; 244 245 for (i = 1; i < vec_len + 1; i++) { 246 vec[i] = guest_byte_from_bitmap(ov->bitmap, (i - 1) * BITS_PER_BYTE); 247 if (vec[i]) { 248 DPRINTFN("encoding guest vector byte %3d / %3d: 0x%.2x", 249 i, vec_len, vec[i]); 250 } 251 } 252 253 return fdt_setprop(fdt, fdt_offset, name, vec, vec_len); 254 } 255