ucontext_t support for Android x86.

sandbox/linux/services/android_x86_ucontext.h

+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SANDBOX_LINUX_SERVICES_ANDROID_X86_UCONTEXT_H_
+#define SANDBOX_LINUX_SERVICES_ANDROID_X86_UCONTEXT_H_
+
+#include <asm/sigcontext.h>
+
+#if !defined(__BIONIC_HAVE_UCONTEXT_T)

[Markus (顧孟勤), 2012/12/21 02:03:54]

Can you please find another reviewer that can verify this is the correct thing
to do? I don't know enough about Android to have any opinion.

[yfw.chromium, 2012/12/21 07:23:17]

This was introduced in Android with this change:
https://android-review.googlesource.com/#/c/38875/4/libc/include/sys/cdefs.h

And several Android components use this as well. So I suppose it's safe to use
it here.

And I don't know who should be involved here as well.

+/* Old versions of the Android <signal.h> didn't define ucontext_t. */
+
+/* Type for general register. */
+typedef long int greg_t;
+
+typedef struct {
+  uint32_t  gregs[32];

[Markus (顧孟勤), 2012/12/21 02:03:54]

Did you actually test this? This looks wrong to me.

On i386, I would expect to see 19 general purpose registers, and on x86_64 I
would expect to see 23. But this is just from reading the sources, without
actually testing things myself.

[Markus (顧孟勤), 2012/12/21 02:03:54]

This should be a "greg_t" instead of a "uint32_t", shouldn't it?

[yfw.chromium, 2012/12/21 07:23:17]

Will change 32 to 19 and use greg_t.

+  void*     fpregs;
+  uint32_t  oldmask;
+  uint32_t  cr2;

[Markus (顧孟勤), 2012/12/21 02:03:54]

I think, these should be "unsigned long" instead of "uint32_t", in order to make
things work both on i386 and x86-64.

But, again, I haven't actually tested this. I might have gotten this wrong. You
should definitely test this.

[yfw.chromium, 2012/12/21 07:23:17]

OK.

+} mcontext_t;
+
+enum {
+  REG_GS = 0, REG_FS, REG_ES, REG_DS,
+  REG_EDI, REG_ESI, REG_EBP, REG_ESP,
+  REG_EBX, REG_EDX, REG_ECX, REG_EAX,
+  REG_TRAPNO, REG_ERR, REG_EIP, REG_CS,
+  REG_EFL, REG_UESP, REG_SS
+};
+
+/* Machine context at the time a signal was raised. */
+typedef struct ucontext {
+    unsigned long uc_flags;
+    struct ucontext* uc_link;
+    stack_t uc_stack;
+    mcontext_t uc_mcontext;
+    sigset_t uc_sigmask;

[Markus (顧孟勤), 2012/12/21 02:03:54]

We really have to have a unittest for this. If you had a proper test, we would
have caught the problem of having the wrong number of general purpose registers.

Can you write a test that (spot) checks the general purpose registers and the
signal mask?

I think, you can do all of this without any assembly coding.

You bind a local variable to a particular CPU register (you might want to check
several), you then raise a signal by triggering an error condition (e.g. a
segmentation fault). Inside the signal handler, you verify that the saved CPU
register has the value that you expect. You then use siglongjmp() to return from
the signal handler, as that allows you to return without re-executing the
faulting instruction.

For the signal mask, you can do the same thing, by setting the mask outside of
the signal handler and then verifying its value inside the signal handler.

Make sure this test works for all of our commonly supported platforms (i.e.
i386, x86-64, and ARM). It should probably go into something like
ucontext_unittest.cc.

And it should test with the implementation of ucontext_t that we pick by default
for this particular platform. I.e. on non-Android builds, we would pick the
implementation in glibc. But on Android builds, we would pick your
implementation.

+} ucontext_t;
+#endif /* !__BIONIC_HAVE_UCONTEXT_T */
+
+#endif  // SANDBOX_LINUX_SERVICES_ANDROID_ARM_UCONTEXT_H_