1 /* Parts of target interface that deal with accessing memory and memory-like 2 objects. 3 4 Copyright (C) 2006-2013 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 #include "defs.h" 22 #include "vec.h" 23 #include "target.h" 24 #include "memory-map.h" 25 26 #include "gdb_assert.h" 27 28 #include <stdio.h> 29 #include <sys/time.h> 30 31 static int 32 compare_block_starting_address (const void *a, const void *b) 33 { 34 const struct memory_write_request *a_req = a; 35 const struct memory_write_request *b_req = b; 36 37 if (a_req->begin < b_req->begin) 38 return -1; 39 else if (a_req->begin == b_req->begin) 40 return 0; 41 else 42 return 1; 43 } 44 45 /* Adds to RESULT all memory write requests from BLOCK that are 46 in [BEGIN, END) range. 47 48 If any memory request is only partially in the specified range, 49 that part of the memory request will be added. */ 50 51 static void 52 claim_memory (VEC(memory_write_request_s) *blocks, 53 VEC(memory_write_request_s) **result, 54 ULONGEST begin, 55 ULONGEST end) 56 { 57 int i; 58 ULONGEST claimed_begin; 59 ULONGEST claimed_end; 60 struct memory_write_request *r; 61 62 for (i = 0; VEC_iterate (memory_write_request_s, blocks, i, r); ++i) 63 { 64 /* If the request doesn't overlap [BEGIN, END), skip it. We 65 must handle END == 0 meaning the top of memory; we don't yet 66 check for R->end == 0, which would also mean the top of 67 memory, but there's an assertion in 68 target_write_memory_blocks which checks for that. */ 69 70 if (begin >= r->end) 71 continue; 72 if (end != 0 && end <= r->begin) 73 continue; 74 75 claimed_begin = max (begin, r->begin); 76 if (end == 0) 77 claimed_end = r->end; 78 else 79 claimed_end = min (end, r->end); 80 81 if (claimed_begin == r->begin && claimed_end == r->end) 82 VEC_safe_push (memory_write_request_s, *result, r); 83 else 84 { 85 struct memory_write_request *n = 86 VEC_safe_push (memory_write_request_s, *result, NULL); 87 88 *n = *r; 89 n->begin = claimed_begin; 90 n->end = claimed_end; 91 n->data += claimed_begin - r->begin; 92 } 93 } 94 } 95 96 /* Given a vector of struct memory_write_request objects in BLOCKS, 97 add memory requests for flash memory into FLASH_BLOCKS, and for 98 regular memory to REGULAR_BLOCKS. */ 99 100 static void 101 split_regular_and_flash_blocks (VEC(memory_write_request_s) *blocks, 102 VEC(memory_write_request_s) **regular_blocks, 103 VEC(memory_write_request_s) **flash_blocks) 104 { 105 struct mem_region *region; 106 CORE_ADDR cur_address; 107 108 /* This implementation runs in O(length(regions)*length(blocks)) time. 109 However, in most cases the number of blocks will be small, so this does 110 not matter. 111 112 Note also that it's extremely unlikely that a memory write request 113 will span more than one memory region, however for safety we handle 114 such situations. */ 115 116 cur_address = 0; 117 while (1) 118 { 119 VEC(memory_write_request_s) **r; 120 121 region = lookup_mem_region (cur_address); 122 r = region->attrib.mode == MEM_FLASH ? flash_blocks : regular_blocks; 123 cur_address = region->hi; 124 claim_memory (blocks, r, region->lo, region->hi); 125 126 if (cur_address == 0) 127 break; 128 } 129 } 130 131 /* Given an ADDRESS, if BEGIN is non-NULL this function sets *BEGIN 132 to the start of the flash block containing the address. Similarly, 133 if END is non-NULL *END will be set to the address one past the end 134 of the block containing the address. */ 135 136 static void 137 block_boundaries (CORE_ADDR address, CORE_ADDR *begin, CORE_ADDR *end) 138 { 139 struct mem_region *region; 140 unsigned blocksize; 141 142 region = lookup_mem_region (address); 143 gdb_assert (region->attrib.mode == MEM_FLASH); 144 blocksize = region->attrib.blocksize; 145 if (begin) 146 *begin = address / blocksize * blocksize; 147 if (end) 148 *end = (address + blocksize - 1) / blocksize * blocksize; 149 } 150 151 /* Given the list of memory requests to be WRITTEN, this function 152 returns write requests covering each group of flash blocks which must 153 be erased. */ 154 155 static VEC(memory_write_request_s) * 156 blocks_to_erase (VEC(memory_write_request_s) *written) 157 { 158 unsigned i; 159 struct memory_write_request *ptr; 160 161 VEC(memory_write_request_s) *result = NULL; 162 163 for (i = 0; VEC_iterate (memory_write_request_s, written, i, ptr); ++i) 164 { 165 CORE_ADDR begin, end; 166 167 block_boundaries (ptr->begin, &begin, 0); 168 block_boundaries (ptr->end - 1, 0, &end); 169 170 if (!VEC_empty (memory_write_request_s, result) 171 && VEC_last (memory_write_request_s, result)->end >= begin) 172 { 173 VEC_last (memory_write_request_s, result)->end = end; 174 } 175 else 176 { 177 struct memory_write_request *n = 178 VEC_safe_push (memory_write_request_s, result, NULL); 179 180 memset (n, 0, sizeof (struct memory_write_request)); 181 n->begin = begin; 182 n->end = end; 183 } 184 } 185 186 return result; 187 } 188 189 /* Given ERASED_BLOCKS, a list of blocks that will be erased with 190 flash erase commands, and WRITTEN_BLOCKS, the list of memory 191 addresses that will be written, compute the set of memory addresses 192 that will be erased but not rewritten (e.g. padding within a block 193 which is only partially filled by "load"). */ 194 195 static VEC(memory_write_request_s) * 196 compute_garbled_blocks (VEC(memory_write_request_s) *erased_blocks, 197 VEC(memory_write_request_s) *written_blocks) 198 { 199 VEC(memory_write_request_s) *result = NULL; 200 201 unsigned i, j; 202 unsigned je = VEC_length (memory_write_request_s, written_blocks); 203 struct memory_write_request *erased_p; 204 205 /* Look at each erased memory_write_request in turn, and 206 see what part of it is subsequently written to. 207 208 This implementation is O(length(erased) * length(written)). If 209 the lists are sorted at this point it could be rewritten more 210 efficiently, but the complexity is not generally worthwhile. */ 211 212 for (i = 0; 213 VEC_iterate (memory_write_request_s, erased_blocks, i, erased_p); 214 ++i) 215 { 216 /* Make a deep copy -- it will be modified inside the loop, but 217 we don't want to modify original vector. */ 218 struct memory_write_request erased = *erased_p; 219 220 for (j = 0; j != je;) 221 { 222 struct memory_write_request *written 223 = VEC_index (memory_write_request_s, 224 written_blocks, j); 225 226 /* Now try various cases. */ 227 228 /* If WRITTEN is fully to the left of ERASED, check the next 229 written memory_write_request. */ 230 if (written->end <= erased.begin) 231 { 232 ++j; 233 continue; 234 } 235 236 /* If WRITTEN is fully to the right of ERASED, then ERASED 237 is not written at all. WRITTEN might affect other 238 blocks. */ 239 if (written->begin >= erased.end) 240 { 241 VEC_safe_push (memory_write_request_s, result, &erased); 242 goto next_erased; 243 } 244 245 /* If all of ERASED is completely written, we can move on to 246 the next erased region. */ 247 if (written->begin <= erased.begin 248 && written->end >= erased.end) 249 { 250 goto next_erased; 251 } 252 253 /* If there is an unwritten part at the beginning of ERASED, 254 then we should record that part and try this inner loop 255 again for the remainder. */ 256 if (written->begin > erased.begin) 257 { 258 struct memory_write_request *n = 259 VEC_safe_push (memory_write_request_s, result, NULL); 260 261 memset (n, 0, sizeof (struct memory_write_request)); 262 n->begin = erased.begin; 263 n->end = written->begin; 264 erased.begin = written->begin; 265 continue; 266 } 267 268 /* If there is an unwritten part at the end of ERASED, we 269 forget about the part that was written to and wait to see 270 if the next write request writes more of ERASED. We can't 271 push it yet. */ 272 if (written->end < erased.end) 273 { 274 erased.begin = written->end; 275 ++j; 276 continue; 277 } 278 } 279 280 /* If we ran out of write requests without doing anything about 281 ERASED, then that means it's really erased. */ 282 VEC_safe_push (memory_write_request_s, result, &erased); 283 284 next_erased: 285 ; 286 } 287 288 return result; 289 } 290 291 static void 292 cleanup_request_data (void *p) 293 { 294 VEC(memory_write_request_s) **v = p; 295 struct memory_write_request *r; 296 int i; 297 298 for (i = 0; VEC_iterate (memory_write_request_s, *v, i, r); ++i) 299 xfree (r->data); 300 } 301 302 static void 303 cleanup_write_requests_vector (void *p) 304 { 305 VEC(memory_write_request_s) **v = p; 306 307 VEC_free (memory_write_request_s, *v); 308 } 309 310 int 311 target_write_memory_blocks (VEC(memory_write_request_s) *requests, 312 enum flash_preserve_mode preserve_flash_p, 313 void (*progress_cb) (ULONGEST, void *)) 314 { 315 struct cleanup *back_to = make_cleanup (null_cleanup, NULL); 316 VEC(memory_write_request_s) *blocks = VEC_copy (memory_write_request_s, 317 requests); 318 unsigned i; 319 int err = 0; 320 struct memory_write_request *r; 321 VEC(memory_write_request_s) *regular = NULL; 322 VEC(memory_write_request_s) *flash = NULL; 323 VEC(memory_write_request_s) *erased, *garbled; 324 325 /* END == 0 would represent wraparound: a write to the very last 326 byte of the address space. This file was not written with that 327 possibility in mind. This is fixable, but a lot of work for a 328 rare problem; so for now, fail noisily here instead of obscurely 329 later. */ 330 for (i = 0; VEC_iterate (memory_write_request_s, requests, i, r); ++i) 331 gdb_assert (r->end != 0); 332 333 make_cleanup (cleanup_write_requests_vector, &blocks); 334 335 /* Sort the blocks by their start address. */ 336 qsort (VEC_address (memory_write_request_s, blocks), 337 VEC_length (memory_write_request_s, blocks), 338 sizeof (struct memory_write_request), compare_block_starting_address); 339 340 /* Split blocks into list of regular memory blocks, 341 and list of flash memory blocks. */ 342 make_cleanup (cleanup_write_requests_vector, ®ular); 343 make_cleanup (cleanup_write_requests_vector, &flash); 344 split_regular_and_flash_blocks (blocks, ®ular, &flash); 345 346 /* If a variable is added to forbid flash write, even during "load", 347 it should be checked here. Similarly, if this function is used 348 for other situations besides "load" in which writing to flash 349 is undesirable, that should be checked here. */ 350 351 /* Find flash blocks to erase. */ 352 erased = blocks_to_erase (flash); 353 make_cleanup (cleanup_write_requests_vector, &erased); 354 355 /* Find what flash regions will be erased, and not overwritten; then 356 either preserve or discard the old contents. */ 357 garbled = compute_garbled_blocks (erased, flash); 358 make_cleanup (cleanup_request_data, &garbled); 359 make_cleanup (cleanup_write_requests_vector, &garbled); 360 361 if (!VEC_empty (memory_write_request_s, garbled)) 362 { 363 if (preserve_flash_p == flash_preserve) 364 { 365 struct memory_write_request *r; 366 367 /* Read in regions that must be preserved and add them to 368 the list of blocks we read. */ 369 for (i = 0; VEC_iterate (memory_write_request_s, garbled, i, r); ++i) 370 { 371 gdb_assert (r->data == NULL); 372 r->data = xmalloc (r->end - r->begin); 373 err = target_read_memory (r->begin, r->data, r->end - r->begin); 374 if (err != 0) 375 goto out; 376 377 VEC_safe_push (memory_write_request_s, flash, r); 378 } 379 380 qsort (VEC_address (memory_write_request_s, flash), 381 VEC_length (memory_write_request_s, flash), 382 sizeof (struct memory_write_request), 383 compare_block_starting_address); 384 } 385 } 386 387 /* We could coalesce adjacent memory blocks here, to reduce the 388 number of write requests for small sections. However, we would 389 have to reallocate and copy the data pointers, which could be 390 large; large sections are more common in loadable objects than 391 large numbers of small sections (although the reverse can be true 392 in object files). So, we issue at least one write request per 393 passed struct memory_write_request. The remote stub will still 394 have the opportunity to batch flash requests. */ 395 396 /* Write regular blocks. */ 397 for (i = 0; VEC_iterate (memory_write_request_s, regular, i, r); ++i) 398 { 399 LONGEST len; 400 401 len = target_write_with_progress (current_target.beneath, 402 TARGET_OBJECT_MEMORY, NULL, 403 r->data, r->begin, r->end - r->begin, 404 progress_cb, r->baton); 405 if (len < (LONGEST) (r->end - r->begin)) 406 { 407 /* Call error? */ 408 err = -1; 409 goto out; 410 } 411 } 412 413 if (!VEC_empty (memory_write_request_s, erased)) 414 { 415 /* Erase all pages. */ 416 for (i = 0; VEC_iterate (memory_write_request_s, erased, i, r); ++i) 417 target_flash_erase (r->begin, r->end - r->begin); 418 419 /* Write flash data. */ 420 for (i = 0; VEC_iterate (memory_write_request_s, flash, i, r); ++i) 421 { 422 LONGEST len; 423 424 len = target_write_with_progress (¤t_target, 425 TARGET_OBJECT_FLASH, NULL, 426 r->data, r->begin, 427 r->end - r->begin, 428 progress_cb, r->baton); 429 if (len < (LONGEST) (r->end - r->begin)) 430 error (_("Error writing data to flash")); 431 } 432 433 target_flash_done (); 434 } 435 436 out: 437 do_cleanups (back_to); 438 439 return err; 440 } 441