pa_offset = offset & ~(sysconf(_SC_PAGE_SIZE) - 1) 详解

已于 2022-05-24 10:28:17 修改
阅读量1.2k 收藏 3
点赞数
分类专栏： C语言 Linux 文章标签： c语言 c++ 开发语言
于 2021-05-21 20:21:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_36002055/article/details/117134073
版权

发现很多文章都没有把pa_offset = offset & ~(sysconf(_SC_PAGE_SIZE) - 1) 详细计算过程写出来，自己专门计算了一遍，附在文末。本例为man mmap中的原样实例程序，加上了一些额外的无关代码及打印输出信息 让总字节数超过一页大小sysconf(_SC_PAGE_SIZE)以方便查看调试信息

#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define handle_error(msg) \
    do { perror(msg); exit(EXIT_FAILURE); } while (0)

int main(int argc, char *argv[])
{
    char *addr;
    int fd;
    struct stat sb;
    off_t offset, pa_offset;
    size_t length;
    ssize_t s;

    if (argc < 3 || argc > 4) {
        fprintf(stderr, "%s file offset [length]\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    fd = open(argv[1], O_RDONLY);
    if (fd == -1)
        handle_error("open");

    if (fstat(fd, &sb) == -1)           /* To obtain file size */
        handle_error("fstat");

    offset = atoi(argv[2]);
    pa_offset = offset & ~(sysconf(_SC_PAGE_SIZE) - 1);
        /* offset for mmap() must be page aligned */
     if (offset >= sb.st_size) {
        fprintf(stderr, "offset is past end of file\n");
        exit(EXIT_FAILURE);
    }

    if (argc == 4) {
        length = atoi(argv[3]);
        if (offset + length > sb.st_size)
            length = sb.st_size - offset;
                /* Can't display bytes past end of file */

    } else {    /* No length arg ==> display to end of file */
        length = sb.st_size - offset;
    }

    addr = mmap(NULL, length + offset - pa_offset, PROT_READ,
                MAP_PRIVATE, fd, pa_offset);
    if (addr == MAP_FAILED)
        handle_error("mmap");

    printf("length = %ld\n", length);
	printf("offset = %ld\n", offset);
	printf("pa_offset = %ld\n", pa_offset);
	printf("length + offset - pa_offset = %ld\n", length + offset - pa_offset);
    
    s = write(STDOUT_FILENO, addr + offset - pa_offset, length);
    if (s != length) {
        if (s == -1)
            handle_error("write");

        fprintf(stderr, "partial write");
        exit(EXIT_FAILURE);
    }

    munmap(addr, length + offset - pa_offset);
    close(fd);

    exit(EXIT_SUCCESS);
}

//**额外增加的代码开始
//**加上了一些额外的无关代码及打印输出信息 让总字节数超过一页大小sysconf(_SC_PAGE_SIZE)以方便查看调试信息**开始
/* 
#include "head.h"
struct msgbuff{
    long mtype;
    char mtext[512];
};

void send_msg(int qid, int type, char *m_msg, int size){
    struct msgbuff msg;
    msg.mtype = type;
    strcpy(msg.mtext, m_msg);
    if(msgsnd(qid, (void *)&msg, sizeof(msg.mtext), IPC_NOWAIT) == -1){
        perror("msgsnd");
        exit(1);
    } 
}

void get_msg(int qid, int type){
    while (1){
        struct msgbuff msg;
        bzero(&msg, sizeof(msg));//清空缓冲区，也可用memmet实现
        if (msgrcv(qid, (void *)&msg, sizeof(msg.mtext),type, MSG_NOERROR) == -1) {
            perror("msgrcv");
            exit(1);
        }
        printf("抢到了资源: <%d> <%s>\n", type, msg.mtext);

    }
}

int main(int argc, char **argv){
    int opt, mode = 2, msgtype = 1;
    int msgq_id;
    char mtext[512] = {0};
    //mode == 1-> send
    while((opt = getopt(argc, argv, "st:rm:")) != -1){
        switch(opt){
            case 's':
                mode = 1;
                break;
            case 'r':
                mode = 2;
                break;
            case 't':
                msgtype = atoi(optarg);
                break;
            case 'm':
                strcpy(mtext, optarg);
                break;
            default:
                fprintf(stderr, "Usage: %s -[s|r] -t type -m msg\n", argv[0]);
                exit(1);
        }
    }
    //int msgget(key_t key, int msgflg);
    if((msgq_id = msgget(2021, IPC_CREAT | 0666)) < 0){
        perror("msgget");
        exit(1);
    }
    if (mode == 1){
        send_msg(msgq_id, msgtype, mtext, sizeof(mtext));
    } else {
        get_msg(msgq_id, msgtype);
    }

    return 0;
}
// ./a.out -s -t 1 -m "I'm the 1th!"
// ./a.out -r -t 1.msgq.c
// #include "head.h"
struct msgbuff{
    long mtype;
    char mtext[512];
};

void send_msg(int qid, int type, char *m_msg, int size){
    struct msgbuff msg;
    msg.mtype = type;
    strcpy(msg.mtext, m_msg);
    if(msgsnd(qid, (void *)&msg, sizeof(msg.mtext), IPC_NOWAIT) == -1){
        perror("msgsnd");
        exit(1);
    }
}

void get_msg(int qid, int type){
    while (1){
        struct msgbuff msg;
        bzero(&msg, sizeof(msg));//清空缓冲区，也可用memmet实现
        if (msgrcv(qid, (void *)&msg, sizeof(msg.mtext),type, MSG_NOERROR) == -1) {
            perror("msgrcv");
            exit(1);
        }
        printf("抢到了资源: <%d> <%s>\n", type, msg.mtext);

    }
}

int main(int argc, char **argv){
    int opt, mode = 2, msgtype = 1;
    int msgq_id;
    char mtext[512] = {0};
    //mode == 1-> send
    while((opt = getopt(argc, argv, "st:rm:")) != -1){
        switch(opt){
            case 's':
                mode = 1;
                break;
            case 'r':
                mode = 2;
                break;
            case 't':
                msgtype = atoi(optarg);
                break;
            case 'm':
                strcpy(mtext, optarg);
                break;
            default:
                fprintf(stderr, "Usage: %s -[s|r] -t type -m msg\n", argv[0]);
                exit(1);
        }
    }
    //int msgget(key_t key, int msgflg);
    if((msgq_id = msgget(2021, IPC_CREAT | 0666)) < 0){
        perror("msgget");
        exit(1);
    }
    if (mode == 1){
        send_msg(msgq_id, msgtype, mtext, sizeof(mtext));
    } else {
        get_msg(msgq_id, msgtype);
    }

    return 0;
}
// ./a.out -s -t 1 -m "I'm the 1th!"
// ./a.out -r -t 1.msgq.c#include "head.h"
struct msgbuff{
    long mtype;
    char mtext[512];
};

void send_msg(int qid, int type, char *m_msg, int size){
    struct msgbuff msg;
    msg.mtype = type;
    strcpy(msg.mtext, m_msg);
    if(msgsnd(qid, (void *)&msg, sizeof(msg.mtext), IPC_NOWAIT) == -1){
        perror("msgsnd");
        exit(1);
    } 
}

void get_msg(int qid, int type){
    while (1){
        struct msgbuff msg;
        bzero(&msg, sizeof(msg));//清空缓冲区，也可用memmet实现
        if (msgrcv(qid, (void *)&msg, sizeof(msg.mtext),type, MSG_NOERROR) == -1) {
            perror("msgrcv");
            exit(1);
        }
        printf("抢到了资源: <%d> <%s>\n", type, msg.mtext);

    }
}

int main(int argc, char **argv){
    int opt, mode = 2, msgtype = 1;
    int msgq_id;
    char mtext[512] = {0};
    //mode == 1-> send
    while((opt = getopt(argc, argv, "st:rm:")) != -1){
        switch(opt){
            case 's':
                mode = 1;
                break;
            case 'r':
                mode = 2;
                break;
            case 't':
                msgtype = atoi(optarg);
                break;
            case 'm':
                strcpy(mtext, optarg);
                break;
            default:
                fprintf(stderr, "Usage: %s -[s|r] -t type -m msg\n", argv[0]);
                exit(1);
        }
    }
    //int msgget(key_t key, int msgflg);
    if((msgq_id = msgget(2021, IPC_CREAT | 0666)) < 0){
        perror("msgget");
        exit(1);
    }
    if (mode == 1){
        send_msg(msgq_id, msgtype, mtext, sizeof(mtext));
    } else {
        get_msg(msgq_id, msgtype);
    }

    return 0;
}
// ./a.out -s -t 1 -m "I'm the 1th!"
// ./a.out -r -t 1.msgq.c#include "head.h"
struct msgbuff{
    long mtype;
    char mtext[512];
};

void send_msg(int qid, int type, char *m_msg, int size){
    struct msgbuff msg;
    msg.mtype = type;
    strcpy(msg.mtext, m_msg);
    if(msgsnd(qid, (void *)&msg, sizeof(msg.mtext), IPC_NOWAIT) == -1){
        perror("msgsnd");
        exit(1);
    } 
}

void get_msg(int qid, int type){
    while (1){
        struct msgbuff msg;
        bzero(&msg, sizeof(msg));//清空缓冲区，也可用memmet实现
        if (msgrcv(qid, (void *)&msg, sizeof(msg.mtext),type, MSG_NOERROR) == -1) {
            perror("msgrcv");
            exit(1);
        }
        printf("抢到了资源: <%d> <%s>\n", type, msg.mtext);

    }
}

int main(int argc, char **argv){
    int opt, mode = 2, msgtype = 1;
    int msgq_id;
    char mtext[512] = {0};
    //mode == 1-> send
    while((opt = getopt(argc, argv, "st:rm:")) != -1){
        switch(opt){
            case 's':
                mode = 1;
                break;
            case 'r':
                mode = 2;
                break;
            case 't':
                msgtype = atoi(optarg);
                break;
            case 'm':
                strcpy(mtext, optarg);
                break;
            default:
                fprintf(stderr, "Usage: %s -[s|r] -t type -m msg\n", argv[0]);
                exit(1);
        }
    }
    //int msgget(key_t key, int msgflg);
    if((msgq_id = msgget(2021, IPC_CREAT | 0666)) < 0){
        perror("msgget");
        exit(1);
    }
    if (mode == 1){
        send_msg(msgq_id, msgtype, mtext, sizeof(mtext));
    } else {
        get_msg(msgq_id, msgtype);
    }

    return 0;
}
// ./a.out -s -t 1 -m "I'm the 1th!"
// ./a.out -r -t 1.msgq.c#include "head.h"
struct msgbuff{
    long mtype;
    char mtext[512];
};

void send_msg(int qid, int type, char *m_msg, int size){
    struct msgbuff msg;
    msg.mtype = type;
    strcpy(msg.mtext, m_msg);
    if(msgsnd(qid, (void *)&msg, sizeof(msg.mtext), IPC_NOWAIT) == -1){
        perror("msgsnd");
        exit(1);
    } 
}

void get_msg(int qid, int type){
    while (1){
        struct msgbuff msg;
        bzero(&msg, sizeof(msg));//清空缓冲区，也可用memmet实现
        if (msgrcv(qid, (void *)&msg, sizeof(msg.mtext),type, MSG_NOERROR) == -1) {
            perror("msgrcv");
            exit(1);
        }
        printf("抢到了资源: <%d> <%s>\n", type, msg.mtext);

    }
}

int main(int argc, char **argv){
    int opt, mode = 2, msgtype = 1;
    int msgq_id;
    char mtext[512] = {0};
    //mode == 1-> send
    while((opt = getopt(argc, argv, "st:rm:")) != -1){
        switch(opt){
            case 's':
                mode = 1;
                break;
            case 'r':
                mode = 2;
                break;
            case 't':
                msgtype = atoi(optarg);
                break;
            case 'm':
                strcpy(mtext, optarg);
                break;
            default:
                fprintf(stderr, "Usage: %s -[s|r] -t type -m msg\n", argv[0]);
                exit(1);
        }
    }
    //int msgget(key_t key, int msgflg);
    if((msgq_id = msgget(2021, IPC_CREAT | 0666)) < 0){
        perror("msgget");
        exit(1);
    }
    if (mode == 1){
        send_msg(msgq_id, msgtype, mtext, sizeof(mtext));
    } else {
        get_msg(msgq_id, msgtype);
    }

    return 0;
}
// ./a.out -s -t 1 -m "I'm the 1th!"
// ./a.out -r -t 1.msgq.c#include "head.h"
struct msgbuff{
    long mtype;
    char mtext[512];
};

void send_msg(int qid, int type, char *m_msg, int size){
    struct msgbuff msg;
    msg.mtype = type;
    strcpy(msg.mtext, m_msg);
    if(msgsnd(qid, (void *)&msg, sizeof(msg.mtext), IPC_NOWAIT) == -1){
        perror("msgsnd");
        exit(1);
    } 
}

void get_msg(int qid, int type){
    while (1){
        struct msgbuff msg;
        bzero(&msg, sizeof(msg));//清空缓冲区，也可用memmet实现
        if (msgrcv(qid, (void *)&msg, sizeof(msg.mtext),type, MSG_NOERROR) == -1) {
            perror("msgrcv");
            exit(1);
        }
        printf("抢到了资源: <%d> <%s>\n", type, msg.mtext);

    }
}

int main(int argc, char **argv){
    int opt, mode = 2, msgtype = 1;
    int msgq_id;
    char mtext[512] = {0};
    //mode == 1-> send
    while((opt = getopt(argc, argv, "st:rm:")) != -1){
        switch(opt){
            case 's':
                mode = 1;
                break;
            case 'r':
                mode = 2;
                break;
            case 't':
                msgtype = atoi(optarg);
                break;
            case 'm':
                strcpy(mtext, optarg);
                break;
            default:
                fprintf(stderr, "Usage: %s -[s|r] -t type -m msg\n", argv[0]);
                exit(1);
        }
    }
    //int msgget(key_t key, int msgflg);
    if((msgq_id = msgget(2021, IPC_CREAT | 0666)) < 0){
        perror("msgget");
        exit(1);
    }
    if (mode == 1){
        send_msg(msgq_id, msgtype, mtext, sizeof(mtext));
    } else {
        get_msg(msgq_id, msgtype);
    }

    return 0;
}
// ./a.out -s -t 1 -m "I'm the 1th!"
// ./a.out -r -t 1.msgq.c

*/
//**额外增加的结束
//加上了一些额外的无关代码及打印输出信息 让总字节数超过一页大小sysconf(_SC_PAGE_SIZE)以方便查看调试信息** 结束

编译命令：gcc mmap.c
程序执行格式： ./a.out file offset [length]
格式解析：./a.out +file 文件名 + offset偏移量 +length可选长度

./a.out mmap.c 10000

//执行结果，示例
length = 2266
offset = 10000
pa_offset = 8192

假设文件mmap.c文件大小为12266 ，
length =文件总大小(12266) - 偏移量offset(1000) = 2266

4096(sysconf(_SC_PAGE_SIZE)一页大小)

0001 0000 0000 0000 = 4096(sysconf(_SC_PAGE_SIZE)一页大小)
0000 1111 1111 1111 = (sysconf(_SC_PAGE_SIZE) - 1) =4095
~(0000 1111 1111 1111)
= 1111 0000 0000 0000 = ~ (sysconf(_SC_PAGE_SIZE) - 1) =61440

pa_offset = offset & ~(sysconf(_SC_PAGE_SIZE) - 1)
=10000 & 61440
=(0010 0111 0001 0000) & (1111 0000 0000 0000)
=(0010 0000 0000 0000)
=8192 //pa_offset即内存中的页偏移量

sysconf(_SC_PAGESIZE)；
sinat_34163739的博客
07-04 998
于是找_dl_pagesize变量在哪赋值的。
Android Native内存泄漏检测方案详解
陆业聪
07-28 1484
本文将分三个部分阐述如何实现 Android Native 内存泄漏监控，包括代理实现的三种方案（Inline Hook、PLT/GOT Hook、LD_PRELOAD）及其优缺点，以及如何检测Native内存泄露和获取Android Native堆栈的方法。本文将提供一套比较全面的解决思路，帮助大家更好地检测 Android Native 内存泄漏问题。
pa_offset = offset & ~(sysconf(_SC_PAGE_SIZE) - 1)计算页偏移
Goallegoal的博客
04-18 1618
pa_offset = offset &amp; ~(sysconf(_SC_PAGE_SIZE) - 1)计算页偏移 在mmap的手册中有一段示例代码，其中有一行： offset = atoi(argv[2]); pa_offset = offset &amp; ~(sysconf(_SC_PAGE_SIZE) - 1); /* offset for mmap() must be page aligned */ 这一行代码表示的含义是：计算出内存中的页偏移量。具体的计算过程可以例举几个值计算一下，得到的
_SC_PAGESIZE
byebyegov5qq
04-30 864
C:\cygwin\usr\include\sys\unistd.h /* * sysconf values per IEEE Std 1003.1, 2008 Edition */ #define _SC_ARG_MAX 0 #define _SC_CHILD_MAX 1 #define _SC_CLK_TCK 2 #define _SC_NGROUPS_MAX 3 #defin...
sysconf()
5G砖家的博客
04-02 1118
sysconf 1、前言 当前计算机都是多核的，linux2.6提供了进程绑定cpu功能，将进程指定到某个core上执行，方便管理进程。linux提供了sysconf系统调用可以获取系统的cpu个数和可用的cpu个数。 2、sysconf 函数 相关宏定义的讲解红色字体部分： sysconf(_SC_PAGESIZE);此宏查看缓存内存页面的大小；打印用%ld长整型。 sysconf(_SC_PHYS_PAGES) 此宏查看内存的总页数；打印用%ld...
进程间通信笔记（8）—mmap详解
上善若水
09-22 4350
linux mmap详解
Linux共享内存（mmap详解）
MJ813的专栏
08-01 7900
mmap()系统调用使得进程之间通过映射同一个普通文件实现共享内存。普通文件被映射到进程地址空间后，进程可以向访问普通内存一样对文件进行访问，不必再调用read()，write（）等操作。
讲一下c++里面mmap映射文件相关的知识
最新发布
03-18
必须是系统页大小的整数倍（通过 `sysconf(_SC_PAGE_SIZE)` 获取）。 --- #### 四、优点与缺点 | 优点 | 缺点 | |------|------| | 高效I/O（减少内核-用户态拷贝） | 大文件可能占用过多内存 | | 支持随机访问 |...
IBinder源码分析
piziliul的博客
10-30 1025
进程隔离简单的说就是 Linux 操作系统设计的一种机制，使进程之间不能共享数据，保持各自数据的独立性，即A进程不能访问B进程数据，同理B进程也不能访问A进程数据。通过虚拟内存技术，达到 Linux 进程中数据不能共享，从而保持独立的功能。所以，Linux 进程之间要进行数据交互就得采用特殊的通信机制，即 IPC 通信！MMU(Memory Management Unit)主要用来管理虚拟存储器、物理存储器的控制线路，同时也负责虚拟地址映射为物理地址，以及提供硬件机制的内存访问授权、多任务多进程操作系统。
sysconf
悠悠余香
09-30 2036
头文件 #include 2函数原型 long sysconf (int name); 3说明 sysconf() 返回选项 (变量) 的当前值，这个值可配置的但也是受系统限制的。在成功完成的情况下，sysconf() 返回变量的当前值。该值受到的限制将少于编译时 ， 或 中可用的对应值。大多数这些变量的值在调用进程的生存时间内不变。 如果出错，那么函数返回 -1 ，并适当地
sysconf函数
热门推荐
calmjiao的博客
01-10 1万+
sysconf 函数用来获取系统执行的配置信息。例如页大小、最大页数、cpu个数、打开句柄的最大个数等等。 函数原型： #include long sysconf(int name);以下为常用的name参数： _SC_CHILD_MAX：每个user可同时运行的最大进程数 _SC_HOST_NAME_MAX：hostname最大长度，需小于_POSIX_HOST_NAM
sysconf zz
weixin_34075268的博客
09-13 166
#include &lt;stdio.h&gt; #include &lt;unistd.h&gt; #define ONE_MB (1024 * 1024) int main (void) { long num_procs; long page_size; long num_pages...
Linux 获取内存页大小
qq_28779021的博客
03-28 8885
如何查看Linux系统的内存页大小： 1. getconf PAGESIZE/PAGE_SIZE  返回值单位为Bytes 点击(此处)折叠或打开 [root@localhost nginx-1.8.0]# getconf PAGESIZE 4096 [root@localhost nginx-1.8.0]# getconf PAGE_SIZE
linux sysconf函数,linux编程|sysconf函数实例讲解
weixin_39662462的博客
05-10 168
[root@gateway xuekun]# cat device.c/** Create by bdkyr* Date 2015-1-27* linux专题精讲*/#include #include #define ONE_MB (1024 * 1024)int main(void){long num_procs;long page_size;long num_pa...
linux内核中__PAGE_OFFSET的问题
paulinehuihui的博客
07-01 1791
[size=large]arch/i386/boot/setup.S中自定的临时GDT表数据段和代码段的基地址都是从0开始的，因此看到内核中i386/kernel/head.S中有些地址需要减去__PAGE_OFFSET(3G),有些不理解，google一下才发现内核链接时的虚拟地址是在arch/i386/kernel/vmlinux.lds.S中指定的，从_PAGE_OFFSET+0x10000...
sysconf的使用
chenyujing1234的专栏
10-28 3561
#include #include #define ONE_MB (1024*1024) int main(void) { long num_procs; long page_size; long num_pages; long free_pages; long long mem; long long free_mem; num_procs = sysconf(_SC_NP
#if defined(__arm__) int process_vm_readv_syscall = 376; int process_vm_writev_syscall = 377; #elif defined(__aarch64__) int process_vm_readv_syscall = 270; int process_vm_writev_syscall = 271; #elif defined(__i386__) int process_vm_readv_syscall = 347; int process_vm_writev_syscall = 348; #else int process_vm_readv_syscall = 310; int process_vm_writev_syscall = 311; #endif ssize_t process_v(pid_t __pid, const struct iovec *__local_iov, unsigned long __local_iov_count, const struct iovec *__remote_iov, unsigned long __remote_iov_count, unsigned long __flags, bool iswrite) { return syscall((iswrite ? process_vm_writev_syscall : process_vm_readv_syscall), __pid, __local_iov, __local_iov_count, __remote_iov, __remote_iov_count, __flags); } bool WriteAddr(void *addr, void *buffer, size_t length) { unsigned long page_size = sysconf(_SC_PAGESIZE); unsigned long size = page_size * sizeof(uintptr_t); return mprotect((void *) ((uintptr_t) addr - ((uintptr_t) addr % page_size) - page_size), (size_t) size, PROT_EXEC | PROT_READ | PROT_WRITE) == 0 &amp;&amp; memcpy(addr, buffer, length) != 0; } // 进程读写内存 bool pvm(void *address, void *buffer, size_t size, bool iswrite) { struct iovec local[1]; struct iovec remote[1]; local[0].iov_base = buffer; local[0].iov_len = size; remote[0].iov_base = address; remote[0].iov_len = size; ssize_t bytes = process_v(pid, local, 1, remote, 1, 0, iswrite); return bytes == size; } // 读取内存 bool vm_readv(long address, void *buffer, size_t size) { return pvm(reinterpret_cast &lt; void *&gt;(address), buffer, size, false); } // 写入内存 bool vm_writev(long address, void *buffer, size_t size) { return pvm(reinterpret_cast &lt; void *&gt;(address), buffer, size, true); }读写不了怎么办
03-18
从您的描述来看，您尝试通过 `process_vm_readv` 和 `process_vm_writev` 系统调用来实现进程间内存读写功能。然而，在某些场景下可能会遇到无法正常工作的情况。 ### 可能的原因分析 1. **权限不足** 调用这两个系统调用需要目标进程有适当的访问权限。如果当前进程对目标进程没有足够的权限（例如目标进程的用户 ID 或者权限级别限制），操作会失败并返回错误码 `-EPERM`。 2. **地址无效** 如果提供的地址超出有效范围（如未映射到虚拟空间、非法指针等），操作系统将拒绝该请求，并返回 `-EFAULT` 错误。 3. **内核配置问题** 某些 Linux 发行版或特定版本的内核可能禁用了 `process_vm_readv/writev` 功能。在这种情况下，即使代码逻辑无误也可能导致函数不可用。 4. **SELinux/AppArmor 的影响** 安全模块（如 SELinux 或 AppArmor）可能会阻止此类跨进程的操作。如果您运行的是启用了强制安全策略的环境，则可能导致失败。 5. **调试模式下的限制** 当前进程中可能存在调试工具附加（如 GDB）。这种状态通常会对远程内存访问施加额外约束，从而引起异常情况发生。 --- ### 解决方案建议 #### 1. 验证是否具备必要权限 检查是否有足够高的权限去操控其他进程的数据段内容。可以临时提升至 root 用户测试效果；若成功说明普通账户缺乏相应权利设置。 ```bash sudo su - ``` 然后再次执行程序看看能否顺利运作起来。 #### 2. 修改目标区域属性 对于一些保护比较严格的页面来说，直接修改其值会被拦截下来。这时我们需要先调整那些存储单元所处位置的相关标志位： ```cpp if (!WriteAddr(address, buffer, size)) { perror(&quot;Failed to change memory protection&quot;); return false; } ``` 上述步骤就是更改指定块为可读写的例子。不过需要注意的是这样做会影响系统的稳定性以及安全性，请谨慎行事！ #### 3. 查看具体的errno信息 为了更精确地定位出错原因，应该捕获 errno 并打印出来供参考: ```cpp #include &lt;cerrno&gt; ... perror(strerror(errno)); return bytes == ssize_t(size); // 返回布尔结果同时保留原语义表达形式 ``` #### 4. 切换至 ptrace 实现备选机制 如果确实由于各种因素而不得不放弃现有的 API ，那么还可以考虑采用 ptrace() 来完成类似的任务 。尽管效率较低且复杂度增加不少，但它兼容性较好并且几乎不受限于前面提到的所有障碍物。 示例片段如下所示： ```cpp long attach_and_rw(pid_t pid,long addr,void* data,size_t len,bool write){ if(0 != ptrace(PTRACE_ATTACH,pid,nullptr,nullptr)){ perror(&quot;Attach failed:&quot;); exit(-1); } waitpid(pid,&amp;status,WUNTRACED); struct iovec io_local={data,len}; struct user_regs_struct regs; ptrace(PTRACE_GETREGS,pid,&amp;regs,sizeof(regs)); if(write){ ioctl(fileno(stdout),&quot;TIOCSTI&quot;,(char*)&amp;io_local.iov_len); ptrace(PTRACE_POKETEXT,pid,(void*)addr,data,strlen((const char*)data)+1); }else{ readlink(&quot;/proc/self/exe&quot;,NULL,PAGE_SIZE); ptrace(PTRACE_PEEKDATA,pid,(void*)addr,&amp;value,sizeof(value)); } detach_process(pid); return SUCCESS; } ``` 以上仅作为思路引导之用，实际应用还需进一步完善细节处理部分。 --- ###
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值