diff mbox

[2/2] linux-user: Implement handling of 5 POSIX timer syscalls.

Message ID 1382083502-761-2-git-send-email-mle+tools@mega-nerd.com
State New
Headers show

Commit Message

Erik de Castro Lopo Oct. 18, 2013, 8:05 a.m. UTC 
From: Erik de Castro Lopo <erikd@mega-nerd.com>

Implement timer_create, timer_settime, timer_gettime, timer_getoverrun
and timer_delete.
---
 linux-user/syscall.c | 199 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 199 insertions(+)

Comments

Peter Maydell Oct. 18, 2013, 9:28 a.m. UTC | #1 
On 18 October 2013 09:05,  <mle+tools@mega-nerd.com> wrote:
> From: Erik de Castro Lopo <erikd@mega-nerd.com>
>
> Implement timer_create, timer_settime, timer_gettime, timer_getoverrun
> and timer_delete.
> ---
>  linux-user/syscall.c | 199 +++++++++++++++++++++++++++++++++++++++++++++++++++
>  1 file changed, 199 insertions(+)
>
> diff --git a/linux-user/syscall.c b/linux-user/syscall.c
> index 4a14a43..ccab0a1 100644
> --- a/linux-user/syscall.c
> +++ b/linux-user/syscall.c
> @@ -428,6 +428,48 @@ _syscall4(int, sys_prlimit64, pid_t, pid, int, resource,
>            struct host_rlimit64 *, old_limit)
>  #endif
>
> +#if defined(TARGET_NR_timer_create)
> +#ifndef __NR_timer_create
> +# define __NR_timer_create -1
> +# define __NR_timer_settime -1
> +# define __NR_timer_gettime -1
> +# define __NR_timer_getoverrun -1
> +# define __NR_timer_delete -1
> +#endif
> +
> +#define __NR_sys_timer_create __NR_timer_create
> +#define __NR_sys_timer_settime __NR_timer_settime
> +#define __NR_sys_timer_gettime __NR_timer_gettime
> +#define __NR_sys_timer_getoverrun __NR_timer_getoverrun
> +#define __NR_sys_timer_delete __NR_timer_delete
> +
> +
> +/* Maxiumum of 32 active timers allowed at any one time. */
> +static timer_t g_posix_timers[32] = { 0, } ;
> +
> +_syscall3(int, sys_timer_create,
> +          clockid_t, clockid, struct sigevent *, sevp, timer_t *, timerid)
> +_syscall4(int, sys_timer_settime,
> +          timer_t, timerid, int, flags, const struct itimerspec *, new_value,
> +          struct itimerspec *, old_value)
> +_syscall2(int, sys_timer_gettime,
> +          timer_t, timerid, struct itimerspec *, curr_value)
> +_syscall1(int, sys_timer_getoverrun, timer_t, timerid)
> +_syscall1(int, sys_timer_delete, timer_t, timerid)

Is there a good reason for doing these all via manual syscalls
rather than just using the host's libc interface to them?

thanks
-- PMM
Erik de Castro Lopo Oct. 18, 2013, 9:40 a.m. UTC | #2 
Peter Maydell wrote:

> Is there a good reason for doing these all via manual syscalls
> rather than just using the host's libc interface to them?

Thats a really good question. As you can see from the commit date
I wrote this patch over a year ago and I can't remember why it ended
up like it did. Possibly it was the first thing I tried that worked.

I'll have a look at doing it as you suggested.

Cheers,
Erik
diff mbox

Patch

diff --git a/linux-user/syscall.c b/linux-user/syscall.c
index 4a14a43..ccab0a1 100644
--- a/linux-user/syscall.c
+++ b/linux-user/syscall.c
@@ -428,6 +428,48 @@  _syscall4(int, sys_prlimit64, pid_t, pid, int, resource,
           struct host_rlimit64 *, old_limit)
 #endif
 
+#if defined(TARGET_NR_timer_create)
+#ifndef __NR_timer_create
+# define __NR_timer_create -1
+# define __NR_timer_settime -1
+# define __NR_timer_gettime -1
+# define __NR_timer_getoverrun -1
+# define __NR_timer_delete -1
+#endif
+
+#define __NR_sys_timer_create __NR_timer_create
+#define __NR_sys_timer_settime __NR_timer_settime
+#define __NR_sys_timer_gettime __NR_timer_gettime
+#define __NR_sys_timer_getoverrun __NR_timer_getoverrun
+#define __NR_sys_timer_delete __NR_timer_delete
+
+
+/* Maxiumum of 32 active timers allowed at any one time. */
+static timer_t g_posix_timers[32] = { 0, } ;
+
+_syscall3(int, sys_timer_create,
+          clockid_t, clockid, struct sigevent *, sevp, timer_t *, timerid)
+_syscall4(int, sys_timer_settime,
+          timer_t, timerid, int, flags, const struct itimerspec *, new_value,
+          struct itimerspec *, old_value)
+_syscall2(int, sys_timer_gettime,
+          timer_t, timerid, struct itimerspec *, curr_value)
+_syscall1(int, sys_timer_getoverrun, timer_t, timerid)
+_syscall1(int, sys_timer_delete, timer_t, timerid)
+
+static inline int next_free_host_timer(void)
+{
+    int k ;
+    /* FIXME: Does finding the next free slot require a lock? */
+    for (k = 0; k < ARRAY_SIZE(g_posix_timers); k++)
+        if (g_posix_timers[k] == 0) {
+            g_posix_timers[k] = (timer_t) 1;
+            return k;
+        }
+    return -1;
+}
+#endif
+
 /* ARM EABI and MIPS expect 64bit types aligned even on pairs or registers */
 #ifdef TARGET_ARM
 static inline int regpairs_aligned(void *cpu_env) {
@@ -4838,6 +4880,45 @@  static inline abi_long host_to_target_timespec(abi_ulong target_addr,
     return 0;
 }
 
+static inline abi_long target_to_host_itimerspec(struct itimerspec *host_itspec,
+                                                 abi_ulong target_addr)
+{
+    struct target_itimerspec *target_itspec;
+
+    if (!lock_user_struct(VERIFY_READ, target_itspec, target_addr, 1)) {
+        return -TARGET_EFAULT;
+    }
+
+    host_itspec->it_interval.tv_sec =
+                            tswapal(target_itspec->it_interval.tv_sec);
+    host_itspec->it_interval.tv_nsec =
+                            tswapal(target_itspec->it_interval.tv_nsec);
+    host_itspec->it_value.tv_sec = tswapal(target_itspec->it_value.tv_sec);
+    host_itspec->it_value.tv_nsec = tswapal(target_itspec->it_value.tv_nsec);
+
+    unlock_user_struct(target_itspec, target_addr, 1);
+    return 0;
+}
+
+static inline abi_long host_to_target_itimerspec(abi_ulong target_addr,
+                                               struct itimerspec *host_its)
+{
+    struct target_itimerspec *target_itspec;
+
+    if (!lock_user_struct(VERIFY_WRITE, target_itspec, target_addr, 0)) {
+        return -TARGET_EFAULT;
+    }
+
+    target_itspec->it_interval.tv_sec = tswapal(host_its->it_interval.tv_sec);
+    target_itspec->it_interval.tv_nsec = tswapal(host_its->it_interval.tv_nsec);
+
+    target_itspec->it_value.tv_sec = tswapal(host_its->it_value.tv_sec);
+    target_itspec->it_value.tv_nsec = tswapal(host_its->it_value.tv_nsec);
+
+    unlock_user_struct(target_itspec, target_addr, 1);
+    return 0;
+}
+
 #if defined(TARGET_NR_stat64) || defined(TARGET_NR_newfstatat)
 static inline abi_long host_to_target_stat64(void *cpu_env,
                                              abi_ulong target_addr,
@@ -9195,6 +9276,124 @@  abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
         break;
     }
 #endif
+
+#ifdef TARGET_NR_timer_create
+    case TARGET_NR_timer_create:
+    {
+        /* args: clockid_t clockid, struct sigevent *sevp, timer_t *timerid */
+
+        struct sigevent host_sevp = { {0}, }, *phost_sevp = NULL;
+        struct target_sigevent *ptarget_sevp;
+        struct target_timer_t *ptarget_timer;
+
+        int clkid = arg1;
+        int timer_index = next_free_host_timer();
+
+        if (timer_index < 0) {
+            ret = -TARGET_EAGAIN;
+        } else {
+            timer_t *phtimer = g_posix_timers  + timer_index;
+
+            if (arg2) {
+                if (!lock_user_struct(VERIFY_READ, ptarget_sevp, arg2, 1)) {
+                    goto efault;
+                }
+
+                host_sevp.sigev_signo = tswap32(ptarget_sevp->sigev_signo);
+                host_sevp.sigev_notify = tswap32(ptarget_sevp->sigev_notify);
+
+                phost_sevp = &host_sevp;
+            }
+
+            ret = get_errno(sys_timer_create(clkid, phost_sevp, phtimer));
+            if (ret) {
+                phtimer = NULL;
+            } else {
+                if (!lock_user_struct(VERIFY_WRITE, ptarget_timer, arg3, 1)) {
+                    goto efault;
+                }
+                ptarget_timer->ptr = tswap32(0xcafe0000 | timer_index);
+                unlock_user_struct(ptarget_timer, arg3, 1);
+            }
+        }
+        break;
+    }
+#endif
+
+#ifdef TARGET_NR_timer_settime
+    case TARGET_NR_timer_settime:
+    {
+        /* args: timer_t timerid, int flags, const struct itimerspec *new_value,
+         * struct itimerspec * old_value */
+        arg1 &= 0xffff;
+        if (arg3 == 0 || arg1 < 0 || arg1 >= ARRAY_SIZE(g_posix_timers)) {
+            ret = -TARGET_EINVAL;
+        } else {
+            timer_t htimer = g_posix_timers[arg1];
+            struct itimerspec hspec_new = {{0},}, hspec_old = {{0},};
+
+            target_to_host_itimerspec(&hspec_new, arg3);
+            ret = get_errno(
+                    sys_timer_settime(htimer, arg2, &hspec_new, &hspec_old));
+            host_to_target_itimerspec(arg2, &hspec_old);
+        }
+        break;
+    }
+#endif
+
+#ifdef TARGET_NR_timer_gettime
+    case TARGET_NR_timer_gettime:
+    {
+        /* args: timer_t timerid, struct itimerspec *curr_value */
+        arg1 &= 0xffff;
+        if (!arg2) {
+            return -TARGET_EFAULT;
+        } else if (arg1 < 0 || arg1 >= ARRAY_SIZE(g_posix_timers)) {
+            ret = -TARGET_EINVAL;
+        } else {
+            timer_t htimer = g_posix_timers[arg1];
+            struct itimerspec hspec;
+            ret = get_errno(sys_timer_gettime(htimer, &hspec));
+
+            if (host_to_target_itimerspec(arg2, &hspec)) {
+                ret = -TARGET_EFAULT;
+            }
+        }
+        break;
+    }
+#endif
+
+#ifdef TARGET_NR_timer_getoverrun
+    case TARGET_NR_timer_getoverrun:
+    {
+        /* args: timer_t timerid */
+        arg1 &= 0xffff;
+        if (arg1 < 0 || arg1 >= ARRAY_SIZE(g_posix_timers)) {
+            ret = -TARGET_EINVAL;
+        } else {
+            timer_t htimer = g_posix_timers[arg1];
+            ret = get_errno(sys_timer_getoverrun(htimer));
+        }
+        break;
+    }
+#endif
+
+#ifdef TARGET_NR_timer_delete
+    case TARGET_NR_timer_delete:
+    {
+        /* args: timer_t timerid */
+        arg1 &= 0xffff;
+        if (arg1 < 0 || arg1 >= ARRAY_SIZE(g_posix_timers)) {
+            ret = -TARGET_EINVAL;
+        } else {
+            timer_t *phtimer = g_posix_timers  + arg1;
+            ret = get_errno(sys_timer_delete(phtimer));
+            g_posix_timers[arg1] = 0;
+        }
+        break;
+    }
+#endif
+
     default:
     unimplemented:
         gemu_log("qemu: Unsupported syscall: %d\n", num);