diff mbox

linux-user: Allow getdents to be provided by getdents64

Message ID 1370193044-24535-1-git-send-email-peter.maydell@linaro.org
State Superseded
Headers show

Commit Message

Peter Maydell June 2, 2013, 5:10 p.m. UTC
Newer architectures may only implement the getdents64 syscall, not
getdents. Provide an implementation of getdents in terms of getdents64
so that we can run getdents-using targets on a getdents64-only host.

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
---
Guess which exciting new architecture doesn't have getdents :-)
Tested on i386 by temporarily nobbling the #ifdefs so we use the
via-getdents64 path rather than via-getdents, and with the test program
from the getdents(2) manpage as the guest binary.

 linux-user/syscall.c |   60 +++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 59 insertions(+), 1 deletion(-)

Comments

Richard Henderson June 3, 2013, 3:15 p.m. UTC | #1
On 06/02/2013 10:10 AM, Peter Maydell wrote:
> +                    tde->d_ino = tswapal(ino);
> +                    tde->d_off = tswapal(off);
> +                    tde->d_reclen = tswap16(treclen);
> +                    memmove(tde->d_name, de->d_name, namelen + 1);

Wouldn't it be better to do the memmove first?  Then you really are reading all
of the dirent64 data first, like your comment says.

> +                    /* The target_dirent type is in what was formerly a padding
> +                     * byte at the end of the structure:
> +                     */
> +                    *(((char *)tde) + treclen - 1) = type;

Maybe easier to read as

  ((char *)tde)[treclen - 1] = type

?


r~
Peter Maydell June 3, 2013, 3:45 p.m. UTC | #2
On 3 June 2013 16:15, Richard Henderson <rth@twiddle.net> wrote:
> On 06/02/2013 10:10 AM, Peter Maydell wrote:
>> +                    tde->d_ino = tswapal(ino);
>> +                    tde->d_off = tswapal(off);
>> +                    tde->d_reclen = tswap16(treclen);
>> +                    memmove(tde->d_name, de->d_name, namelen + 1);
>
> Wouldn't it be better to do the memmove first?  Then you really are reading all
> of the dirent64 data first, like your comment says.

It doesn't actually make a difference, in fact, but I agree
it would be clearer that way round.

>> +                    /* The target_dirent type is in what was formerly a padding
>> +                     * byte at the end of the structure:
>> +                     */
>> +                    *(((char *)tde) + treclen - 1) = type;
>
> Maybe easier to read as
>
>   ((char *)tde)[treclen - 1] = type
>
> ?

Dunno. It's not actually a char array, so I kind of prefer
to use plain pointer arithmetic for this kind of thing.

-- PMM
Richard Henderson June 3, 2013, 3:58 p.m. UTC | #3
On 06/03/2013 08:45 AM, Peter Maydell wrote:
>>> >> +                    /* The target_dirent type is in what was formerly a padding
>>> >> +                     * byte at the end of the structure:
>>> >> +                     */
>>> >> +                    *(((char *)tde) + treclen - 1) = type;
>> >
>> > Maybe easier to read as
>> >
>> >   ((char *)tde)[treclen - 1] = type
>> >
>> > ?
> Dunno. It's not actually a char array, so I kind of prefer
> to use plain pointer arithmetic for this kind of thing.

Then drop the unnecessary parenthesis

  *((char *)tde + trelen - 1) = type;

?


r~
Peter Maydell June 3, 2013, 4:17 p.m. UTC | #4
On 3 June 2013 16:58, Richard Henderson <rth@twiddle.net> wrote:
> On 06/03/2013 08:45 AM, Peter Maydell wrote:
>> Dunno. It's not actually a char array, so I kind of prefer
>> to use plain pointer arithmetic for this kind of thing.
>
> Then drop the unnecessary parenthesis
>
>   *((char *)tde + trelen - 1) = type;
>
> ?

That parenthesis is there under my "if you can't immediately
say what the relative precedence of two operators is then
add brackets" rule. (ie I don't offhand know precedence
of the cast operator).

-- PMM
diff mbox

Patch

diff --git a/linux-user/syscall.c b/linux-user/syscall.c
index 053fa14..15c771a 100644
--- a/linux-user/syscall.c
+++ b/linux-user/syscall.c
@@ -208,8 +208,11 @@  static int gettid(void) {
     return -ENOSYS;
 }
 #endif
+#ifdef __NR_getdents
 _syscall3(int, sys_getdents, uint, fd, struct linux_dirent *, dirp, uint, count);
-#if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
+#endif
+#if !defined(__NR_getdents) || \
+    (defined(TARGET_NR_getdents64) && defined(__NR_getdents64))
 _syscall3(int, sys_getdents64, uint, fd, struct linux_dirent64 *, dirp, uint, count);
 #endif
 #if defined(TARGET_NR__llseek) && defined(__NR_llseek)
@@ -6963,6 +6966,7 @@  abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
         break;
 #endif
     case TARGET_NR_getdents:
+#ifdef __NR_getdents
 #if TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64
         {
             struct target_dirent *target_dirp;
@@ -7035,6 +7039,60 @@  abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
             unlock_user(dirp, arg2, ret);
         }
 #endif
+#else
+        /* Implement getdents in terms of getdents64 */
+        {
+            struct linux_dirent64 *dirp;
+            abi_long count = arg3;
+
+            dirp = lock_user(VERIFY_WRITE, arg2, count, 0);
+            if (!dirp) {
+                goto efault;
+            }
+            ret = get_errno(sys_getdents64(arg1, dirp, count));
+            if (!is_error(ret)) {
+                /* Convert the dirent64 structs to target dirent.  We do this
+                 * in-place, since we can guarantee that a target_dirent is no
+                 * larger than a dirent64; however this means we have to be
+                 * careful to read everything before writing in the new format.
+                 */
+                struct linux_dirent64 *de;
+                struct target_dirent *tde;
+                int len = ret;
+                int tlen = 0;
+
+                de = dirp;
+                tde = (struct target_dirent *)dirp;
+                while (len > 0) {
+                    int namelen, treclen;
+                    int reclen = de->d_reclen;
+                    uint64_t ino = de->d_ino;
+                    int64_t off = de->d_off;
+                    uint8_t type = de->d_type;
+
+                    namelen = strlen(de->d_name);
+                    treclen = offsetof(struct target_dirent, d_name) + namelen + 2;
+                    treclen = QEMU_ALIGN_UP(treclen, sizeof(abi_long));
+
+                    tde->d_ino = tswapal(ino);
+                    tde->d_off = tswapal(off);
+                    tde->d_reclen = tswap16(treclen);
+                    memmove(tde->d_name, de->d_name, namelen + 1);
+                    /* The target_dirent type is in what was formerly a padding
+                     * byte at the end of the structure:
+                     */
+                    *(((char *)tde) + treclen - 1) = type;
+
+                    de = (struct linux_dirent64 *)((char *)de + reclen);
+                    tde = (struct target_dirent *)((char *)tde + treclen);
+                    len -= reclen;
+                    tlen += treclen;
+                }
+                ret = tlen;
+            }
+            unlock_user(dirp, arg2, ret);
+        }
+#endif
         break;
 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
     case TARGET_NR_getdents64: