实现底层api

最新推荐文章于 2023-03-17 09:30:29 发布
最新推荐文章于 2023-03-17 09:30:29 发布
阅读量203 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lichao890427/article/details/77524693
版权 
//
// Created by lichao26 on 2017/8/16 0016.
//

#include <sys/types.h>
#include <unistd.h>
#include <syscall.h>

#define str(s) #s

#if defined(__arm__) || defined(__i386__)

#if defined(__arm__)
#define linux_syscall_0(syscallnum) {\
    static_assert(sizeof(asm_ret) <= 4, "linux_syscall wrong return size"); \
    asm volatile(                           \
        "PUSH   {R0,R7}\n"                  \
        "MOV    R7, " str(syscallnum) "\n"  \
        "SWI    #0\n"                       \
        "MOV    %[ret_],R0\n"               \
        "POP    {R0,R7}\n"                  \
        :[ret_]"=r"(asm_ret)                \
        :                                   \
        :"r0");                             \
}
#elif defined(__i386__)
#define linux_syscall_0(syscallnum) {\
    static_assert(sizeof(asm_ret) <= 4, "linux_syscall wrong return size"); \
    asm volatile(                           \
        "PUSHL  %%EAX\n"                    \
        "MOVL   $" str(syscallnum) ", %%EAX\n"\
        "INT    $0x80\n"                    \
        "MOVL   %%EAX,%[ret_]\n"            \
        "POPL   %%EAX\n"                    \
        :[ret_]"=r"(asm_ret)                \
        :                                   \
        :);                       \
}
#else
#define linux_syscall_0(syscallnum) static_assert(false, "linux_syscall wrong arch")
#endif

#if defined(__arm__)
#define linux_syscall_1(syscallnum, arg0) {\
    static_assert(sizeof(asm_ret) <= 4, "linux_syscall wrong return size"); \
    asm volatile(                           \
        "PUSH   {R0,R7}\n"                  \
        "MOV    R0, %[arg0_]\n"             \
        "MOV    R7, " str(syscallnum) "\n"  \
        "SWI    #0\n"                       \
        "MOV    %[ret_],R0\n"               \
        "POP    {R0,R7}\n"                  \
        :[ret_]"=r"(asm_ret)                \
        :[arg0_]"r"(arg0)                   \
        :"r0");                             \
}
#elif defined(__i386__)
#define linux_syscall_1(syscallnum, arg0) {\
    static_assert(sizeof(asm_ret) <= 4, "linux_syscall wrong return size"); \
    asm volatile(                           \
        "PUSHL  %%EAX\n"                    \
        "PUSHL  %%EBX\n"                    \
        "MOVL   8(%%EBP),%%EBX\n"           \
        "MOVL   $" str(syscallnum) ",%%EAX\n"\
        "INT    $0x80\n"                    \
        "MOVL   %%EAX,%[ret_]\n"            \
        "POPL   %%EBX\n"                    \
        "POPL   %%EAX\n"                    \
        :[ret_]"=r"(asm_ret)                \
        :                                   \
        :"ebx");                            \
}
#else
#define linux_syscall_1(syscallnum, arg0) static_assert(false, "linux_syscall wrong arch")
#endif

#if defined(__arm__)
#define linux_syscall_2(syscallnum, arg0, arg1) {\
    static_assert(sizeof(asm_ret) <= 4, "linux_syscall wrong return size"); \
    asm volatile(                           \
        "PUSH   {R0-R1,R7}\n"               \
        "MOV    R0, %[arg0_]\n"             \
        "MOV    R1, %[arg1_]\n"             \
        "MOV    R7, " str(syscallnum) "\n"  \
        "SWI    #0\n"                       \
        "MOV    %[ret_],R0\n"               \
        "POP    {R0-R1,R7}\n"               \
        :[ret_]"=r"(asm_ret)                \
        :[arg0_]"r"(arg0), [arg1_]"r"(arg1) \
        :"r0", "r1");                       \
}
#elif defined(__i386__)
#define linux_syscall_2(syscallnum, arg0, arg1) {\
    static_assert(sizeof(asm_ret) <= 4, "linux_syscall wrong return size"); \
    asm volatile(                           \
        "PUSHL  %%EAX\n"                    \
        "PUSHL  %%EBX\n"                    \
        "PUSHL  %%ECX\n"               \
        "MOVL   8(%%EBP),%%EBX\n"           \
        "MOVL  12(%%EBP),%%ECX\n"       \
        "MOVL   $" str(syscallnum) ",%%EAX\n"\
        "INT    $0x80\n"                    \
        "MOVL   %%EAX,%[ret_]\n"            \
        "POPL  %%ECX\n"               \
        "POPL   %%EBX\n"                    \
        "POPL   %%EAX\n"                    \
        :[ret_]"=r"(asm_ret)                \
        :                                   \
        :"ebx", "ecx");                     \
}
#else
#define linux_syscall_2(syscallnum, arg0, arg1) static_assert(false, "linux_syscall wrong arch")
#endif

#if defined(__arm__)
#define linux_syscall_3(syscallnum, arg0, arg1, arg2) {\
    static_assert(sizeof(asm_ret) <= 4, "linux_syscall wrong return size"); \
    asm volatile(                           \
        "PUSH   {R0-R2,R7}\n"               \
        "MOV    R0, %[arg0_]\n"             \
        "MOV    R1, %[arg1_]\n"             \
        "MOV    R2, %[arg2_]\n"             \
        "MOV    R7, " str(syscallnum) "\n"  \
        "SWI    #0\n"                       \
        "MOV    %[ret_],R0\n"               \
        "POP    {R0-R2,R7}\n"               \
        :[ret_]"=r"(asm_ret)                \
        :[arg0_]"r"(arg0), [arg1_]"r"(arg1), [arg2_]"r"(arg2)\
        :"r0", "r1", "r2");                 \
}
#elif defined(__i386__)
#define linux_syscall_3(syscallnum, arg0, arg1, arg2) {\
    static_assert(sizeof(asm_ret) <= 4, "linux_syscall wrong return size"); \
    asm volatile(                           \
        "PUSHL  %%EAX\n"                    \
        "PUSHL  %%EBX\n"                    \
        "PUSHL  %%ECX\n"               \
        "PUSHL %%EDX\n"               \
        "MOVL   8(%%EBP),%%EBX\n"           \
        "MOVL  12(%%EBP),%%ECX\n"       \
        "MOVL  16(%%EBP),%%EDX\n"       \
        "MOVL   $" str(syscallnum) ",%%EAX\n"\
        "INT    $0x80\n"                    \
        "MOVL   %%EAX,%[ret_]\n"            \
        "POPL  %%EDX\n"               \
        "POPL  %%ECX\n"               \
        "POPL   %%EBX\n"                    \
        "POPL   %%EAX\n"                    \
        :[ret_]"=r"(asm_ret)                \
        :                                   \
        :"ebx", "ecx", "edx");              \
}
#else
#define linux_syscall_3(syscallnum, arg0, arg1, arg2) \
    static_assert(false, "linux_syscall wrong arch")
#endif

#if defined(__arm__)
#define linux_syscall_4(syscallnum, arg0, arg1, arg2, arg3) {\
    static_assert(sizeof(asm_ret) <= 4, "linux_syscall wrong return size"); \
    asm volatile(                           \
        "PUSH   {R0-R3,R7}\n"               \
        "MOV    R0, %[arg0_]\n"             \
        "MOV    R1, %[arg1_]\n"             \
        "MOV    R2, %[arg2_]\n"             \
        "MOV    R3, %[arg3_]\n"             \
        "MOV    R7, " str(syscallnum) "\n"  \
        "SWI    #0\n"                       \
        "MOV    %[ret_],R0\n"               \
        "POP    {R0-R3,R7}\n"               \
        :[ret_]"=r"(asm_ret)                \
        :[arg0_]"r"(arg0), [arg1_]"r"(arg1), [arg2_]"r"(arg2), [arg3_]"r"(arg3)\
        :"r0", "r1", "r2", "r3");           \
}
#elif defined(__i386__)
#define linux_syscall_4(syscallnum, arg0, arg1, arg2, arg3) {\
    static_assert(sizeof(asm_ret) <= 4, "linux_syscall wrong return size"); \
    asm volatile(                           \
        "PUSHL  %%EAX\n"                    \
        "PUSHL  %%EBX\n"                    \
        "PUSHL  %%ECX\n"               \
        "PUSHL %%EDX\n"               \
        "PUSHL %%ESI\n"               \
        "MOVL   8(%%EBP),%%EBX\n"           \
        "MOVL  12(%%EBP),%%ECX\n"       \
        "MOVL  16(%%EBP),%%EDX\n"       \
        "MOVL  20(%%EBP),%%ESI\n"       \
        "MOVL   $" str(syscallnum) ",%%EAX\n"\
        "INT    $0x80\n"                    \
        "MOVL   %%EAX,%[ret_]\n"            \
        "POPL  %%ESI\n"               \
        "POPL  %%EDX\n"               \
        "POPL  %%ECX\n"               \
        "POPL   %%EBX\n"                    \
        "POPL   %%EAX\n"                    \
        :[ret_]"=r"(asm_ret)                \
        :                                   \
        :"ebx", "ecx", "edx", "esi");       \
}
#else
#define linux_syscall_4(syscallnum, arg0, arg1, arg2, arg3) \
    static_assert(false, "linux_syscall wrong arch")
#endif

#define _syscall_exit(status) linux_syscall_1(__NR_exit_group, status) // not __NR_exit
#define _syscall_fork() linux_syscall_0(__NR_fork)
#define _syscall_read(fd, buf, count) linux_syscall_3(__NR_read, fd, buf, count)
#define _syscall_write(fd, buf, count) linux_syscall_3(__NR_write, fd, buf, count)
#define _syscall_open(pathname, flags) linux_syscall_2(__NR_open, pathname, flags)
#define _syscall_close(fd) linux_syscall_1(__NR_close, fd)
#define _syscall_unlink(pathname) linux_syscall_1(__NR_unlink, pathname)
#define _syscall_execve(filename, argv, envp) linux_syscall_3(__NR_execve, filename, argv, envp)
#define _syscall_chmod(path, mode) linux_syscall_2(__NR_chmod, path, (int)mode)
#define _syscall_lseek(fd, offset, whence) linux_syscall_3(__NR_lseek, fd, offset, whence)
#define _syscall_getpid() linux_syscall_0(__NR_getpid)
#define _syscall_ptrace(req, pid, addr, data) linux_syscall_4(__NR_ptrace, req, pid, addr, data)
#define _syscall_access(pathname, mode) linux_syscall_2(__NR_access, pathname, (int)mode)
#define _syscall_kill(pid, sig) linux_syscall_2(__NR_kill, pid, sig)
#define _syscall_mkdir(pathname, mode) linux_syscall_2(__NR_mkdir, pathname, (int)mode)
#define _syscall_rmdir(pathname) linux_syscall_1(__NR_rmdir, pathname)
#define _syscall_getppid()  linux_syscall_0(__NR_getppid)
#define _syscall_sigaction(signum, act, oldact) linux_syscall_3(__NR_sigaction, signum, act, oldact)
#define _syscall_symlink(oldpath, newpath) linux_syscall_2(__NR_symlink, oldpath, newpath)
#define _syscall_readlink(path, buf, bufsize) linux_syscall_3(__NR_readlink, path, buf, bufsize)
#define _syscall_stat(path, buf) linux_syscall_2(__NR_stat, path, buf)
#define _syscall_mprotect(addr, len, prot) linux_syscall_3(__NR_mprotect, addr, len, prot)
// callnumber > 255  => MOV R7,num error

void safe_exit(int status) {
    void *asm_ret;
    _syscall_exit(status);
    return;
}

pid_t safe_fork(void) {
    pid_t asm_ret;
    _syscall_fork();
    return asm_ret;
}

ssize_t safe_read(int fd, void *buf, size_t count) {
    ssize_t asm_ret;
    _syscall_read(fd, buf, count);
    return asm_ret;
}

ssize_t safe_write(int fd, const void *buf, size_t count) {
    ssize_t asm_ret;
    _syscall_write(fd, buf, count);
    return asm_ret;
}

int safe_open(const char *pathname, int flags) {
    ssize_t asm_ret;
    _syscall_open(pathname, flags);
    return asm_ret;
}

int safe_close(int fd) {
    int asm_ret;
    _syscall_close(fd);
    return asm_ret;
}

int safe_unlink(const char *pathname) {
    int asm_ret;
    _syscall_unlink(pathname);
    return asm_ret;
}

int safe_execve(const char *filename, char *const argv[], char *const envp[]) {
    int asm_ret;
    _syscall_execve(filename, argv, envp);
    return asm_ret;
}

int safe_chmod(const char *path, mode_t mode) {
    int asm_ret;
    _syscall_chmod(path, mode);
    return asm_ret;
}

off_t safe_lseek(int fd, off_t offset, int whence) {
    off_t asm_ret;
    _syscall_lseek(fd, offset, whence);
    return asm_ret;
}

pid_t safe_getpid() {
    pid_t asm_ret;
    _syscall_getpid();
    return asm_ret;
}

long safe_ptrace(int request, pid_t pid, void *addr, void *data) {
    long asm_ret;
    _syscall_ptrace(request, pid, addr, data);
    return asm_ret;
}

int safe_access(const char *pathname, int mode) {
    int asm_ret;
    _syscall_access(pathname, mode);
    return asm_ret;
}

int safe_kill(pid_t pid, int sig) {
    int asm_ret;
    _syscall_kill(pid, sig);
    return asm_ret;
}

int safe_mkdir(const char *pathname, mode_t mode) {
    int asm_ret;
    _syscall_mkdir(pathname, mode);
    return asm_ret;
}

int safe_rmdir(const char *pathname) {
    int asm_ret;
    _syscall_rmdir(pathname);
    return asm_ret;
}

pid_t safe_getppid() {
    pid_t asm_ret;
    _syscall_getppid();
    return asm_ret;
}

int safe_sigaction(int signum, const struct sigaction *act, struct sigaction *oldact) {
    int asm_ret;
    _syscall_sigaction(signum, act, oldact);
    return asm_ret;
}

int safe_symlink(const char *oldpath, const char *newpath) {
    int asm_ret;
    _syscall_symlink(oldpath, newpath);
    return asm_ret;
}

ssize_t safe_readlink(const char *path, char *buf, size_t bufsize) {
    ssize_t asm_ret;
    _syscall_readlink(path, buf, bufsize);
    return asm_ret;
}

int safe_stat(const char *path, struct stat *buf) {
    int asm_ret;
    _syscall_stat(path, buf);
    return asm_ret;
}

int safe_mprotect(void *addr, size_t len, int prot) {
    int asm_ret;
    _syscall_mprotect(addr, len, prot);
    return asm_ret;
}

#endif
lichao890427
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
APP底层接口API开发
04-28
分组接口、消息群发接口、客服接口、资源接口、二维码接口、短网址接口、标签接口、用户接口，以及微信支付接口
C# 调用底层API实现高精度计时器
06-01
C#通过调用底层API函数利用CUP的时钟实现的高精度计时，计时利用Win32 API 使用 QueryPerformanceCounter() 和 QueryPerformanceFrequency() 方法
Flink学习之路（七）—— ProcessFunction API（底层 API）
weixin_45417821的博客
01-14 243
我们之前学习的转换算子是无法访问事件的时间戳信息和水位线信息的。而这在一些应用场景下，极为重要。例如 MapFunction 这样的 map 转换算子就无法访问时间戳或者当前事件的事件时间。 基于此，DataStream API 提供了一系列的 Low-Level 转换算子。可以访问时间戳、watermark 以及注册定时事件。还可以输出特定的一些事件，例如超时事件等。 Process Function 用来构建事件驱动的应用以及实现自定义的业务逻辑(使用之前的window 函数和转换算子无法实现)。例如，
底层并发 API
Guide_Sun的博客
08-20 950
底层并发 API 这篇文章里，我们将会讨论一些iOS和OS X 都可以使用的底层API. 出了dispatch_once,我们一般不鼓励使用其中的任何一种技术。我们想要揭示出表面之下深层次的一些可利用的方面。这些底层的 API 提供了大量的灵活性，随之而来的是大量的复杂度和更多的责任。在我们的文章常见的后台实践中提到的高层的 API 和模式能够让你专注于手头的任务并且
ProcessFunction API(底层API)
qq_28403781的博客
11-02 584
我们之前学习的转换算子是无法访问事件的时间戳信息和水位线信息的。而这在一些应用场景下，极为重要。例如MapFunction这样的map转换算子就无法访问时间戳或者当前事件的事件时间。 ​ 基于此，DataStream API提供了一系列的Low-Level转换算子。可以访问时间戳、watermark以及注册定时事件。还可以输出特定的一些事件，例如超时事件等。Process Function用来构建事件驱动的应用以及实现自定义的业务逻辑(使用之前的window函数和转换算子无法实现)。例如，FlinkSQL
Flink ProcessFunction API （底层API）
寒暄的博客
03-11 294
Process Function用来构建事件驱动的应用以及实现自定义的业务逻辑，Flink提供了8个Process Function： ProcessFunction ：最原始，自定义程度高，什么都能做 KeyedProcessFunction：keyby后使用得process中传入得Process Function CoProcessFunction：connect后使用得process中传入得Process Function ProcessJoinFunction：两条流Join连接后使用得proce
框架源码 API JAVA
12-17
框架底层源码， 深入学习研究的 最好途径，各种api。各种实现过程
基于 Go 实现的 API server.zip
最新发布
05-24
基于 Go 实现的 API serverGo语言（也称为Golang）是由Google开发的一种静态强类型、编译型的编程语言。它旨在成为一门简单、高效、安全和并发的编程语言，特别适用于构建高性能的服务器和分布式系统。以下是Go语言...
things.py:基于Python的底层API
03-26
物联网Python API 一个简单的Python 3库，用于读取数据。 在可以找到其他一些语言的实现。 目录 安装 $ pip3 install things.py # or $ git clone ...
Api-pytodoist.zip
09-18
它使用更高级别的抽象隐藏了底层的api调用，这使得在python中使用todoist非常容易。,一个api可以被认为是多个软件设备之间通信的指导手册。例如，api可用于web应用程序之间的数据库通信。通过提取实现并将数据放弃到...
Spring AOP：底层API
longhuihu的专栏
12-11 649
上一章介绍了Spring AOP的概念和基本用法，本章探寻SpringAOP更底层API，一窥Spring AOP的实现原理。在使用层面，上一章介绍的知识完全足够了，并不推荐在实际项目中使用本章介绍的API。 本章对应的官方原文档的地址。 PointCut API 通过上一章我们知道，@PoinCut注解可以定义的切点，可在多个通知之间复用。因此在实现层面，切点和通知也是完全解耦的。切点通过接口o...
HTML5 底层API概要
piziliweiguang的专栏
07-29 4527
一、Drag & Drop API 1.创建拖放事件监听程序时，一定要阻止默认行为，尤其是在dragover事件中一定要执行preventDefault()，否则drop事件不会出发，同时dropEffect也不会生效。 2.dataTransfer接口： dataTransfer.effectAllowed[=value] dataTransfer.dropEffect[=value]
CUDA底层驱动API
专注于人工智能领域的小何尚
06-07 1011
驱动程序 API 在 cuda 动态库（ 或 ）中实现，该库在安装设备驱动程序期间复制到系统上。 它的所有入口点都以 cu 为前缀。它是一个基于句柄的命令式 API：大多数对象都由不透明的句柄引用，这些句柄可以指定给函数来操作对象。驱动程序 API 中可用的对象汇总在下表中。在调用驱动程序 API 的任何函数之前，必须使用 初始化驱动程序 API。 然后必须创建一个附加到特定设备的 CUDA 上下文，并使其成为当前调用主机线程，如上下文中所述。在 CUDA 上下文中，内核作为 PTX 或二进制对象由主机代
系统音频系统底层API[转]
xiaojun11的专栏
05-18 1223
Core Audio APIs 的优势：       Windows Vista 、  Windows 7 、  Windows server 2008 等系统 音频系统相比之前的系统有很大的变化，产生了一套新的底层  API 即  Core Audio APIs 。该低层  API 为高层  API( 如  Media Foundation( 将要取代  DirectShow 等高层  A...
从源码刨析java底层API
qq_27528193的博客
09-29 535
【代码】从源码刨析java底层API。
Web API是干什么的？底层原理是什么？
长风破浪会有时的博客
03-17 327
这些接口是通过浏览器底层的JavaScript引擎和浏览器的渲染引擎来实现的。当JavaScript代码通过Web API调用这些接口时，浏览器会根据调用的接口类型和参数，从渲染引擎、网络模块、文件系统等底层模块中调用相应的功能，执行相应的操作，并返回结果给JavaScript代码。例如，当JavaScript代码调用DOM API来操作Web页面中的HTML元素时，浏览器会根据调用的接口类型和参数，从渲染引擎中获取相应的HTML元素，并执行相应的操作，如修改元素属性、插入新元素等。
linux 之 基础API底层执行过程
流年りゅう
11-06 1253
accept建立连接过程三次握手过程中内核的处理流程 阻塞模式接收过程 非阻塞模式接收过程 三次握手过程中内核的处理流程两个队列满了后，新的请求到达了后的处理过程： 若SYN队列满，则会直接丢弃请求 如果ACCEPT队列满，则不会导致放弃连接，也不会把连接从SYN列队中移出 阻塞模式接收过程非阻塞模式接收过程TCP消息发送过程— 内核处理消息发送过程TCP消息接收过程— 内核处理消息发送过程TCP消
pytorch底层api常用复习(2021 summer)
andy dennis的博客
08-14 307
前言 打工人开启… 先熟悉一下pytorch吧，尤其是对张量一些维度上的操作，经常会用到。 熟悉这个操作有利于理解比如提取的表征是怎么处理的。 import torch 张量数据类型 1标量 生成一个两行三列的随机矩阵： a = torch.randn(2, 3) 查看 a 的类型 a.type() 判断a的类型是不是浮点类型的张量。 isinstance(a, torch.FloatTensor) # data = data.cuda() isinstance(a, torch.cuda.Do
uiautomator调用底层api
06-09
UI Automator可以调用底层API来实现更高级的测试，例如使用AccessibilityService类获取应用程序中的元素。以下是一个示例： ``` // 获取系统的AccessibilityManager AccessibilityManager accessibilityManager = ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值