path: root/ndk/sources/android/libportable/arch-mips/signal.c

/*
 * Copyright 2012, The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <portability.h>
#include <unistd.h>
#include <stdarg.h>
#include <stdlib.h>
#include <signal.h>
#include <signal_portable.h>
#include <portability.h>
#include <stdio.h>
#include <errno.h>
#include <errno_portable.h>
#include <asm/unistd-portable.h>
#include <asm/unistd.h>
#include <signalfd_portable.h>
#include <filefd_portable.h>

#define PORTABLE_TAG "signal_portable"
#include <log_portable.h>


#if SIGBUS_PORTABLE == SIGBUS
#error Bad build environment
#endif

typedef void  (*sig3handler_t)(int, siginfo_t *, void *);

static volatile int signal_handler_mapping_enabled = 1;

extern int syscall(int, ...);


__hidden void signal_disable_mapping()
{
    ALOGV("%s(): signal_handler_mapping_enabled:%d = 0;", __func__,
                 signal_handler_mapping_enabled);

    signal_handler_mapping_enabled = 0;
}


/*
 * The next five hidden functions are not exposed in the
 * libportable shared object. They are used here and other
 * functions, like waitpid(), which need to map signal numbers.
 */
__hidden char *map_portable_signum_to_name(int portable_signum)
{
    char *name;

    switch(portable_signum) {
    case SIGHUP_PORTABLE:       name = "SIGHUP_PORTABLE:1";             break;
    case SIGINT_PORTABLE:       name = "SIGINT_PORTABLE:2";             break;
    case SIGQUIT_PORTABLE:      name = "SIGQUIT_PORTABLE:3";            break;
    case SIGILL_PORTABLE:       name = "SIGILL_PORTABLE:4";             break;
    case SIGTRAP_PORTABLE:      name = "SIGTRAP_PORTABLE:5";            break;
    case SIGABRT_PORTABLE:      name = "SIGABRT_PORTABLE:6";            break;
    case SIGBUS_PORTABLE:       name = "SIGBUS_PORTABLE:7";             break;
    case SIGFPE_PORTABLE:       name = "SIGFPE_PORTABLE:8";             break;
    case SIGKILL_PORTABLE:      name = "SIGKILL_PORTABLE:9";            break;
    case SIGUSR1_PORTABLE:      name = "SIGUSR1_PORTABLE:10";           break;
    case SIGSEGV_PORTABLE:      name = "SIGSEGV_PORTABLE:11";           break;
    case SIGUSR2_PORTABLE:      name = "SIGUSR2_PORTABLE:12";           break;
    case SIGPIPE_PORTABLE:      name = "SIGPIPE_PORTABLE:13";           break;
    case SIGALRM_PORTABLE:      name = "SIGALRM_PORTABLE:14";           break;
    case SIGTERM_PORTABLE:      name = "SIGTERM_PORTABLE:15";           break;
    case SIGSTKFLT_PORTABLE:    name = "SIGSTKFLT_PORTABLE:16";         break;
    case SIGCHLD_PORTABLE:      name = "SIGCHLD_PORTABLE:17";           break;
    case SIGCONT_PORTABLE:      name = "SIGCONT_PORTABLE:18";           break;
    case SIGSTOP_PORTABLE:      name = "SIGSTOP_PORTABLE:19";           break;
    case SIGTSTP_PORTABLE:      name = "SIGTSTP_PORTABLE:20";           break;
    case SIGTTIN_PORTABLE:      name = "SIGTTIN_PORTABLE:21";           break;
    case SIGTTOU_PORTABLE:      name = "SIGTTOU_PORTABLE:22";           break;
    case SIGURG_PORTABLE:       name = "SIGURG_PORTABLE:23";            break;
    case SIGXCPU_PORTABLE:      name = "SIGXCPU_PORTABLE:24";           break;
    case SIGXFSZ_PORTABLE:      name = "SIGXFSZ_PORTABLE:25";           break;
    case SIGVTALRM_PORTABLE:    name = "SIGVTALRM_PORTABLE:26";         break;
    case SIGPROF_PORTABLE:      name = "SIGPROF_PORTABLE:27";           break;
    case SIGWINCH_PORTABLE:     name = "SIGWINCH_PORTABLE:28";          break;
    case SIGIO_PORTABLE:        name = "SIGIO_PORTABLE:29";             break;
    case SIGPWR_PORTABLE:       name = "SIGPWR_PORTABLE:30";            break;
    case SIGSYS_PORTABLE:       name = "SIGSYS_PORTABLE:31";            break;
    case SIGRTMIN_PORTABLE:     name = "SIGRTMIN_PORTABLE:32";          break;

    case SIGRT_1_PORTABLE:      name = "SIGRT_1_PORTABLE:33";           break;
    case SIGRT_2_PORTABLE:      name = "SIGRT_2_PORTABLE:34";           break;
    case SIGRT_3_PORTABLE:      name = "SIGRT_3_PORTABLE:35";           break;
    case SIGRT_4_PORTABLE:      name = "SIGRT_4_PORTABLE:36";           break;
    case SIGRT_5_PORTABLE:      name = "SIGRT_5_PORTABLE:37";           break;
    case SIGRT_6_PORTABLE:      name = "SIGRT_6_PORTABLE:38";           break;
    case SIGRT_7_PORTABLE:      name = "SIGRT_7_PORTABLE:39";           break;
    case SIGRT_8_PORTABLE:      name = "SIGRT_8_PORTABLE:40";           break;
    case SIGRT_9_PORTABLE:      name = "SIGRT_9_PORTABLE:41";           break;
    case SIGRT_10_PORTABLE:     name = "SIGRT_10_PORTABLE:42";          break;
    case SIGRT_11_PORTABLE:     name = "SIGRT_11_PORTABLE:43";          break;
    case SIGRT_12_PORTABLE:     name = "SIGRT_12_PORTABLE:44";          break;
    case SIGRT_13_PORTABLE:     name = "SIGRT_13_PORTABLE:45";          break;
    case SIGRT_14_PORTABLE:     name = "SIGRT_14_PORTABLE:46";          break;
    case SIGRT_15_PORTABLE:     name = "SIGRT_15_PORTABLE:47";          break;
    case SIGRT_16_PORTABLE:     name = "SIGRT_16_PORTABLE:48";          break;
    case SIGRT_17_PORTABLE:     name = "SIGRT_17_PORTABLE:49";          break;
    case SIGRT_18_PORTABLE:     name = "SIGRT_18_PORTABLE:50";          break;
    case SIGRT_19_PORTABLE:     name = "SIGRT_19_PORTABLE:51";          break;
    case SIGRT_20_PORTABLE:     name = "SIGRT_20_PORTABLE:52";          break;
    case SIGRT_21_PORTABLE:     name = "SIGRT_21_PORTABLE:53";          break;
    case SIGRT_22_PORTABLE:     name = "SIGRT_22_PORTABLE:54";          break;
    case SIGRT_23_PORTABLE:     name = "SIGRT_23_PORTABLE:55";          break;
    case SIGRT_24_PORTABLE:     name = "SIGRT_24_PORTABLE:56";          break;
    case SIGRT_25_PORTABLE:     name = "SIGRT_25_PORTABLE:57";          break;
    case SIGRT_26_PORTABLE:     name = "SIGRT_26_PORTABLE:58";          break;
    case SIGRT_27_PORTABLE:     name = "SIGRT_27_PORTABLE:59";          break;
    case SIGRT_28_PORTABLE:     name = "SIGRT_28_PORTABLE:60";          break;
    case SIGRT_29_PORTABLE:     name = "SIGRT_29_PORTABLE:61";          break;
    case SIGRT_30_PORTABLE:     name = "SIGRT_30_PORTABLE:62";          break;
    case SIGRT_31_PORTABLE:     name = "SIGRT_31_PORTABLE:63";          break;
    case SIGRTMAX_PORTABLE:     name = "SIGRTMAX_PORTABLE:64";          break;

    default:                    name = "<<UNKNOWN>>";                   break;
    }
    return name;
}


__hidden char *map_mips_signum_to_name(int mips_signum)
{
    char *name;

    switch(mips_signum) {
    case SIGHUP:        name = "SIGHUP:1";      break;
    case SIGINT:        name = "SIGINT:2";      break;
    case SIGQUIT:       name = "SIGQUIT:3";     break;
    case SIGILL:        name = "SIGILL:4";      break;
    case SIGTRAP:       name = "SIGTRAP:5";     break;
    case SIGIOT:        name = "SIGIOT:6";      break;
    case SIGEMT:        name = "SIGEMT:7";      break;
    case SIGFPE:        name = "SIGFPE:8";      break;
    case SIGKILL:       name = "SIGKILL:9";     break;
    case SIGBUS:        name = "SIGBUS:10";     break;
    case SIGSEGV:       name = "SIGSEGV:11";    break;
    case SIGSYS:        name = "SIGSYS:12";     break;
    case SIGPIPE:       name = "SIGPIPE:13";    break;
    case SIGALRM:       name = "SIGALRM:14";    break;
    case SIGTERM:       name = "SIGTERM:15";    break;
    case SIGUSR1:       name = "SIGUSR1:16";    break;
    case SIGUSR2:       name = "SIGUSR2:17";    break;
    case SIGCHLD:       name = "SIGCHLD:18";    break;
    case SIGPWR:        name = "SIGPWR:19";     break;
    case SIGWINCH:      name = "SIGWINCH:20";   break;
    case SIGURG:        name = "SIGURG:21";     break;
    case SIGIO:         name = "SIGIO:22";      break;
    case SIGSTOP:       name = "SIGSTOP:23";    break;
    case SIGTSTP:       name = "SIGTSTP:24";    break;
    case SIGCONT:       name = "SIGCONT:25";    break;
    case SIGTTIN:       name = "SIGTTIN:26";    break;
    case SIGTTOU:       name = "SIGTTOU:27";    break;
    case SIGVTALRM:     name = "SIGVTALRM:28";  break;
    case SIGPROF:       name = "SIGPROF:29";    break;
    case SIGXCPU:       name = "SIGXCPU:30";    break;
    case SIGXFSZ:       name = "SIGXFSZ:31";    break;

    case SIGRTMIN:      name = "SIGRTMIN:32";   break;
    case SIGRT_1:       name = "SIGRT_1:33";    break;
    case SIGRT_2:       name = "SIGRT_2:34";    break;
    case SIGRT_3:       name = "SIGRT_3:35";    break;
    case SIGRT_4:       name = "SIGRT_4:36";    break;
    case SIGRT_5:       name = "SIGRT_5:37";    break;
    case SIGRT_6:       name = "SIGRT_6:38";    break;
    case SIGRT_7:       name = "SIGRT_7:39";    break;
    case SIGRT_8:       name = "SIGRT_8:40";    break;
    case SIGRT_9:       name = "SIGRT_9:41";    break;
    case SIGRT_10:      name = "SIGRT_10:42";   break;
    case SIGRT_11:      name = "SIGRT_11:43";   break;
    case SIGRT_12:      name = "SIGRT_12:44";   break;
    case SIGRT_13:      name = "SIGRT_13:45";   break;
    case SIGRT_14:      name = "SIGRT_14:46";   break;
    case SIGRT_15:      name = "SIGRT_15:47";   break;
    case SIGRT_16:      name = "SIGRT_16:48";   break;
    case SIGRT_17:      name = "SIGRT_17:49";   break;
    case SIGRT_18:      name = "SIGRT_18:50";   break;
    case SIGRT_19:      name = "SIGRT_19:51";   break;
    case SIGRT_20:      name = "SIGRT_20:52";   break;
    case SIGRT_21:      name = "SIGRT_21:53";   break;
    case SIGRT_22:      name = "SIGRT_22:54";   break;
    case SIGRT_23:      name = "SIGRT_23:55";   break;
    case SIGRT_24:      name = "SIGRT_24:56";   break;
    case SIGRT_25:      name = "SIGRT_25:57";   break;
    case SIGRT_26:      name = "SIGRT_26:58";   break;
    case SIGRT_27:      name = "SIGRT_27:59";   break;
    case SIGRT_28:      name = "SIGRT_28:60";   break;
    case SIGRT_29:      name = "SIGRT_29:61";   break;
    case SIGRT_30:      name = "SIGRT_30:62";   break;
    case SIGRT_31:      name = "SIGRT_31:63";   break;
    case SIGRT_32:      name = "SIGRT_32:64";   break;

    /* NOTE: SIGRT_33...SIGRTMAX-1 Not printed */

    case SIGRTMAX:      name = "SIGRTMAX:128";  break;
    default:            name = "<<UNKNOWN>>";   break;
    }
    return name;
}


/*
 * Maps a signal number from portable to native.
 */
__hidden int signum_pton(int portable_signum)
{
    int mips_signum = -1;

    switch(portable_signum) {
    case SIGHUP_PORTABLE:               /* 1 */
        return SIGHUP;

    case SIGINT_PORTABLE:               /* 2 */
        return SIGINT;

    case SIGQUIT_PORTABLE:              /* 3 */
        return SIGQUIT;

    case SIGILL_PORTABLE:               /* 4 */
        return SIGILL;

    case SIGTRAP_PORTABLE:              /* 5 */
        return SIGTRAP;

    case SIGABRT_PORTABLE:              /* 6 */
        return SIGABRT;

    case SIGBUS_PORTABLE:               /* 7 --> 10 */
        return SIGBUS;

    case SIGFPE_PORTABLE:               /* 8 */
        return SIGFPE;

    case SIGKILL_PORTABLE:              /* 9 */
        return SIGKILL;

    case SIGUSR1_PORTABLE:              /* 10 --> 16 */
        return SIGUSR1;

    case SIGSEGV_PORTABLE:              /* 11 */
        return SIGSEGV;

    case SIGUSR2_PORTABLE:              /* 12 --> 17 */
        return SIGUSR2;

    case SIGPIPE_PORTABLE:              /* 13 */
        return SIGPIPE;

    case SIGALRM_PORTABLE:              /* 14 */
        return SIGALRM;

    case SIGTERM_PORTABLE:              /* 15 */
        return SIGTERM;

    case SIGSTKFLT_PORTABLE:            /* 16 --> 7 */
        return SIGEMT;                  /* No native SIGSTKFLT exist  ...
                                           ... mapping it to SIGEMT. */

    case SIGCHLD_PORTABLE:              /* 17 --> 18 */
        return SIGCHLD;

    case SIGCONT_PORTABLE:              /* 18 --> 25 */
        return SIGCONT;

    case SIGSTOP_PORTABLE:              /* 19 --> 23 */
        return SIGSTOP;

    case SIGTSTP_PORTABLE:              /* 20 --> 24 */
        return SIGTSTP;

    case SIGTTIN_PORTABLE:              /* 21 --> 26 */
        return SIGTTIN;

    case SIGTTOU_PORTABLE:              /* 22 --> 27 */
        return SIGTTOU;

    case SIGURG_PORTABLE:               /* 23 --> 21 */
        return SIGURG;

    case SIGXCPU_PORTABLE:              /* 24 --> 30 */
        return SIGXCPU;

    case SIGXFSZ_PORTABLE:              /* 25 --> 31 */
        return SIGXFSZ;

    case SIGVTALRM_PORTABLE:            /* 26 --> 28 */
        return SIGVTALRM;

    case SIGPROF_PORTABLE:              /* 27 --> 29 */
        return SIGPROF;

    case SIGWINCH_PORTABLE:             /* 28 --> 20 */
        return SIGWINCH;

    case SIGIO_PORTABLE:                /* 29 --> 22 */
        return SIGIO;

    case SIGPWR_PORTABLE:               /* 30 --> 19 */
        return SIGPWR;

    case SIGSYS_PORTABLE:               /* 31 --> 12 */
        return SIGSYS;
    /*
     * Mapping lower 32 Real Time signals to identical Native signal numbers.
     * NOTE: SIGRTMAX_PORTABLE == 64 but SIGRTMAX == 128.
     */
    case SIGRTMIN_PORTABLE...SIGRTMAX_PORTABLE:         /* 32 ... 64 */
        ASSERT(SIGRTMIN_PORTABLE == SIGRTMIN);
        ASSERT(SIGRTMAX_PORTABLE <= SIGRTMAX);
        return portable_signum;

    default:
        ALOGE("%s: switch default: NOTE portable_signum:%d Not supported. Just a Test?",
              __func__,                 portable_signum);
        /*
         * User could be LTP testing with bogus signal numbers,
         * if so we mimic the test.
         *
         * If the signal is just outside the PORTABLE range
         * we use a signal just outside the Native/MIPS range.
         */
        if (portable_signum < 0) {
            mips_signum = portable_signum;
        } else if (portable_signum > NSIG_PORTABLE) {
            mips_signum = (portable_signum - NSIG_PORTABLE) +  NSIG;
        } else {
            ALOGE("%s: 0 <= portable_signum:%d <= NSIG_PORTABLE:%d; Not supported, return(0);",
                  __func__, portable_signum,      NSIG_PORTABLE);

            mips_signum = 0;
        }
        break;
    }
    ALOGV("%s(portable_signum:%d): return(mips_signum:%d);", __func__,
              portable_signum,            mips_signum);

    return mips_signum;
}


/*
 * Maps a signal number from native to portable.
 */
__hidden int signum_ntop(int mips_signum)
{
    int portable_ssignum = -1;

    switch(mips_signum) {
    case SIGHUP:                        /* 1 */
        return SIGHUP_PORTABLE;

    case SIGINT:                        /* 2 */
        return SIGINT_PORTABLE;

    case SIGQUIT:                       /* 3 */
        return SIGQUIT_PORTABLE;

    case SIGILL:                        /* 4 */
        return SIGILL_PORTABLE;

    case SIGTRAP:                       /* 5 */
        return SIGTRAP_PORTABLE;

    case SIGABRT:                       /* 6 */
        return SIGABRT_PORTABLE;

    case SIGBUS:                        /* 7 <-- 10 */
        return SIGBUS_PORTABLE;

    case SIGFPE:                        /* 8 */
        return SIGFPE_PORTABLE;

    case SIGKILL:                       /* 9 */
        return SIGKILL_PORTABLE;

    case SIGUSR1:                       /* 10 <-- 16 */
        return SIGUSR1_PORTABLE;

    case SIGSEGV:                       /* 11 */
        return SIGSEGV_PORTABLE;

    case SIGUSR2:                       /* 12 <-- 17 */
        return SIGUSR2_PORTABLE;

    case SIGPIPE:                       /* 13 */
        return SIGPIPE_PORTABLE;

    case SIGALRM:                       /* 14 */
        return SIGALRM_PORTABLE;

    case SIGTERM:                       /* 15 */
        return SIGTERM_PORTABLE;

    case SIGEMT:                        /* 16 <--- 7 */
        return SIGSTKFLT_PORTABLE;      /* No native SIGSTKFLT exist ...
                                           ... reverse mapping SIGEMT ...
                                           ...  back to SIGSTKFLT. */

    case SIGCHLD:                       /* 17 <-- 18 */
        return SIGCHLD_PORTABLE;

    case SIGCONT:                       /* 18 <-- 15 */
        return SIGCONT_PORTABLE;

    case SIGSTOP:                       /* 19 <-- 23 */
        return SIGSTOP_PORTABLE;

    case SIGTSTP:                       /* 20 <-- 24 */
        return SIGTSTP_PORTABLE;

    case SIGTTIN:                       /* 21 <-- 26 */
        return SIGTTIN_PORTABLE;

    case SIGTTOU:                       /* 22 <-- 27 */
        return SIGTTOU_PORTABLE;

    case SIGURG:                        /* 23 <-- 21 */
        return SIGURG_PORTABLE;

    case SIGXCPU:                       /* 24 <-- 30 */
        return SIGXCPU_PORTABLE;

    case SIGXFSZ:                       /* 25 <-- 31 */
        return SIGXFSZ_PORTABLE;

    case SIGVTALRM:                     /* 26 <-- 28 */
        return SIGVTALRM_PORTABLE;

    case SIGPROF:                       /* 27 <-- 29 */
        return SIGPROF_PORTABLE;

    case SIGWINCH:                      /* 28 <-- 20 */
        return SIGWINCH_PORTABLE;

    case SIGIO:                         /* 29 <-- 22 */
        return SIGIO_PORTABLE;

    case SIGPWR:                        /* 30 <-- 19 */
        return SIGPWR_PORTABLE;

    case SIGSYS:                        /* 31 <-- 12 */
        return SIGSYS_PORTABLE;

    /*
     * Mapping lower 32 Real Time signals to identical Portable signal numbers.
     * NOTE: SIGRTMAX_PORTABLE == 64 but SIGRTMAX == 128.
     */
    case SIGRTMIN...SIGRTMAX_PORTABLE:              /* 32 ... 64 */
        ASSERT(SIGRTMIN == SIGRTMIN_PORTABLE);
        ASSERT(SIGRTMAX >= SIGRTMAX_PORTABLE);
        return mips_signum;

   /*
    * Mapping upper 63 Native Real Time signals to the last Portable signal number.
    * Shouldn't even be possible to be using these signals.
    */
    case (SIGRTMAX_PORTABLE+1)...SIGRTMAX:          /* 65 ... 128 */
        ASSERT(SIGRTMIN == SIGRTMIN_PORTABLE);
        ASSERT(SIGRTMAX >= SIGRTMAX_PORTABLE);

        ALOGE("%s: mips_signum:%d Can't be mapped to a unique portable signal;", __func__,
                   mips_signum);

        ALOGE("%s: Mapping highest 63 Real Time Signals to the largest RT Portable SigNo.",
                __func__);

        return SIGRTMAX_PORTABLE;


    default:
        ALOGE("%s: switch default: mips_signum:%d Not supported! return(0);", __func__,
                                   mips_signum);
#if 0
        LOG_FATAL("%s: mips_signum:%d is not portable;", __func__, mips_signum);
#endif
        return 0;
    }
    return portable_ssignum;
}


/*
 * Deal with siginfo structure being a bit different.
 * Need to swap errno and code fields.
 */
static void siginfo_pton(siginfo_portable_t *portable_sip, siginfo_t *native_sip)
{

    ALOGV("%s(portable_sip:%p, native_sip:%p) {", __func__,
              portable_sip,    native_sip);

    ASSERT(sizeof(siginfo_portable_t) == sizeof(siginfo_t));

    /*
     * Default to the same structure members,
     * code and errno are swapped between ARM and MIPS,
     * and errno needs to be translated.
     *
     * The signal number isn't translated, as the kernel
     * will fill it it when it delivers the signal.
     */

    *native_sip = *((siginfo_t *)portable_sip);
    native_sip->si_signo = 0;
    native_sip->si_code = portable_sip->si_code;
    native_sip->si_errno = errno_pton(portable_sip->si_errno);

    ALOGV("%s: return; }", __func__);
}


static void siginfo_ntop(siginfo_t *native_sip, siginfo_portable_t *portable_sip)
{

    ALOGV("%s(native_sip,:%p, portable_sip:%p) {", __func__,
              native_sip,     portable_sip);

    ASSERT(sizeof(siginfo_portable_t) == sizeof(siginfo_t));

    /*
     * Structure assignment to default to the same structure members,
     * as only the code and errno are swapped in position between
     * ARM and MIPS; errno and signal number also need to be translated.
     */
    *portable_sip = *((siginfo_portable_t *)native_sip);

    portable_sip->si_signo = signum_ntop(native_sip->si_signo);
    portable_sip->si_code = native_sip->si_code;
    portable_sip->si_errno = errno_ntop(native_sip->si_errno);

    ALOGV("%s: return; }", __func__);
}


/*
 * Array of signal handlers as the portable users expects they
 * they have been registered in the kernel. Problem is we need
 * to have our own handler to map the MIPS signal number to a
 * portable signal number.
 */
static sig3handler_portable_t mips_portable_sighandler[NSIG_PORTABLE + 1] = { NULL };

static void mips_sigaction_handler(int mips_signum, siginfo_t *sip, void *ucp)
{
    int portable_signum;
    char *portable_signame;
    char *mips_signame = map_mips_signum_to_name(mips_signum);
    sig3handler_portable_t portable_sighandler;
    siginfo_portable_t portable_si;
    siginfo_portable_t *portable_sip;

    ALOGV(" ");
    ALOGV("%s(mips_signum:%d:'%s', sip:%p, ucp:%p) {", __func__,
              mips_signum,
              mips_signame,        sip,    ucp);

    portable_signum = signum_ntop(mips_signum);
    portable_signame = map_portable_signum_to_name(portable_signum);
    portable_sighandler = mips_portable_sighandler[portable_signum];

    if (invalid_pointer(portable_sighandler)) {
        /*
         * If a portable/ARM application tries to set signals in the signal mask > 32
         * it results in a signal_handler being set to -1:SIG_ERR. Calling a function
         * at location -1 doesn't produce very informative Android backtraces on MIPS.
         */
        ALOGE("%s: invalid_pointer(portable_sighandler:%p); Likely about to Trap or Bus Error!",
                __func__,          portable_sighandler);

        ALOGE("%s: HINT: Likely best to use gdbserver and look at sigaction arguments.", __func__);
    }
    ASSERT(portable_sighandler != NULL);
    ASSERT(portable_sighandler != (sig3handler_portable_t) SIG_DFL);
    ASSERT(portable_sighandler != (sig3handler_portable_t) SIG_IGN);

    if (sip == NULL) {
        portable_sip = NULL;
    } else {
        /* Map signinfo from native to portable format */
        portable_sip = &portable_si;
        siginfo_ntop(sip, portable_sip);
    }


    ALOGV("%s: Calling portable_sighandler:%p(portable_signum:%d, portable_sip:%p, ucp:%p);",
          __func__,    portable_sighandler,   portable_signum,    portable_sip,    ucp);

    portable_sighandler(portable_signum, portable_sip, ucp);

    ALOGV("%s: return; }", __func__);
}


static void mips_sighandler(int mips_signum)
{
    int portable_signum;
    char *portable_signame;
    char *mips_signame = map_mips_signum_to_name(mips_signum);
    sig3handler_portable_t portable_sighandler;

    ALOGV(" ");
    ALOGV("%s(mips_signum:%d:'%s') {", __func__, mips_signum, mips_signame);

    mips_sigaction_handler(mips_signum, NULL, NULL);

    ALOGV("%s: return; }", __func__);
}


static sighandler_t sighandler_pton(sighandler_portable_t portable_handler, int sigaction)
{
    sighandler_t mips_handler;

    ALOGV("%s(portable_handler:%p, sigaction:%d) {", __func__,
              portable_handler,    sigaction);

    switch((int) portable_handler) {
    case (int) SIG_DFL:
    case (int) SIG_IGN:
        mips_handler = portable_handler;
        break;

    default:    /* NOTE: Includes SIG_ERR:-1 */
        if (invalid_pointer(portable_handler)) {
            /*
             * Calling sigaction() with a bogus signal handler doesn't fail,
             * so we let the portable cases fail later as the native case would.
             */
            ALOGE("%s: invalid_pointer(portable_handler:%p)!", __func__, portable_handler);
            ALOGE("%s: HINT: Likely to cause a BUS Error ....", __func__);
            ALOGE("%s: HINT: ... when the signal handler is called!", __func__);
        }

        /*
         * Signal Mapping can be disabled in the rare case of the clone
         * flags not being compatble for VM and file descriptors.
         */
        if (signal_handler_mapping_enabled) {
            if (sigaction)
                mips_handler = (sighandler_t) mips_sigaction_handler;
            else
                mips_handler = (sighandler_t) mips_sighandler;
        } else {
            mips_handler = portable_handler;        /* Don't MAP */
        }
        break;
    }

    ALOGV("%s: return(mips_handler:%p); }", __func__, mips_handler);
    return mips_handler;
}


/*
 * This function maps the signal number and calls one of the low level mips signal()
 * functions implemented in libc/unistd/signal.c:
 *              sysv_signal()
 *              bsd_signal()
 *
 * The last 2 parameters to this static function, mips_signal_fn*, specify which of
 * these functions to call.  We intercept the above to functions, as well as signal(),
 * and call the associated *_portable() functions below.
 *
 * In addition, we intercept the signal_handler with our own handlers that map the
 * signal number from the MIPS convention to the PORTABLE/ARM convention.
 */
static sighandler_portable_t
do_signal_portable(int portable_signum, sighandler_portable_t portable_handler,
                   __sighandler_t (mips_signal_fn)(int, __sighandler_t))
{
    char *portable_signame = map_portable_signum_to_name(portable_signum);
    int mips_signum;
    sighandler_t mips_handler;
    sighandler_portable_t rv;
    sighandler_portable_t prev_portable_handler;

    ALOGV("%s(portable_signum:%d:%s, portable_handler:%p,  mips_signal_fn:%p) {", __func__,
              portable_signum,
              portable_signame,      portable_handler,     mips_signal_fn);

    mips_signum = signum_pton(portable_signum);

    if ((portable_signum != 0) && ((mips_signum <= 0) || (mips_signum > NSIG))) {
        /*
         * Invalid request; Let the kernel generate the proper return value and set errno.
         */
        mips_handler = sighandler_pton(portable_handler, 0);
        rv = mips_signal_fn(mips_signum, mips_handler);
    } else {
        /*
         * We have a usable signal number, redirect it to our signal handler
         * if a portable handler was provided so we can convert the signal number.
         * Save our current mapped signal handler for likely return.
         */
        prev_portable_handler = (sighandler_portable_t) mips_portable_sighandler[portable_signum];

        mips_handler = sighandler_pton(portable_handler, 0);
        if (mips_handler != portable_handler) {
            mips_portable_sighandler[portable_signum] = (sig3handler_portable_t) portable_handler;
        }
        rv = mips_signal_fn(mips_signum, mips_handler);

        if ((rv == (sighandler_portable_t) mips_sighandler) ||
            (rv == (sighandler_portable_t) mips_sigaction_handler)) {

            rv = (sighandler_t) prev_portable_handler;
        }
    }

    ALOGV("%s: return(rv:%p); }", __func__, rv);
    return rv;
}


/*
 * signal() can't be called directly, due to an in-line function in signal.h which
 * redirects the call to bsd_signal(). _signal() is a static function; not to be called
 * directly. This function isn't actually needed.
 */
sighandler_portable_t WRAP(signal)(int portable_signum, sighandler_portable_t handler)
{
    sighandler_portable_t rv;

    ALOGV(" ");
    ALOGV("%s(portable_signum:%d, handler:%p) {", __func__,
              portable_signum,    handler);

    /* bsd does a SA_RESTART */
    rv = do_signal_portable(portable_signum, handler, bsd_signal);

    ALOGV("%s: return(ret:%p); }", __func__, rv);
    return rv;
}


sighandler_portable_t WRAP(sysv_signal)(int portable_signum, sighandler_portable_t handler)
{
    sighandler_portable_t rv;

    ALOGV(" ");
    ALOGV("%s(portable_signum:%d, handler:%p) {", __func__,
              portable_signum,    handler);

    /* sysv does a SA_RESETHAND */
    rv = do_signal_portable(portable_signum, handler, sysv_signal);

    ALOGV("%s: return(ret:%p); }", __func__, rv);
    return rv;
}


/*
 * NOTE:
 *    handler is either the Bionic
 *      bsd_signal() signal handler
 * or
 *      the sysv_signal() signal handler.
 */

sighandler_portable_t WRAP(bsd_signal)(int portable_signum, sighandler_portable_t handler)
{
    sighandler_portable_t rv;

    ALOGV(" ");
    ALOGV("%s(portable_signum:%d, handler:%p) {", __func__,
              portable_signum,    handler);

    /* bsd does a SA_RESTART */
    rv = do_signal_portable(portable_signum, handler, bsd_signal);

    ALOGV("%s: return(ret:%p); }", __func__, rv);
    return rv;
}


static int do_kill(int id, int portable_signum, int (*fn)(int, int))
{
    char *portable_signame = map_portable_signum_to_name(portable_signum);
    int mips_signum;
    int rv;

    ALOGV("%s(id:%d, portable_signum:%d:'%s', fn:%p) {", __func__,
              id,    portable_signum,
                     portable_signame,        fn);

    mips_signum = signum_pton(portable_signum);

    if ((portable_signum != 0) && (mips_signum == 0)) {
        rv = 0;
    } else {
        ALOGV("%s: Calling fn:%p(id:%d, mips_signum:%d);", __func__,
                           fn,   id,    mips_signum);

        rv =  fn(id, mips_signum);
    }
    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}


int WRAP(killpg)(int pgrp, int portable_signum)
{
    extern int REAL(killpg)(int pgrp, int sig);
    int rv;

    ALOGV(" ");
    ALOGV("%s(pgrp:%d, portable_signum:%d) {", __func__,
              pgrp,    portable_signum);

    rv = do_kill(pgrp, portable_signum, REAL(killpg));

    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}


int WRAP(kill)(pid_t pid, int portable_signum)
{
    extern int REAL(kill)(pid_t, int);
    int rv;

    ALOGV(" ");
    ALOGV("%s(pid:%d, portable_signum:%d) {", __func__,
              pid,    portable_signum);

    rv = do_kill(pid, portable_signum, REAL(kill));

    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}


int WRAP(tkill)(int tid, int portable_signum)
{
    extern int REAL(tkill)(int, int);
    int rv;

    ALOGV(" ");
    ALOGV("%s(tid:%d, portable_signum:%d) {", __func__,
              tid,    portable_signum);

    rv = do_kill(tid, portable_signum, REAL(tkill));

    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}


/* tgkill is not exported from android-14 libc.so */
#if 0
int WRAP(tgkill)(int tgid, int tid, int portable_signum)
{
    extern int tgkill(int, int, int);
    char *portable_signame = map_portable_signum_to_name(portable_signum);
    int mips_signum;
    int rv;

    ALOGV("%s(tgid:%d, tid:%d, portable_signum:%d:'%s') {", __func__,
              tgid,    tid,    portable_signum, portable_signame);

    mips_signum = signum_pton(portable_signum);

    if ((portable_signum != 0) && (mips_signum == 0))
        rv = 0;
    else
        rv = REAL(tgkill)(tgid, tid, mips_signum);

    ALOGV("%s: return rv:%d; }", __func__, rv);
    return rv;
}
#endif


int WRAP(raise)(int portable_signum)
{
    char *portable_signame = map_portable_signum_to_name(portable_signum);
    int mips_signum = signum_pton(portable_signum);
    int rv;

    ALOGV("%s(portable_signum:%d:'%s') {", __func__, portable_signum, portable_signame);

    if ((portable_signum != 0) && (mips_signum == 0))
        rv = 0;
    else
        rv = REAL(raise)(mips_signum);

    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}


void sigset_pton(sigset_portable_t *portable_sigset, sigset_t *mips_sigset)
{
    int portable_signum;

    ASSERT(mips_sigset != NULL);

    ALOGV("%s(portable_sigset:%p, mips_sigset:%p) {", __func__,
              portable_sigset,    mips_sigset);

    sigemptyset(mips_sigset);
    if (invalid_pointer((void *)portable_sigset)) {
        ALOGE("%s: portable_sigset:%p is not valid; returning empty set.", __func__,
                   portable_sigset);
        goto done;
    }

    for(portable_signum = 1; portable_signum <= NSIG_PORTABLE; portable_signum++) {

        if (WRAP(sigismember)(portable_sigset, portable_signum)) {
            char *portable_signame = map_portable_signum_to_name(portable_signum);
            int mips_signum = signum_pton(portable_signum);
            char *mips_signame;

            if (mips_signum != 0) {
                int err;

                mips_signame = map_mips_signum_to_name(mips_signum);
                ALOGV("%s: sigaddset(mips_sigset:%p, mips_signum:%d:'%s');", __func__,
                                     mips_sigset,    mips_signum,
                                                     mips_signame);

                err = sigaddset(mips_sigset, mips_signum);
                if (err == -1) {
                    PERROR("sigaddset");
                }
            }
        }
    }

done:
    ALOGV("%s: return; }", __func__);
    return;
}


void
sigset_ntop(const sigset_t *const_mips_sigset, sigset_portable_t *portable_sigset)
{
    int mips_signum;
    sigset_t *mips_sigset = (sigset_t *) const_mips_sigset;

    ALOGV("%s(const_mips_sigset:%p, portable_sigset:%p) {", __func__,
              const_mips_sigset,    portable_sigset);

    ASSERT(mips_sigset != NULL);

    if (invalid_pointer((void *)portable_sigset)) {
        ALOGE("%s: portable_sigset:%p is not Valid; can't return sigset", __func__,
                   portable_sigset);
        goto done;
    }
    WRAP(sigemptyset)(portable_sigset);

    for(mips_signum = 1; mips_signum <= NSIG; mips_signum++) {
        if (sigismember(mips_sigset, mips_signum)) {
            int portable_signum = signum_ntop(mips_signum);

            if (portable_signum != 0)
                WRAP(sigaddset)(portable_sigset, portable_signum);
        }
    }

done:
    ALOGV("%s: return; }", __func__);
    return;
}


static int sigaction_flags_pton(int portable_flags)
{
    int mips_flags = 0;

    if (portable_flags & SA_NOCLDSTOP_PORTABLE) {
        mips_flags |= SA_NOCLDSTOP;
    }
    if (portable_flags & SA_NOCLDWAIT_PORTABLE) {
        mips_flags |= SA_NOCLDWAIT;
    }
    if (portable_flags & SA_SIGINFO_PORTABLE) {
        mips_flags |= SA_SIGINFO;
    }
    if (portable_flags & SA_THIRTYTWO_PORTABLE) {
        ALOGV("%s: SA_THIRTYTWO_PORTABLE isn't SUPPORTED.", __func__);
    }
    if (portable_flags & SA_RESTORER_PORTABLE) {
        mips_flags |= SA_RESTORER;
    }
    if (portable_flags & SA_ONSTACK_PORTABLE) {
        mips_flags |= SA_ONSTACK;
    }
    if (portable_flags & SA_RESTART_PORTABLE) {
        mips_flags |= SA_RESTART;
    }
    if (portable_flags & SA_NODEFER_PORTABLE) {
        mips_flags |= SA_NODEFER;
    }
    if (portable_flags & SA_RESETHAND_PORTABLE) {
        mips_flags |= SA_RESETHAND;
    }

    ALOGV("%s(portable_flags:0x%x) return(mips_flags:0x%x);", __func__,
              portable_flags,             mips_flags);

    return mips_flags;
}


int sigaction_flags_ntop(int mips_flags)
{
    int portable_flags = 0;

    if (mips_flags & SA_NOCLDSTOP)      portable_flags |= SA_NOCLDSTOP_PORTABLE;
    if (mips_flags & SA_NOCLDWAIT)      portable_flags |= SA_NOCLDWAIT_PORTABLE;
    if (mips_flags & SA_SIGINFO)        portable_flags |= SA_SIGINFO_PORTABLE;
#ifdef SA_THIRTYTWO
    if (mips_flags & SA_THIRTYTWO)      portable_flags |= SA_THIRTYTWO_PORTABLE;
#endif
    if (mips_flags & SA_RESTORER)       portable_flags |= SA_RESTORER_PORTABLE;
    if (mips_flags & SA_ONSTACK)        portable_flags |= SA_ONSTACK_PORTABLE;
    if (mips_flags & SA_RESTART)        portable_flags |= SA_RESTART_PORTABLE;
    if (mips_flags & SA_NODEFER)        portable_flags |= SA_NODEFER_PORTABLE;
    if (mips_flags & SA_RESETHAND)      portable_flags |= SA_RESETHAND_PORTABLE;

    ALOGV("%s(mips_flags:0x%x) return(portable_flags:0x%x);", __func__,
              mips_flags,             portable_flags);

    return portable_flags;
}


/*
 * Called by portable/ARM code, which we map and do MIPS system calls.
 *
 * The incoming system call used a Portable/ARM sigaction structure:
 * ------------------------------------------------------------------
 *   struct sigaction_portable {
 *     union {
 *       __sighandler_portable_t        _sa_handler;
 *       __sigaction_handler_portable_t _sa_sigaction;
 *     } _u;
 *     sigset_portable_t sa_mask;
 *     unsigned long sa_flags;
 *     void (*sa_restorer)(void);
 * };
 *
 * A similar, but different, structure is used in the MIPS/Native system call:
 * ---------------------------------------------------------------------------
 *    struct sigaction {
 *      unsigned int sa_flags;
 *      union {
 *        __sighandler_t                  sa_handler;
 *        __sigaction_handler_portable_t _sa_sigaction;
 *      } __u;
 *      sigset_t sa_mask;
 *  };
 *
 * This sigaction structure needs to be mapped before the MIPS systems call as well as after for
 * returning the old/previous sigaction. Also, like signal_portable() above, we need to maintain
 * a table of signal handlers that our intercepting handler can call after it converts the signal
 * numbers.
 */
static int do_sigaction_portable(int portable_signum, const struct sigaction_portable *act,
                                 struct sigaction_portable *oldact, sigaction_fn fn,
                                 rt_sigaction_fn rt_fn)
{
    int mips_signum;
    char *mips_signame;
    struct sigaction mips_act;
    struct sigaction *mips_act_ptr;
    struct sigaction mips_oldact;
    sighandler_t mips_handler;
    sighandler_portable_t portable_handler;
    sig3handler_portable_t prev_portable_handler;
    char *portable_signame = map_portable_signum_to_name(portable_signum);
    int rv;

    ALOGV("%s(portable_signum:%d:'%s', act:%p, oldact:%p, fn:%p, rt_fn:%p) {", __func__,
              portable_signum,
              portable_signame,        act,    oldact,    fn,    rt_fn);

    mips_signum = signum_pton(portable_signum);
    mips_signame = map_mips_signum_to_name(mips_signum);

    if ((portable_signum != 0) && (mips_signum == 0)) {
        /* We got a portable signum that we can't map; Ignore the request */
        rv = 0;
        goto done;
    }
    if (portable_signum > 0 && portable_signum <= NSIG_PORTABLE)
        prev_portable_handler = mips_portable_sighandler[portable_signum];
    else
        prev_portable_handler = NULL;

    memset(&mips_act, 0, sizeof(mips_act));

    if (invalid_pointer((void *)act)) {
        mips_act_ptr = (struct sigaction *)act;
    } else {
        /*
         * Make the MIPS version of sigaction, which has no sa_restorer function pointer.
         * Also the handler will be called with a pointer to a to a sigcontext structure
         * which is totally non-portable.
         */
        sigset_pton(((sigset_portable_t *)&act->sa_mask),
                                    ((sigset_t *) &mips_act.sa_mask));

        mips_act.sa_flags = sigaction_flags_pton(act->sa_flags);

        if (mips_act.sa_flags & SA_SIGINFO) {
            /*
             * Providing the three argument version of a signal handler.
             */
            portable_handler = (sighandler_portable_t) act->sa_sigaction_portable;
            if ((portable_signum <= 0) || (portable_signum > NSIG_PORTABLE)) {
                /*
                 * Let the kernel generate the proper return value and set errno.
                 */
                mips_act.sa_sigaction = (sig3handler_t) portable_handler;
            } else {
                mips_handler = sighandler_pton(portable_handler, 1);
                if (mips_handler != portable_handler) {
                    mips_portable_sighandler[portable_signum] =
                                                       (sig3handler_portable_t) portable_handler;
                }
                mips_act.sa_sigaction = (sig3handler_t) mips_handler;
            }
        } else {
            /*
             * Providing the classic single argument version of a signal handler.
             */
            portable_handler = act->sa_handler_portable;
            if ((portable_signum <= 0) || (portable_signum > NSIG_PORTABLE)) {
                /*
                 * Let the kernel generate the proper return value and set errno.
                 */
                mips_act.sa_handler = (sighandler_t) portable_handler;
            } else {
                mips_handler = sighandler_pton(portable_handler, 1);
                if (mips_handler != portable_handler) {
                    mips_portable_sighandler[portable_signum] =
                                                       (sig3handler_portable_t) portable_handler;
                }
                mips_act.sa_handler = mips_handler;
            }
        }
        mips_act_ptr = &mips_act;
    }

    if (fn != NULL) {
        ASSERT(rt_fn == NULL);
        rv = fn(mips_signum, mips_act_ptr, &mips_oldact);
    } else {
        ASSERT(rt_fn != NULL);
        rv = rt_fn(mips_signum, mips_act_ptr, &mips_oldact, sizeof(sigset_t));
    }

    if (rv == 0 && oldact) {
        if (mips_oldact.sa_sigaction == (__sigaction_handler_portable_t) mips_sigaction_handler ||
            mips_oldact.sa_sigaction == (__sigaction_handler_portable_t) mips_sighandler) {

            oldact->sa_sigaction_portable =
                                        (__sigaction_handler_portable_t) prev_portable_handler;
        } else {
            oldact->sa_sigaction_portable =
                                        (__sigaction_handler_portable_t) mips_oldact.sa_sigaction;
        }
        sigset_ntop((sigset_t *) &(mips_oldact.sa_mask),
                                    (sigset_portable_t *) &(oldact->sa_mask));

        oldact->sa_flags = sigaction_flags_ntop(mips_oldact.sa_flags);
        oldact->sa_restorer = NULL;
    }

done:
    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}


int WRAP(sigaction)(int portable_signum, const struct sigaction_portable *act,
                       struct sigaction_portable *oldact)
{
    extern int REAL(sigaction)(int, const struct sigaction *, struct sigaction *);
    int rv;

    ALOGV(" ");
    ALOGV("%s(portable_signum:%d, act:%p, oldact:%p) {", __func__,
              portable_signum,    act,    oldact);

    rv = do_sigaction_portable(portable_signum, act, oldact, REAL(sigaction), NULL);

    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}


/*
 * Currently signalfd() isn't supported by bionic with
 * only the portable syscall.c code using this code by
 * intercepting the syscall(__NR_signalfd4, ...) in bionic.
 */
__hidden int do_signalfd4_portable(int fd, const sigset_portable_t *portable_sigmask,
                                   int portable_sigsetsize, int portable_flags)
{
    sigset_t native_sigmask;
    int native_sigsetsize = sizeof(native_sigmask);
    int native_flags = 0;
    int rv;

    ALOGV("%s(fd:%d, portable_sigmask:%p, portable_sigsetsize:%d, portable_flags:0x%x) {",
    __func__, fd,    portable_sigmask,    portable_sigsetsize,    portable_flags);

    sigset_pton((sigset_portable_t *)portable_sigmask, &native_sigmask);

    if (portable_flags & SFD_NONBLOCK_PORTABLE) {
        native_flags |= SFD_NONBLOCK;
    }
    if (portable_flags & SFD_CLOEXEC_PORTABLE) {
        native_flags |= SFD_CLOEXEC;
    }
    rv = syscall(__NR_signalfd4, fd, &native_sigmask, native_sigsetsize, native_flags);

    if (rv >= 0) {
        if (native_flags & SFD_CLOEXEC) {
            filefd_CLOEXEC_enabled(rv);
        }

        /*
         * Reads on this file descriptor must be mapped to be portable.
         * The mapping should survive a fork and most clones naturally.
         * For the system call to be completely portable it has to propagate
         * these mapped files after an execve(). Environment variables have
         * been added to do that. See filefd.c for details.
         */
        filefd_opened(rv, SIGNAL_FD_TYPE);
    }

    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}


#if 0
/*
 * signalfd() isn't available in Bionic yet. When it is, it will be implemented like
 * the glibc version where the sigsetsize is computed in the bionic code and passed
 * down to the kernel with __NR_signalfd4.
 *
 * This function can't be called from bionic, so there isn't an entry in the experimental
 * linker.cpp table for testing and this function.
 */
int WRAP(signalfd)(int fd, const sigset_portable_t *portable_sigmask, int portable_flags)
{
    int portable_sigsetsize = sizeof(sigset_portable_t);
    int rv;

    ALOGV("%s(fd:%d, portable_sigmask:%p, portable_flags:0x%x) {", __func__,
              fd,    portable_sigmask,    portable_flags);

    rv = do_signalfd4_portable(fd, portable_sigsetsize, portable_sigmask, portable_flags);

    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}
#endif


/*
 * Called by read_portable() to do signalfd read() mapping.
 */
__hidden int read_signalfd_mapper(int fd, void *buf, size_t count)
{
    int rv;

    ALOGV("%s(fd:%d, buf:0x%p, count:%d) {", __func__,
              fd,    buf,      count);

    rv = read(fd, buf, count);
    if (rv > 0) {
        int siginfos = rv/sizeof(struct signalfd_siginfo);
        struct signalfd_siginfo *si = (struct signalfd_siginfo *) buf;
        int i;

        /* Read signalfd_siginfo structure(s) if read is large enough */
        for (i = 0; i < siginfos; i++, si++) {
            int ssi_signo;

            ssi_signo = si->ssi_signo;
            si->ssi_signo = signum_ntop(si->ssi_signo);
            ALOGV("%s: si->ssi_signo:%d = signum_ntop(si->ssi_signo:%d); i:%d", __func__,
                       si->ssi_signo,                     ssi_signo,     i);

            si->ssi_errno = errno_ntop(si->ssi_errno);

            /*
             * The ssi_codes appear to be generic; defined in
             * the kernel in include/asm-generic/siginfo.h
             */
            if (si->ssi_status > 0 && si->ssi_status <= NSIG) {
                si->ssi_status = signum_ntop(si->ssi_status);
            }

            /*
             * The rest of the struct members, like
             *  ssi_trapno, ssi_int, ssi_ptr
             * are not likely worth dealing with.
             */
        }
    }

    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}

int WRAP(sigsuspend)(const sigset_portable_t *portable_sigmask)
{
    int rv;
    sigset_t mips_sigmask;

    ALOGV("%s(portable_sigmask:%p) {", __func__, portable_sigmask);

    if (invalid_pointer((void *)portable_sigmask)) {
        *REAL(__errno)() = EFAULT;
        rv = -1;
    } else {
        sigset_pton((sigset_portable_t *)portable_sigmask, &mips_sigmask);
        rv = REAL(sigsuspend)(&mips_sigmask);
    }

    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}


int WRAP(sigpending)(sigset_portable_t *portable_sigset)
{
    int rv;
    sigset_t mips_sigset;

    ALOGV("%s(portable_sigset:%p) {", __func__,
              portable_sigset);

    if (invalid_pointer((void *)portable_sigset)) {
        *REAL(__errno)() = EFAULT;
        rv = -1;
    } else {
        rv = REAL(sigpending)(&mips_sigset);
        sigset_ntop(&mips_sigset, portable_sigset);
    }

    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}


int WRAP(sigwait)(const sigset_portable_t *portable_sigset, int *ptr_to_portable_sig)
{
    int rv;
    sigset_t mips_sigset;
    int mips_sig;
    int portable_sig;

    ALOGV("%s(portable_sigset:%p, ptr_to_portable_sig:%p) {", __func__,
              portable_sigset,    ptr_to_portable_sig);

    if (invalid_pointer((void *)portable_sigset)) {
        *REAL(__errno)() = EFAULT;
        rv = -1;
    } else {
        sigset_pton((sigset_portable_t *)portable_sigset, &mips_sigset);

        rv = REAL(sigwait)(&mips_sigset, &mips_sig);

        portable_sig = signum_ntop(mips_sig);
        *ptr_to_portable_sig = portable_sig;
    }
    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}


int WRAP(siginterrupt)(int portable_signum, int flag)

{
    int rv;
    int mips_signum;

    ALOGV("%s(portable_signum:%d, flag:0x%x) {", __func__,
              portable_signum,    flag);

    mips_signum = signum_pton(portable_signum);

    if ((portable_signum != 0) && (mips_signum == 0)) {
        ALOGE("%s: Unsupported portable_signum:%d; Ignoring.", __func__,
                               portable_signum);
        rv = 0;
    } else {
        rv = REAL(siginterrupt)(mips_signum, flag);
    }
    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}


__hidden int do_sigmask(int portable_how, const sigset_portable_t *portable_sigset,
                        sigset_portable_t *portable_oldset, sigmask_fn fn,
                        rt_sigmask_fn rt_fn)
{
    int rv;
    int how;
    char *how_name;
    sigset_t mips_sigset, *mips_sigset_p;
    sigset_t mips_oldset, *mips_oldset_p;

    ALOGV("%s(portable_how:%d, portable_sigset:%p, portable_oldset:%p, fn:%p, rt_fn:%p) {",
    __func__, portable_how,    portable_sigset,    portable_oldset,    fn,    rt_fn);

    switch(portable_how) {
    case SIG_BLOCK_PORTABLE:    how = SIG_BLOCK;        how_name = "SIG_BLOCK";         break;
    case SIG_UNBLOCK_PORTABLE:  how = SIG_UNBLOCK;      how_name = "SIG_UNBLOCK";       break;
    case SIG_SETMASK_PORTABLE:  how = SIG_SETMASK;      how_name = "SIG_SETMASK";       break;

    default:
        ALOGE("%s: portable_how:%d NOT SUPPORTED!", __func__, portable_how);
        how = -1;
        break;
    }

    if (invalid_pointer((void *)portable_sigset)) {
        mips_sigset_p = (sigset_t *) portable_sigset;
    } else {
        mips_sigset_p = &mips_sigset;
        memset(mips_sigset_p, 0, sizeof(mips_sigset));
        sigemptyset(mips_sigset_p);
        sigset_pton((sigset_portable_t *)portable_sigset, &mips_sigset);
    }

    if (invalid_pointer((void *)portable_oldset)) {
        mips_oldset_p = (sigset_t *) portable_oldset;
    } else {
        mips_oldset_p = &mips_oldset;
        memset(mips_oldset_p, 0, sizeof(mips_oldset));
        sigemptyset(mips_oldset_p);
    }

    if (fn != NULL) {
        ASSERT(rt_fn == NULL);
        rv = fn(how, mips_sigset_p, mips_oldset_p);
    } else {
        ASSERT(rt_fn != NULL);
        rv = rt_fn(how, mips_sigset_p, mips_oldset_p, sizeof(sigset_t));
    }

    if (rv == 0 && !invalid_pointer(portable_oldset)) {
        /* Map returned mips_oldset to portable_oldset for return to caller */
        sigset_ntop(mips_oldset_p, portable_oldset);
    }

    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}


int WRAP(sigprocmask)(int portable_how, const sigset_portable_t *portable_sigset,
                         sigset_portable_t *portable_oldset)
{
    extern int REAL(sigprocmask)(int, const sigset_t *, sigset_t *);
    int rv;

    ALOGV(" ");
    ALOGV("%s(portable_how:%d, portable_sigset:%p, portable_oldset:%p) {", __func__,
              portable_how,    portable_sigset,    portable_oldset);

    rv = do_sigmask(portable_how, portable_sigset, portable_oldset, REAL(sigprocmask), NULL);

    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}


int WRAP(__rt_sigaction)(int portable_signum, const struct sigaction_portable *act,
                            struct sigaction_portable *oldact, size_t sigsetsize)
{
    extern int REAL(__rt_sigaction)(int , const struct sigaction *, struct sigaction *, size_t);
    int rv;

    ALOGV(" ");
    ALOGV("%s(portable_signum:%d, act:%p, oldset:%p, sigsetsize:%d) {", __func__,
              portable_signum,    act,    oldact,    sigsetsize);

    /* NOTE: ARM kernel is expecting sizeof(sigset_t) to be 8 bytes */
    if (sigsetsize != (2* sizeof(long))) {
        *REAL(__errno)() = EINVAL;
        rv = -1;
        goto done;
    }
    rv = do_sigaction_portable(portable_signum, act, oldact, NULL, REAL(__rt_sigaction));

done:
    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}

int WRAP(__rt_sigprocmask)(int portable_how,
                              const sigset_portable_t *portable_sigset,
                              sigset_portable_t *portable_oldset,
                              size_t sigsetsize)
{
    extern int REAL(__rt_sigprocmask)(int, const sigset_t *, sigset_t *, size_t);
    int rv;

    ALOGV(" ");
    ALOGV("%s(portable_how:%d, portable_sigset:%p, portable_oldset:%p, sigsetsize:%d) {",
    __func__, portable_how,    portable_sigset,    portable_oldset,    sigsetsize);

    /* NOTE: ARM kernel is expecting sizeof(sigset_t) to be 8 bytes */
    if (sigsetsize != (2* sizeof(long))) {
        *REAL(__errno)() = EINVAL;
        rv = -1;
        goto done;
    }
    rv = do_sigmask(portable_how, portable_sigset, portable_oldset, NULL, REAL(__rt_sigprocmask));

 done:
    ALOGV("%s: return(rv:%d); }", __func__, rv);

    return rv;
}


int WRAP(__rt_sigtimedwait)(const sigset_portable_t *portable_sigset,
                               siginfo_portable_t *portable_siginfo,
                               const struct timespec *timeout,
                               size_t portable_sigsetsize)
{
    extern int REAL(__rt_sigtimedwait)(const sigset_t *, siginfo_t *, const struct timespec *, size_t);

    sigset_t native_sigset_struct;
    sigset_t *native_sigset = &native_sigset_struct;
    siginfo_t native_siginfo_struct;
    siginfo_t *native_siginfo;
    int rv;

    ALOGV(" ");
    ALOGV("%s(portable_sigset:%p, portable_siginfo:%p, timeout:%p, portable_sigsetsize:%d) {",
    __func__, portable_sigset,    portable_siginfo,    timeout,    portable_sigsetsize);

    /* NOTE: ARM kernel is expecting sizeof(sigset_t) to be 8 bytes */
    if (portable_sigsetsize != (2* sizeof(long))) {
        *REAL(__errno)() = EINVAL;
        rv = -1;
        goto done;
    }
    if (portable_sigset == NULL) {
        native_sigset = NULL;
    } else {
        sigset_pton((sigset_portable_t *)portable_sigset, native_sigset);
    }
    if (portable_siginfo == NULL) {
        native_siginfo = NULL;
    } else {
        native_siginfo = &native_siginfo_struct;
    }
    rv = REAL(__rt_sigtimedwait)(native_sigset, native_siginfo, timeout, sizeof(sigset_t));
    if (rv == 0 && native_siginfo != NULL) {
        /* Map siginfo struct from native to portable format. */
        siginfo_ntop(native_siginfo, portable_siginfo);
    }

done:
    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}


#ifdef  __NR_rt_sigqueueinfo

#if 0
/*
 * sigqueue():
 *    This function became available in UNIX GLIBC after 1993.
 *    It's not available in any versions of Android yet, and
 *    it can't be called via syscall(). It's been useful for
 *    testing with the LTP by the posix testsuite, and tests
 *    show that it works fine.
 *
 * NOTE:
 *    Android has in incorrect limit on the number of queueable signals
 *    defined in libc/unistd/sysconf.c:
 *
 *        #define  SYSTEM_SIGQUEUE_MAX    32
 *
 *    sigqueue() must return EAGAIN if exceeded and we don't on Android.
 */
int WRAP(sigqueue)(pid_t pid, int portable_sig, const union sigval value)
{
    siginfo_t native_siginfo;
    siginfo_t *native_sip;
    siginfo_portable_t portable_siginfo;
    siginfo_portable_t *portable_sip;
    int native_sig;
    int rv;

    ALOGV(" ");
    ALOGV("%s(pid:%d, portable_sig:%d, value:%p) {", __func__,
              pid,    portable_sig,    value.sival_ptr);

    native_sig = signum_pton(portable_sig);
    native_sip = &native_siginfo;

    portable_sip = &portable_siginfo;
    portable_sip->si_signo = 0;                 /* Filled in by the kernel */
    portable_sip->si_code = SI_QUEUE;
    portable_sip->si_pid = getpid();            /* Process ID of sender */
    portable_sip->si_uid = getuid();            /* Real UID of sender */
    portable_sip->si_value = value;             /* Last arg supplied */

    siginfo_pton(portable_sip, native_sip);

    /*
     * man page says sigqueue() is implemented via rt_sigqueueinfo().
     */
    ALOGV("%s: calling syscall(__NR_rt_sigqueueinfo:%d, pid:%d, native_sig:%d, native_sip:%p);",
           __func__,           __NR_rt_sigqueueinfo,    pid,    native_sig,    native_sip);

    rv = syscall(__NR_rt_sigqueueinfo, pid, native_sig, native_sip);

    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}
#endif


/*
 * Real Time version of sigqueueinfo().
 */
int WRAP(rt_sigqueueinfo)(pid_t pid, int portable_sig, siginfo_portable_t *portable_sip)
{
    int native_sig;
    siginfo_t native_siginfo, *native_sip;
    int rv;

    ALOGV(" ");
    ALOGV("%s(pid:%d, portable_sig:%d, portable_sip:%p) {", __func__,
              pid,    portable_sig,    portable_sip);

    native_sig = signum_pton(portable_sig);

    if (portable_sip != NULL) {
        native_sip = &native_siginfo;
        siginfo_pton(portable_sip, native_sip);
    } else {
        native_sip = NULL;
    }
    rv = syscall(__NR_rt_sigqueueinfo, pid, native_sig, native_sip);

    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}
#endif /* __NR_rt_sigqueueinfo */


#ifdef __NR_rt_tgsigqueueinfo
/*
 * Thread Group flavor of the real time version of sigqueueinfo().
 */
int WRAP(rt_tgsigqueueinfo)(pid_t tgid, pid_t pid, int portable_sig,
                               siginfo_portable_t *portable_sip)
{
    siginfo_t native_siginfo, *native_sip;
    int native_sig;
    int rv;

    ALOGV(" ");
    ALOGV("%s(tgid:%d, pid:%d, portable_sig:%d, portable_sip:%p) {", __func__,
              tgid,    pid,    portable_sig,    portable_sip);

    native_sig = signum_pton(portable_sig);

    if (portable_sip != NULL) {
        native_sip = &native_siginfo;
        siginfo_pton(portable_sip, native_sip);
    } else {
        native_sip = NULL;
    }
    rv = syscall(__NR_rt_tgsigqueueinfo, pid, native_sig, native_sip);

    ALOGV("%s: return(rv:%d); }", __func__, rv);
    return rv;
}
#endif /* __NR_rt_tgsigqueueinfo */


/*
 * ss_flags and ss_size are located in different locations in stack_t structure:
 *
 * Incomming ARM/Portable stack_t:                  Outgoing MIPS stack_t:
 * -------------------------------              ----------------------------
 *    typedef struct sigaltstack {              typedef struct sigaltstack {
 *        void __user *ss_sp;                       void *ss_sp;
 *        int ss_flags;                             size_t ss_size;
 *        size_t ss_size;                           int ss_flags;
 *    } stack_t;
 *
 */
int WRAP(sigaltstack)(const portable_stack_t *ss, portable_stack_t *oss)
{
    int rv;
    stack_t new_stack, *mips_ss;
    stack_t old_stack, *mips_oss;

    ALOGV(" ");
    ALOGV("%s(ss:%p, oss:%p) {", __func__, ss, oss);

    if (ss == NULL) {
        mips_ss = NULL;
    } else {
        if (invalid_pointer((void *)ss)) {
            ALOGE("%s: invalid_pointer(ss:%p): Let kernel set proper errno and set return value.",
                   __func__,           ss);

            mips_ss = (stack_t *) ss;
        } else {
            memset(&new_stack, 0, sizeof(stack_t));
            new_stack.ss_sp = ss->ss_sp;
            new_stack.ss_flags = ss->ss_flags;
            new_stack.ss_size = ss->ss_size;
            mips_ss = &new_stack;
        }
    }
    if (oss == NULL) {
        mips_oss = NULL;
    } else {
        if (invalid_pointer((void *)oss)) {
            ALOGE("%s: invalid_pointer(oss:%p): Let kernel set proper errno and return value.",
                   __func__,           oss);

            mips_oss = (stack_t *)oss;
        } else {
            memset(&old_stack, 0, sizeof(stack_t));
            mips_oss = &old_stack;
        }
    }

    rv = REAL(sigaltstack)(mips_ss, mips_oss);

    if (!invalid_pointer(oss)) {
        oss->ss_sp = old_stack.ss_sp;
        oss->ss_flags = old_stack.ss_flags;
        oss->ss_size = old_stack.ss_size;
    }
    ALOGV("%s: return(rv:%d); }", __func__, rv);

    return rv;
}