├── app
    ├── .gitignore
    ├── src
    │   ├── main
    │   │   ├── res
    │   │   │   ├── values
    │   │   │   │   ├── strings.xml
    │   │   │   │   ├── colors.xml
    │   │   │   │   └── styles.xml
    │   │   │   ├── mipmap-hdpi
    │   │   │   │   ├── ic_launcher.png
    │   │   │   │   └── ic_launcher_round.png
    │   │   │   ├── mipmap-mdpi
    │   │   │   │   ├── ic_launcher.png
    │   │   │   │   └── ic_launcher_round.png
    │   │   │   ├── mipmap-xhdpi
    │   │   │   │   ├── ic_launcher.png
    │   │   │   │   └── ic_launcher_round.png
    │   │   │   ├── mipmap-xxhdpi
    │   │   │   │   ├── ic_launcher.png
    │   │   │   │   └── ic_launcher_round.png
    │   │   │   ├── mipmap-xxxhdpi
    │   │   │   │   ├── ic_launcher.png
    │   │   │   │   └── ic_launcher_round.png
    │   │   │   ├── mipmap-anydpi-v26
    │   │   │   │   ├── ic_launcher.xml
    │   │   │   │   └── ic_launcher_round.xml
    │   │   │   ├── layout
    │   │   │   │   └── activity_main.xml
    │   │   │   ├── drawable-v24
    │   │   │   │   └── ic_launcher_foreground.xml
    │   │   │   └── drawable
    │   │   │   │   └── ic_launcher_background.xml
    │   │   ├── AndroidManifest.xml
    │   │   ├── java
    │   │   │   └── com
    │   │   │   │   └── dodola
    │   │   │   │       └── traphooks
    │   │   │   │           └── MainActivity.kt
    │   │   └── cpp
    │   │   │   ├── CMakeLists.txt
    │   │   │   ├── native-lib.cpp
    │   │   │   ├── phaser.h
    │   │   │   ├── sigmux.h
    │   │   │   ├── phaser.c
    │   │   │   └── sigmux.c
    │   ├── test
    │   │   └── java
    │   │   │   └── com
    │   │   │       └── dodola
    │   │   │           └── traphooks
    │   │   │               └── ExampleUnitTest.kt
    │   └── androidTest
    │   │   └── java
    │   │       └── com
    │   │           └── dodola
    │   │               └── traphooks
    │   │                   └── ExampleInstrumentedTest.kt
    ├── proguard-rules.pro
    └── build.gradle
├── settings.gradle
├── img
    ├── img.png
    └── traphook.jpeg
├── gradle
    └── wrapper
    │   ├── gradle-wrapper.jar
    │   └── gradle-wrapper.properties
├── README.md
├── .gitignore
├── LICENSE
├── gradle.properties
├── gradlew.bat
└── gradlew


/app/.gitignore:
--------------------------------------------------------------------------------
1 | /build
2 | 


--------------------------------------------------------------------------------
/settings.gradle:
--------------------------------------------------------------------------------
1 | include ':app'
2 | rootProject.name='TrapHooks'
3 | 


--------------------------------------------------------------------------------
/img/img.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dodola/TrapHook/HEAD/img/img.png


--------------------------------------------------------------------------------
/img/traphook.jpeg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dodola/TrapHook/HEAD/img/traphook.jpeg


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dodola/TrapHook/HEAD/gradle/wrapper/gradle-wrapper.jar


--------------------------------------------------------------------------------
/app/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 |     <string name="app_name">TrapHooks</string>
3 | </resources>
4 | 


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-hdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dodola/TrapHook/HEAD/app/src/main/res/mipmap-hdpi/ic_launcher.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-mdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dodola/TrapHook/HEAD/app/src/main/res/mipmap-mdpi/ic_launcher.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dodola/TrapHook/HEAD/app/src/main/res/mipmap-xhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dodola/TrapHook/HEAD/app/src/main/res/mipmap-xxhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dodola/TrapHook/HEAD/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-hdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dodola/TrapHook/HEAD/app/src/main/res/mipmap-hdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-mdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dodola/TrapHook/HEAD/app/src/main/res/mipmap-mdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dodola/TrapHook/HEAD/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dodola/TrapHook/HEAD/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dodola/TrapHook/HEAD/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # TrapHook
 2 | 
 3 | ![traphook](img/traphook.jpeg)
 4 | 
 5 | ![img](img/img.png)
 6 | 
 7 | ## Download
 8 | 
 9 | https://github.com/dodola/TrapHook/releases
10 | 


--------------------------------------------------------------------------------
/app/src/main/res/values/colors.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <resources>
3 |     <color name="colorPrimary">#008577</color>
4 |     <color name="colorPrimaryDark">#00574B</color>
5 |     <color name="colorAccent">#D81B60</color>
6 | </resources>
7 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *.iml
 2 | .gradle
 3 | /local.properties
 4 | /.idea/caches
 5 | /.idea/libraries
 6 | /.idea/modules.xml
 7 | /.idea/workspace.xml
 8 | /.idea/navEditor.xml
 9 | /.idea/assetWizardSettings.xml
10 | .DS_Store
11 | /build
12 | /captures
13 | .externalNativeBuild
14 | .cxx
15 | 


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | #Mon May 13 18:17:54 CST 2019
2 | distributionBase=GRADLE_USER_HOME
3 | distributionPath=wrapper/dists
4 | zipStoreBase=GRADLE_USER_HOME
5 | zipStorePath=wrapper/dists
6 | distributionUrl=https\://services.gradle.org/distributions/gradle-5.4-rc-1-all.zip
7 | 


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
3 |     <background android:drawable="@drawable/ic_launcher_background"/>
4 |     <foreground android:drawable="@drawable/ic_launcher_foreground"/>
5 | </adaptive-icon>


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
3 |     <background android:drawable="@drawable/ic_launcher_background"/>
4 |     <foreground android:drawable="@drawable/ic_launcher_foreground"/>
5 | </adaptive-icon>


--------------------------------------------------------------------------------
/app/src/main/res/values/styles.xml:
--------------------------------------------------------------------------------
 1 | <resources>
 2 | 
 3 |     <!-- Base application theme. -->
 4 |     <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
 5 |         <!-- Customize your theme here. -->
 6 |         <item name="colorPrimary">@color/colorPrimary</item>
 7 |         <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
 8 |         <item name="colorAccent">@color/colorAccent</item>
 9 |     </style>
10 | 
11 | </resources>
12 | 


--------------------------------------------------------------------------------
/app/src/test/java/com/dodola/traphooks/ExampleUnitTest.kt:
--------------------------------------------------------------------------------
 1 | package com.dodola.traphooks
 2 | 
 3 | import org.junit.Test
 4 | 
 5 | import org.junit.Assert.*
 6 | 
 7 | /**
 8 |  * Example local unit test, which will execute on the development machine (host).
 9 |  *
10 |  * See [testing documentation](http://d.android.com/tools/testing).
11 |  */
12 | class ExampleUnitTest {
13 |     @Test
14 |     fun addition_isCorrect() {
15 |         assertEquals(4, 2 + 2)
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/app/src/androidTest/java/com/dodola/traphooks/ExampleInstrumentedTest.kt:
--------------------------------------------------------------------------------
 1 | package com.dodola.traphooks
 2 | 
 3 | import androidx.test.platform.app.InstrumentationRegistry
 4 | import androidx.test.ext.junit.runners.AndroidJUnit4
 5 | 
 6 | import org.junit.Test
 7 | import org.junit.runner.RunWith
 8 | 
 9 | import org.junit.Assert.*
10 | 
11 | /**
12 |  * Instrumented test, which will execute on an Android device.
13 |  *
14 |  * See [testing documentation](http://d.android.com/tools/testing).
15 |  */
16 | @RunWith(AndroidJUnit4::class)
17 | class ExampleInstrumentedTest {
18 |     @Test
19 |     fun useAppContext() {
20 |         // Context of the app under test.
21 |         val appContext = InstrumentationRegistry.getInstrumentation().targetContext
22 |         assertEquals("com.dodola.traphooks", appContext.packageName)
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/app/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <manifest xmlns:android="http://schemas.android.com/apk/res/android"
 3 |           package="com.dodola.traphooks">
 4 | 
 5 |     <application
 6 |             android:allowBackup="true"
 7 |             android:icon="@mipmap/ic_launcher"
 8 |             android:label="@string/app_name"
 9 |             android:roundIcon="@mipmap/ic_launcher_round"
10 |             android:supportsRtl="true"
11 |             android:theme="@style/AppTheme">
12 |         <activity android:name=".MainActivity">
13 |             <intent-filter>
14 |                 <action android:name="android.intent.action.MAIN"/>
15 | 
16 |                 <category android:name="android.intent.category.LAUNCHER"/>
17 |             </intent-filter>
18 |         </activity>
19 |     </application>
20 | 
21 | </manifest>


--------------------------------------------------------------------------------
/app/proguard-rules.pro:
--------------------------------------------------------------------------------
 1 | # Add project specific ProGuard rules here.
 2 | # You can control the set of applied configuration files using the
 3 | # proguardFiles setting in build.gradle.
 4 | #
 5 | # For more details, see
 6 | #   http://developer.android.com/guide/developing/tools/proguard.html
 7 | 
 8 | # If your project uses WebView with JS, uncomment the following
 9 | # and specify the fully qualified class name to the JavaScript interface
10 | # class:
11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
12 | #   public *;
13 | #}
14 | 
15 | # Uncomment this to preserve the line number information for
16 | # debugging stack traces.
17 | #-keepattributes SourceFile,LineNumberTable
18 | 
19 | # If you keep the line number information, uncomment this to
20 | # hide the original source file name.
21 | #-renamesourcefileattribute SourceFile
22 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/dodola/traphooks/MainActivity.kt:
--------------------------------------------------------------------------------
 1 | package com.dodola.traphooks
 2 | 
 3 | import androidx.appcompat.app.AppCompatActivity
 4 | import android.os.Bundle
 5 | import android.widget.Button
 6 | import android.widget.TextView
 7 | import kotlinx.android.synthetic.main.activity_main.*
 8 | 
 9 | class MainActivity : AppCompatActivity() {
10 | 
11 |     override fun onCreate(savedInstanceState: Bundle?) {
12 |         super.onCreate(savedInstanceState)
13 |         setContentView(R.layout.activity_main)
14 |         findViewById<Button>(R.id.button).setOnClickListener {
15 |             findViewById<TextView>(R.id.sample_text).setText("1+2=" + intFromJNI())
16 |         }
17 |     }
18 | 
19 |     external fun intFromJNI(): Int
20 | 
21 |     companion object {
22 |         init {
23 |             System.loadLibrary("native-lib")
24 |         }
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 dodola
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/app/src/main/res/layout/activity_main.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <androidx.constraintlayout.widget.ConstraintLayout
 3 |         xmlns:android="http://schemas.android.com/apk/res/android"
 4 |         xmlns:tools="http://schemas.android.com/tools"
 5 |         xmlns:app="http://schemas.android.com/apk/res-auto"
 6 |         android:layout_width="match_parent"
 7 |         android:layout_height="match_parent"
 8 |         tools:context=".MainActivity">
 9 | 
10 |     <TextView
11 |             android:id="@+id/sample_text"
12 |             android:layout_width="wrap_content"
13 |             android:layout_height="wrap_content"
14 |             android:text="1+2="
15 |             app:layout_constraintBottom_toBottomOf="parent"
16 |             app:layout_constraintLeft_toLeftOf="parent"
17 |             app:layout_constraintRight_toRightOf="parent"
18 |             app:layout_constraintTop_toTopOf="parent"/>
19 |     <Button
20 |             android:text="Button"
21 |             android:layout_width="wrap_content"
22 |             android:layout_height="wrap_content" tools:layout_editor_absoluteY="74dp"
23 |             tools:layout_editor_absoluteX="185dp" android:id="@+id/button"/>
24 | 
25 | </androidx.constraintlayout.widget.ConstraintLayout>


--------------------------------------------------------------------------------
/gradle.properties:
--------------------------------------------------------------------------------
 1 | # Project-wide Gradle settings.
 2 | # IDE (e.g. Android Studio) users:
 3 | # Gradle settings configured through the IDE *will override*
 4 | # any settings specified in this file.
 5 | # For more details on how to configure your build environment visit
 6 | # http://www.gradle.org/docs/current/userguide/build_environment.html
 7 | # Specifies the JVM arguments used for the daemon process.
 8 | # The setting is particularly useful for tweaking memory settings.
 9 | org.gradle.jvmargs=-Xmx1536m
10 | # When configured, Gradle will run in incubating parallel mode.
11 | # This option should only be used with decoupled projects. More details, visit
12 | # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
13 | # org.gradle.parallel=true
14 | # AndroidX package structure to make it clearer which packages are bundled with the
15 | # Android operating system, and which are packaged with your app's APK
16 | # https://developer.android.com/topic/libraries/support-library/androidx-rn
17 | android.useAndroidX=true
18 | # Automatically convert third-party libraries to use AndroidX
19 | android.enableJetifier=true
20 | # Kotlin code style for this project: "official" or "obsolete":
21 | kotlin.code.style=official
22 | 


--------------------------------------------------------------------------------
/app/build.gradle:
--------------------------------------------------------------------------------
 1 | apply plugin: 'com.android.application'
 2 | 
 3 | apply plugin: 'kotlin-android'
 4 | 
 5 | apply plugin: 'kotlin-android-extensions'
 6 | 
 7 | android {
 8 |     compileSdkVersion 28
 9 |     defaultConfig {
10 |         applicationId "com.dodola.traphooks"
11 |         minSdkVersion 15
12 |         targetSdkVersion 28
13 |         versionCode 1
14 |         versionName "1.0"
15 |         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
16 |         ndk{
17 |             abiFilters 'armeabi-v7a'
18 |         }
19 |         externalNativeBuild {
20 |             cmake {
21 |                 cppFlags ""
22 |             }
23 |         }
24 |     }
25 |     buildTypes {
26 |         release {
27 |             minifyEnabled false
28 |             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
29 |         }
30 |     }
31 |     externalNativeBuild {
32 |         cmake {
33 |             path "src/main/cpp/CMakeLists.txt"
34 |             version "3.10.2"
35 |         }
36 |     }
37 | }
38 | 
39 | dependencies {
40 |     implementation fileTree(dir: 'libs', include: ['*.jar'])
41 |     implementation"org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
42 |     implementation 'androidx.appcompat:appcompat:1.0.2'
43 |     implementation 'androidx.core:core-ktx:1.0.2'
44 |     implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
45 |     testImplementation 'junit:junit:4.12'
46 |     androidTestImplementation 'androidx.test.ext:junit:1.1.0'
47 |     androidTestImplementation 'androidx.test.espresso:espresso-core:3.1.1'
48 | }
49 | 


--------------------------------------------------------------------------------
/app/src/main/cpp/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | # For more information about using CMake with Android Studio, read the
 2 | # documentation: https://d.android.com/studio/projects/add-native-code.html
 3 | 
 4 | # Sets the minimum version of CMake required to build the native library.
 5 | 
 6 | cmake_minimum_required(VERSION 3.4.1)
 7 | 
 8 | # Creates and names a library, sets it as either STATIC
 9 | # or SHARED, and provides the relative paths to its source code.
10 | # You can define multiple libraries, and CMake builds them for you.
11 | # Gradle automatically packages shared libraries with your APK.
12 | 
13 | add_library( # Sets the name of the library.
14 |         native-lib
15 | 
16 |         # Sets the library as a shared library.
17 |         SHARED
18 | 
19 |         # Provides a relative path to your source file(s).
20 |         phaser.c
21 |         sigmux.c
22 |         native-lib.cpp)
23 | include_directories(.)
24 | 
25 | # Searches for a specified prebuilt library and stores the path as a
26 | # variable. Because CMake includes system libraries in the search path by
27 | # default, you only need to specify the name of the public NDK library
28 | # you want to add. CMake verifies that the library exists before
29 | # completing its build.
30 | 
31 | find_library( # Sets the name of the path variable.
32 |         log-lib
33 | 
34 |         # Specifies the name of the NDK library that
35 |         # you want CMake to locate.
36 |         log)
37 | 
38 | # Specifies libraries CMake should link to your target library. You
39 | # can link multiple libraries, such as libraries you define in this
40 | # build script, prebuilt third-party libraries, or system libraries.
41 | 
42 | target_link_libraries( # Specifies the target library.
43 |         native-lib
44 | 
45 |         # Links the target library to the log library
46 |         # included in the NDK.
47 |         ${log-lib})


--------------------------------------------------------------------------------
/app/src/main/res/drawable-v24/ic_launcher_foreground.xml:
--------------------------------------------------------------------------------
 1 | <vector xmlns:android="http://schemas.android.com/apk/res/android"
 2 |         xmlns:aapt="http://schemas.android.com/aapt"
 3 |         android:width="108dp"
 4 |         android:height="108dp"
 5 |         android:viewportHeight="108"
 6 |         android:viewportWidth="108">
 7 |     <path
 8 |             android:fillType="evenOdd"
 9 |             android:pathData="M32,64C32,64 38.39,52.99 44.13,50.95C51.37,48.37 70.14,49.57 70.14,49.57L108.26,87.69L108,109.01L75.97,107.97L32,64Z"
10 |             android:strokeColor="#00000000"
11 |             android:strokeWidth="1">
12 |         <aapt:attr name="android:fillColor">
13 |             <gradient
14 |                     android:endX="78.5885"
15 |                     android:endY="90.9159"
16 |                     android:startX="48.7653"
17 |                     android:startY="61.0927"
18 |                     android:type="linear">
19 |                 <item
20 |                         android:color="#44000000"
21 |                         android:offset="0.0"/>
22 |                 <item
23 |                         android:color="#00000000"
24 |                         android:offset="1.0"/>
25 |             </gradient>
26 |         </aapt:attr>
27 |     </path>
28 |     <path
29 |             android:fillColor="#FFFFFF"
30 |             android:fillType="nonZero"
31 |             android:pathData="M66.94,46.02L66.94,46.02C72.44,50.07 76,56.61 76,64L32,64C32,56.61 35.56,50.11 40.98,46.06L36.18,41.19C35.45,40.45 35.45,39.3 36.18,38.56C36.91,37.81 38.05,37.81 38.78,38.56L44.25,44.05C47.18,42.57 50.48,41.71 54,41.71C57.48,41.71 60.78,42.57 63.68,44.05L69.11,38.56C69.84,37.81 70.98,37.81 71.71,38.56C72.44,39.3 72.44,40.45 71.71,41.19L66.94,46.02ZM62.94,56.92C64.08,56.92 65,56.01 65,54.88C65,53.76 64.08,52.85 62.94,52.85C61.8,52.85 60.88,53.76 60.88,54.88C60.88,56.01 61.8,56.92 62.94,56.92ZM45.06,56.92C46.2,56.92 47.13,56.01 47.13,54.88C47.13,53.76 46.2,52.85 45.06,52.85C43.92,52.85 43,53.76 43,54.88C43,56.01 43.92,56.92 45.06,56.92Z"
32 |             android:strokeColor="#00000000"
33 |             android:strokeWidth="1"/>
34 | </vector>
35 | 


--------------------------------------------------------------------------------
/gradlew.bat:
--------------------------------------------------------------------------------
 1 | @if "%DEBUG%" == "" @echo off
 2 | @rem ##########################################################################
 3 | @rem
 4 | @rem  Gradle startup script for Windows
 5 | @rem
 6 | @rem ##########################################################################
 7 | 
 8 | @rem Set local scope for the variables with windows NT shell
 9 | if "%OS%"=="Windows_NT" setlocal
10 | 
11 | set DIRNAME=%~dp0
12 | if "%DIRNAME%" == "" set DIRNAME=.
13 | set APP_BASE_NAME=%~n0
14 | set APP_HOME=%DIRNAME%
15 | 
16 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
17 | set DEFAULT_JVM_OPTS=
18 | 
19 | @rem Find java.exe
20 | if defined JAVA_HOME goto findJavaFromJavaHome
21 | 
22 | set JAVA_EXE=java.exe
23 | %JAVA_EXE% -version >NUL 2>&1
24 | if "%ERRORLEVEL%" == "0" goto init
25 | 
26 | echo.
27 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
28 | echo.
29 | echo Please set the JAVA_HOME variable in your environment to match the
30 | echo location of your Java installation.
31 | 
32 | goto fail
33 | 
34 | :findJavaFromJavaHome
35 | set JAVA_HOME=%JAVA_HOME:"=%
36 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe
37 | 
38 | if exist "%JAVA_EXE%" goto init
39 | 
40 | echo.
41 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
42 | echo.
43 | echo Please set the JAVA_HOME variable in your environment to match the
44 | echo location of your Java installation.
45 | 
46 | goto fail
47 | 
48 | :init
49 | @rem Get command-line arguments, handling Windows variants
50 | 
51 | if not "%OS%" == "Windows_NT" goto win9xME_args
52 | 
53 | :win9xME_args
54 | @rem Slurp the command line arguments.
55 | set CMD_LINE_ARGS=
56 | set _SKIP=2
57 | 
58 | :win9xME_args_slurp
59 | if "x%~1" == "x" goto execute
60 | 
61 | set CMD_LINE_ARGS=%*
62 | 
63 | :execute
64 | @rem Setup the command line
65 | 
66 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
67 | 
68 | @rem Execute Gradle
69 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
70 | 
71 | :end
72 | @rem End local scope for the variables with windows NT shell
73 | if "%ERRORLEVEL%"=="0" goto mainEnd
74 | 
75 | :fail
76 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
77 | rem the _cmd.exe /c_ return code!
78 | if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
79 | exit /b 1
80 | 
81 | :mainEnd
82 | if "%OS%"=="Windows_NT" endlocal
83 | 
84 | :omega
85 | 


--------------------------------------------------------------------------------
/app/src/main/res/drawable/ic_launcher_background.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <vector
 3 |         xmlns:android="http://schemas.android.com/apk/res/android"
 4 |         android:height="108dp"
 5 |         android:width="108dp"
 6 |         android:viewportHeight="108"
 7 |         android:viewportWidth="108">
 8 |     <path android:fillColor="#008577"
 9 |           android:pathData="M0,0h108v108h-108z"/>
10 |     <path android:fillColor="#00000000" android:pathData="M9,0L9,108"
11 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
12 |     <path android:fillColor="#00000000" android:pathData="M19,0L19,108"
13 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
14 |     <path android:fillColor="#00000000" android:pathData="M29,0L29,108"
15 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
16 |     <path android:fillColor="#00000000" android:pathData="M39,0L39,108"
17 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
18 |     <path android:fillColor="#00000000" android:pathData="M49,0L49,108"
19 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
20 |     <path android:fillColor="#00000000" android:pathData="M59,0L59,108"
21 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
22 |     <path android:fillColor="#00000000" android:pathData="M69,0L69,108"
23 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
24 |     <path android:fillColor="#00000000" android:pathData="M79,0L79,108"
25 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
26 |     <path android:fillColor="#00000000" android:pathData="M89,0L89,108"
27 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
28 |     <path android:fillColor="#00000000" android:pathData="M99,0L99,108"
29 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
30 |     <path android:fillColor="#00000000" android:pathData="M0,9L108,9"
31 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
32 |     <path android:fillColor="#00000000" android:pathData="M0,19L108,19"
33 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
34 |     <path android:fillColor="#00000000" android:pathData="M0,29L108,29"
35 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
36 |     <path android:fillColor="#00000000" android:pathData="M0,39L108,39"
37 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
38 |     <path android:fillColor="#00000000" android:pathData="M0,49L108,49"
39 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
40 |     <path android:fillColor="#00000000" android:pathData="M0,59L108,59"
41 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
42 |     <path android:fillColor="#00000000" android:pathData="M0,69L108,69"
43 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
44 |     <path android:fillColor="#00000000" android:pathData="M0,79L108,79"
45 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
46 |     <path android:fillColor="#00000000" android:pathData="M0,89L108,89"
47 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
48 |     <path android:fillColor="#00000000" android:pathData="M0,99L108,99"
49 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
50 |     <path android:fillColor="#00000000" android:pathData="M19,29L89,29"
51 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
52 |     <path android:fillColor="#00000000" android:pathData="M19,39L89,39"
53 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
54 |     <path android:fillColor="#00000000" android:pathData="M19,49L89,49"
55 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
56 |     <path android:fillColor="#00000000" android:pathData="M19,59L89,59"
57 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
58 |     <path android:fillColor="#00000000" android:pathData="M19,69L89,69"
59 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
60 |     <path android:fillColor="#00000000" android:pathData="M19,79L89,79"
61 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
62 |     <path android:fillColor="#00000000" android:pathData="M29,19L29,89"
63 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
64 |     <path android:fillColor="#00000000" android:pathData="M39,19L39,89"
65 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
66 |     <path android:fillColor="#00000000" android:pathData="M49,19L49,89"
67 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
68 |     <path android:fillColor="#00000000" android:pathData="M59,19L59,89"
69 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
70 |     <path android:fillColor="#00000000" android:pathData="M69,19L69,89"
71 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
72 |     <path android:fillColor="#00000000" android:pathData="M79,19L79,89"
73 |           android:strokeColor="#33FFFFFF" android:strokeWidth="0.8"/>
74 | </vector>
75 | 


--------------------------------------------------------------------------------
/gradlew:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env sh
  2 | 
  3 | ##############################################################################
  4 | ##
  5 | ##  Gradle start up script for UN*X
  6 | ##
  7 | ##############################################################################
  8 | 
  9 | # Attempt to set APP_HOME
 10 | # Resolve links: $0 may be a link
 11 | PRG="$0"
 12 | # Need this for relative symlinks.
 13 | while [ -h "$PRG" ] ; do
 14 |     ls=`ls -ld "$PRG"`
 15 |     link=`expr "$ls" : '.*-> \(.*\)$'`
 16 |     if expr "$link" : '/.*' > /dev/null; then
 17 |         PRG="$link"
 18 |     else
 19 |         PRG=`dirname "$PRG"`"/$link"
 20 |     fi
 21 | done
 22 | SAVED="`pwd`"
 23 | cd "`dirname \"$PRG\"`/" >/dev/null
 24 | APP_HOME="`pwd -P`"
 25 | cd "$SAVED" >/dev/null
 26 | 
 27 | APP_NAME="Gradle"
 28 | APP_BASE_NAME=`basename "$0"`
 29 | 
 30 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 31 | DEFAULT_JVM_OPTS=""
 32 | 
 33 | # Use the maximum available, or set MAX_FD != -1 to use that value.
 34 | MAX_FD="maximum"
 35 | 
 36 | warn () {
 37 |     echo "$*"
 38 | }
 39 | 
 40 | die () {
 41 |     echo
 42 |     echo "$*"
 43 |     echo
 44 |     exit 1
 45 | }
 46 | 
 47 | # OS specific support (must be 'true' or 'false').
 48 | cygwin=false
 49 | msys=false
 50 | darwin=false
 51 | nonstop=false
 52 | case "`uname`" in
 53 |   CYGWIN* )
 54 |     cygwin=true
 55 |     ;;
 56 |   Darwin* )
 57 |     darwin=true
 58 |     ;;
 59 |   MINGW* )
 60 |     msys=true
 61 |     ;;
 62 |   NONSTOP* )
 63 |     nonstop=true
 64 |     ;;
 65 | esac
 66 | 
 67 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 68 | 
 69 | # Determine the Java command to use to start the JVM.
 70 | if [ -n "$JAVA_HOME" ] ; then
 71 |     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
 72 |         # IBM's JDK on AIX uses strange locations for the executables
 73 |         JAVACMD="$JAVA_HOME/jre/sh/java"
 74 |     else
 75 |         JAVACMD="$JAVA_HOME/bin/java"
 76 |     fi
 77 |     if [ ! -x "$JAVACMD" ] ; then
 78 |         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
 79 | 
 80 | Please set the JAVA_HOME variable in your environment to match the
 81 | location of your Java installation."
 82 |     fi
 83 | else
 84 |     JAVACMD="java"
 85 |     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 86 | 
 87 | Please set the JAVA_HOME variable in your environment to match the
 88 | location of your Java installation."
 89 | fi
 90 | 
 91 | # Increase the maximum file descriptors if we can.
 92 | if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
 93 |     MAX_FD_LIMIT=`ulimit -H -n`
 94 |     if [ $? -eq 0 ] ; then
 95 |         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
 96 |             MAX_FD="$MAX_FD_LIMIT"
 97 |         fi
 98 |         ulimit -n $MAX_FD
 99 |         if [ $? -ne 0 ] ; then
100 |             warn "Could not set maximum file descriptor limit: $MAX_FD"
101 |         fi
102 |     else
103 |         warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
104 |     fi
105 | fi
106 | 
107 | # For Darwin, add options to specify how the application appears in the dock
108 | if $darwin; then
109 |     GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
110 | fi
111 | 
112 | # For Cygwin, switch paths to Windows format before running java
113 | if $cygwin ; then
114 |     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
115 |     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
116 |     JAVACMD=`cygpath --unix "$JAVACMD"`
117 | 
118 |     # We build the pattern for arguments to be converted via cygpath
119 |     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
120 |     SEP=""
121 |     for dir in $ROOTDIRSRAW ; do
122 |         ROOTDIRS="$ROOTDIRS$SEP$dir"
123 |         SEP="|"
124 |     done
125 |     OURCYGPATTERN="(^($ROOTDIRS))"
126 |     # Add a user-defined pattern to the cygpath arguments
127 |     if [ "$GRADLE_CYGPATTERN" != "" ] ; then
128 |         OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
129 |     fi
130 |     # Now convert the arguments - kludge to limit ourselves to /bin/sh
131 |     i=0
132 |     for arg in "$@" ; do
133 |         CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
134 |         CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
135 | 
136 |         if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
137 |             eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
138 |         else
139 |             eval `echo args$i`="\"$arg\""
140 |         fi
141 |         i=$((i+1))
142 |     done
143 |     case $i in
144 |         (0) set -- ;;
145 |         (1) set -- "$args0" ;;
146 |         (2) set -- "$args0" "$args1" ;;
147 |         (3) set -- "$args0" "$args1" "$args2" ;;
148 |         (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
149 |         (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
150 |         (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
151 |         (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
152 |         (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
153 |         (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
154 |     esac
155 | fi
156 | 
157 | # Escape application args
158 | save () {
159 |     for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
160 |     echo " "
161 | }
162 | APP_ARGS=$(save "$@")
163 | 
164 | # Collect all arguments for the java command, following the shell quoting and substitution rules
165 | eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
166 | 
167 | # by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
168 | if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
169 |   cd "$(dirname "$0")"
170 | fi
171 | 
172 | exec "$JAVACMD" "$@"
173 | 


--------------------------------------------------------------------------------
/app/src/main/cpp/native-lib.cpp:
--------------------------------------------------------------------------------
  1 | #include <jni.h>
  2 | #include <string>
  3 | #include <sys/ptrace.h>
  4 | #include <unistd.h>
  5 | #include <android/log.h>
  6 | #include <sys/wait.h>
  7 | #include <sys/mman.h>
  8 | #include "sigmux.h"
  9 | #include <ucontext.h>
 10 | 
 11 | #define  LOG_TAG    "testjni"
 12 | #define  ALOG(...)  __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
 13 | #define PAGE_START(addr)    (~(PAGE_SIZE - 1) & (addr))
 14 | #define SET_BIT0(addr)        (addr | 1)
 15 | #define CLEAR_BIT0(addr)    (addr & 0xFFFFFFFE)
 16 | #define TEST_BIT0(addr)        (addr & 1)
 17 | struct sigmux_registration *volatile r1 = NULL;
 18 | 
 19 | //static const char *testdata = "ddddddd";
 20 | static const unsigned char break_insn[] = {0xf0, 0x01, 0xf0, 0xe7};
 21 | static const unsigned char thumb_break_insn[] = {0x01, 0xde};
 22 | static unsigned char origin_insn[4];
 23 | static unsigned char origin_thumb_insn[2];
 24 | static sigjmp_buf jmp;
 25 | 
 26 | void insertTrap(uintptr_t addr);
 27 | 
 28 | void resetTrap(uintptr_t addr);
 29 | 
 30 | void ptrace_detach(pid_t target) {
 31 |     if (ptrace(PTRACE_DETACH, target, NULL, NULL) == -1) {
 32 |         ALOG("ptrace(PTRACE_DETACH) failed\n");
 33 |     }
 34 | }
 35 | 
 36 | void ptrace_attach(pid_t target) {
 37 |     int waitpidstatus;
 38 | 
 39 |     if (ptrace(PTRACE_ATTACH, target, NULL, NULL) == -1) {
 40 |         ALOG("ptrace(PTRACE_ATTACH) failed\n %s", strerror(errno));
 41 |         return;
 42 |     }
 43 | 
 44 |     if (waitpid(target, &waitpidstatus, WUNTRACED) != target) {
 45 |         ALOG("waitpid(%d) failed\n", target);
 46 |         return;
 47 |     }
 48 | }
 49 | 
 50 | JNIEXPORT static int add(int a, int b) {
 51 |     return a + b;
 52 | }
 53 | 
 54 | static void dump_memory(int pid, uintptr_t addr) {
 55 |     char code_buffer[64];
 56 |     char ascii_buffer[32];
 57 |     uintptr_t p, end;
 58 |     p = addr & ~3;
 59 |     p -= 32;
 60 |     if (p > addr) {
 61 |         p = 0;
 62 |     }
 63 |     end = p + 80;
 64 |     while (end < p)
 65 |         end -= 16;
 66 |     while (p < end) {
 67 |         char *asc_out = ascii_buffer;
 68 |         sprintf(code_buffer, "%08x ", p);
 69 |         int i;
 70 |         for (i = 0; i < 4; i++) {
 71 | 
 72 |             long data = ptrace(PTRACE_PEEKTEXT, pid, (void *) p, NULL);
 73 | //            ALOG("%s %d ======", strerror(errno), errno);
 74 |             sprintf(code_buffer + strlen(code_buffer), "%08lx ", data);
 75 |             int j;
 76 |             for (j = 0; j < 4; j++) {
 77 |                 char val = (data >> (j * 8)) & 0xff;
 78 |                 if (val >= 0x20 && val < 0x7f) {
 79 |                     *asc_out++ = val;
 80 |                 } else {
 81 |                     *asc_out++ = '.';
 82 |                 }
 83 |             }
 84 |             p += 4;
 85 |         }
 86 |         *asc_out = '\0';
 87 |         ALOG("%s %s\n", code_buffer, ascii_buffer);
 88 |     }
 89 | }
 90 | 
 91 | int add2(int a, int b) {
 92 |     return a * b + 111;
 93 | }
 94 | 
 95 | 
 96 | extern "C"
 97 | JNIEXPORT jint
 98 | JNICALL
 99 | Java_com_dodola_traphooks_MainActivity_intFromJNI(
100 |         JNIEnv *env,
101 |         jobject) {
102 |     int result = add(1, 2);
103 |     ALOG("%d=====", result);
104 |     return result;
105 | }
106 | 
107 | static void setJump() {
108 |     if (sigsetjmp(jmp, 1) == 1) {
109 |         ALOG("got longjmp from %p\n", r1);
110 | //        sigmux_unregister(r1);
111 | 
112 |     }
113 | }
114 | 
115 | 
116 | static enum sigmux_action
117 | handle_testreg(struct sigmux_siginfo *siginfo,
118 |                void *handler_data) {
119 |     const char *name = static_cast<const char *>(handler_data);
120 |     ALOG("got signal (testreg) name=%s\n", name);
121 |     if (!strcmp(static_cast<const char *>(handler_data), "add")) {
122 |         struct ucontext *uc = reinterpret_cast<struct ucontext *>(siginfo->context);
123 |         struct sigcontext *sc = reinterpret_cast<struct sigcontext *>(&uc->uc_mcontext);
124 |         sc->arm_pc = reinterpret_cast<unsigned long>(add2);
125 | //        sigmux_longjmp(siginfo, jmp, 1);//跳转别的地方去执行 for signal safe
126 |     }
127 |     return SIGMUX_CONTINUE_EXECUTION;
128 | }
129 | 
130 | static struct sigmux_registration *
131 | register_testreg(const char *name) {
132 |     struct sigmux_registration *reg;
133 |     sigset_t signals;
134 | 
135 |     sigemptyset(&signals);
136 |     sigaddset(&signals, SIGTRAP);
137 |     reg = sigmux_register(&signals, handle_testreg, (void *) name, 0);
138 |     if (reg == NULL) {
139 |         ALOG("sigmux_register failed: %s\n", strerror(errno));
140 |     }
141 | 
142 |     ALOG("registered handler %p for %s\n", reg, name);
143 |     return reg;
144 | }
145 | 
146 | 
147 | jint JNI_OnLoad(JavaVM *vm, void *reserved) {
148 |     setJump();
149 | //    int pid = fork();
150 |     uintptr_t addr = (uintptr_t) add;
151 | //    if (pid < 0) {
152 | //
153 | //    } else if (pid == 0) { //.....放弃 ，hin不实用
154 | //        ALOG("-----pid:%d,ppid:%d----", getpid(), getppid());
155 | //        ptrace_attach(getppid());
156 | //        dump_memory(getppid(), addr);
157 | //        bp.addr = reinterpret_cast<void *>(addr);
158 | //        hook_init(&bp);
159 | //        enable_hook(getppid(), &bp);
160 | //        dump_memory(getppid(), addr);
161 | //        ptrace_detach(getppid());
162 | //    } else{}
163 |     insertTrap(addr);
164 | 
165 |     if (sigmux_init(SIGTRAP) != 0) {
166 |         ALOG("sigmux_init failed: %s\n", strerror(errno));
167 |         return JNI_VERSION_1_4;
168 |     }
169 | 
170 |     r1 = register_testreg("add");
171 | 
172 |     return JNI_VERSION_1_4;
173 | }
174 | 
175 | void insertTrap(uintptr_t addr) {
176 |     mprotect((void *) PAGE_START(CLEAR_BIT0(addr)), PAGE_SIZE * 2, PROT_READ | PROT_WRITE | PROT_EXEC);
177 | 
178 |     int thumb_mode = ((uintptr_t) addr) & 1;
179 |     if (thumb_mode) {
180 |         addr = ((uintptr_t) addr & ~1);
181 |     }
182 | 
183 |     if (thumb_mode) {
184 |         memcpy(origin_thumb_insn, reinterpret_cast<const void *>(addr), 2);
185 |         memcpy(reinterpret_cast<void *>(addr), thumb_break_insn, 2);
186 |     } else {
187 |         memcpy(origin_insn, reinterpret_cast<const void *>(addr), 4);
188 |         memcpy(reinterpret_cast<void *>(addr), break_insn, 4);
189 |     }
190 | }
191 | 
192 | void resetTrap(uintptr_t addr) {
193 |     mprotect((void *) PAGE_START(CLEAR_BIT0(addr)), PAGE_SIZE * 2, PROT_READ | PROT_WRITE | PROT_EXEC);
194 | 
195 |     int thumb_mode = ((uintptr_t) addr) & 1;
196 |     if (thumb_mode) {
197 |         addr = ((uintptr_t) addr & ~1);
198 |     }
199 | 
200 |     if (thumb_mode) {
201 |         memcpy(reinterpret_cast<void *>(addr), origin_thumb_insn, 2);
202 |     } else {
203 |         memcpy(reinterpret_cast<void *>(addr), origin_insn, 4);
204 |     }
205 | }
206 | 


--------------------------------------------------------------------------------
/app/src/main/cpp/phaser.h:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Copyright 2018-present, Facebook, Inc.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *     http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | #pragma once
 18 | #include <stddef.h>
 19 | #include <stdint.h>
 20 | 
 21 | /**
 22 | * DESCRIPTION
 23 | * -----------
 24 | *
 25 | * A "phaser" is a synchronization primitive that allows a thread to
 26 | * know that all other threads have passed a certain point in
 27 | * execution, but without blocking any of these threads.  It is useful
 28 | * in cases where callers want to guarantee that a shared resource is
 29 | * no longer visible before deallocating it.
 30 | *
 31 | * Any number of threads can enter and exit a "critical region"
 32 | * guarded by a phaser; they use the routines exit phaser_enter and
 33 | * phaser_exit.  These functions are non-waiting, non-blocking, fully
 34 | * reentrant, infallible, and async-signal-safe.
 35 | *
 36 | * Another thread (at most one at a time) can concurrently call
 37 | * phaser_drain.  This function blocks until all threads that had
 38 | * entered the monitored region before the call to phaser_drain make
 39 | * the corresponding call to phaser_exit to exit the region.
 40 | *
 41 | * phaser_enter and phaser_exit are async-signal-safe and completely
 42 | * reentrant, making them ideal for use in signal handlers where other
 43 | * synchronization primitives may be cumbersome.
 44 | *
 45 | * PERFORMANCE
 46 | * -----------
 47 | *
 48 | * Phaser is heavily read-oriented.  phaser_enter and phaser_exit are
 49 | * atomic increment and atomic decrement in the common case.  On an
 50 | * Intel i7-4600U, a phaser_enter and phaser_exit pair completes in
 51 | * approximately 28 cycles.  That cost approximately doubles if a
 52 | * phaser_drain is running concurrently.
 53 | *
 54 | * While phaser by itself performs adequately, it occupies only a
 55 | * single cache-line, potentially hurting performance in the
 56 | * heavily-contended case.  Callers can improve performance in this
 57 | * case by a factor of two by using multiple phasers, each situated on
 58 | * different cache line.  Threads entering critical sections can choose
 59 | * a phaser based on CPU affinity, and a thread wanting synchronize on
 60 | * all readers can call phaser_drain on each cacheline's phased in
 61 | * turn.
 62 | *
 63 | * PORTABILITY
 64 | * -----------
 65 | *
 66 | * Phaser relies on the OS providing some kind of wait-on-address
 67 | * functionality.  On Linux, we use futex directly.  On Windows, it
 68 | * would be possible to use WaitOnAddress.  On FreeBSD, umtx ought to
 69 | * work; on iOS, the kernels' psynch_cvwait psynch_cvsignal should
 70 | * suffice.
 71 | *
 72 | * EXAMPLE
 73 | * -------
 74 | *
 75 | * A contrived example may help clarify the use case.  Note that
 76 | * worker_threads() performs no heavyweight synchronization and that
 77 | * any number of calls to worker_threads() and
 78 | * atomically_increment_array() can run concurrently.
 79 | *
 80 | * std::vector<int>* g_array;
 81 | * pthread_mutex_t array_phaser_lock = PTHREAD_MUTEX_INITIALIZER;
 82 | * phaser_t array_phaser;
 83 | *
 84 | * void init()
 85 | * {
 86 | *   pthread_mutex_init(&array_phaser_lock);
 87 | *   phaser_init(&array_phaser);
 88 | * }
 89 | *
 90 | * void worker_threads()
 91 | * {
 92 | *   phaser_phase phase;
 93 | *   for(;;) {
 94 | *     phase = phaser_enter(array_phaser);
 95 | *     operate_on_array(array);
 96 | *     phaser_exit(array_phaser, phase);
 97 | *   }
 98 | * }
 99 | *
100 | * void atomically_increment_array()
101 | * {
102 | *   std::vector<int>* old_array;
103 | *   std::vector<int>* new_array;
104 | *   bool success;
105 | *
106 | *   do {
107 | *     phaser_enter(array_phaser);
108 | *
109 | *     old_array = __atomic_load_n(&g_array, __ATOMIC_ACQUIRE);
110 | *     // NB: in real code, the std::vector constructor can throw,
111 | *     // and calling code should take care to exit the phaser
112 | *     // critical section if it does.
113 | *     new_array = new std::vector<int>(*old_array);
114 | *     for(auto it = new_array->begin(); it != new_array->end(); ++it) {
115 | *       *it += 1;
116 | *     }
117 | *
118 | *     // Important to use __ATOMIC_RELEASE on the success path:
119 | *     // other threads must see only fully-constructed vector.
120 | *     success =
121 | *       __atomic_compare_exchange_n(
122 | *         &g_array,
123 | *         &old_array,
124 | *         new_array,
125 | *         true // weak: we loop anyway,
126 | *         __ATOMIC_RELEASE,
127 | *         __ATOMIC_RELAXED);
128 | *
129 | *     phaser_exit(array_phaser);
130 | *
131 | *     if(!success) {
132 | *       * Someone else beat us to the increment, so try again.
133 | *       delete new_array;
134 | *     }
135 | *   } while(!success);
136 | *
137 | *   // We exclusively own the old array.  Wait for pending readers
138 | *   // to finish.
139 | *
140 | *   pthread_mutex_lock(&array_phaser_lock);
141 | *   phaser_drain(array_phaser);
142 | *   pthread_mutex_unlock(&array_phaser_lock);
143 | *
144 | *   // Now we know that nobody is using old_array: all
145 | *   // references to array occur inside a phaser critical
146 | *   // section, and the call to phaser_drain ensured that
147 | *   // all critical sections that began while g_array still
148 | *   // pointed at old_array have now terminated.
149 | *
150 | *   delete old_array;
151 | * }
152 | */
153 | 
154 | #ifdef __cplusplus
155 | extern "C" {
156 | #endif
157 | 
158 | #define STRATEGY_FUTEX 1
159 | #define STRATEGY_PIPE 2
160 | 
161 | #ifndef PHASER_STRATEGY
162 | #ifdef __linux__
163 | #define PHASER_STRATEGY STRATEGY_FUTEX
164 | #else
165 | #define PHASER_STRATEGY STRATEGY_PIPE
166 | #endif
167 | #endif
168 | 
169 | #if PHASER_STRATEGY == STRATEGY_FUTEX
170 | #define PHASER_UNINITIALIZED { { 0, 0 } }
171 | #elif PHASER_STRATEGY == STRATEGY_PIPE
172 | #define PHASER_UNINITIALIZED { { 0, 0 }, { -1, -1 } }
173 | #else
174 | #error "Unknown phaser strategy"
175 | #endif
176 | 
177 | #define NUM_PHASES 2 /* must be power of two! */
178 | 
179 | typedef struct phaser {
180 |   size_t counter[NUM_PHASES];
181 | #if PHASER_STRATEGY == STRATEGY_PIPE
182 |   /* We don't have futex on non-Linux, so we fall back to using a pipe
183 |      as a semaphore: down = read a byte, up = write a byte. We only
184 |      need one pipe because we only drain one counter at a time. */
185 |   int counter_pipe[2];
186 | #endif
187 | } phaser_t;
188 | 
189 | typedef uint32_t phaser_phase;
190 | 
191 | /**
192 |  * Initialize a phaser object. This function must be paired with
193 |  * phaser_destroy.
194 |  * Returns 0 on success, nonzero on failure. On failure, errno is set.
195 |  */
196 | int phaser_init(phaser_t* ph);
197 | 
198 | /**
199 |  * De-initialize a phaser object. ph must previously have been
200 |  * successfully initialized with phaser_init.
201 |  */
202 | void phaser_destroy(phaser_t* ph);
203 | 
204 | /**
205 |  * Enter a phaser critical region.  This function must be paired with
206 |  * phaser_exit.  Return a token to pass to phaser_exit.  This function
207 |  * is reentrant and async-signal-safe: it may be called even on a
208 |  * thread currently executing phaser_drain (e.g., from a signal
209 |  * handler).  This function cannot fail and does not block or wait.
210 |  *
211 |  * phaser_enter is a full memory barrier.
212 |  */
213 | __attribute__ ((warn_unused_result))
214 | phaser_phase phaser_enter(phaser_t* ph);
215 | 
216 | /**
217 |  * Exit a phaser critical region.  This function is reentrant and
218 |  * async-signal-safe.  PHASE is the return value of the matching
219 |  * phaser_enter call.
220 |  *
221 |  * phaser_exit is a full memory barrier.
222 |  */
223 | void phaser_exit(phaser_t* ph, phaser_phase phase);
224 | 
225 | /**
226 |  * Block and wait for all active critical regions on PH to exit.
227 |  * (That is, wait for the phaser_exit calls corresponding to any
228 |  * unpaired phaser_enter calls on PH.)  This routine is *not*
229 |  * async-signal-safe.  Do not call it while the current thread is PH's
230 |  * critical region.  phaser_drain may or may not wait for the end of
231 |  * some critical regions that begin while a phaser_drain call is in
232 |  * active, but phaser_drain is guaranteed to make forward progress and
233 |  * complete in finite time, assuming critical sections do the same.
234 |  *
235 |  * Callers must serialize phaser_drain calls on a given phaser object.
236 |  * phaser_drain is a full memory barrier and a pthread cancellation
237 |  * point.
238 |  */
239 | void phaser_drain(phaser_t* ph);
240 | 
241 | #ifdef __cplusplus
242 | } // extern "C"
243 | #endif
244 | 


--------------------------------------------------------------------------------
/app/src/main/cpp/sigmux.h:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Copyright 2018-present, Facebook, Inc.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *     http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | /*
 18 |  * The sigmux library provides a central point for cooperative
 19 |  * signal handling in a single process on POSIX systems.
 20 |  *
 21 |  * The POSIX signal API associates signals with handlers for an entire
 22 |  * process, and a given signal can have only one handler.  This
 23 |  * property makes it difficult for distinct components running in a
 24 |  * single process to cooperate.  While a newly-registered signal
 25 |  * handler can forward to a previously-installer handler (many
 26 |  * existing libraries using this approach), this technique requires a
 27 |  * strict nesting of handling installation and uninstallation, making
 28 |  * it impossible in practice to safely remove handlers and unload
 29 |  * components.
 30 |  *
 31 |  * libsigmux provides a central dispatch point for signal handling.
 32 |  * Components can register for signal handler processing and elect to
 33 |  * either handle a given signal or delegate to other handlers.
 34 |  * Components can register and unregister their handlers in arbitrary
 35 |  * order.
 36 |  *
 37 |  */
 38 | 
 39 | #pragma once
 40 | #include <stddef.h>
 41 | #include <stdint.h>
 42 | #include <signal.h>
 43 | #include <setjmp.h>
 44 | 
 45 | #ifdef SIGMUX_BUILD_DSO
 46 | #define SIGMUX_EXPORT __attribute__((visibility("default")))
 47 | #else
 48 | #define SIGMUX_EXPORT
 49 | #endif
 50 | 
 51 | #ifdef __cplusplus
 52 | extern "C" {
 53 | #endif
 54 | 
 55 | struct sigmux_registration;
 56 | 
 57 | enum sigmux_action {
 58 |   SIGMUX_CONTINUE_SEARCH,
 59 |   SIGMUX_CONTINUE_EXECUTION
 60 | };
 61 | 
 62 | struct sigmux_siginfo {
 63 |   int signum;
 64 |   siginfo_t* info;
 65 |   void* context;
 66 | };
 67 | 
 68 | /**
 69 |  * Handle callback for a signal.  See sigmux_add.
 70 |  */
 71 | typedef enum sigmux_action (*sigmux_handler)(
 72 |   struct sigmux_siginfo* siginfo,
 73 |   void* handler_data
 74 | );
 75 | 
 76 | /**
 77 |  * Initialize the library for use with signal signum.  On success,
 78 |  * return 0.  On error, return -1 with errno set.
 79 |  *
 80 |  * sigmux_init installs a signal handler with sigaction.  If a signal
 81 |  * handler is installed when sigmux_init is called, sigmux will invoke
 82 |  * that handler when no sigmux-registered handler opts to handle a
 83 |  * signal.  Do not manually install signal handlers for signum after
 84 |  * calling sigmux_init on signum.  The signal handler is installed
 85 |  * with SA_NODEFER | SA_ONSTACK | SA_RESTART.
 86 |  *
 87 |  * Once initialized, the sigmux library cannot be uninitialized or
 88 |  * removed from memory.
 89 |  *
 90 |  * sigmux_init is idempotent with respect to a given signal number.
 91 |  */
 92 | SIGMUX_EXPORT extern int sigmux_init(
 93 |   int signum
 94 | );
 95 | 
 96 | #define RESET_ORIG_SIGACTION_FLAG (1<<0)
 97 | 
 98 | /**
 99 |  * This forces sigmux to re-init. Before calling sigmux needs to have
100 |  * been called at least once, otherwise this does nothing.
101 |  *
102 |  * You most likely don't need to do this. The main case is to re-init
103 |  * sigaction for the specific signum (similar as sigmux_init).
104 |  * This can happen when some other libraries mess with the sigaction.
105 |  * without letting sigmux know.
106 |  *
107 |  * RESET_ORIG_SIGACTION_FLAG decides whether we should reset the stored
108 |  * original sigaction or replace it with the sigaction currently there.
109 |  */
110 | SIGMUX_EXPORT extern int sigmux_reinit(
111 |  int signum,
112 |  int flags
113 | );
114 | 
115 | /**
116 |  * Exit non-locally from a sigmux handler.  Use this routine instead
117 |  * of longjmp or siglongjmp in order to restore internal sigmux
118 |  * bookkeeping information.  SIGINFO is the signal information passed
119 |  * to the current handler; BUF and VAL are as for regular siglongjmp.
120 |  */
121 | SIGMUX_EXPORT __attribute__((noreturn)) void sigmux_longjmp(
122 |   struct sigmux_siginfo* siginfo,
123 |   sigjmp_buf buf,
124 |   int val
125 | );
126 | 
127 | #define SIGMUX_LOW_PRIORITY (1<<0)
128 | 
129 | /**
130 |  * Register a signal handler with sigmux.  Return a registration
131 |  * cookie on success or NULL with errno set on error.
132 |  *
133 |  * SIGNALS is a set of signals for which to invoke HANDLER.
134 |  * Registration occurs atomically for all signals.  HANDLER is a
135 |  * function to call when a signal in SIGNALS arrives.  HANDLER_DATA is
136 |  * passed to HANDLER along with signal-specific information.
137 |  *
138 |  * Handlers for a given signal are invoked in reverse order of
139 |  * registration.
140 |  *
141 |  * When a signal arrives, sigmux invokes all registered handlers for
142 |  * that signal until one returns SIGMUX_CONTINUE_EXECUTION.  If a
143 |  * handler returns SIGMUX_CONTINUE_EXECUTION, sigmux returns normally
144 |  * from its POSIX signal handler.  If no sigmux handler returns
145 |  * SIGMUX_CONTINUE_EXECUTION, sigmux invokes the signal handler that
146 |  * was in effect when sigmux_init was called on that signal.
147 |  *
148 |  * FLAGS contains zero or more of the SIGMUX_ flag constants above.
149 |  *
150 |  * SIGMUX_LOW_PRIORITY --- try the corresponding handler only after
151 |  * all handlers that did not specify SIGMUX_LOW_PRIORITY returned
152 |  * SIGMUX_CONTINUE_SEARCH.
153 |  *
154 |  * In rare cases, sigmux may re-run handlers that returned
155 |  * SIGMUX_CONTINUE_SEARCH.
156 |  *
157 |  * The caller must have called sigmux_init on each signal number for
158 |  * which a handler is being registered.
159 |  */
160 | SIGMUX_EXPORT struct sigmux_registration* sigmux_register(
161 |   const sigset_t* signals,
162 |   sigmux_handler handler,
163 |   void* handler_data,
164 |   unsigned flags
165 | );
166 | 
167 | /**
168 |  * Unregister a signal handler registered with sigmux_register.
169 |  * REGISTRATION_COOKIE is the value sigmux_register returned.
170 |  */
171 | SIGMUX_EXPORT void sigmux_unregister(
172 |   struct sigmux_registration* registration_cookie
173 | );
174 | 
175 | /**
176 |  * Like sigaction(2), but operates on the next-signal handlers instead
177 |  * of the current one.  This routine is useful either as a drop-in
178 |  * replacement for sigaction(2) or as a forced replacement for
179 |  * sigaction emplaced with LD_PRELOAD or a function hooking library
180 |  * like distract.  Use sigmux_set_real_sigaction to tell sigmux the
181 |  * function to call instead of sigaction.
182 |  */
183 | SIGMUX_EXPORT int sigmux_sigaction(int signum,
184 |                                    const struct sigaction* act,
185 |                                    struct sigaction* oldact);
186 | 
187 | /**
188 |  * Sigmux sigaction implementation.
189 |  */
190 | typedef int (*sigmux_sigaction_function)(
191 |   int signum,
192 |   const struct sigaction* act,
193 |   struct sigaction* oldact);
194 | 
195 | #define SIGMUX_SIGACTION_DEFAULT NULL
196 | 
197 | /**
198 |  * Tell sigmux to call REAL_SIGACTION intead of the default
199 |  * sigaction(2).  This routine is useful then using a hooking facility
200 |  * to redirect the default operating system sigaction(2) to
201 |  * sigmux_sigaction.  If SIGMUX_SIGACTION_DEFAULT is specified, call
202 |  * the default function.  Return the previous sigaction handler.
203 |  *
204 |  * N.B. We provide this method instead of just using the rt_sigaction
205 |  * system call so that we properly integrate with someone who's hooked
206 |  * sigaction before we did, e.g., libsigchain in Android's
207 |  * ART runtime.
208 |  */
209 | SIGMUX_EXPORT sigmux_sigaction_function sigmux_set_real_sigaction(
210 |   sigmux_sigaction_function real_sigaction);
211 | 
212 | /**
213 |  * Consider handlers registered with normal priority.
214 |  */
215 | #define SIGMUX_HANDLE_SIGNAL_NORMAL_PRIORITY (1<<0)
216 | 
217 | /**
218 |  * Consider handlers registered at low priority
219 |  */
220 | #define SIGMUX_HANDLE_SIGNAL_LOW_PRIORITY (1<<1)
221 | 
222 | /**
223 |  * Invoke the original signal handler
224 |  */
225 | #define SIGMUX_HANDLE_SIGNAL_INVOKE_DEFAULT (1<<2)
226 | 
227 | /**
228 |  * Signal handler exposed directly; useful for callers that hook other
229 |  * signal handler wrappers.  SIGNUM, INFO, and CONTEXT are as for
230 |  * siginfo(2).  FLAGS tells us how to handle the signal and is zero or
231 |  * more of the SIGMUX_HANDLE_SIGNAL_* constants.  Return what we did
232 |  * with the signal.
233 |  */
234 | SIGMUX_EXPORT enum sigmux_action sigmux_handle_signal(
235 |   int signum,
236 |   siginfo_t* info,
237 |   void* context,
238 |   int flags);
239 | 
240 | 
241 | #ifdef __cplusplus
242 | } // extern "C"
243 | #endif
244 | 


--------------------------------------------------------------------------------
/app/src/main/cpp/phaser.c:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Copyright 2018-present, Facebook, Inc.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *     http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | #include <unistd.h>
 18 | #include <stdio.h>
 19 | #include <stdlib.h>
 20 | #include <string.h>
 21 | #include <assert.h>
 22 | #include <stdbool.h>
 23 | #include <errno.h>
 24 | #include <limits.h>
 25 | #include <sys/syscall.h>
 26 | #include <pthread.h>
 27 | #include "phaser.h"
 28 | 
 29 | #if PHASER_STRATEGY == STRATEGY_FUTEX
 30 | #include <linux/futex.h>
 31 | #endif
 32 | 
 33 | //
 34 | // Fundamentally, Phaser is an RCU facility.  A basic understanding of
 35 | // Linux kernel RCU is helpful, but not necessary, for the discussion
 36 | // below.  What RCU calls "read-side critical sections", we just call
 37 | // "critical sections".
 38 | //
 39 | // Phaser allows arbitrary threads to enter "critical sections" (to
 40 | // borrow RCU terminology) using phaser_enter and exit them with
 41 | // phaser_exit.  The purpose of phaser_drain is to wait for the
 42 | // termination of all critical sections that were active at the
 43 | // instant phaser_drain began executing.
 44 | //
 45 | // Entry and exit from critical sections needs to be fast,
 46 | // non-blocking, and completely reentrant.  Note that we need to be
 47 | // able to enter a critical section from *inside* phaser_drain, as
 48 | // arbitrary signals can arrive during phaser_drain calls.
 49 | //
 50 | // We optimize for critical sections, since they're much more common
 51 | // than phaser_drain calls.  In the common case, phaser_enter is an
 52 | // atomic increment and phaser_exit is an atomic decrement.  It's only
 53 | // when phaser_drain is running that we need something more complex.
 54 | //
 55 | // Normally, phaser_enter just increments one of the counter values,
 56 | // but if it finds the counter's high bit (the DRAINING bit) set, we
 57 | // try incrementing another counter instead.  phaser_drain guarantees
 58 | // that at most one counter has a DRAINING bit set, so phaser_enter
 59 | // will always be able to find a counter to increment.
 60 | //
 61 | // phaser_exit decrements the counter phaser_enter incremented.  If
 62 | // the DRAINING bit is set on the counter after increment and the
 63 | // counter has reached COUNT_DRAINED (which is (DRAINING | 0)), make a
 64 | // FUTEX_WAKE system call so that phaser_drain knows it's safe to
 65 | // continue.
 66 | //
 67 | // phaser_drain itself: at the start, from the perspective of the
 68 | // thread running phaser_drain, we don't know anything about the
 69 | // values of our counters, except that none of them has the DRAINING
 70 | // bit set.  We walk through all our counters and drain them by
 71 | // setting the DRAINING bit and FUTEX_WAITing for them to go to
 72 | // COUNT_DRAINED.  We make sure to drain only one counter at a time,
 73 | // so phaser_enter will always be able to make progress; it just might
 74 | // have to settle for its second choice of counter.
 75 | //
 76 | // Architecture notes: on ARM, we only have single-word CAS available,
 77 | // so any solution to the problem that involves CAS on double-word
 78 | // values won't work.  We try to distribute cacheline updates across
 79 | // different cache lines; doing that improves benchmarks by 25% or so.
 80 | //
 81 | // An earlier version of this code distributed the counts across cache
 82 | // lines and was able to speed up a four-thread benchmark by 50%.  A
 83 | // factor of two speedup wasn't worth the significant additional
 84 | // complexity.
 85 | //
 86 | // (If the implementation seems trivial, that's because it is:
 87 | // most of the work is proving that the trivial implementation
 88 | // is correct.
 89 | //
 90 | 
 91 | #define ARRAY_SIZE(x) (sizeof ((x)) / sizeof ((x)[0]))
 92 | 
 93 | #define SIZE_T_HIGH_BIT (SIZE_MAX - (SIZE_MAX >> 1))
 94 | static const size_t DRAINING = SIZE_T_HIGH_BIT;
 95 | static const size_t COUNT_DRAINED = SIZE_T_HIGH_BIT | 0;
 96 | 
 97 | #define likely(x)       __builtin_expect((x),1)
 98 | #define unlikely(x)     __builtin_expect((x),0)
 99 | 
100 | #if PHASER_STRATEGY == STRATEGY_FUTEX
101 | static int
102 | phaser_futex(void* uaddr, int op, int val,
103 |              const struct timespec* timeout,
104 |              int* uaddr2,
105 |              int val3)
106 | {
107 |   return syscall(__NR_futex, uaddr, op, val, timeout, uaddr2, val3);
108 | }
109 | #endif
110 | 
111 | int
112 | phaser_init(phaser_t* ph)
113 | {
114 |   memset(ph->counter, 0, sizeof (ph->counter));
115 | #if PHASER_STRATEGY == STRATEGY_PIPE
116 |   int success = pipe(ph->counter_pipe);
117 |   if (success != 0) {
118 |     return -1;
119 |   }
120 | #endif
121 |   return 0;
122 | }
123 | 
124 | void
125 | phaser_destroy(phaser_t* ph)
126 | {
127 | #if PHASER_STRATEGY == STRATEGY_PIPE
128 |   close(ph->counter_pipe[0]);
129 |   close(ph->counter_pipe[1]);
130 | #endif
131 | }
132 | 
133 | static bool
134 | phaser_counter_try_inc(size_t* counter)
135 | {
136 |   // N.B. It's very important to try reading the value and test for
137 |   // the DRAINING bit _before_ trying to increment the value.  If we
138 |   // don't, we live-lock once a sufficient number of threads pound on
139 |   // a DRAINING counter and never let it actually reach COUNT_DRAINED.
140 | 
141 |   if (unlikely(__atomic_load_n(counter, __ATOMIC_RELAXED) & DRAINING)) {
142 |     return false;
143 |   }
144 | 
145 |   // Use increment, not CAS: XADD is much faster than CMPXCHG on x86,
146 |   // and on ARM it doesn't make a difference.  We can tolerate the
147 |   // race, as explained below.
148 | 
149 |   __atomic_add_fetch(counter, 1, __ATOMIC_RELAXED);
150 | 
151 |   // No need to check incremented value.  Yes, phaser_drain races
152 |   // against phaser_enter's check of the DRAINING bit, but we
153 |   // consciously check DRAINING _before_ atomically incrementing the
154 |   // counter, knowing that phaser_drain might set DRAINING between the
155 |   // time of check and time of increment.  That's okay: we'll go on to
156 |   // decrement the counter, and this race can happen only a small
157 |   // number of times.
158 | 
159 |   return true;
160 | }
161 | 
162 | phaser_phase
163 | phaser_enter(phaser_t* ph)
164 | {
165 |   phaser_phase nr_phases = ARRAY_SIZE(ph->counter);
166 |   phaser_phase phase = 0;
167 | 
168 |   while (!phaser_counter_try_inc(&ph->counter[phase])) {
169 |     phase = (phase + 1) & (nr_phases - 1);
170 |   }
171 | 
172 |   __atomic_thread_fence(__ATOMIC_SEQ_CST);
173 |   return phase;
174 | }
175 | 
176 | void
177 | phaser_exit(phaser_t* ph, phaser_phase phase)
178 | {
179 |   size_t* counter;
180 |   size_t value;
181 |   int ret;
182 | 
183 |   __atomic_thread_fence(__ATOMIC_SEQ_CST);
184 | 
185 |   counter = &ph->counter[phase];
186 |   value = __atomic_add_fetch(counter, -1, __ATOMIC_RELAXED);
187 |   if (unlikely(value == COUNT_DRAINED)) {
188 | #if PHASER_STRATEGY == STRATEGY_FUTEX
189 |     /* Using INT_MAX here is an abundance of caution. The API contract
190 |        limits us to one waiter. */
191 |     ret = phaser_futex(counter, FUTEX_WAKE, INT_MAX, NULL, NULL, 0);
192 |     assert(ret != -1);
193 |     (void) ret;
194 | #elif PHASER_STRATEGY == STRATEGY_PIPE
195 |     /* up our "semaphore" */
196 |     char buf = '\0';
197 |     int old_errno = errno;
198 |     do {
199 |       ret = write(ph->counter_pipe[1], &buf, 1);
200 |       if (ret == -1) {
201 |         assert(errno == EINTR);
202 |       }
203 |     } while (ret == -1);
204 |     errno = old_errno;
205 | #else
206 | #error "Unknown phaser strategy"
207 | #endif
208 |   }
209 | }
210 | 
211 | static void
212 | phaser_drain_counter(phaser_t* ph, phaser_phase phase)
213 | {
214 |   size_t* counter = &ph->counter[phase];
215 |   size_t value;
216 | 
217 |   value = __atomic_or_fetch(counter, DRAINING, __ATOMIC_RELEASE);
218 | #if PHASER_STRATEGY == STRATEGY_FUTEX
219 |   while (value != COUNT_DRAINED) {
220 |     if (phaser_futex(counter, FUTEX_WAIT, value, NULL, NULL, 0) == -1) {
221 |       assert(errno == EWOULDBLOCK || errno == EINTR);
222 |     }
223 | 
224 |     __atomic_load(counter, &value, __ATOMIC_RELAXED);
225 |   }
226 | 
227 | #elif PHASER_STRATEGY == STRATEGY_PIPE
228 |   if (value != COUNT_DRAINED) {
229 |     /* down our "semaphore" */
230 |     int ret;
231 |     char junk;
232 |     do {
233 |       ret = read(ph->counter_pipe[0], &junk, 1);
234 |     } while (ret < 0 && errno == EINTR);
235 |     assert(ret == 1);
236 |   }
237 | #else
238 | #error "Unknown phaser strategy"
239 | #endif
240 |   __atomic_and_fetch(counter, ~DRAINING, __ATOMIC_RELAXED);
241 | }
242 | 
243 | void
244 | phaser_drain(phaser_t* ph)
245 | {
246 |   for (phaser_phase i = 0; i < ARRAY_SIZE(ph->counter); ++i) {
247 |     phaser_drain_counter(ph, i);
248 |     __atomic_thread_fence(__ATOMIC_SEQ_CST);
249 |   }
250 | }
251 | 


--------------------------------------------------------------------------------
/app/src/main/cpp/sigmux.c:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Copyright 2018-present, Facebook, Inc.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *     http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | #include <stdlib.h>
 18 | #include <pthread.h>
 19 | #include <string.h>
 20 | #include <assert.h>
 21 | #include <stdbool.h>
 22 | #include <errno.h>
 23 | 
 24 | #include "sigmux.h"
 25 | #include "phaser.h"
 26 | 
 27 | #ifndef USE_RT_SIGPROCMASK
 28 | # if defined(__linux__) && defined(__ANDROID__)
 29 | #  define USE_RT_SIGPROCMASK 1
 30 | # else
 31 | #  define USE_RT_SIGPROCMASK 0
 32 | # endif
 33 | #endif
 34 | 
 35 | #if USE_RT_SIGPROCMASK
 36 | # include "linux_syscall_support.h"
 37 | #endif
 38 | 
 39 | #define ARRAY_SIZE(a) ((sizeof ((a)) / (sizeof ((a)[0]))))
 40 | static inline bool verify_dummy(bool b) {return b;}
 41 | #ifdef NDEBUG
 42 | #define VERIFY(e) verify_dummy((e))
 43 | #else
 44 | #define VERIFY(e) (assert((e)), verify_dummy(true))
 45 | #endif
 46 | 
 47 | // Cast from part of a structure to the whole thing.  Identical to the
 48 | // Linux kernel container_of macro.
 49 | #define container_of(ptr, type, member) ({                      \
 50 |       const typeof( ((type *)0)->member ) *__mptr = (ptr);      \
 51 |       (type *)( (char *)__mptr - offsetof(type,member) );       \
 52 |     })
 53 | 
 54 | struct sigmux_siginfo_internal {
 55 |   struct sigmux_siginfo public;
 56 |   phaser_phase phase;
 57 | };
 58 | 
 59 | // N.B. concurrent readers may only iterate over the list in the
 60 | // forward direction.  Access to prev pointers requires callers to
 61 | // hold the modification mutex.
 62 | 
 63 | struct sigmux_registration_link {
 64 |   struct sigmux_registration_link* prev;
 65 |   struct sigmux_registration_link* next;
 66 | };
 67 | 
 68 | struct sigmux_registration {
 69 |   struct sigmux_registration_link link;
 70 |   sigset_t signals;
 71 |   sigmux_handler handler;
 72 |   void* handler_data;
 73 |   unsigned flags;
 74 | };
 75 | 
 76 | // Use uint8_t and own bit-set structure instead of sigset_t for
 77 | // sigmux_global.initsig.  This way, the debugger doesn't have to
 78 | // understand the implementation of sigset_t.
 79 | struct sigmux_sigset {
 80 |   uint8_t s[(NSIG+7)/8];
 81 | };
 82 | 
 83 | // N.B. Not static --- we want to be able to find this symbol using
 84 | // gdb.lookup_global_symbol.  We use -fvisibility=hidden, so this
 85 | // symbol still isn't exposed to other DSOs.
 86 | struct sigmux_global {
 87 |   pthread_mutex_t lock;
 88 |   phaser_t phaser;
 89 |   int phaser_needs_init;
 90 |   struct sigaction* orig_sigact[NSIG];
 91 |   struct sigaction* alt_sigact[NSIG];
 92 |   struct sigmux_registration_link handlers;
 93 |   sigmux_sigaction_function real_sigaction;
 94 |   struct sigmux_sigset initsig;
 95 | } sigmux_global = {
 96 |   .lock = PTHREAD_MUTEX_INITIALIZER,
 97 |   .phaser = PHASER_UNINITIALIZED,
 98 |   .phaser_needs_init = 1,
 99 |   .handlers = { &sigmux_global.handlers, &sigmux_global.handlers },
100 | };
101 | 
102 | #ifdef __ANDROID__
103 | static const sigset_t no_signals;
104 | #endif
105 | 
106 | static int
107 | invoke_real_sigaction(int signum,
108 |                  const struct sigaction* act,
109 |                  struct sigaction* oldact)
110 | {
111 |   return (sigmux_global.real_sigaction ?: sigaction)(signum, act, oldact);
112 | }
113 | 
114 | static int
115 | sigmux_sigismember(const struct sigmux_sigset* ss, int signum)
116 | {
117 |   if (!(0 < signum && signum < NSIG)) {
118 |     errno = EINVAL;
119 |     return -1;
120 |   }
121 | 
122 |   return !!(ss->s[signum/8] & (1<<(signum % 8)));
123 | }
124 | 
125 | static void
126 | sigmux_sigaddset(struct sigmux_sigset* ss, int signum)
127 | {
128 |   ss->s[signum/8] |= (1<<(signum % 8));
129 | }
130 | 
131 | /**
132 |  * Is this signal fatal when configured for SIG_DFL?
133 |  */
134 | static bool
135 | signal_default_fatal_p(int signum)
136 | {
137 |   switch (signum) {
138 |     case SIGCHLD:
139 |     case SIGWINCH:
140 |       return false;
141 |     default:
142 |       return true;
143 |   }
144 | }
145 | 
146 | /**
147 |  * Is this signal fatal when configured for SIG_IGN?
148 |  */
149 | static bool
150 | signal_always_fatal_p(int signum)
151 | {
152 |   switch (signum) {
153 |     case SIGSEGV:
154 |     case SIGBUS:
155 |     case SIGABRT:
156 |     case SIGILL:
157 |       return true;
158 |     default:
159 |       return false;
160 |   }
161 | }
162 | 
163 | /* Clang does not have noclone. */
164 | #ifdef __clang__
165 | #pragma clang diagnostic push
166 | #pragma clang diagnostic ignored "-Wunknown-attributes"
167 | #endif
168 | /**
169 |  * The debugger sets a breakpoint here to run code when sigmux has run
170 |  * out of signal-handling options and is about to die horribly.
171 |  */
172 | __attribute__((noinline,noclone))
173 | void // Not static!
174 | sigmux_gdbhook_on_fatal_signal(siginfo_t* info, void* context)
175 | {
176 |   /* Noop: debugger sets breakpoint here */
177 |   (void) info;
178 |   (void) context;
179 |   asm volatile ("");
180 | }
181 | 
182 | /**
183 |  * The debugger sets a breakpoint here to run code after sigmux has
184 |  * taken over responsibility for a signal.
185 |  */
186 | __attribute__((noinline,noclone))
187 | void // Not static!
188 | sigmux_gdbhook_on_signal_seized(void)
189 | {
190 |   /* Noop: debugger sets breakpoint here */
191 |   asm volatile ("");
192 | }
193 | 
194 | #ifdef __clang__
195 | #pragma clang diagnostic pop
196 | #endif
197 | 
198 | static void
199 | set_signal_handler_to_default(int signum)
200 | {
201 | #if USE_RT_SIGPROCMASK
202 |   // sigchain has a bug in Android 5.0.x where it ignores attempts to
203 |   // reset to SIG_DFL; just use the system call directly in this case.
204 |   struct kernel_sigaction sa;
205 |   memset(&sa, 0, sizeof(sa));
206 |   sys_sigemptyset(&sa.sa_mask);
207 |   sa.sa_handler_ = SIG_DFL;
208 |   sa.sa_flags = SA_RESTART;
209 |   sys_rt_sigaction(signum, &sa, NULL, sizeof(struct kernel_sigset_t));
210 | #else
211 |   struct sigaction sa;
212 |   memset(&sa, 0, sizeof (sa));
213 |   sa.sa_handler = SIG_DFL;
214 |   sa.sa_flags = SA_RESTART;
215 |   invoke_real_sigaction(signum, &sa, NULL);
216 | #endif
217 | }
218 | 
219 | static void
220 | set_sigmask_for_handler(const struct sigaction* action, int signum)
221 | {
222 |   sigset_t new_mask;
223 |   memcpy(&new_mask, &action->sa_mask, sizeof (sigset_t));
224 |   if ((action->sa_flags & SA_NODEFER) == 0) {
225 |     sigaddset(&new_mask, signum);
226 |   }
227 |   sigprocmask(SIG_SETMASK, &new_mask, NULL);
228 | }
229 | 
230 | static void
231 | invoke_sighandler(const struct sigaction* action,
232 |                   int signum,
233 |                   siginfo_t* info,
234 |                   void* context)
235 | {
236 |   if (signal_always_fatal_p(signum)) {
237 |     sigmux_gdbhook_on_fatal_signal(info, context);
238 |   }
239 | 
240 |   // N.B. We don't need to restore the signal mask, since returning
241 |   // normally from the signal handler will do it for us.  If the
242 |   // signal handler returns non-locally, it has the burden of
243 |   // resetting the signal mask whether it's being called by the kernel
244 |   // directly or by us.
245 |   //
246 |   // Also note that the default action of any signal is to either do
247 |   // nothing, bring down the process, or stop the process.
248 | 
249 |   bool is_siginfo = (action->sa_flags & SA_SIGINFO);
250 |   bool is_default = is_siginfo
251 |     ? action->sa_sigaction == NULL
252 |     : action->sa_handler == SIG_DFL;
253 |   bool is_ignore = !is_siginfo && action->sa_handler == SIG_IGN;
254 | 
255 |   if (is_siginfo && !is_default && !is_ignore) {
256 |     set_sigmask_for_handler(action, signum);
257 |     action->sa_sigaction(signum, info, context);
258 |   } else if (!is_siginfo && !is_default && !is_ignore) {
259 |     set_sigmask_for_handler(action, signum);
260 |     action->sa_handler(signum);
261 |   } else if (signal_always_fatal_p(signum) ||
262 |              (is_default && signal_default_fatal_p(signum)))
263 |   {
264 |     sigset_t to_unblock;
265 |     set_signal_handler_to_default(signum);
266 |     sigemptyset(&to_unblock);
267 |     sigaddset(&to_unblock, signum);
268 |     sigprocmask(SIG_UNBLOCK, &to_unblock, NULL);
269 |     raise(signum);
270 |     abort();
271 |   } else if (is_default && (signum == SIGTSTP ||
272 |                             signum == SIGTTIN ||
273 |                             signum == SIGTTOU))
274 |   {
275 |     raise(SIGSTOP);
276 |   }
277 | }
278 | 
279 | void
280 | sigmux_longjmp(
281 |   struct sigmux_siginfo* public_siginfo,
282 |   sigjmp_buf buf,
283 |   int val)
284 | {
285 |   struct sigmux_siginfo_internal* siginfo =
286 |     container_of(public_siginfo,
287 |                  struct sigmux_siginfo_internal,
288 |                  public);
289 | 
290 |   phaser_exit(&sigmux_global.phaser, siginfo->phase);
291 |   siglongjmp(buf, val);
292 | }
293 | 
294 | enum sigmux_action
295 | sigmux_handle_signal(
296 |   int signum,
297 |   siginfo_t* info,
298 |   void* context,
299 |   int flags)
300 | {
301 |   struct sigmux_registration* reg;
302 |   struct sigmux_registration_link* it;
303 |   struct sigmux_registration_link* reglist;
304 | 
305 |   enum sigmux_action action;
306 |   struct sigmux_siginfo_internal siginfo = {
307 |     .public = {
308 |       .signum = signum,
309 |       .info = info,
310 |       .context = context,
311 |     },
312 | 
313 |     .phase = phaser_enter(&sigmux_global.phaser),
314 |   };
315 | 
316 |   // __ATOMIC_RELAXED is fine: phaser_enter is a memory barrier.
317 |   reglist = __atomic_load_n(&sigmux_global.handlers.next, __ATOMIC_RELAXED);
318 |   action = SIGMUX_CONTINUE_SEARCH;
319 | 
320 |   if ((flags & SIGMUX_HANDLE_SIGNAL_NORMAL_PRIORITY)) {
321 |     for (it = reglist;
322 |          it != &sigmux_global.handlers && action == SIGMUX_CONTINUE_SEARCH;
323 |          it = it->next)
324 |     {
325 |       reg = container_of(it, struct sigmux_registration, link);
326 |       if ((reg->flags & SIGMUX_LOW_PRIORITY) == 0 &&
327 |           sigismember(&reg->signals, signum))
328 |       {
329 |         action = reg->handler(&siginfo.public, reg->handler_data);
330 |       }
331 |     }
332 |   }
333 | 
334 |   if ((flags & SIGMUX_HANDLE_SIGNAL_LOW_PRIORITY)) {
335 |     for (it = reglist;
336 |          it != &sigmux_global.handlers && action == SIGMUX_CONTINUE_SEARCH;
337 |          it = it->next)
338 |     {
339 |       reg = container_of(it, struct sigmux_registration, link);
340 |       if ((reg->flags & SIGMUX_LOW_PRIORITY) != 0 &&
341 |           sigismember(&reg->signals, signum))
342 |       {
343 |         action = reg->handler(&siginfo.public, reg->handler_data);
344 |       }
345 |     }
346 |   }
347 | 
348 |   // We need to copy the next handler to local storage _before_ we end
349 |   // the phase, then use this local storage in invoke_sighandler.
350 |   // If we just used the default sighandler directly, we'd race with
351 |   // concurrent callers to sigmux_sigaction.  We can't just end the
352 |   // phase after we call invoke_sighandler, because invoke_sighandler
353 |   // may return non-locally.  For the same reason, we can't just
354 |   // protect orig_sigact with a lock.
355 | 
356 |   struct sigaction next_handler;
357 | 
358 |   if ((flags & SIGMUX_HANDLE_SIGNAL_INVOKE_DEFAULT) &&
359 |       action == SIGMUX_CONTINUE_SEARCH) {
360 |     struct sigaction* next_handler_snapshot =
361 |       __atomic_load_n(&sigmux_global.orig_sigact[signum], __ATOMIC_CONSUME);
362 |     next_handler = *next_handler_snapshot;
363 |     // For one-shot signal handlers, we execute the action only once,
364 |     // so let threads compete to see who can set sa_handler (or
365 |     // sa_sigaction) to NULL first.  If we win, the CAS succeeds and
366 |     // sa_handler (or sa_sigaction) ends up with the handler to
367 |     // execute.  If we lose, it ends up with SIG_DFL (or NULL), which
368 |     // tells us to ignore the signal in invoke_sighandler.
369 |     if (next_handler.sa_flags & SA_RESETHAND) {
370 |       if (next_handler.sa_flags & SA_SIGINFO) {
371 |         (void) __atomic_compare_exchange_n(&next_handler_snapshot->sa_handler,
372 |                                            &next_handler.sa_handler,
373 |                                            SIG_DFL,
374 |                                            true,
375 |                                            __ATOMIC_RELAXED,
376 |                                            __ATOMIC_RELAXED);
377 |       } else {
378 |         (void) __atomic_compare_exchange_n(&next_handler_snapshot->sa_sigaction,
379 |                                            &next_handler.sa_sigaction,
380 |                                            NULL,
381 |                                            true,
382 |                                            __ATOMIC_RELAXED,
383 |                                            __ATOMIC_RELAXED);
384 | 
385 |       }
386 |       // Don't bother going through this process next time.
387 |       next_handler_snapshot->sa_flags &= ~SA_RESETHAND;
388 |     }
389 |   }
390 | 
391 |   phaser_exit(&sigmux_global.phaser, siginfo.phase);
392 | 
393 |   if ((flags & SIGMUX_HANDLE_SIGNAL_INVOKE_DEFAULT) &&
394 |       action == SIGMUX_CONTINUE_SEARCH) {
395 |     invoke_sighandler(&next_handler, signum, info, context);
396 |     action = SIGMUX_CONTINUE_EXECUTION;
397 |   }
398 | 
399 |   return action;
400 | }
401 | 
402 | static void
403 | sigmux_handle_signal_1(
404 |   int signum,
405 |   siginfo_t* info,
406 |   void* context)
407 | {
408 | #ifdef __ANDROID__
409 |   // Depending on Android version, sigchain can call us with any
410 |   // random signal mask set despite our asking for no blocked signals
411 |   // and our using SA_NODEFER.  Reset the signal mask explicitly.
412 |   sigprocmask(SIG_SETMASK, &no_signals, NULL);
413 | #endif
414 |   (void) sigmux_handle_signal(
415 |     signum,
416 |     info,
417 |     context,
418 |     ( SIGMUX_HANDLE_SIGNAL_NORMAL_PRIORITY |
419 |       SIGMUX_HANDLE_SIGNAL_LOW_PRIORITY |
420 |       SIGMUX_HANDLE_SIGNAL_INVOKE_DEFAULT ));
421 | }
422 | 
423 | static struct sigaction*
424 | allocate_sigaction(struct sigaction** sap)
425 | {
426 |   if (*sap == NULL) {
427 |     *sap = calloc(1, sizeof (**sap));
428 |   }
429 |   return *sap;
430 | }
431 | 
432 | int
433 | sigmux_init(int signum)
434 | {
435 |   int ismem;
436 |   struct sigaction newact;
437 |   int ret = -1;
438 | 
439 |   VERIFY(0 == pthread_mutex_lock(&sigmux_global.lock));
440 |   if (sigmux_global.phaser_needs_init) {
441 |     if (phaser_init(&sigmux_global.phaser) != 0) {
442 |       goto out;
443 |     }
444 |     sigmux_global.phaser_needs_init = 0;
445 |   }
446 |   ismem = sigmux_sigismember(&sigmux_global.initsig, signum);
447 |   if (ismem == -1) {
448 |     goto out;
449 |   }
450 | 
451 |   if (ismem == 0) {
452 | 
453 |     struct sigaction* orig_sigact =
454 |       allocate_sigaction(&sigmux_global.orig_sigact[signum]);
455 |     if (orig_sigact == NULL) {
456 |       goto out;
457 |     }
458 | 
459 |     // Pre-allocate spare memory for sigmux_sigaction, since it isn't
460 |     // allowed to fail with ENOMEM.
461 |     if (allocate_sigaction(&sigmux_global.alt_sigact[signum]) == NULL) {
462 |       goto out;
463 |     }
464 | 
465 |     memset(&newact, 0, sizeof (newact));
466 |     newact.sa_sigaction = sigmux_handle_signal_1;
467 |     newact.sa_flags = SA_NODEFER | SA_SIGINFO | SA_ONSTACK | SA_RESTART;
468 |     if (invoke_real_sigaction(signum, &newact, orig_sigact) != 0) {
469 |       goto out;
470 |     }
471 | 
472 |     sigmux_sigaddset(&sigmux_global.initsig, signum);
473 |     __atomic_signal_fence(__ATOMIC_SEQ_CST);
474 |     sigmux_gdbhook_on_signal_seized();
475 |   }
476 | 
477 |   ret = 0;
478 | 
479 |   out:
480 | 
481 |   VERIFY(0 == pthread_mutex_unlock(&sigmux_global.lock));
482 |   return ret;
483 | }
484 | 
485 | int
486 | sigmux_reinit(int signum, int flags)
487 | {
488 |   int ismem;
489 |   struct sigaction reinitact;
490 |   int ret = -1;
491 | 
492 |   VERIFY(0 == pthread_mutex_lock(&sigmux_global.lock));
493 | 
494 |   ismem = sigmux_sigismember(&sigmux_global.initsig, signum);
495 |   if (ismem == -1) {
496 |     goto out;
497 |   }
498 | 
499 |   // Not inited
500 |   if (ismem == 0) {
501 |     goto out;
502 |   }
503 | 
504 |   struct sigaction* orig_sigaction_tmp =
505 |     (flags & RESET_ORIG_SIGACTION_FLAG) != 0
506 |          ? calloc(1, sizeof(struct sigaction))
507 |          : NULL;
508 | 
509 |   memset(&reinitact, 0, sizeof (reinitact));
510 |   reinitact.sa_sigaction = sigmux_handle_signal_1;
511 |   reinitact.sa_flags = SA_NODEFER | SA_SIGINFO | SA_ONSTACK | SA_RESTART;
512 |   if (invoke_real_sigaction(signum, &reinitact, orig_sigaction_tmp) != 0) {
513 |     goto out;
514 |   }
515 | 
516 |   // Only reset the original sigaction if were asked to
517 |   if (orig_sigaction_tmp != NULL) {
518 |     struct sigaction* old_orig_sigaction = sigmux_global.orig_sigact[signum];
519 |     sigmux_global.orig_sigact[signum] = orig_sigaction_tmp;
520 |     free(old_orig_sigaction);
521 |   }
522 | 
523 |   __atomic_signal_fence(__ATOMIC_SEQ_CST);
524 |   sigmux_gdbhook_on_signal_seized();
525 | 
526 |   ret = 0;
527 | 
528 |   out:
529 | 
530 |   VERIFY(0 == pthread_mutex_unlock(&sigmux_global.lock));
531 |   return ret;
532 | }
533 | 
534 | struct sigmux_registration*
535 | sigmux_register(
536 |   const sigset_t* signals,
537 |   sigmux_handler handler,
538 |   void* handler_data,
539 |   unsigned flags)
540 | {
541 |   struct sigmux_registration* reg;
542 | 
543 |   reg = calloc(1, sizeof (*reg));
544 |   if (reg == NULL) {
545 |     return NULL;
546 |   }
547 | 
548 |   reg->signals = *signals;
549 |   reg->handler = handler;
550 |   reg->handler_data = handler_data;
551 |   reg->flags = flags;
552 | 
553 |   VERIFY(0 == pthread_mutex_lock(&sigmux_global.lock));
554 | 
555 |   // Atomically prepend our handler to the list.  We perform all
556 |   // modification to the list under sigmux_global.lock, so we need
557 |   // only worry about concurrent readers of
558 |   // sigmux_global.handlers.next, who will see either the old
559 |   // sigmux_global.handlers.next or our new one.  __ATOMIC_RELEASE
560 |   // ensures readers see only fully-constructed object.
561 | 
562 |   reg->link.next = sigmux_global.handlers.next;
563 |   reg->link.prev = &sigmux_global.handlers;
564 |   reg->link.next->prev = &reg->link;
565 |   __atomic_store_n(&sigmux_global.handlers.next, &reg->link, __ATOMIC_RELEASE);
566 | 
567 |   VERIFY(0 == pthread_mutex_unlock(&sigmux_global.lock));
568 | 
569 |   return reg;
570 | }
571 | 
572 | void
573 | sigmux_unregister(struct sigmux_registration* registration_cookie)
574 | {
575 |   struct sigmux_registration* reg = registration_cookie;
576 | 
577 |   // Make concurrent readers bypass the handler we're trying to
578 |   // unregister.  Wait for all active readers to complete.  The
579 |   // phaser_drain is a memory barrier, so our write to reg->prev will
580 |   // be visible.
581 |   VERIFY(0 == pthread_mutex_lock(&sigmux_global.lock));
582 |   reg->link.prev->next = reg->link.next;
583 |   reg->link.next->prev = reg->link.prev;
584 |   phaser_drain(&sigmux_global.phaser);
585 |   VERIFY(0 == pthread_mutex_unlock(&sigmux_global.lock));
586 |   free(reg);
587 | }
588 | 
589 | int
590 | sigmux_sigaction(int signum,
591 |                  const struct sigaction* act,
592 |                  struct sigaction* oldact)
593 | {
594 |   VERIFY(0 == pthread_mutex_lock(&sigmux_global.lock));
595 | 
596 |   if (!sigmux_sigismember(&sigmux_global.initsig, signum)
597 |       || signum <= 0 || signum >= NSIG)
598 |   {
599 |     // We're not hooked, so just defer to the original sigaction.
600 |     // Make sure to release the lock before we do so that if
601 |     // real_sigaction is some kind of weird thing that ends up calling
602 |     // back into us, we don't deadlock.
603 |     VERIFY(0 == pthread_mutex_unlock(&sigmux_global.lock));
604 |     return invoke_real_sigaction(signum, act, oldact);
605 |   }
606 | 
607 |   // sigaction(2) is technically isn't allowed to crash if ACT or
608 |   // OLDACT points to invalid memory (it's supposed to fail with
609 |   // EFAULT instead), and we do, but this particular spec violation
610 |   // probably doesn't matter.  (We could use mincore(2) to test the
611 |   // memory, but we could still race with an unmap or mprotect.)
612 | 
613 |   if (oldact != NULL) {
614 |     *oldact = *sigmux_global.orig_sigact[signum];
615 | 
616 |     // If the current handler is a one-shot handler, it may be in an
617 |     // invalid state as a result of how we use atomic CAS to implement
618 |     // SA_RESETHAND.  In this case, munge the returned struct
619 |     // sigaction to make it look like we atomically reset the
620 |     // whole thing.
621 | 
622 |     bool pretend_default =
623 |       ((oldact->sa_flags & SA_SIGINFO) && oldact->sa_sigaction == NULL) ||
624 |       (!(oldact->sa_flags & SA_SIGINFO) && oldact->sa_handler == SIG_DFL);
625 | 
626 |     if (pretend_default) {
627 |       oldact->sa_flags &= ~(SA_RESETHAND | SA_SIGINFO);
628 |       oldact->sa_handler = SIG_DFL;
629 |     }
630 |   }
631 | 
632 |   if (act != NULL) {
633 |     *sigmux_global.alt_sigact[signum] = *act;
634 |     __atomic_exchange(&sigmux_global.orig_sigact[signum],
635 |                       &sigmux_global.alt_sigact[signum],
636 |                       &sigmux_global.alt_sigact[signum],
637 |                       __ATOMIC_RELEASE);
638 |     phaser_drain(&sigmux_global.phaser);
639 |   }
640 | 
641 |   VERIFY(0 == pthread_mutex_unlock(&sigmux_global.lock));
642 |   return 0;
643 | }
644 | 
645 | 
646 | sigmux_sigaction_function
647 | sigmux_set_real_sigaction(sigmux_sigaction_function real_sigaction)
648 | {
649 |   sigmux_sigaction_function old_sigaction;
650 |   VERIFY(0 == pthread_mutex_lock(&sigmux_global.lock));
651 |   old_sigaction = sigmux_global.real_sigaction;
652 |   sigmux_global.real_sigaction = real_sigaction;
653 |   VERIFY(0 == pthread_mutex_unlock(&sigmux_global.lock));
654 |   return old_sigaction;
655 | }
656 | 


--------------------------------------------------------------------------------