mirror of
https://github.com/espressif/binutils-gdb.git
synced 2025-08-06 14:49:38 +08:00
Return target_xfer_status in to_xfer_partial
This patch does the conversion of to_xfer_partial from
LONGEST (*to_xfer_partial) (struct target_ops *ops,
enum target_object object, const char *annex,
gdb_byte *readbuf, const gdb_byte *writebuf,
ULONGEST offset, ULONGEST len);
to
enum target_xfer_status (*to_xfer_partial) (struct target_ops *ops,
enum target_object object, const char *annex,
gdb_byte *readbuf, const gdb_byte *writebuf,
ULONGEST offset, ULONGEST len, ULONGEST *xfered_len);
It changes to_xfer_partial return the transfer status and the transfered
length by *XFERED_LEN. Generally, the return status has three stats,
- TARGET_XFER_OK,
- TARGET_XFER_EOF,
- TARGET_XFER_E_XXXX,
See the comments to them in 'enum target_xfer_status'. Note that
Pedro suggested not name TARGET_XFER_DONE, as it is confusing,
compared with "TARGET_XFER_OK". We finally name it TARGET_XFER_EOF.
With this change, GDB core can handle unavailable data in a convenient
way.
The rationale behind this change was mentioned here
https://sourceware.org/ml/gdb-patches/2013-10/msg00761.html
Consider an object/value like this:
0 100 150 200 512
DDDDDDDDDDDxxxxxxxxxDDDDDD...DDIIIIIIIIIIII..III
where D is valid data, and xxx is unavailable data, and I is beyond
the end of the object (Invalid). Currently, if we start the
xfer at 0, requesting, say 512 bytes, we'll first get back 100 bytes.
The xfer machinery then retries fetching [100,512), and gets back
TARGET_XFER_E_UNAVAILABLE. That's sufficient when you're either
interested in either having the whole of the 512 bytes available,
or erroring out. But, in this scenario, we're interested in
the data at [150,512). The problem is that the last
TARGET_XFER_E_UNAVAILABLE gives us no indication where to
start the read next. We'd need something like:
get me [0,512) >>>
<<< here's [0,100), *xfered_len is 100, returns TARGET_XFER_OK
get me [100,512) >>> (**1)
<<< [100,150) is unavailable, *xfered_len is 50, return TARGET_XFER_E_UNAVAILABLE.
get me [150,512) >>>
<<< here's [150,200), *xfered_len is 50, return TARGET_XFER_OK.
get me [200,512) >>>
<<< no more data, return TARGET_XFER_EOF.
This naturally implies pushing down the decision of whether
to return TARGET_XFER_E_UNAVAILABLE or something else
down to the target. (Which kinds of leads back to tfile
itself reading from RO memory from file (though we could
export a function in exec.c for that that tfile delegates to,
instead of re-adding the old code).
Beside this change, we also add a macro TARGET_XFER_STATUS_ERROR_P to
check whether a status is an error or not, to stop using "status < 0".
This patch also eliminates the comparison between status and 0.
No target implementations to to_xfer_partial adapts this new
interface. The interface still behaves as before.
gdb:
2014-02-11 Yao Qi <yao@codesourcery.com>
* target.h (enum target_xfer_error): Rename to ...
(enum target_xfer_status): ... it. New. All users updated.
(enum target_xfer_status) <TARGET_XFER_OK>, <TARGET_XFER_EOF>:
New.
(TARGET_XFER_STATUS_ERROR_P): New macro.
(target_xfer_error_to_string): Remove declaration.
(target_xfer_status_to_string): Declare.
(target_xfer_partial_ftype): Adjust it.
(struct target_ops) <to_xfer_partial>: Return
target_xfer_status. Add argument xfered_len. Update
comments.
* target.c (target_xfer_error_to_string): Rename to ...
(target_xfer_status_to_string): ... it. New. All callers
updated.
(target_read_live_memory): Likewise. Call target_xfer_partial
instead of target_read.
(memory_xfer_live_readonly_partial): Return
target_xfer_status. Add argument xfered_len.
(raw_memory_xfer_partial): Likewise.
(memory_xfer_partial_1): Likewise.
(memory_xfer_partial): Likewise.
(target_xfer_partial): Likewise. Check *XFERED_LEN is set
properly. Update debug message.
(default_xfer_partial, current_xfer_partial): Likewise.
(target_write_partial): Likewise.
(target_read_partial): Likewise. All callers updated.
(read_whatever_is_readable): Likewise.
(target_write_with_progress): Likewise.
(target_read_alloc_1): Likewise.
* aix-thread.c (aix_thread_xfer_partial): Likewise.
* auxv.c (procfs_xfer_auxv): Likewise.
(ld_so_xfer_auxv, memory_xfer_auxv): Likewise.
* bfd-target.c (target_bfd_xfer_partial): Likewise.
* bsd-kvm.c (bsd_kvm_xfer_partial): Likewise.
* bsd-uthread.c (bsd_uthread_xfer_partia): Likewise.
* corefile.c (read_memory): Adjust.
* corelow.c (core_xfer_partial): Likewise.
* ctf.c (ctf_xfer_partial): Likewise.
* darwin-nat.c (darwin_read_dyld_info): Likewise. All callers
updated.
(darwin_xfer_partial): Likewise.
* exec.c (section_table_xfer_memory_partial): Likewise. All
callers updated.
(exec_xfer_partial): Likewise.
* exec.h (section_table_xfer_memory_partial): Update
declaration.
* gnu-nat.c (gnu_xfer_memory): Likewise. Assert 'res' is not
negative.
(gnu_xfer_partial): Likewise.
* ia64-hpux-nat.c (ia64_hpux_xfer_memory_no_bs): Likewise.
(ia64_hpux_xfer_memory, ia64_hpux_xfer_uregs): Likewise.
(ia64_hpux_xfer_solib_got): Likewise.
* inf-ptrace.c (inf_ptrace_xfer_partial): Likewise. Change
type of 'partial_len' to ULONGEST.
* inf-ttrace.c (inf_ttrace_xfer_partial): Likewise.
* linux-nat.c (linux_xfer_siginfo ): Likewise.
(linux_nat_xfer_partial): Likewise.
(linux_proc_xfer_partial, linux_xfer_partial): Likewise.
(linux_proc_xfer_spu, linux_nat_xfer_osdata): Likewise.
* monitor.c (monitor_xfer_memory): Likewise.
(monitor_xfer_partial): Likewise.
* procfs.c (procfs_xfer_partial): Likewise.
* record-btrace.c (record_btrace_xfer_partial): Likewise.
* record-full.c (record_full_xfer_partial): Likewise.
(record_full_core_xfer_partial): Likewise.
* remote-sim.c (gdbsim_xfer_memory): Likewise.
(gdbsim_xfer_partial): Likewise.
* remote.c (remote_write_bytes_aux): Likewise. All callers
updated.
(remote_write_bytes, remote_read_bytes): Likewise. All
callers updated.
(remote_flash_erase): Likewise. All callers updated.
(remote_write_qxfer): Likewise. All callers updated.
(remote_read_qxfer): Likewise. All callers updated.
(remote_xfer_partial): Likewise.
* rs6000-nat.c (rs6000_xfer_partial): Likewise.
(rs6000_xfer_shared_libraries): Likewise.
* sol-thread.c (sol_thread_xfer_partial): Likewise.
(sol_thread_xfer_partial): Likewise.
* sparc-nat.c (sparc_xfer_wcookie): Likewise.
(sparc_xfer_partial): Likewise.
* spu-linux-nat.c (spu_proc_xfer_spu): Likewise. All callers
updated.
(spu_xfer_partial): Likewise.
* spu-multiarch.c (spu_xfer_partial): Likewise.
* tracepoint.c (tfile_xfer_partial): Likewise.
* windows-nat.c (windows_xfer_memory): Likewise.
(windows_xfer_shared_libraries): Likewise.
(windows_xfer_partial): Likewise.
* valprint.c: Replace 'target_xfer_error' with
'target_xfer_status' in comments.
This commit is contained in:
Yao Qi
60
gdb/auxv.c
60
gdb/auxv.c
@ -38,15 +38,16 @@
|
||||
/* This function handles access via /proc/PID/auxv, which is a common
|
||||
method for native targets. */
|
||||
|
||||
static LONGEST
|
||||
static enum target_xfer_status
|
||||
procfs_xfer_auxv (gdb_byte *readbuf,
|
||||
const gdb_byte *writebuf,
|
||||
ULONGEST offset,
|
||||
ULONGEST len)
|
||||
ULONGEST len,
|
||||
ULONGEST *xfered_len)
|
||||
{
|
||||
char *pathname;
|
||||
int fd;
|
||||
LONGEST n;
|
||||
ssize_t l;
|
||||
|
||||
pathname = xstrprintf ("/proc/%d/auxv", ptid_get_pid (inferior_ptid));
|
||||
fd = gdb_open_cloexec (pathname, writebuf != NULL ? O_WRONLY : O_RDONLY, 0);
|
||||
@ -56,24 +57,32 @@ procfs_xfer_auxv (gdb_byte *readbuf,
|
||||
|
||||
if (offset != (ULONGEST) 0
|
||||
&& lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
|
||||
n = -1;
|
||||
l = -1;
|
||||
else if (readbuf != NULL)
|
||||
n = read (fd, readbuf, len);
|
||||
l = read (fd, readbuf, (size_t) len);
|
||||
else
|
||||
n = write (fd, writebuf, len);
|
||||
l = write (fd, writebuf, (size_t) len);
|
||||
|
||||
(void) close (fd);
|
||||
|
||||
return n;
|
||||
if (l < 0)
|
||||
return TARGET_XFER_E_IO;
|
||||
else if (l == 0)
|
||||
return TARGET_XFER_EOF;
|
||||
else
|
||||
{
|
||||
*xfered_len = (ULONGEST) l;
|
||||
return TARGET_XFER_OK;
|
||||
}
|
||||
}
|
||||
|
||||
/* This function handles access via ld.so's symbol `_dl_auxv'. */
|
||||
|
||||
static LONGEST
|
||||
static enum target_xfer_status
|
||||
ld_so_xfer_auxv (gdb_byte *readbuf,
|
||||
const gdb_byte *writebuf,
|
||||
ULONGEST offset,
|
||||
ULONGEST len)
|
||||
ULONGEST len, ULONGEST *xfered_len)
|
||||
{
|
||||
struct minimal_symbol *msym;
|
||||
CORE_ADDR data_address, pointer_address;
|
||||
@ -132,7 +141,10 @@ ld_so_xfer_auxv (gdb_byte *readbuf,
|
||||
if (writebuf != NULL)
|
||||
{
|
||||
if (target_write_memory (data_address, writebuf, len) == 0)
|
||||
return len;
|
||||
{
|
||||
*xfered_len = (ULONGEST) len;
|
||||
return TARGET_XFER_OK;
|
||||
}
|
||||
else
|
||||
return TARGET_XFER_E_IO;
|
||||
}
|
||||
@ -147,7 +159,7 @@ ld_so_xfer_auxv (gdb_byte *readbuf,
|
||||
return TARGET_XFER_E_IO;
|
||||
|
||||
if (extract_typed_address (ptr_buf, ptr_type) == AT_NULL)
|
||||
return 0;
|
||||
return TARGET_XFER_EOF;
|
||||
}
|
||||
|
||||
retval = 0;
|
||||
@ -166,12 +178,12 @@ ld_so_xfer_auxv (gdb_byte *readbuf,
|
||||
|
||||
block &= -auxv_pair_size;
|
||||
if (block == 0)
|
||||
return retval;
|
||||
break;
|
||||
|
||||
if (target_read_memory (data_address, readbuf, block) != 0)
|
||||
{
|
||||
if (block <= auxv_pair_size)
|
||||
return retval;
|
||||
break;
|
||||
|
||||
block = auxv_pair_size;
|
||||
continue;
|
||||
@ -189,27 +201,31 @@ ld_so_xfer_auxv (gdb_byte *readbuf,
|
||||
retval += auxv_pair_size;
|
||||
|
||||
if (extract_typed_address (readbuf, ptr_type) == AT_NULL)
|
||||
return retval;
|
||||
{
|
||||
*xfered_len = (ULONGEST) retval;
|
||||
return TARGET_XFER_OK;
|
||||
}
|
||||
|
||||
readbuf += auxv_pair_size;
|
||||
block -= auxv_pair_size;
|
||||
}
|
||||
}
|
||||
|
||||
return retval;
|
||||
*xfered_len = (ULONGEST) retval;
|
||||
return TARGET_XFER_OK;
|
||||
}
|
||||
|
||||
/* This function is called like a to_xfer_partial hook, but must be
|
||||
called with TARGET_OBJECT_AUXV. It handles access to AUXV. */
|
||||
|
||||
LONGEST
|
||||
enum target_xfer_status
|
||||
memory_xfer_auxv (struct target_ops *ops,
|
||||
enum target_object object,
|
||||
const char *annex,
|
||||
gdb_byte *readbuf,
|
||||
const gdb_byte *writebuf,
|
||||
ULONGEST offset,
|
||||
ULONGEST len)
|
||||
ULONGEST len, ULONGEST *xfered_len)
|
||||
{
|
||||
gdb_assert (object == TARGET_OBJECT_AUXV);
|
||||
gdb_assert (readbuf || writebuf);
|
||||
@ -223,14 +239,14 @@ memory_xfer_auxv (struct target_ops *ops,
|
||||
|
||||
if (current_inferior ()->attach_flag != 0)
|
||||
{
|
||||
LONGEST retval;
|
||||
enum target_xfer_status ret;
|
||||
|
||||
retval = ld_so_xfer_auxv (readbuf, writebuf, offset, len);
|
||||
if (retval != -1)
|
||||
return retval;
|
||||
ret = ld_so_xfer_auxv (readbuf, writebuf, offset, len, xfered_len);
|
||||
if (ret != TARGET_XFER_E_IO)
|
||||
return ret;
|
||||
}
|
||||
|
||||
return procfs_xfer_auxv (readbuf, writebuf, offset, len);
|
||||
return procfs_xfer_auxv (readbuf, writebuf, offset, len, xfered_len);
|
||||
}
|
||||
|
||||
/* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
|
||||
|
||||
Reference in New Issue
Block a user