1 /* Parts of target interface that deal with accessing memory and memory-like 2 objects. 3 4 Copyright (C) 2006-2019 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 "common/vec.h" 23 #include "target.h" 24 #include "memory-map.h" 25 26 #include "common/gdb_sys_time.h" 27 #include <algorithm> 28 29 static bool 30 compare_block_starting_address (const memory_write_request &a_req, 31 const memory_write_request &b_req) 32 { 33 return a_req.begin < b_req.begin; 34 } 35 36 /* Adds to RESULT all memory write requests from BLOCK that are 37 in [BEGIN, END) range. 38 39 If any memory request is only partially in the specified range, 40 that part of the memory request will be added. */ 41 42 static void 43 claim_memory (const std::vector<memory_write_request> &blocks, 44 std::vector<memory_write_request> *result, 45 ULONGEST begin, 46 ULONGEST end) 47 { 48 ULONGEST claimed_begin; 49 ULONGEST claimed_end; 50 51 for (const memory_write_request &r : blocks) 52 { 53 /* If the request doesn't overlap [BEGIN, END), skip it. We 54 must handle END == 0 meaning the top of memory; we don't yet 55 check for R->end == 0, which would also mean the top of 56 memory, but there's an assertion in 57 target_write_memory_blocks which checks for that. */ 58 59 if (begin >= r.end) 60 continue; 61 if (end != 0 && end <= r.begin) 62 continue; 63 64 claimed_begin = std::max (begin, r.begin); 65 if (end == 0) 66 claimed_end = r.end; 67 else 68 claimed_end = std::min (end, r.end); 69 70 if (claimed_begin == r.begin && claimed_end == r.end) 71 result->push_back (r); 72 else 73 { 74 struct memory_write_request n = r; 75 76 n.begin = claimed_begin; 77 n.end = claimed_end; 78 n.data += claimed_begin - r.begin; 79 80 result->push_back (n); 81 } 82 } 83 } 84 85 /* Given a vector of struct memory_write_request objects in BLOCKS, 86 add memory requests for flash memory into FLASH_BLOCKS, and for 87 regular memory to REGULAR_BLOCKS. */ 88 89 static void 90 split_regular_and_flash_blocks (const std::vector<memory_write_request> &blocks, 91 std::vector<memory_write_request> *regular_blocks, 92 std::vector<memory_write_request> *flash_blocks) 93 { 94 struct mem_region *region; 95 CORE_ADDR cur_address; 96 97 /* This implementation runs in O(length(regions)*length(blocks)) time. 98 However, in most cases the number of blocks will be small, so this does 99 not matter. 100 101 Note also that it's extremely unlikely that a memory write request 102 will span more than one memory region, however for safety we handle 103 such situations. */ 104 105 cur_address = 0; 106 while (1) 107 { 108 std::vector<memory_write_request> *r; 109 110 region = lookup_mem_region (cur_address); 111 r = region->attrib.mode == MEM_FLASH ? flash_blocks : regular_blocks; 112 cur_address = region->hi; 113 claim_memory (blocks, r, region->lo, region->hi); 114 115 if (cur_address == 0) 116 break; 117 } 118 } 119 120 /* Given an ADDRESS, if BEGIN is non-NULL this function sets *BEGIN 121 to the start of the flash block containing the address. Similarly, 122 if END is non-NULL *END will be set to the address one past the end 123 of the block containing the address. */ 124 125 static void 126 block_boundaries (CORE_ADDR address, CORE_ADDR *begin, CORE_ADDR *end) 127 { 128 struct mem_region *region; 129 unsigned blocksize; 130 CORE_ADDR offset_in_region; 131 132 region = lookup_mem_region (address); 133 gdb_assert (region->attrib.mode == MEM_FLASH); 134 blocksize = region->attrib.blocksize; 135 136 offset_in_region = address - region->lo; 137 138 if (begin) 139 *begin = region->lo + offset_in_region / blocksize * blocksize; 140 if (end) 141 *end = region->lo + (offset_in_region + blocksize - 1) / blocksize * blocksize; 142 } 143 144 /* Given the list of memory requests to be WRITTEN, this function 145 returns write requests covering each group of flash blocks which must 146 be erased. */ 147 148 static std::vector<memory_write_request> 149 blocks_to_erase (const std::vector<memory_write_request> &written) 150 { 151 std::vector<memory_write_request> result; 152 153 for (const memory_write_request &request : written) 154 { 155 CORE_ADDR begin, end; 156 157 block_boundaries (request.begin, &begin, 0); 158 block_boundaries (request.end - 1, 0, &end); 159 160 if (!result.empty () && result.back ().end >= begin) 161 result.back ().end = end; 162 else 163 result.emplace_back (begin, end); 164 } 165 166 return result; 167 } 168 169 /* Given ERASED_BLOCKS, a list of blocks that will be erased with 170 flash erase commands, and WRITTEN_BLOCKS, the list of memory 171 addresses that will be written, compute the set of memory addresses 172 that will be erased but not rewritten (e.g. padding within a block 173 which is only partially filled by "load"). */ 174 175 static std::vector<memory_write_request> 176 compute_garbled_blocks (const std::vector<memory_write_request> &erased_blocks, 177 const std::vector<memory_write_request> &written_blocks) 178 { 179 std::vector<memory_write_request> result; 180 181 unsigned j; 182 unsigned je = written_blocks.size (); 183 184 /* Look at each erased memory_write_request in turn, and 185 see what part of it is subsequently written to. 186 187 This implementation is O(length(erased) * length(written)). If 188 the lists are sorted at this point it could be rewritten more 189 efficiently, but the complexity is not generally worthwhile. */ 190 191 for (const memory_write_request &erased_iter : erased_blocks) 192 { 193 /* Make a deep copy -- it will be modified inside the loop, but 194 we don't want to modify original vector. */ 195 struct memory_write_request erased = erased_iter; 196 197 for (j = 0; j != je;) 198 { 199 const memory_write_request *written = &written_blocks[j]; 200 201 /* Now try various cases. */ 202 203 /* If WRITTEN is fully to the left of ERASED, check the next 204 written memory_write_request. */ 205 if (written->end <= erased.begin) 206 { 207 ++j; 208 continue; 209 } 210 211 /* If WRITTEN is fully to the right of ERASED, then ERASED 212 is not written at all. WRITTEN might affect other 213 blocks. */ 214 if (written->begin >= erased.end) 215 { 216 result.push_back (erased); 217 goto next_erased; 218 } 219 220 /* If all of ERASED is completely written, we can move on to 221 the next erased region. */ 222 if (written->begin <= erased.begin 223 && written->end >= erased.end) 224 { 225 goto next_erased; 226 } 227 228 /* If there is an unwritten part at the beginning of ERASED, 229 then we should record that part and try this inner loop 230 again for the remainder. */ 231 if (written->begin > erased.begin) 232 { 233 result.emplace_back (erased.begin, written->begin); 234 erased.begin = written->begin; 235 continue; 236 } 237 238 /* If there is an unwritten part at the end of ERASED, we 239 forget about the part that was written to and wait to see 240 if the next write request writes more of ERASED. We can't 241 push it yet. */ 242 if (written->end < erased.end) 243 { 244 erased.begin = written->end; 245 ++j; 246 continue; 247 } 248 } 249 250 /* If we ran out of write requests without doing anything about 251 ERASED, then that means it's really erased. */ 252 result.push_back (erased); 253 254 next_erased: 255 ; 256 } 257 258 return result; 259 } 260 261 int 262 target_write_memory_blocks (const std::vector<memory_write_request> &requests, 263 enum flash_preserve_mode preserve_flash_p, 264 void (*progress_cb) (ULONGEST, void *)) 265 { 266 std::vector<memory_write_request> blocks = requests; 267 std::vector<memory_write_request> regular; 268 std::vector<memory_write_request> flash; 269 std::vector<memory_write_request> erased, garbled; 270 271 /* END == 0 would represent wraparound: a write to the very last 272 byte of the address space. This file was not written with that 273 possibility in mind. This is fixable, but a lot of work for a 274 rare problem; so for now, fail noisily here instead of obscurely 275 later. */ 276 for (const memory_write_request &iter : requests) 277 gdb_assert (iter.end != 0); 278 279 /* Sort the blocks by their start address. */ 280 std::sort (blocks.begin (), blocks.end (), compare_block_starting_address); 281 282 /* Split blocks into list of regular memory blocks, 283 and list of flash memory blocks. */ 284 split_regular_and_flash_blocks (blocks, ®ular, &flash); 285 286 /* If a variable is added to forbid flash write, even during "load", 287 it should be checked here. Similarly, if this function is used 288 for other situations besides "load" in which writing to flash 289 is undesirable, that should be checked here. */ 290 291 /* Find flash blocks to erase. */ 292 erased = blocks_to_erase (flash); 293 294 /* Find what flash regions will be erased, and not overwritten; then 295 either preserve or discard the old contents. */ 296 garbled = compute_garbled_blocks (erased, flash); 297 298 std::vector<gdb::unique_xmalloc_ptr<gdb_byte>> mem_holders; 299 if (!garbled.empty ()) 300 { 301 if (preserve_flash_p == flash_preserve) 302 { 303 /* Read in regions that must be preserved and add them to 304 the list of blocks we read. */ 305 for (memory_write_request &iter : garbled) 306 { 307 gdb_assert (iter.data == NULL); 308 gdb::unique_xmalloc_ptr<gdb_byte> holder 309 ((gdb_byte *) xmalloc (iter.end - iter.begin)); 310 iter.data = holder.get (); 311 mem_holders.push_back (std::move (holder)); 312 int err = target_read_memory (iter.begin, iter.data, 313 iter.end - iter.begin); 314 if (err != 0) 315 return err; 316 317 flash.push_back (iter); 318 } 319 320 std::sort (flash.begin (), flash.end (), 321 compare_block_starting_address); 322 } 323 } 324 325 /* We could coalesce adjacent memory blocks here, to reduce the 326 number of write requests for small sections. However, we would 327 have to reallocate and copy the data pointers, which could be 328 large; large sections are more common in loadable objects than 329 large numbers of small sections (although the reverse can be true 330 in object files). So, we issue at least one write request per 331 passed struct memory_write_request. The remote stub will still 332 have the opportunity to batch flash requests. */ 333 334 /* Write regular blocks. */ 335 for (const memory_write_request &iter : regular) 336 { 337 LONGEST len; 338 339 len = target_write_with_progress (current_top_target (), 340 TARGET_OBJECT_MEMORY, NULL, 341 iter.data, iter.begin, 342 iter.end - iter.begin, 343 progress_cb, iter.baton); 344 if (len < (LONGEST) (iter.end - iter.begin)) 345 { 346 /* Call error? */ 347 return -1; 348 } 349 } 350 351 if (!erased.empty ()) 352 { 353 /* Erase all pages. */ 354 for (const memory_write_request &iter : erased) 355 target_flash_erase (iter.begin, iter.end - iter.begin); 356 357 /* Write flash data. */ 358 for (const memory_write_request &iter : flash) 359 { 360 LONGEST len; 361 362 len = target_write_with_progress (current_top_target (), 363 TARGET_OBJECT_FLASH, NULL, 364 iter.data, iter.begin, 365 iter.end - iter.begin, 366 progress_cb, iter.baton); 367 if (len < (LONGEST) (iter.end - iter.begin)) 368 error (_("Error writing data to flash")); 369 } 370 371 target_flash_done (); 372 } 373 374 return 0; 375 } 376