Re: [Qemu-devel] qemu qemu-doc.texi

[Wolfgang Schildbach <Wolfgang.Schildbach@codingtechnologies.com>]

[-- Attachment #1: Type: text/plain, Size: 2719 bytes --]

Hi Paul,

Thanks for the explanation. I feel like fixing the alignment issue in the 
qemu code is a little above my head right now. However, it turns out that 
the alignment issue can be solved on the arm compiler/linker side, by 
giving appropriate arguments to the linker (--ro-base 0x8034). The 
"missing command line issue" can be attributed to the fact that the 
corresponding ARM semihosting function was not implemented.

The patch below implements the SYS_GET_CMDLINE semihosting call, by 
keeping a global pointer to the user space commandline arguments, and by 
re-building a space-separated command line in the guest side supplied 
buffer. This patch has two shortcomings:

- I am keeping a global pointer in order to have a handle on the command 
line arguments inside do_arm_semihosting. Is there a better place to keep 
this?
- The ARM (guest) side supplied buffer is only 256 bytes long; if the user 
supplied command line is larger, the semihosting call will fail 
(gracefully). A better strategy may be to build the string on the initial 
guest stack (similar to loader_build_argptgr()) and then hand that pointer 
to the guest.

I am not quite sure whether the ARGS[] array should be locked before 
access (then again, none of the functions in do_arm_semihosting() do 
this).

Anyhow, with the patch below (and the linker flags above), I can 
successfully execute ADS/RVCT compiled binaries, together with command 
line arguments, both little- and bigendian.

All comments welcome.

- Wolfgang

Paul Brook <paul@codesourcery.com> wrote on 12.06.2006 18:47:12:

> > Where would I (start to) look for the reasons behind this? Is this
> > something that needs to be "fixed" on the ARM side (i.e. fix the 
location
> > where the ARM code looks for the environment)?
> 
> Look at the code in load_elf_binary that uses target_mmap to map 
theloadable 
> segments into memory. The page size I'm referring to below is the target 
page 
> size (4k for qemu-arm). target_mmap is more-or-less a wrapper around 
normal 
> mmap that deals with the corner cases and differences in page size when 
> host != target. 
> 
> There are two issues:
> - mmap requires the file offset be a multiple of the page size.  This is 

> relatively easy to fix. If the file data is misaligned create an 
anonymous 
> mapping and pread the data.
> 
> - The code assumes the VMA of the segments after roundind to a page 
boundary 
> do not overlap. ie. a single memory page will contain data from no more 
than 
> one segment. Fixing this is more complicated and probably involves 
merging 
> the regions used by sections with "overlapping" pages.
> 
> Paul

--
Wolfgang Schildbach, Senior Research Engineer
Coding Technologies GmbH

[-- Attachment #2: arm_semihosting_commandline.diff --]
[-- Type: application/octet-stream, Size: 2838 bytes --]

Index: linux-user/arm-semi.c
===================================================================
RCS file: /sources/qemu/qemu/linux-user/arm-semi.c,v
retrieving revision 1.5
diff -r1.5 arm-semi.c
80c80,81
< #define ARG(n) tget32(args + n * 4)
---
> #define ARG(n) tget32(args + (n) * 4)
> #define SET_ARG(n,val) tput32(args + (n) * 4,val)
161,164c162,201
<         /* XXX: Not implemented.  */
<         s = (char *)g2h(ARG(0));
<         *s = 0;
<         return -1;
---
>         /* The ARM semihosting interface requires that the commandline is
>            presented with blanks separating the arguments. Thus, we need
>            to build a new command line, given the global pointer to the
>            command line we received.
>            A better way would be to build this command line on the user stack,
>            similar to the way it is done in loader_build_argptr(), and then
>            just hand that pointer back to the caller */
>         {
>             extern char **global_userspace_argv ; /* initialized in main() */
>             char **av = global_userspace_argv ;   /* work ptr */
>             int len = ARG(1); /* amount of RAM that the ARM binary has set
>                                  aside for the command line */
>             /* lock the buffer on the ARM side */
>             char *cmdline_buffer = (char*)lock_user(ARG(0),len,0);
>             s = cmdline_buffer ;
>             do {
>                 int n = strlen(*av) ;
> 
>                 /* is there still space in the supplied buffer, including
>                    the terminating zero? */
>                 if (s - cmdline_buffer + n+1 > len)
>                     break ; /* no */
> 
>                 memcpy(s,*av,n);
>                 s += n ;
>                 *s++ = ' ';
>                 len -= n+1 ;
>                 av++;
>             } while (*av);
>             *s++ = 0; /* terminate cmdline string */
> 
>             /* unlock the buffer on the ARM side */
>             unlock_user(cmdline_buffer, ARG(0), ARG(1));
> 
>             /* adjust the commandline length argument */
>             SET_ARG(1, (uint32_t)(s - cmdline_buffer));
> 
>             /* successfull return if commandline fit into buffer */
>             return *av == 0 ? 0 : -1 ;
>         }
Index: linux-user/main.c
===================================================================
RCS file: /sources/qemu/qemu/linux-user/main.c,v
retrieving revision 1.88
diff -r1.88 main.c
312a313,315
> /* XXX: this is an ugly hack, to make argc/argv available to ARM semihosting */
> char **global_userspace_argv ;
> 
1531,1532c1534,1536
<     
<     if (loader_exec(filename, argv+optind, environ, regs, info) != 0) {
---
>     global_userspace_argv = argv + optind;
> 
>     if ((loader_exec(filename, global_userspace_argv, environ, regs, info)) != 0) {