Skip to contentSkip to conversation

Fix TLS support on x86

PATCH In review Alexander Graf 7 participants 11 messages Jun 8, 2007 – Nov 14, 2007 3 messages not in the archive

lore
Share & tools
lore

Alexander Graf

author
#0 lore raw

PATCH 1/1 Fix TLS support on x86

Hi,

this patch is based on the NPTL/TLS patch, David Woodhouse sent to the list some months ago, which unfortulately did not work for me, so these are the fixes needed to get it working. After all there is a certain chance, that I got something wrong but basically it does the following:

1. Implement the tg_kill syscall
2. Set the GS shadow register according to the information set_thread_area receives. I'm not sure about that part, but using the qemu internal functions (cpu_x86_load_seg) did not work for me.
3. Implement the "new" (2.5.xx) TID setting features of clone()
4. Use clone() for forking, since fork() did not always work for me (especially when using TLS)

I'm open for suggestions. Using this patch all single-threaded and most simple multi-threaded current applications (glibc 2.5) do work. Everything bigger however does not. If anyone on this list is more into these things, I would very much appreciate any help.

Regards,

Alexander Graf

linux-user/i386/syscall_nr.h +1 -0
Index: qemu-0.9.0/linux-user/i386/syscall_nr.h
===================================================================
@@ -271,5 +271,6 @@
 #define TARGET_NR_clock_getres	(TARGET_NR_timer_create+7)
 #define TARGET_NR_clock_nanosleep	(TARGET_NR_timer_create+8)
 
+#define TARGET_NR_tgkill		270
 #define TARGET_NR_utimes		271
 #define TARGET_NR_fadvise64_64		272
linux-user/syscall.c +54 -26

190 lines not on this page · raw message

#1 lore raw
Quoted 7 lines · Alexander Graf

Hi,

this patch is based on the NPTL/TLS patch, David Woodhouse sent to the list some months ago, which unfortulately did not work for me, so these are the fixes needed to get it working. After all there is a certain chance, that I got something wrong but basically it does the following:

Quoted 7 lines

1. Implement the tg_kill syscall
2. Set the GS shadow register according to the information set_thread_area receives. I'm not sure about that part, but using the qemu internal functions (cpu_x86_load_seg) did not work for me.
3. Implement the "new" (2.5.xx) TID setting features of clone()
4. Use clone() for forking, since fork() did not always work for me (especially when using TLS)

Please split the patch per-feature, and make sure it applies to CVS head. (It fails to apply because it appears to depend on another patch which adds fadvise64 support.) Also, keep the code formatting style the same as the surrounding code (line length, space vs. tabs, whitespace around parentheses, ... ).

Thiemo

author
#2 lore raw
Quoted 18 lines · Thiemo Seufer
Quoted 7 lines · Alexander Graf

Hi,

this patch is based on the NPTL/TLS patch, David Woodhouse sent to the list some months ago, which unfortulately did not work for me, so these are the fixes needed to get it working. After all there is a certain chance, that I got something wrong but basically it does the following:

Quoted 8 lines

1. Implement the tg_kill syscall
2. Set the GS shadow register according to the information set_thread_area receives. I'm not sure about that part, but using the qemu internal functions (cpu_x86_load_seg) did not work for me.
3. Implement the "new" (2.5.xx) TID setting features of clone()
4. Use clone() for forking, since fork() did not always work for me (especially when using TLS)

Quoted 11 lines

Please split the patch per-feature, and make sure it applies to CVS head. (It fails to apply because it appears to depend on another patch which adds fadvise64 support.) Also, keep the code formatting style the same as the surrounding code (line length, space vs. tabs, whitespace around parentheses, ... ).

Thiemo

These are all of my patches so far, split as far as I thought might be helpful and including the patch by David Woodhouse. Basically they are independent of each other, because they affect similar areas of the sources it's best to apply them in order though. I believe, I sent the fadvise64-patch to the list as well some time ago. It is invalid and everything should work without it as well though.
Would it be better to tgz the patches if I plan to send them to the list?

I hope there are no formatting mistakes left and everything applies properly to CVS.

qemu-cvs-tgkill.patch

implements the tgkill syscall.

qemu-cvs-tls.patch

implements set_thread_area for x86 and modifies the do_clone function, so TLS is evaluated. This is 90% done by David Woodhouse, I only changed it so it works for me (TID setters, proper segment register setters, fork() fix).

qemu-cvs-futex.patch

implements futexes (this is mostly done by David Woodhouse as well, FUTEX_WAKE_OP done by me)

qemu-cvs-set_robust_list.patch

set_robust_list is only implemented in > 2.6.16, so it does not hurt to ignore that one

qemu-cvs-sched_getaffinity.patch

Flash9 needs sys_get_getaffinity to work properly. As far as I can tell there should be no need for endianness-conversion, because the information is written bit-wise.

qemu-cvs-wine.patch

Wine checks if %FS is 0, and if it is initializes it properly. This usually is the case with a normal i586 system (26 in qemu-i386), so we should emulate that behavior as well. I'm not sure if this is the way to go though, somehow the code looks ugly ;-)

linux-user/syscall.c +93 -0
Index: qemu/linux-user/syscall.c
===================================================================
@@ -17,6 +17,8 @@
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
+
+#define __user
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>

@@ -60,6 +62,7 @@
 #define tchars host_tchars /* same as target */
 #define ltchars host_ltchars /* same as target */
 
+#include <linux/futex.h>
 #include <linux/termios.h>
 #include <linux/unistd.h>
 #include <linux/utsname.h>

@@ -2556,6 +2559,91 @@ static inline void host_to_target_timesp
     unlock_user_struct(target_ts, target_addr, 1);
 }
 
+#ifdef BSWAP_NEEDED
+static int futex_op(int oldval, int op, int oparg)
+{
+	int retval = oparg;
+	switch(op) {
+	    case FUTEX_OP_SET: break;
+	    case FUTEX_OP_ADD: retval += oparg; break;
+	    case FUTEX_OP_OR: retval |= oparg; break;
+	    case FUTEX_OP_ANDN: retval &= oparg; break;
+	    case FUTEX_OP_XOR: retval ^= oparg; break;
+	}
+	return retval;
+}
+
+static int futex_cmp(int oldval, int cmp, int cmparg)
+{
+	switch(cmp) {
+	    case FUTEX_OP_CMP_EQ: return oldval == cmparg;
+	    case FUTEX_OP_CMP_NE: return oldval != cmparg;
+	    case FUTEX_OP_CMP_LT: return oldval <  cmparg;
+	    case FUTEX_OP_CMP_LE: return oldval <= cmparg;
+	    case FUTEX_OP_CMP_GT: return oldval >  cmparg;
+	    case FUTEX_OP_CMP_GE: return oldval >= cmparg;
+	}
+	return -1;
+}
+#endif
+
+static long do_futex(target_ulong uaddr, int op, uint32_t val,
+                    target_ulong utime, target_ulong uaddr2,
+                    uint32_t val3)
+{
+       struct timespec host_utime;
+       unsigned long val2 = utime;
+       long retval;
+
+       if (utime && (op == FUTEX_WAIT || op == FUTEX_LOCK_PI)) {
+               target_to_host_timespec(&host_utime, utime);
+               val2 = (unsigned long)&host_utime;
+       }
+ 
+#ifdef BSWAP_NEEDED
+       switch(op) {
+       case FUTEX_CMP_REQUEUE:
+               val3 = tswap32(val3);
+       case FUTEX_REQUEUE:
+               val2 = tswap32(val2);
+       case FUTEX_WAIT:
+       case FUTEX_WAKE:
+       case FUTEX_WAKE_OP:
+               val = tswap32(val);
+       case FUTEX_LOCK_PI: /* This one's icky, but comes out OK */
+       case FUTEX_UNLOCK_PI:
+               break;
+       default: 
+               gemu_log("qemu: Unsupported futex op %d\n", op);
+               spin_unlock(&mmap_lock);
+               return -ENOSYS;
+       } 
+       if (op == FUTEX_WAKE_OP) {
+               /* Need to munge the secondary operation (val3) */
+               val3 = tswap32(val3);
+               int op2 = (val3 >> 28) & 0xf;
+               int cmp = (val3 >> 24) & 0xf;
+               int oparg = (val3 >> 12) & 0xfff;
+               int cmparg = val3 & 0xfff;
+               int shift = val3 & (FUTEX_OP_OPARG_SHIFT << 28);
+               int oldval = tget32(uaddr2);
+               if (shift)
+                   oparg = 1 << oparg;
+
+              tput32(uaddr2,futex_op(oldval, op2, oparg));
+              retval = syscall(__NR_futex, g2h(uaddr), FUTEX_WAKE, val, 0, 0, 0);
+              if(futex_cmp(oldval, cmp, cmparg)) {
+                  retval = syscall(__NR_futex, g2h(uaddr2), FUTEX_WAKE, val2, 0, 0, 0);
+              }
+       } else {
+              retval = syscall(__NR_futex, g2h(uaddr), op, val, val2, g2h(uaddr2), val3);
+       }
+#else
+       retval = syscall(__NR_futex, g2h(uaddr), op, val, val2, g2h(uaddr2), val3);
+#endif
+       return retval;
+}
+
 long do_syscall(void *cpu_env, int num, long arg1, long arg2, long arg3, 
                 long arg4, long arg5, long arg6)
 {

@@ -4715,6 +4804,11 @@ long do_syscall(void *cpu_env, int num, 
     }
 #endif
 
+#ifdef TARGET_NR_futex
+    case TARGET_NR_futex:
+        ret = get_errno(do_futex(arg1, arg2, arg3, arg4, arg5, arg6));
+        break;
+#endif
 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
     case TARGET_NR_set_tid_address:
       ret = get_errno(set_tid_address((int *) arg1));
linux-user/syscall.c +8 -0
Index: qemu/linux-user/syscall.c
===================================================================
@@ -149,6 +149,7 @@ type name (type1 arg1,type2 arg2,type3 a
 #define __NR_sys_syslog __NR_syslog
 #define __NR_sys_tgkill __NR_tgkill
 #define __NR_sys_clone __NR_clone
+#define __NR_sys_sched_getaffinity __NR_sched_getaffinity
 
 #if defined(__alpha__) || defined (__ia64__) || defined(__x86_64__)
 #define __NR__llseek __NR_lseek

@@ -171,6 +172,7 @@ _syscall3(int,sys_rt_sigqueueinfo,int,pi
 _syscall3(int,sys_syslog,int,type,char*,bufp,int,len)
 _syscall3(int,sys_tgkill,int,tgid,int,pid,int,sig)
 _syscall5(int,sys_clone, int, flags, void *, child_stack, int *, parent_tidptr, struct user_desc *, newtls, int *, child_tidptr)
+_syscall3(int,sys_sched_getaffinity,pid_t,pid,unsigned int,cpusetsize,void*,mask)
 #ifdef __NR_exit_group
 _syscall1(int,exit_group,int,error_code)
 #endif

@@ -4826,6 +4828,12 @@ long do_syscall(void *cpu_env, int num, 
 	goto unimplemented_nowarn;
 #endif
 
+#ifdef TARGET_NR_sched_getaffinity
+    case TARGET_NR_sched_getaffinity:
+	ret = get_errno(sys_sched_getaffinity((pid_t)arg1, (unsigned int)arg2, (void*)arg3));
+	break;
+#endif
+
     default:
     unimplemented:
         gemu_log("qemu: Unsupported syscall: %d\n", num);
linux-user/i386/syscall_nr.h +2 -0
Index: qemu/linux-user/i386/syscall_nr.h
===================================================================
@@ -273,3 +273,5 @@
 
 #define TARGET_NR_tgkill		270
 #define TARGET_NR_utimes		271
+
+#define TARGET_NR_set_robust_list	311
linux-user/syscall.c +6 -1
Index: qemu/linux-user/syscall.c
===================================================================
@@ -4821,10 +4821,15 @@ long do_syscall(void *cpu_env, int num, 
 	break;
 #endif
 
+#ifdef TARGET_NR_set_robust_list
+    case TARGET_NR_set_robust_list:
+	goto unimplemented_nowarn;
+#endif
+
     default:
     unimplemented:
         gemu_log("qemu: Unsupported syscall: %d\n", num);
-#if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname)
+#if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)
     unimplemented_nowarn:
 #endif
         ret = -ENOSYS;
linux-user/i386/syscall_nr.h +1 -0
Index: qemu/linux-user/i386/syscall_nr.h
===================================================================
@@ -271,4 +271,5 @@
 #define TARGET_NR_clock_getres	(TARGET_NR_timer_create+7)
 #define TARGET_NR_clock_nanosleep	(TARGET_NR_timer_create+8)
 
+#define TARGET_NR_tgkill		270
 #define TARGET_NR_utimes		271
linux-user/syscall.c +8 -0
Index: qemu/linux-user/syscall.c
===================================================================
@@ -144,6 +144,7 @@ type name (type1 arg1,type2 arg2,type3 a
 #define __NR_sys_getdents64 __NR_getdents64
 #define __NR_sys_rt_sigqueueinfo __NR_rt_sigqueueinfo
 #define __NR_sys_syslog __NR_syslog
+#define __NR_sys_tgkill __NR_tgkill
 
 #if defined(__alpha__) || defined (__ia64__) || defined(__x86_64__)
 #define __NR__llseek __NR_lseek

@@ -164,6 +165,7 @@ _syscall5(int, _llseek,  uint,  fd, ulon
           loff_t *, res, uint, wh);
 _syscall3(int,sys_rt_sigqueueinfo,int,pid,int,sig,siginfo_t *,uinfo)
 _syscall3(int,sys_syslog,int,type,char*,bufp,int,len)
+_syscall3(int,sys_tgkill,int,tgid,int,pid,int,sig)
 #ifdef __NR_exit_group
 _syscall1(int,exit_group,int,error_code)
 #endif

@@ -4604,6 +4606,12 @@ long do_syscall(void *cpu_env, int num, 
       break;
 #endif
 
+#ifdef TARGET_NR_tgkill
+    case TARGET_NR_tgkill:
+	ret = get_errno(sys_tgkill((int)arg1, (int)arg2, (int)arg3));
+	break;
+#endif
+
     default:
     unimplemented:
         gemu_log("qemu: Unsupported syscall: %d\n", num);
linux-user/main.c +1 -1
Index: qemu/linux-user/main.c
===================================================================
@@ -156,7 +156,7 @@ static void set_gate(void *ptr, unsigned
     p[1] = tswapl(e2);
 }
 
-uint64_t gdt_table[6];
+uint64_t gdt_table[9];
 uint64_t idt_table[256];
 
 /* only dpl matters as we do only user space emulation */
linux-user/syscall.c +134 -19

236 lines not on this page · raw message

linux-user/main.c +1 -0
Index: qemu/linux-user/main.c
===================================================================
@@ -1933,6 +1933,7 @@ int main(int argc, char **argv)
     cpu_x86_load_seg(env, R_FS, __USER_DS);
     cpu_x86_load_seg(env, R_GS, __USER_DS);
 
+    env->segs[R_FS].selector = 0;
 #elif defined(TARGET_ARM)
     {
         int i;
#3 lore raw
Quoted 2 lines · Alexander Graf

implements futexes (this is mostly done by David Woodhouse as well, FUTEX_WAKE_OP done by me)

#ifdef BSWAP_NEEDED, only FUTEX_OP_CMP_EQ and FUTEX_OP_CMP_NE will work as expected. If we want to do the rest then we'll need to implement FUTEX_OP_CMP_LT_WRONGENDIAN &c in the kernel.

Or maybe, since we don't do set_robust_list (and would need wrong-endian support in the kernel for that too), we can assume that it's all in-process, and hence all _within_ qemu, and we could actually implement the futex stuff entirely within qemu with qemu's own locking?

For now I think the safer option is just to leave FUTEX_WAKE_OP unimplemented. Jakub, what do you think?

Signature · 1 line
dwmw2
#4 lore raw
Quoted 8 lines · David Woodhouse
Quoted 2 lines · Alexander Graf

implements futexes (this is mostly done by David Woodhouse as well, FUTEX_WAKE_OP done by me)

#ifdef BSWAP_NEEDED, only FUTEX_OP_CMP_EQ and FUTEX_OP_CMP_NE will work as expected. If we want to do the rest then we'll need to implement FUTEX_OP_CMP_LT_WRONGENDIAN &c in the kernel.

Quoted 7 lines

Or maybe, since we don't do set_robust_list (and would need wrong-endian support in the kernel for that too), we can assume that it's all in-process, and hence all _within_ qemu, and we could actually implement the futex stuff entirely within qemu with qemu's own locking?

For now I think the safer option is just to leave FUTEX_WAKE_OP unimplemented. Jakub, what do you think?

FUTEX_WAKE_OP is just an optimization and the only op glibc uses is FUTEX_OP_CLEAR_WAKE_IF_GT_ONE, so something that would need kernel help. But all glibcs so far if syscall (SYS_futex, ... FUTEX_WAKE_OP, ...) fails just fall back to syscall (SYS_futex, ... FUTEX_WAKE, ...) + unlock.

So I think it is safe to leave FUTEX_WAKE_OP not supported for BSWAP_NEEDED.

Jakub

author
#5 lore raw
In reply to David Woodhouse
Quoted 7 lines · David Woodhouse
Quoted 2 lines · Alexander Graf

implements futexes (this is mostly done by David Woodhouse as well, FUTEX_WAKE_OP done by me)

#ifdef BSWAP_NEEDED, only FUTEX_OP_CMP_EQ and FUTEX_OP_CMP_NE will work as expected. If we want to do the rest then we'll need to implement FUTEX_OP_CMP_LT_WRONGENDIAN &c in the kernel.

Tell me if I'm wrong there, but as far as I could tell from the documentation by Ulrich Drapper (http://people.redhat.com/drepper/futex.pdf) and the kernel source, FUTEX_WAKE_OP can be easily expressed as two conditional FUTEX_WAKE calls. Because the only real endianness problems that exist are in the conditional checking, we should be on the safe side if that is done in qemu (which is what I was implementing).

Alex

A message that is not in the archive (sent off-list or not yet received): [email protected]

A message that is not in the archive (sent off-list or not yet received): [email protected]

A message that is not in the archive (sent off-list or not yet received): [email protected]

author
#9 lore raw

Hi,

these are the updated patches for TLS support:

qemu-cvs-futex.patch

This patches futex support into qemu-user. It is basically done by David Woodhouse and I implemented FUTEX_WAKE_OP because actually one application did not work without (I don't really remember which one though). If FUTEX_WAKE_OP gets triggered qemu throws a warning though so if anyone experiences problems with it and it works without we should disable it then.

qemu-cvs-sched_getaffinity.patch

Flash9 needs sys_get_getaffinity to work properly. As far as I can tell there should be no need for endianness-conversion, because the information is written bit-wise.

qemu-cvs-tls.patch

implements set_thread_area for x86 and modifies the do_clone function, so TLS is evaluated. This is 90% done by David Woodhouse, I only changed it so it works for me (TID setters, proper segment register setters, fork() fix, made clone() work).

Alex

linux-user/syscall.c +93 -0
Index: qemu/linux-user/syscall.c
===================================================================
@@ -17,6 +17,8 @@
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
+
+#define __user
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>

@@ -60,6 +62,7 @@
 #define tchars host_tchars /* same as target */
 #define ltchars host_ltchars /* same as target */
 
+#include <linux/futex.h>
 #include <linux/termios.h>
 #include <linux/unistd.h>
 #include <linux/utsname.h>

@@ -2554,6 +2557,91 @@ static inline void host_to_target_timesp
     unlock_user_struct(target_ts, target_addr, 1);
 }
 
+#ifdef BSWAP_NEEDED
+static int futex_op(int oldval, int op, int oparg)
+{
+	int retval = oparg;
+	switch(op) {
+	    case FUTEX_OP_SET: break;
+	    case FUTEX_OP_ADD: retval += oparg; break;
+	    case FUTEX_OP_OR: retval |= oparg; break;
+	    case FUTEX_OP_ANDN: retval &= oparg; break;
+	    case FUTEX_OP_XOR: retval ^= oparg; break;
+	}
+	return retval;
+}
+
+static int futex_cmp(int oldval, int cmp, int cmparg)
+{
+	switch(cmp) {
+	    case FUTEX_OP_CMP_EQ: return oldval == cmparg;
+	    case FUTEX_OP_CMP_NE: return oldval != cmparg;
+	    case FUTEX_OP_CMP_LT: return oldval <  cmparg;
+	    case FUTEX_OP_CMP_LE: return oldval <= cmparg;
+	    case FUTEX_OP_CMP_GT: return oldval >  cmparg;
+	    case FUTEX_OP_CMP_GE: return oldval >= cmparg;
+	}
+	return -1;
+}
+#endif
+
+static long do_futex(target_ulong uaddr, int op, uint32_t val,
+                    target_ulong utime, target_ulong uaddr2,
+                    uint32_t val3)
+{
+       struct timespec host_utime;
+       unsigned long val2 = utime;
+       long retval;
+
+       if (utime && (op == FUTEX_WAIT || op == FUTEX_LOCK_PI)) {
+               target_to_host_timespec(&host_utime, utime);
+               val2 = (unsigned long)&host_utime;
+       }
+ 
+#ifdef BSWAP_NEEDED
+       switch(op) {
+       case FUTEX_CMP_REQUEUE:
+               val3 = tswap32(val3);
+       case FUTEX_REQUEUE:
+               val2 = tswap32(val2);
+       case FUTEX_WAIT:
+       case FUTEX_WAKE:
+       case FUTEX_WAKE_OP:
+               val = tswap32(val);
+       case FUTEX_LOCK_PI: /* This one's icky, but comes out OK */
+       case FUTEX_UNLOCK_PI:
+               break;
+       default: 
+               gemu_log("qemu: Unsupported futex op %d\n", op);
+               return -ENOSYS;
+       } 
+       if (op == FUTEX_WAKE_OP) {
+               /* Need to munge the secondary operation (val3) */
+	       gemu_log("qemu: Tricky FUTEX_WAKE_OP - trying to emulate it\n");
+               val3 = tswap32(val3);
+               int op2 = (val3 >> 28) & 0xf;
+               int cmp = (val3 >> 24) & 0xf;
+               int oparg = (val3 >> 12) & 0xfff;
+               int cmparg = val3 & 0xfff;
+               int shift = val3 & (FUTEX_OP_OPARG_SHIFT << 28);
+               int oldval = tget32(uaddr2);
+               if (shift)
+                   oparg = 1 << oparg;
+
+              tput32(uaddr2,futex_op(oldval, op2, oparg));
+              retval = syscall(__NR_futex, g2h(uaddr), FUTEX_WAKE, val, 0, 0, 0);
+              if(futex_cmp(oldval, cmp, cmparg)) {
+                  retval = syscall(__NR_futex, g2h(uaddr2), FUTEX_WAKE, val2, 0, 0, 0);
+              }
+       } else {
+              retval = syscall(__NR_futex, g2h(uaddr), op, val, val2, g2h(uaddr2), val3);
+       }
+#else
+       retval = syscall(__NR_futex, g2h(uaddr), op, val, val2, g2h(uaddr2), val3);
+#endif
+       return retval;
+}
+
 long do_syscall(void *cpu_env, int num, long arg1, long arg2, long arg3, 
                 long arg4, long arg5, long arg6)
 {

@@ -4713,6 +4801,11 @@ long do_syscall(void *cpu_env, int num, 
     }
 #endif
 
+#ifdef TARGET_NR_futex
+    case TARGET_NR_futex:
+        ret = get_errno(do_futex(arg1, arg2, arg3, arg4, arg5, arg6));
+        break;
+#endif
 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
     case TARGET_NR_set_tid_address:
       ret = get_errno(set_tid_address((int *) arg1));
linux-user/syscall.c +13 -0
Index: qemu/linux-user/syscall.c
===================================================================
@@ -149,6 +149,7 @@ type name (type1 arg1,type2 arg2,type3 a
 #define __NR_sys_syslog __NR_syslog
 #define __NR_sys_tgkill __NR_tgkill
 #define __NR_sys_clone __NR_clone
+#define __NR_sys_sched_getaffinity __NR_sched_getaffinity
 
 #if defined(__alpha__) || defined (__ia64__) || defined(__x86_64__)
 #define __NR__llseek __NR_lseek

@@ -171,6 +172,7 @@ _syscall3(int,sys_rt_sigqueueinfo,int,pi
 _syscall3(int,sys_syslog,int,type,char*,bufp,int,len)
 _syscall3(int,sys_tgkill,int,tgid,int,pid,int,sig)
 _syscall5(int,sys_clone, int, flags, void *, child_stack, int *, parent_tidptr, void *, newtls, int *, child_tidptr)
+_syscall3(int,sys_sched_getaffinity,pid_t,pid,unsigned int,cpusetsize,void*,mask)
 #ifdef __NR_exit_group
 _syscall1(int,exit_group,int,error_code)
 #endif

@@ -4823,6 +4825,17 @@ long do_syscall(void *cpu_env, int num, 
 	goto unimplemented_nowarn;
 #endif
 
+#ifdef TARGET_NR_sched_getaffinity
+    case TARGET_NR_sched_getaffinity:
+    {
+        cpu_set_t *mask;
+        lock_user_struct(mask, arg3, 1);                                                                                                          
+        ret = get_errno(sys_sched_getaffinity((pid_t)arg1, (unsigned int)arg2, mask));
+        unlock_user_struct(mask, arg3, 0);                                                                                                        
+        break;
+    }
+#endif
+
     default:
     unimplemented:
         gemu_log("qemu: Unsupported syscall: %d\n", num);
linux-user/main.c +1 -1
Index: qemu/linux-user/main.c
===================================================================
@@ -156,7 +156,7 @@ static void set_gate(void *ptr, unsigned
     p[1] = tswapl(e2);
 }
 
-uint64_t gdt_table[6];
+uint64_t gdt_table[9];
 uint64_t idt_table[256];
 
 /* only dpl matters as we do only user space emulation */
linux-user/syscall.c +131 -18

233 lines not on this page · raw message

#10 lore raw

Hi,

I'd like to test user mode emulation on MIPS host.

Do you have newer versions of your patches which match current CVS HEAD? TLS support is still missing there, so QEMU user mode emulation is not really usable without working patches.

Regards
Stefan

Quoted 27 lines · Alexander Graf

Hi,

these are the updated patches for TLS support:

qemu-cvs-futex.patch

This patches futex support into qemu-user. It is basically done by David Woodhouse and I implemented FUTEX_WAKE_OP because actually one application did not work without (I don't really remember which one though). If FUTEX_WAKE_OP gets triggered qemu throws a warning though so if anyone experiences problems with it and it works without we should disable it then.

qemu-cvs-sched_getaffinity.patch

Flash9 needs sys_get_getaffinity to work properly. As far as I can tell there should be no need for endianness-conversion, because the information is written bit-wise.

qemu-cvs-tls.patch

implements set_thread_area for x86 and modifies the do_clone function, so TLS is evaluated. This is 90% done by David Woodhouse, I only changed it so it works for me (TID setters, proper segment register setters, fork() fix, made clone() work).

Alex

#11 lore raw
Quoted 8 lines · Stefan Weil

Hi,

I'd like to test user mode emulation on MIPS host.

Do you have newer versions of your patches which match current CVS HEAD? TLS support is still missing there, so QEMU user mode emulation is not really usable without working patches.

I don't know about anyone else, but I have some patches for TLS for arm and i386. The patches are significantly out of date with the recent linux-user changes. I won't be updating them until I finish with the current set of changes to linux-user.

Quoted 30 lines
Quoted 27 lines · Alexander Graf

Hi,

these are the updated patches for TLS support:

qemu-cvs-futex.patch

This patches futex support into qemu-user. It is basically done by David Woodhouse and I implemented FUTEX_WAKE_OP because actually one application did not work without (I don't really remember which one though). If FUTEX_WAKE_OP gets triggered qemu throws a warning though so if anyone experiences problems with it and it works without we should disable it then.

qemu-cvs-sched_getaffinity.patch

Flash9 needs sys_get_getaffinity to work properly. As far as I can tell there should be no need for endianness-conversion, because the information is written bit-wise.

qemu-cvs-tls.patch

implements set_thread_area for x86 and modifies the do_clone function, so TLS is evaluated. This is 90% done by David Woodhouse, I only changed it so it works for me (TID setters, proper segment register setters, fork() fix, made clone() work).

Alex

#12 lore raw
Quoted 10 lines · Thayne Harbaugh
Quoted 8 lines · Stefan Weil

Hi,

I'd like to test user mode emulation on MIPS host.

Do you have newer versions of your patches which match current CVS HEAD? TLS support is still missing there, so QEMU user mode emulation is not really usable without working patches.

Quoted 4 lines

I don't know about anyone else, but I have some patches for TLS for arm and i386. The patches are significantly out of date with the recent linux-user changes. I won't be updating them until I finish with the current set of changes to linux-user.

I'll try to merge and improve the i386 TLS patch ASAP.

Moreover, after having looked again at the linux-user code and at the regression tests, my conclusion is that the linux-user QEMU targets must be statically linked and that it should not depend on host libraries such as the C library.

Fabrice.

#13 lore raw
Quoted 14 lines · Fabrice Bellard
Quoted 4 lines · Stefan Weil
Quoted 4 lines

Hi,

I'd like to test user mode emulation on MIPS host.

Quoted 8 lines
Quoted 4 lines

Do you have newer versions of your patches which match current CVS HEAD? TLS support is still missing there, so QEMU user mode emulation is not really usable without working patches.

I don't know about anyone else, but I have some patches for TLS for arm and i386. The patches are significantly out of date with the recent linux-user changes. I won't be updating them until I finish with the current set of changes to linux-user.

Quoted 8 lines

I'll try to merge and improve the i386 TLS patch ASAP.

Moreover, after having looked again at the linux-user code and at the regression tests, my conclusion is that the linux-user QEMU targets must be statically linked and that it should not depend on host libraries such as the C library.

Fabrice.

Thank you, Fabrice. With your latest changes in QEMU CVS, the user mode emulation qemu-i386 works again:

* i386 host:
statically linked hello, Debian echo, Debian top, Debian ls ok

* mips host (le and be QEMU Malta emulation):
statically linked hello, Debian echo, Debian top ok Debian ls fails (segmentation fault)

Debian top complains about 2.4+ kernel w/o ELF notes - this might be a missing feature in the linux user mode emulation.

Mips hosts need patches (published but still missing in CVS HEAD) for user mode emulation.

Regards
Stefan