驱动程序设计 Linux设备驱动中的阻塞与非阻塞IO、信号与函数 7.12

最新推荐文章于 2024-08-25 17:57:55 发布
最新推荐文章于 2024-08-25 17:57:55 发布
阅读量135 收藏
点赞数
分类专栏： 驱动程序设计 文章标签： linux 算法 运维 嵌入式硬件 驱动开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45241469/article/details/131688349
版权
本文介绍了Linux设备驱动中的I/O处理方式，包括阻塞I/O的实现，如使用等待队列和循环检查，以及非阻塞I/O和异步通知机制，如select、poll和信号（SIGIO）通知。通过示例代码展示了如何在驱动程序和应用程序中实现这些机制。
摘要由CSDN通过智能技术生成

linux设备驱动中的阻塞与非阻塞I/O

阻塞：等待某种资源，如果获取不到，就会把当前任务挂起，等待资源准备好

1.
int flag = 0;
while(flag == 0);
2.等待队列
wait_event(q,flag > 0);
wakeup(q);

非阻塞：等待某种资源非阻塞，循环搭配，反复的获取

异步通知：做自己的事，当资源准备好了，系统通知它去获取资源

阻塞等待

驱动程序

/*===============================================
 *   文件名称：modSpin.c
 *   创 建 者: memories
 *   创建日期：2023年07月11日
 *   描    述：have a nice day
 ================================================*/
//头文件
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/kdev_t.h>
#include <linux/delay.h>
#include <asm/io.h>
#include <asm/uaccess.h>

#define MA 300
#define MI 0
#define MAX_LEN 10

static dev_t no = 0;
static unsigned count = 1;
static const char * name = "mydev";
static struct cdev mydev;
static char buf[MAX_LEN] = {0};
static spinlock_t lock;
static struct mutex my_mutex;
static wait_queue_head_t my_queue;
static int  w=0,r=0 ;


int myopen(struct inode *pi, struct file *pf)
{
    if( mutex_trylock(&my_mutex)==0 )
        return -1;
    return 0;
}

int myrelease(struct inode *pi, struct file *pf)
{

    mutex_unlock(&my_mutex);
    return 0;
}

static int rlen = 0;
ssize_t myread (struct file *pf, char __user *rbuf, size_t len, loff_t *poff)
{
    int ret = -1;
    //计算读的空间
    wait_event_interruptible(my_queue, rlen >= len);
    if(r<w)
        ret = copy_to_user(rbuf,buf+r,len);
    else
    {
        if(len <= MAX_LEN-r)
            ret = copy_to_user(rbuf,buf+r,len);
        else
        {
            ret = copy_to_user(rbuf,buf+r,(MAX_LEN-r));
            ret = copy_to_user(rbuf+(MAX_LEN-r),buf,len-(MAX_LEN-w));
        }
    }
    if(ret != 0)
    {
        printk("copy read is failed\n");
        return -1;
    }
    r = (r+len)%MAX_LEN;
    if(r <= w)
        rlen = w - r;
    else
        rlen = w + (MAX_LEN-r);
    return len;
}
ssize_t mywrite (struct file *pf, const char __user *wbuf, size_t len, loff_t *poff)
{
    int ret = -1;
    int wlen = 0;
    //计算可写空间大小
    if(w >= r)
        wlen = r+(MAX_LEN-w);
    else
        wlen = w - r;
    //判断若数据长度大于可写空间大小，则无法输出
    if(len > wlen)
        return -1;
    //如果数据长度不大于可写空间大小
    if(MAX_LEN-w >= len)//如果剩余可写长度能容纳len长度的数据则一次性输入
        ret = copy_from_user(buf+w,wbuf,len);
    else//如果不能则分段输入
    {
        ret = copy_from_user(buf+w,wbuf,MAX_LEN-w);
        ret = copy_from_user(buf,wbuf+(MAX_LEN-w),len-(MAX_LEN-w));
    }
    if(ret != 0)
    {
        printk("copy write is failed\n");
        return -1;
    }
    w = (w+len)%MAX_LEN;

    if(r <= w)
        rlen = w - r;
    else
        rlen = w + (MAX_LEN-r);

    wake_up_interruptible(&my_queue);
    return len;
}


static struct file_operations myfops={
    .open = myopen,
    .release = myrelease,
    .write = mywrite,
    .read = myread,
};
//初始化
int myinit(void)
{
    int ret = -1;
    //向上内核
    no = MKDEV(MA,MI);
    //1.注册设备号
    ret = register_chrdev_region(no,count,name);
    if(ret != 0)
    {
        printk("register is failed\n");
        return -1;
    }
    //2.设备操作初始化
    cdev_init(&mydev,&myfops);
    //3.添加设备
    ret = cdev_add(&mydev,no,count);
    if(ret != 0)
    {
        unregister_chrdev_region(no,count);
        printk("add is failed\n");
        return -1;
    }
    //向下驱动
    spin_lock_init(&lock);
    mutex_init(&my_mutex);
    init_waitqueue_head(&my_queue);
    printk("my init is ready\n");
    return 0;
}
//退出
void myexit(void)
{
    //删除设备
    cdev_del(&mydev);
    //注销设备号
    unregister_chrdev_region(no,count);
    printk("my exit is ready\n");
}
module_init(myinit);
module_exit(myexit);
//信息
MODULE_LICENSE("GPL");

应用程序

/*===============================================
 *   文件名称：mainSpin.c
 *   创 建 者: memories
 *   创建日期：2023年07月11日
 *   描    述：have a nice day
 ================================================*/
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>

char wbuf0[32] = "01234567899876543210";
char wbuf1[32] = "abcdefg";
char buf[16] = {0};
int fd = 0;
void *fun1(void* arg )
{
    sleep(1);
    write(fd,1234567,8);
    printf("write 1 is ok\n");
    sleep(1);
    write(fd,"abc",2);
    printf("write 2 is ok\n");
    sleep(1);
    write(fd,"8912",3);
    printf("write 3 is ok\n");
}

int main(int argc, char *argv[])
{ 
    int ret = 0;
    fd = open("/dev/mydev",O_RDWR);
    if(fd < 0)
    {
        printf("open fd failed\n");
        return;
    }
    pthread_t t1,t2;
    ret = pthread_create(&t1,NULL,fun1,NULL);
    if(ret != 0)
    {
        printf("pthread is failed\n");
        return -1;
    }
    pthread_detach(t1);
    printf("read is ready\n");
    read(fd,buf,5);
    printf("buf1=%s\n",buf);
    read(fd,buf,5);
    printf("buf2=%s\n",buf);
    read(fd,buf,5);
    printf("buf3=%s\n",buf);
    return 0;
}

异步通知 select-poll

在驱动里面会提供一个select文件操作集为poll，驱动在进行通讯时，自动的写自动的读

static wait_queue_head_t my_queue;//定义等待队列

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZjeLQOcz-1689159240281)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20230712134513666.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KVRdRHiy-1689159240282)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20230712140529357.png)]

驱动程序

/*===============================================
 *   文件名称：modSpin.c
 *   创 建 者: memories
 *   创建日期：2023年07月11日
 *   描    述：have a nice day
 ================================================*/
//头文件
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/kdev_t.h>
#include <linux/delay.h>
#include <linux/poll.h>
#include <asm/io.h>
#include <asm/uaccess.h>

#define MA 300
#define MI 0
#define MAX_LEN 10

static dev_t no = 0;
static unsigned count = 1;
static const char * name = "mydev";
static struct cdev mydev;
static char buf[MAX_LEN] = {0};
static spinlock_t lock;
static struct mutex my_mutex;
static wait_queue_head_t my_queue;
static int flag = 0;

int myopen(struct inode *pi, struct file *pf)
{
    if( mutex_trylock(&my_mutex)==0 )
        return -1;
    return 0;
}

int myrelease(struct inode *pi, struct file *pf)
{

    mutex_unlock(&my_mutex);
    return 0;
}

ssize_t myread (struct file *pf, char __user *rbuf, size_t len, loff_t *poff)
{
    int ret = -1;
    ret = copy_to_user(rbuf,buf,len);
    if(ret != 0)
    {
        printk("copy read is failed\n");
        return -1;
    }
    flag = 0;
    return len;
}
ssize_t mywrite (struct file *pf, const char __user *wbuf, size_t len, loff_t *poff)
{
    int ret = -1;
    ret = copy_from_user(buf,wbuf,len);
    if(ret != 0)
    {
        printk("copy write is failed\n");
        return -1;
    }
    flag = 1;
    return len;
}

unsigned int mypoll(struct file *filp, struct poll_table_struct *wait)
{
      unsigned int mask = 0;
    poll_wait(filp, &my_queue, wait);//调用select、poll、epoll的进程挂到驱动程序的等待队列中
    if (flag==1)//可读
    {
        mask |= POLLIN | POLLRDNORM; /*标示数据可获得*/
    }
    if (flag==0)//可写
    {
        mask |= POLLOUT | POLLWRNORM; /*标示数据可写入*/
    }
    return mask;
}

static struct file_operations myfops={
    .open = myopen,
    .release = myrelease,
    .write = mywrite,
    .read = myread,
    .poll = mypoll,
};
//初始化
int myinit(void)
{
    int ret = -1;
    //向上内核
    no = MKDEV(MA,MI);
    //1.注册设备号
    ret = register_chrdev_region(no,count,name);
    if(ret != 0)
    {
        printk("register is failed\n");
        return -1;
    }
    //2.设备操作初始化
    cdev_init(&mydev,&myfops);
    //3.添加设备
    ret = cdev_add(&mydev,no,count);
    if(ret != 0)
    {
        unregister_chrdev_region(no,count);
        printk("add is failed\n");
        return -1;
    }
    //向下驱动
    spin_lock_init(&lock);
    mutex_init(&my_mutex);
    init_waitqueue_head(&my_queue);
    printk("my init is ready\n");
    return 0;
}
//退出
void myexit(void)
{
    //删除设备
    cdev_del(&mydev);
    //注销设备号
    unregister_chrdev_region(no,count);
    printk("my exit is ready\n");
}
module_init(myinit);
module_exit(myexit);
//信息
MODULE_LICENSE("GPL");

应用程序

/*===============================================
 *   文件名称：mainSpin.c
 *   创 建 者: memories
 *   创建日期：2023年07月11日
 *   描    述：have a nice day
 ================================================*/
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <fcntl.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>

char wbuf[32] = "01234567899876543210";
char wbuf1[32] = "abcdefg";
char rbuf[16] = {0};
int fd = 0;

int main(int argc, char *argv[])
{ 
    int ret = 0;
    fd = open("/dev/mydev",O_RDWR);
    if(fd < 0)
    {
        printf("open fd failed\n");
        return;
    }
    while(1)
    {
    fd_set  rds,wds;
    FD_ZERO(&rds);
    FD_ZERO(&wds);
    FD_SET(fd,&rds);
    FD_SET(fd,&wds);

    select(fd+1,&rds,&wds,NULL,0);
    if(FD_ISSET(fd,&rds))
    {
        read(fd,rbuf,16);
        printf("rbuf is %s\n",rbuf);
    }
    if(FD_ISSET(fd,&wds))
    {
        write(fd,wbuf,16);
        printf("write is ok\n");
    }
    }
    close(fd);
    return 0;
}

信号与函数

驱动函数

//1.异步结构定义
//2.异步初始化
//3.发送信号
/*===============================================
 *   文件名称：modSpin.c
 *   创 建 者: memories
 *   创建日期：2023年07月11日
 *   描    述：have a nice day
 ================================================*/
//头文件
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/kdev_t.h>
#include <linux/delay.h>
#include <linux/poll.h>
#include <asm/io.h>
#include <asm/uaccess.h>

#define MA 300
#define MI 0
#define MAX_LEN 10

static dev_t no = 0;
static unsigned count = 1;
static const char * name = "mydev";
static struct cdev mydev;
static char buf[MAX_LEN] = {0};
static spinlock_t lock;
static struct mutex my_mutex;
static struct fasync_struct *async_queue = NULL;

static int flag = 0;

int myopen(struct inode *pi, struct file *pf)
{
    if( mutex_trylock(&my_mutex)==0 )
        return -1;
    return 0;
}

int myrelease(struct inode *pi, struct file *pf)
{

    mutex_unlock(&my_mutex);
    return 0;
}

ssize_t myread (struct file *pf, char __user *rbuf, size_t len, loff_t *poff)
{
    int ret = -1;
    ret = copy_to_user(rbuf,buf,len);
    if(ret != 0)
    {
        printk("copy read is failed\n");
        return -1;
    }
    flag = 0;
    return len;
}
ssize_t mywrite (struct file *pf, const char __user *wbuf, size_t len, loff_t *poff)
{
    int ret = -1;
    ret = copy_from_user(buf,wbuf,len);
    if(ret != 0)
    {
        printk("copy write is failed\n");
        return -1;
    }
    flag = 1;
    kill_fasync(&async_queue,SIGIO,POLL_IN);
    return len;
}

int myfasync(int fd, struct file *filp, int mode)
{
    return fasync_helper(fd,filp,mode,&async_queue);
}


static struct file_operations myfops={
    .open = myopen,
    .release = myrelease,
    .write = mywrite,
    .read = myread,
    .fasync = myfasync,
};
//初始化
int myinit(void)
{
    int ret = -1;
    //向上内核
    no = MKDEV(MA,MI);
    //1.注册设备号
    ret = register_chrdev_region(no,count,name);
    if(ret != 0)
    {
        printk("register is failed\n");
        return -1;
    }
    //2.设备操作初始化
    cdev_init(&mydev,&myfops);
    //3.添加设备
    ret = cdev_add(&mydev,no,count);
    if(ret != 0)
    {
        unregister_chrdev_region(no,count);
        printk("add is failed\n");
        return -1;
    }
    //向下驱动
    spin_lock_init(&lock);
    mutex_init(&my_mutex);
    printk("my init is ready\n");
    return 0;
}
//退出
void myexit(void)
{
    //删除设备
    cdev_del(&mydev);
    //注销设备号
    unregister_chrdev_region(no,count);
    printk("my exit is ready\n");
}
module_init(myinit);
module_exit(myexit);
//信息
MODULE_LICENSE("GPL");

应用函数

//1.绑定signal信号
signal(SIGIO,handler);
//2.设置进程和信号绑定 fd是在进程里面工作的(file--->f_owner)
fcntl(fd,F_SETOWN,getpid());
//3.设置异步标志
int oflags = fcntl(fd,F_GETFL);
fcntl(fd,F_SETFL,oflags|FASYNC);//让fd设备具备异步通知的能力

/*===============================================
 *   文件名称：mainSpin.c
 *   创 建 者: memories
 *   创建日期：2023年07月11日
 *   描    述：have a nice day
 ================================================*/
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <fcntl.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>

char wbuf[32] = "01234567899876543210";
char wbuf1[32] = "abcdefg";
char rbuf[16] = {0};
int fd = 0;

void handler(int no)
{
    read(fd,rbuf,16);
    printf("rbuf=%s\n",rbuf);
}

int main(int argc, char *argv[])
{ 
    int ret = 0;
    fd = open("/dev/mydev",O_RDWR);
    if(fd < 0)
    {
        printf("open fd failed\n");
        return;
    }

    while(1)
    {
    signal(SIGIO,handler);
    fcntl(fd,F_SETOWN,getpid());
    int oflags = fcntl(fd,F_GETFL);
    fcntl(fd,F_SETFL,oflags|FASYNC);
    sleep(1);
    write(fd,wbuf,16);
    printf("write is ok\n");
    }

    close(fd);
    return 0;
}
孤独memories
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
EDA/PLD中的proteus 7.12与 keil 8.0的联调方法
11-09
本文将详细解释如何在Proteus 7.12与Keil 8.0之间进行联调，以便于进行实时的程序调试和硬件仿真。 Proteus是一款强大的电路仿真软件，它支持多种微控制器模型，并允许用户构建和仿真复杂的电子系统。而Keil则是一...
proteus 7.12与 keil 8.0的联调方法
01-19
对于proteus 6.9以后的版本,在安装盘里或LABCENTER公司有vdmagdi插件,安装该插件即可实现与KEIL的联调。 　首先安装vdmagdi软件，然后再进行以下设置： 　Keil设置 　在Keil软件上单击“Project菜单/Options for ...
世纪星V7.12函数在线说明
03-20
《世纪星V7.12函数在线说明》是针对世纪星软件系统中V7.12版本函数功能的详尽指南。这份文档旨在帮助用户更好地理解和利用世纪星V7.12的各项函数，提高在实际操作中的效率。下面将对其中的关键知识点进行深入解析。 ...
ThinkPad E460网卡驱动 v7.12.39.12 官方最新版
07-01
联想E460无线网卡驱动是由联想官方专为ThinkPadE460型号笔记本电脑打造的无线网卡驱动程序，安装了这款驱动程序，你就可以正常使用无线wifi上网了，有需要的用户赶快来下载体验吧！ThinkPadE460网卡驱动安装方法重要...
最新版linux logstash-7.12.0-linux-x86_64.tar.gz
03-30
这个最新版本的软件是专为64位Linux系统设计的，提供了高效的数据流处理能力，帮助系统管理员和开发人员从各种来源收集日志数据，对其进行过滤、转换，并将结果输出到各种目的地，如Elasticsearch、Kibana或其他存储...
多进程和多线程基础概念LINUX
2301_79109608的博客
08-22 1095
直接访问物理地址,会导致地址空间没有隔离,很容易导致数据被修改通过虚拟地址空间可以实现每个进程空间都是独立的，操作系统会映射到不用的物理地址区间，在访问时互不干扰.进程状态分为三个基本状态，即运行态，就绪态，阻塞态。在五态模型中，进程分为新建态、终止态，运行态，就绪态，阻塞态。并发：有限的 cpu 核芯的情况下 ,利用快速交替(时间片轮转)执行来达到宏观上的同时执行。虚拟地址 : 虚拟地址并不代表真实的内存空间,而是一个用于寻址的编号。并行：在 cpu 多核的支持下，实现物理上的同时执行。
Linux 线程的控制 互斥与同步
qq_63145217的博客
08-23 925
include //头文件sem_t sem;信号量的类型 信号量的变量。
在Linux上构建Windows应用程序：深入探索跨平台开发的实践与挑战
w651428055的博客
08-21 1106
在Linux上构建Windows应用程序，不仅拓宽了开发者的技能范围，也为软件产品的多平台部署提供了灵活性和成本效益。虽然这一过程面临挑战，但通过合理选择工具、框架和策略，可以有效地克服这些障碍。随着技术的不断进步，跨平台开发将变得更加成熟和便捷，为软件开发带来更多的可能性和机遇。未来，随着更多高效工具和框架的出现，跨平台开发的效率和质量有望进一步提升，为软件工程领域注入新的活力。
Linux中信号量相关接口及环形队列
2301_77479435的博客
08-22 335
Linux中信号量相关接口及环形队列
【Linux】生产消费模型实践 --- 基于信号量的环形队列
JLX_1的博客
08-21 749
本文实践了生产消费模型，通过基于信号量的环形队列来模拟生产消费的过程！讲解了信号量的相关基础知识！
linux定期统计某个目录内每天的文件增量大小
mengbing1990的博客
08-21 199
每天统计一次前一天的日志量大小，并将每个目录的大小记录一份日志。 本测试脚本下，所有目录产生的日志均有固定格式，如每个目录不一样的话，需定义find语句中的name变量。
Linux之RabbitMQ集群部署
m0_54563444的博客
08-21 1404
消息中间件也可以称消息队列，是利用高效可靠的消息传递机制进行异步的数据传输并基于数据通信来进行分布式系统的集成。当下主流的消息中间件有等。Kafka是LinkedIn开源的分布式发布-订阅消息系统，目前归属于Apache顶级项目。Kafka主要特点是追求高吞吐量(单机可达到10万级)时效性是毫秒级的，一开始的目的就是用于日志收集和传输。对消息的重复、丢失、错误没有严格要求，适合产生大量数据的互联网服务的数据收集业务。
Linux 实用运维sh脚本分享
08-22 292
【代码】Linux 实用运维sh脚本分享。
Linuxctags——R的使用
m0_71703182的博客
08-23 388
按下。
linux被植入木马排查思路
qq_59634082的博客
08-20 920
1、查看一定时间内文件的情况 find / -name "*" -type f -newermt '2022-08-25 00:00:00'!2、查看tomcat、nginx的比较大的.jsp .htm文件 find /目录 -name .jsp -o -size +10000k。在相应的文件里把tomcat2用户添加的内容删除 /etc/shadow /etc/group ，异常用户直接锁定。3、查看passwd的修改时间，判断是否在不知情的情况下被添加用户 ls -l /etc/passwd。
linux查询目录文件基础操作
qq_43826626的博客
08-22 281
ls -l。
Docker镜像添加Linux普通用户
lukabruce的博客
08-22 177
2) useradd normalUserName //新增普通用户名，比如新增tom: useradd tom;1) docker run -it --name X1 ;1）基于客户端打客户端镜像包client.tar.gz。3）id -u tom //查看用户tom的UID。4）docker commit X1 镜像B。2) 构建镜像C build-imageC.sh。（3）构建带有普通用户名UID的镜像C。1) 创建DockerFile。
Linux性能调优指南(1)：聚焦CPU性能与缓存优化策略
weixin_73298423的博客
08-20 1226
一， CPU性能调优 。 1.选择适合的CPU · 1.1 性能评估工具 ·1.2 CPU信息查看命令 · 1.3基准测试工具 2.CPU缓存优化 · 2.1.了解缓存结构 ·2.2. 缓存预热 ·2.3.数据布局和访问模式优化 ·2.4.使用性能分析工具· 2.4.1. perf的安装 ·2.4.2. perf的基本使用 ·2.4.3. perf的高级功能 ·2.4.4.perf的工作原理 ·2.5.调整内核参数 · 2.6. 编译器优化 ·2.7.代码优化 ·2.8.多线程与并发控制
Linux 部署 MinIO（远程服务器）
最新发布
qq_70786441的博客
08-25 533
自定义账号与登录密码，直接在本目录默认登录账号和密码都是：minioadmin# 设置控制台账号（最少3位）# 登录密码（最少8位）创建文件存储目录与日志目录：# 创建存储目录#创建日志文件创建 启动脚本：# 使用 vim 或 vi 创建启动脚本# i 进行编辑 操作脚本授权：# 脚本授权# 进入存放 启动命令目录下# 启动命令./start.sh查看进程：# 查看 minio 进程。
Java GUI设计与实现：事件处理与AWT组件解析
"本资源是关于Java语言和面向对象程序设计的第15讲，主要讲解图形用户界面（GUI）的设计与实现。内容包括GUI概述、用户自定义组件、标准组件与事件处理、各种类型的控件及其事件、布局设计、菜单系统以及Swing组件等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

孤独memories

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值