gdb/target-memory.c - gdb

Functions defined

Source code

  1. /* Parts of target interface that deal with accessing memory and memory-like
  2.    objects.

  4.    Copyright (C) 2006-2015 Free Software Foundation, Inc.

  6.    This file is part of GDB.

  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.

  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.

  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/>.  */

  21. #include "defs.h"
  22. #include "vec.h"
  23. #include "target.h"
  24. #include "memory-map.h"

  26. #include <sys/time.h>

  28. static int
  29. ‌compare_block_starting_address (const void *a, const void *b)
  30. {
  31.   const struct memory_write_request *a_req = a;
  32.   const struct memory_write_request *b_req = b;

  34.   if (a_req->begin < b_req->begin)
  35.     return -1;
  36.   else if (a_req->begin == b_req->begin)
  37.     return 0;
  38.   else
  39.     return 1;
  40. }

  42. /* Adds to RESULT all memory write requests from BLOCK that are
  43.    in [BEGIN, END) range.

  45.    If any memory request is only partially in the specified range,
  46.    that part of the memory request will be added.  */

  48. static void
  49. ‌claim_memory (VEC(memory_write_request_s) *blocks,
  50.               VEC(memory_write_request_s) **result,
  51.               ULONGEST begin,
  52.               ULONGEST end)
  53. {
  54.   int i;
  55.   ULONGEST claimed_begin;
  56.   ULONGEST claimed_end;
  57.   struct memory_write_request *r;

  59.   for (i = 0; VEC_iterate (memory_write_request_s, blocks, i, r); ++i)
  60.     {
  61.       /* If the request doesn't overlap [BEGIN, END), skip it.  We
  62.          must handle END == 0 meaning the top of memory; we don't yet
  63.          check for R->end == 0, which would also mean the top of
  64.          memory, but there's an assertion in
  65.          target_write_memory_blocks which checks for that.  */

  67.       if (begin >= r->end)
  68.         continue;
  69.       if (end != 0 && end <= r->begin)
  70.         continue;

  72.       claimed_begin = max (begin, r->begin);
  73.       if (end == 0)
  74.         claimed_end = r->end;
  75.       else
  76.         claimed_end = min (end, r->end);

  78.       if (claimed_begin == r->begin && claimed_end == r->end)
  79.         VEC_safe_push (memory_write_request_s, *result, r);
  80.       else
  81.         {
  82.           struct memory_write_request *n =
  83.             VEC_safe_push (memory_write_request_s, *result, NULL);

  85.           *n = *r;
  86.           n->begin = claimed_begin;
  87.           n->end = claimed_end;
  88.           n->data += claimed_begin - r->begin;
  89.         }
  90.     }
  91. }

  93. /* Given a vector of struct memory_write_request objects in BLOCKS,
  94.    add memory requests for flash memory into FLASH_BLOCKS, and for
  95.    regular memory to REGULAR_BLOCKS.  */

  97. static void
  98. ‌split_regular_and_flash_blocks (VEC(memory_write_request_s) *blocks,
  99.                                 VEC(memory_write_request_s) **regular_blocks,
  100.                                 VEC(memory_write_request_s) **flash_blocks)
  101. {
  102.   struct mem_region *region;
  103.   CORE_ADDR cur_address;

  105.   /* This implementation runs in O(length(regions)*length(blocks)) time.
  106.      However, in most cases the number of blocks will be small, so this does
  107.      not matter.

  109.      Note also that it's extremely unlikely that a memory write request
  110.      will span more than one memory region, however for safety we handle
  111.      such situations.  */

  113.   cur_address = 0;
  114.   while (1)
  115.     {
  116.       VEC(memory_write_request_s) **r;

  118.       region = lookup_mem_region (cur_address);
  119.       r = region->attrib.mode == MEM_FLASH ? flash_blocks : regular_blocks;
  120.       cur_address = region->hi;
  121.       claim_memory (blocks, r, region->lo, region->hi);

  123.       if (cur_address == 0)
  124.         break;
  125.     }
  126. }

  128. /* Given an ADDRESS, if BEGIN is non-NULL this function sets *BEGIN
  129.    to the start of the flash block containing the address.  Similarly,
  130.    if END is non-NULL *END will be set to the address one past the end
  131.    of the block containing the address.  */

  133. static void
  134. ‌block_boundaries (CORE_ADDR address, CORE_ADDR *begin, CORE_ADDR *end)
  135. {
  136.   struct mem_region *region;
  137.   unsigned blocksize;

  139.   region = lookup_mem_region (address);
  140.   gdb_assert (region->attrib.mode == MEM_FLASH);
  141.   blocksize = region->attrib.blocksize;
  142.   if (begin)
  143.     *begin = address / blocksize * blocksize;
  144.   if (end)
  145.     *end = (address + blocksize - 1) / blocksize * blocksize;
  146. }

  148. /* Given the list of memory requests to be WRITTEN, this function
  149.    returns write requests covering each group of flash blocks which must
  150.    be erased.  */

  152. ‌static VEC(memory_write_request_s) *
  153. blocks_to_erase (VEC(memory_write_request_s) *written)
  154. {
  155.   unsigned i;
  156.   struct memory_write_request *ptr;

  158.   VEC(memory_write_request_s) *result = NULL;

  160.   for (i = 0; VEC_iterate (memory_write_request_s, written, i, ptr); ++i)
  161.     {
  162.       CORE_ADDR begin, end;

  164.       block_boundaries (ptr->begin, &begin, 0);
  165.       block_boundaries (ptr->end - 1, 0, &end);

  167.       if (!VEC_empty (memory_write_request_s, result)
  168.           && VEC_last (memory_write_request_s, result)->end >= begin)
  169.         {
  170.           VEC_last (memory_write_request_s, result)->end = end;
  171.         }
  172.       else
  173.         {
  174.           struct memory_write_request *n =
  175.             VEC_safe_push (memory_write_request_s, result, NULL);

  177.           memset (n, 0, sizeof (struct memory_write_request));
  178.           n->begin = begin;
  179.           n->end = end;
  180.         }
  181.     }

  183.   return result;
  184. }

  186. /* Given ERASED_BLOCKS, a list of blocks that will be erased with
  187.    flash erase commands, and WRITTEN_BLOCKS, the list of memory
  188.    addresses that will be written, compute the set of memory addresses
  189.    that will be erased but not rewritten (e.g. padding within a block
  190.    which is only partially filled by "load").  */

  192. ‌static VEC(memory_write_request_s) *
  193. compute_garbled_blocks (VEC(memory_write_request_s) *erased_blocks,
  194.                         VEC(memory_write_request_s) *written_blocks)
  195. {
  196.   VEC(memory_write_request_s) *result = NULL;

  198.   unsigned i, j;
  199.   unsigned je = VEC_length (memory_write_request_s, written_blocks);
  200.   struct memory_write_request *erased_p;

  202.   /* Look at each erased memory_write_request in turn, and
  203.      see what part of it is subsequently written to.

  205.      This implementation is O(length(erased) * length(written)).  If
  206.      the lists are sorted at this point it could be rewritten more
  207.      efficiently, but the complexity is not generally worthwhile.  */

  209.   for (i = 0;
  210.        VEC_iterate (memory_write_request_s, erased_blocks, i, erased_p);
  211.        ++i)
  212.     {
  213.       /* Make a deep copy -- it will be modified inside the loop, but
  214.          we don't want to modify original vector.  */
  215.       struct memory_write_request erased = *erased_p;

  217.       for (j = 0; j != je;)
  218.         {
  219.           struct memory_write_request *written
  220.             = VEC_index (memory_write_request_s,
  221.                          written_blocks, j);

  223.           /* Now try various cases.  */

  225.           /* If WRITTEN is fully to the left of ERASED, check the next
  226.              written memory_write_request.  */
  227.           if (written->end <= erased.begin)
  228.             {
  229.               ++j;
  230.               continue;
  231.             }

  233.           /* If WRITTEN is fully to the right of ERASED, then ERASED
  234.              is not written at all.  WRITTEN might affect other
  235.              blocks.  */
  236.           if (written->begin >= erased.end)
  237.             {
  238.               VEC_safe_push (memory_write_request_s, result, &erased);
  239.               goto next_erased;
  240.             }

  242.           /* If all of ERASED is completely written, we can move on to
  243.              the next erased region.  */
  244.           if (written->begin <= erased.begin
  245.               && written->end >= erased.end)
  246.             {
  247.               goto next_erased;
  248.             }

  250.           /* If there is an unwritten part at the beginning of ERASED,
  251.              then we should record that part and try this inner loop
  252.              again for the remainder.  */
  253.           if (written->begin > erased.begin)
  254.             {
  255.               struct memory_write_request *n =
  256.                 VEC_safe_push (memory_write_request_s, result, NULL);

  258.               memset (n, 0, sizeof (struct memory_write_request));
  259.               n->begin = erased.begin;
  260.               n->end = written->begin;
  261.               erased.begin = written->begin;
  262.               continue;
  263.             }

  265.           /* If there is an unwritten part at the end of ERASED, we
  266.              forget about the part that was written to and wait to see
  267.              if the next write request writes more of ERASED.  We can't
  268.              push it yet.  */
  269.           if (written->end < erased.end)
  270.             {
  271.               erased.begin = written->end;
  272.               ++j;
  273.               continue;
  274.             }
  275.         }

  277.       /* If we ran out of write requests without doing anything about
  278.          ERASED, then that means it's really erased.  */
  279.       VEC_safe_push (memory_write_request_s, result, &erased);

  281.     next_erased:
  282.       ;
  283.     }

  285.   return result;
  286. }

  288. static void
  289. ‌cleanup_request_data (void *p)
  290. {
  291.   VEC(memory_write_request_s) **v = p;
  292.   struct memory_write_request *r;
  293.   int i;

  295.   for (i = 0; VEC_iterate (memory_write_request_s, *v, i, r); ++i)
  296.     xfree (r->data);
  297. }

  299. static void
  300. ‌cleanup_write_requests_vector (void *p)
  301. {
  302.   VEC(memory_write_request_s) **v = p;

  304.   VEC_free (memory_write_request_s, *v);
  305. }

  307. int
  308. ‌target_write_memory_blocks (VEC(memory_write_request_s) *requests,
  309.                             enum flash_preserve_mode preserve_flash_p,
  310.                             void (*progress_cb) (ULONGEST, void *))
  311. {
  312.   struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
  313.   VEC(memory_write_request_s) *blocks = VEC_copy (memory_write_request_s,
  314.                                                   requests);
  315.   unsigned i;
  316.   int err = 0;
  317.   struct memory_write_request *r;
  318.   VEC(memory_write_request_s) *regular = NULL;
  319.   VEC(memory_write_request_s) *flash = NULL;
  320.   VEC(memory_write_request_s) *erased, *garbled;

  322.   /* END == 0 would represent wraparound: a write to the very last
  323.      byte of the address space.  This file was not written with that
  324.      possibility in mind.  This is fixable, but a lot of work for a
  325.      rare problem; so for now, fail noisily here instead of obscurely
  326.      later.  */
  327.   for (i = 0; VEC_iterate (memory_write_request_s, requests, i, r); ++i)
  328.     gdb_assert (r->end != 0);

  330.   make_cleanup (cleanup_write_requests_vector, &blocks);

  332.   /* Sort the blocks by their start address.  */
  333.   qsort (VEC_address (memory_write_request_s, blocks),
  334.          VEC_length (memory_write_request_s, blocks),
  335.          sizeof (struct memory_write_request), compare_block_starting_address);

  337.   /* Split blocks into list of regular memory blocks,
  338.      and list of flash memory blocks.  */
  339.   make_cleanup (cleanup_write_requests_vector, &regular);
  340.   make_cleanup (cleanup_write_requests_vector, &flash);
  341.   split_regular_and_flash_blocks (blocks, &regular, &flash);

  343.   /* If a variable is added to forbid flash write, even during "load",
  344.      it should be checked here.  Similarly, if this function is used
  345.      for other situations besides "load" in which writing to flash
  346.      is undesirable, that should be checked here.  */

  348.   /* Find flash blocks to erase.  */
  349.   erased = blocks_to_erase (flash);
  350.   make_cleanup (cleanup_write_requests_vector, &erased);

  352.   /* Find what flash regions will be erased, and not overwritten; then
  353.      either preserve or discard the old contents.  */
  354.   garbled = compute_garbled_blocks (erased, flash);
  355.   make_cleanup (cleanup_request_data, &garbled);
  356.   make_cleanup (cleanup_write_requests_vector, &garbled);

  358.   if (!VEC_empty (memory_write_request_s, garbled))
  359.     {
  360.       if (preserve_flash_p == flash_preserve)
  361.         {
  362.           struct memory_write_request *r;

  364.           /* Read in regions that must be preserved and add them to
  365.              the list of blocks we read.  */
  366.           for (i = 0; VEC_iterate (memory_write_request_s, garbled, i, r); ++i)
  367.             {
  368.               gdb_assert (r->data == NULL);
  369.               r->data = xmalloc (r->end - r->begin);
  370.               err = target_read_memory (r->begin, r->data, r->end - r->begin);
  371.               if (err != 0)
  372.                 goto out;

  374.               VEC_safe_push (memory_write_request_s, flash, r);
  375.             }

  377.           qsort (VEC_address (memory_write_request_s, flash),
  378.                  VEC_length (memory_write_request_s, flash),
  379.                  sizeof (struct memory_write_request),
  380.                  compare_block_starting_address);
  381.         }
  382.     }

  384.   /* We could coalesce adjacent memory blocks here, to reduce the
  385.      number of write requests for small sections.  However, we would
  386.      have to reallocate and copy the data pointers, which could be
  387.      large; large sections are more common in loadable objects than
  388.      large numbers of small sections (although the reverse can be true
  389.      in object files).  So, we issue at least one write request per
  390.      passed struct memory_write_request.  The remote stub will still
  391.      have the opportunity to batch flash requests.  */

  393.   /* Write regular blocks.  */
  394.   for (i = 0; VEC_iterate (memory_write_request_s, regular, i, r); ++i)
  395.     {
  396.       LONGEST len;

  398.       len = target_write_with_progress (current_target.beneath,
  399.                                         TARGET_OBJECT_MEMORY, NULL,
  400.                                         r->data, r->begin, r->end - r->begin,
  401.                                         progress_cb, r->baton);
  402.       if (len < (LONGEST) (r->end - r->begin))
  403.         {
  404.           /* Call error?  */
  405.           err = -1;
  406.           goto out;
  407.         }
  408.     }

  410.   if (!VEC_empty (memory_write_request_s, erased))
  411.     {
  412.       /* Erase all pages.  */
  413.       for (i = 0; VEC_iterate (memory_write_request_s, erased, i, r); ++i)
  414.         target_flash_erase (r->begin, r->end - r->begin);

  416.       /* Write flash data.  */
  417.       for (i = 0; VEC_iterate (memory_write_request_s, flash, i, r); ++i)
  418.         {
  419.           LONGEST len;

  421.           len = target_write_with_progress (&current_target,
  422.                                             TARGET_OBJECT_FLASH, NULL,
  423.                                             r->data, r->begin,
  424.                                             r->end - r->begin,
  425.                                             progress_cb, r->baton);
  426.           if (len < (LONGEST) (r->end - r->begin))
  427.             error (_("Error writing data to flash"));
  428.         }

  430.       target_flash_done ();
  431.     }

  433. out:
  434.   do_cleanups (back_to);

  436.   return err;
  437. }