傻瓜式的LinuxU盘自动挂载-C语言

最新推荐文章于 2021-05-02 14:56:57 发布
最新推荐文章于 2021-05-02 14:56:57 发布
阅读量1.1k 收藏 14
点赞数
分类专栏： C linux 文章标签： c语言 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38627652/article/details/105833322
版权
linux 同时被 2 个专栏收录
16 篇文章 0 订阅
订阅专栏
C
2 篇文章 0 订阅
订阅专栏

能work就行

目的很简单，插上U盘后能自动挂载，但加点小要求：第一，挂载的目录要在/media上。第二，挂载的目录名要和系统识别U盘的名字一样。比如，我有一个三个区的U盘，怼入后fdisk -l看一下看到它为/dev/sdb1\2\3，那么正常来讲，它应该挂载到/media/sdb1\2\3目录。

那基于这个目标，撸起袖子干。本来linux内置udev服务可以完美解决。但参考一堆教程配置来配置去有各种奇奇怪怪的问题达不到预期目的。外加上由于这个是小系统被剪过（从2G剪到550M的fedora...），缺了什么咱们还真不确定。

至此，一个低端的自动挂载程序想法悄咪咪的生成。但求能work out。

 

思路与想法

简单的说，就是不断检查系统硬盘分区，多了就加，少了就减。

当然这是个特例，因为目标系统定死了首先它只有一个硬盘装的是系统，也就是sda。其次它如果有新的硬盘进入系统，也只能是U盘。

所以分三块：
1.  流程控制，控制执行频率和挂载卸载执行分支；
2.  查看系统硬盘状态，并得到相应数据；
3.  生成硬盘信息数据结构，同步挂载卸载；
    

流程控制，简单的采用while(1)和sleep控制，采用数据对比每番进行判断；
硬盘状态，在/proc/partitions可以读取，再加个wc -l细化处理可以简单得到当前硬盘数；
数据结构，由于每个硬盘可能有几个区，而代表每个区的是字符串结构，符合这种直接用二维数组，再由于顺序没有特别的重要，善用字符串比较和下标就行，所以总的来说算是一个比较离散的二维数组吧。

上流程图：

由于也只有一条线程，也不用考虑数据的冲突，就一路往下跑就是了。

 

数据结构

细想整个流程最重要的部分，也就是有一个全局的二维数组来记录着当前挂载了的硬盘。
每当硬盘有变动，这个二维数组就产生相应的变化，那具体的增删，是有点点类似队列但又不是，因为你无法判断是哪个先出（是哪个磁盘先拔出来），考虑过链表，不过总共才四五个USB口用数组它不香吗。

那么假设现在挂载了个三个分区的U盘B，sdb1，sdb2，sdb3，那么在这个全局数组中数据应该是这样的：

这时如果先插入两个分区的U盘C和一个分区的U盘D，它应该会进行添加即：
                     --->                       

而如果此时拔出U盘C，它该进行如下减少并调整：
                      --->                       

添加的时候是从尾部添加，删除时及时移位进行前面的空位补全。其中有一个对应的全局变量记录着当前挂载的硬盘数，可以用作这个全局数组的下标进行处理。

 

代码层级

从代码层级上说，从上往下简要的几个重要部份。

宏定义和全局，全局也就上述提到那俩~

#define PARTITION_CNT_MAX        50                        //最大接入硬盘数，稍微给大点没事
#define PARTITION_LEN_SIZE        5                        //最大分区名字长度
#define SLEEP_TIME_US            1000*500                //睡眠时间，等于是频率

#define BUFF_SIZE                1024*4                    //取得数据中转缓存
#define CMD_SIZE                100                        //存放Linux命令缓存
#define BUFF_SIZE_MINOR            10                        //取得数据中转小缓存

#define LAST_DISK_POINT          "sda1"                    //固有硬盘的最后一个，往下都是添加的
#define NORMAL_DISK_NUM            4                        //没新接硬盘时的正常/proc/partitions行数
#define DEBUG                                            //调试开关

char g_disk_mount[PARTITION_CNT_MAX][PARTITION_LEN_SIZE] = {0};      
int g_disk_mount_cnt = 0;

 

一开始先检查硬盘数目，将数据转化成自己想要的信息：

int check_Disk_Num()
{
    int disk_num;
    char buff[BUFF_SIZE_MINOR] = {0};
    char cmd[CMD_SIZE] = {0};
    sprintf(cmd, "cat /proc/partitions | wc -l");
    FILE *fp = popen(cmd, "r");
    while( fgets(buff, BUFF_SIZE_MINOR-1, fp) != NULL)
    {
        continue;
    }

    disk_num = atoi(buff);
    #ifdef DEBUG
    printf("check disk num:  %d\n", disk_num);
    #endif
    pclose(fp);
    return disk_num;    
}

 

每当检测到硬盘数目增加，会先取得增加的硬盘名字列表，保存在disk[]这个数组里：

char *p = strstr(buff,LAST_DISK_POINT);
if(p != NULL)
{
    disk_partition_cnt = 0;
    while(1)
    {
        if (disk_partition_cnt >= PARTITION_CNT_MAX)
            break;

        p = strstr(p + 4,"sd");
        if(p != NULL)
        {
            //get mount disk list
            memset(disk[disk_partition_cnt], 0, PARTITION_LEN_SIZE);
            memcpy(disk[disk_partition_cnt], p, 4);
            change_Enter(disk[disk_partition_cnt]);
            disk_partition_cnt++;
        }
        else
        {
            break;
        }
    }
}

 

得到数组列表，判断下是否单分区是否已存在，进行全局数据添加操作和系统挂载：

//judge and add to global
disk_mount_cnt_temp = g_disk_mount_cnt;
for (int i = 0; i < disk_partition_cnt; i++)
{
    if (disk_Is_Exit(disk[i]))
        continue;

    //if len=3 disk have no partition
    if (strlen(disk[i]) == 3)
    {
        if ( !disk_Is_Single_Partition(disk[i]))
            continue;
    }

    memcpy(g_disk_mount[g_disk_mount_cnt], disk[i], strlen(disk[i]));
    g_disk_mount_cnt++;
}
run_Mount(g_disk_mount_cnt - disk_mount_cnt_temp);

 

根据获取的实际挂载磁盘信息和全局数组进行比对，如果发现实际的少了些，那要进行卸载和全局数组调整删除操作了：

for (int i = 0; i < g_disk_mount_cnt; i++)
{
    if (strstr(buff,g_disk_mount[i]) == NULL)
    {    
        memset(cmd, 0, CMD_SIZE);
        sprintf(cmd,"umount /media/%s",g_disk_mount[i]);
        if ( 0 != run_System_Cmd(cmd))
        {
            memset(cmd, 0, CMD_SIZE);
            sprintf(cmd,"umount /media/%s -l",g_disk_mount[i]);
            run_System_Cmd(cmd);
        }

        memset(cmd, 0, CMD_SIZE);
        sprintf(cmd, "rm /media/%s -rf", g_disk_mount[i]);
        run_System_Cmd(cmd);

        disk_umount_pos[disk_umount_cnt] = i;
        disk_umount_cnt++;
    }
}

 

卸载系统里已经没有了的硬盘后，进行数组的清除和移位操作：

//clear the umount disk from global
for (int i = 0; i < disk_umount_cnt; i++)
{
    if (disk_umount_pos[i] == -1)
        continue;

    memset(g_disk_mount[disk_umount_pos[i]], 0, PARTITION_LEN_SIZE);
}

//reset the global
g_disk_mount_cnt = g_disk_mount_cnt - disk_umount_cnt;
int temp_cnt = 0;
for (int i = 0; i < PARTITION_CNT_MAX; i++)
{
    if (temp_cnt == g_disk_mount_cnt)
        break;

    if (strlen(g_disk_mount[i]) != 0)
    {
        memcpy(g_disk_mount[temp_cnt], g_disk_mount[i], PARTITION_LEN_SIZE);
        temp_cnt++;
    }
}
for (int i = temp_cnt; i < PARTITION_CNT_MAX; i++)
{
    memset(g_disk_mount[i], 0, PARTITION_LEN_SIZE);
}


主要操作就这么多，当然还有很多细代码块，实现的方法也有很多。
还是那句话，能work就行。。。

 

终语

是有点儿low的，不过的确也能按照要求完成任务，最起码baseline是达到的。
还是挺感概这个哈皮方法能上的了台~毕竟当初记得有一个作业，说把开发板作为一个电子相册，插入满是图片的U盘时开发版自动挂载U盘并显示图片出来。
哈哈哈如今竟然用到了，只不过别人变成了实际的用处，用在哪咱也不知道也不敢问，但完成底层的挂卸载管他怎么操作呢。

最后放上挂卸载时程序消耗图吧和一个服务检测这个程序会不会挂掉，挂掉就拉起来：

鹅还有哈皮代码：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <getopt.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <malloc.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <asm/types.h>
#include <stdbool.h>

#define PARTITION_CNT_MAX		50
#define PARTITION_LEN_SIZE		5

#define SLEEP_TIME_US			1000*500

#define BUFF_SIZE				1024*4
#define CMD_SIZE				100

#define BUFF_SIZE_MINOR			10

#define LAST_DISK_POINT  		"sda1"
#define NORMAL_DISK_NUM			4
#define DEBUG

char g_disk_mount[PARTITION_CNT_MAX][PARTITION_LEN_SIZE] = {0};  	//	record the mounted disk
int g_disk_mount_cnt = 0;											//	record the mounted disk count

bool run_System_Cmd(char *cmd)
{
	if (cmd == NULL)
		return false;
		
	#ifdef DEBUG
	printf("run shell: %s\n", cmd);
	#endif
	bool ret = system(cmd);
	//printf("ret = %d\n", ret);
    return ret;
}

int check_Disk_Num()
{
	int disk_num;
	char buff[BUFF_SIZE_MINOR] = {0};
	char cmd[CMD_SIZE] = {0};
	sprintf(cmd, "cat /proc/partitions | wc -l");
	FILE *fp = popen(cmd, "r");
	while( fgets(buff, BUFF_SIZE_MINOR-1, fp) != NULL)
    {
		continue;
    }

	disk_num = atoi(buff);
	#ifdef DEBUG
	printf("check disk num:  %d\n", disk_num);
	#endif
	pclose(fp);
	return disk_num;	
}

bool disk_Is_Single_Partition(char *disk)
{
	if (disk == NULL)
		return false;

	unsigned char buff[BUFF_SIZE_MINOR] = {0};
	unsigned char cmd[CMD_SIZE] = {0};
	sprintf(cmd, "cat /proc/partitions | grep %s | wc -l", disk);
	FILE *fp = popen(cmd, "r");
	while( fgets(buff, BUFF_SIZE_MINOR-1, fp) != NULL)
    {
		continue;
    }
	
	pclose(fp);

	if ( 1 == atoi(buff))
	{
		#ifdef DEBUG
		printf("disk: %s is single partition\n",disk);
		#endif
		return true;
	}
	
	return false;
}


int get_Partition_Info(char *info)
{
	char buff[BUFF_SIZE] = {0};
	char cmd[CMD_SIZE] = {0};
	sprintf(cmd, "cat /proc/partitions");
	FILE *fp = popen(cmd, "r");

	if (fp == NULL)
		return -1;

	while( fgets(buff, BUFF_SIZE-1, fp) != NULL)
    {
    	strncat(info, buff, strlen(buff));
		continue;
    }
    
    #ifdef DEBUG
	printf("\n----partitions info----:\n %s\n", info);
	#endif
	
	pclose(fp);
	return 0;
}

void run_Mount(int add)
{
	unsigned char cmd[CMD_SIZE] = {0};
	for (int i = g_disk_mount_cnt - add; i < g_disk_mount_cnt; i++)
	{
		memset(cmd, 0, CMD_SIZE);
		sprintf(cmd, "mkdir /media/%s", g_disk_mount[i]);
		run_System_Cmd(cmd);

		memset(cmd, 0, CMD_SIZE);
		sprintf(cmd,"mount -t auto /dev/%s /media/%s",g_disk_mount[i],g_disk_mount[i]);  
		run_System_Cmd(cmd);
	}
}

bool disk_Is_Exit(char *disk)
{
	for (int i = 0; i < g_disk_mount_cnt; i++)
	{
		if (strcmp(disk , g_disk_mount[i]) == 0)
		{
			return true;
		}
	}
	return false;
}

void change_Enter(char *temp)
{
	if (temp == NULL)
		return ;	
	
	for (int i = 0; i < strlen(temp); i++)
	{
		if (temp[i] == '\n')
		{
			temp[i] = '\0';
		}
	}
}

bool check_Disk_Mount(char * buff)
{
	if (buff == NULL)
		return false;
		
	for (int i = 0; i < g_disk_mount_cnt; i++)
	{
		//not in file buff
		if (strstr(buff,g_disk_mount[i]) == NULL)
		{
			return false;
		}
	}
	
	return true;
}

void main()
{
	int disk_partition_cnt = 0;
	int disk_num_temp;
	int disk_num = NORMAL_DISK_NUM;
	int disk_mount_cnt_temp;
	
	char buff[BUFF_SIZE] = {0};
	char disk[PARTITION_CNT_MAX][PARTITION_LEN_SIZE] = {0};
	char cmd[CMD_SIZE] = {0};
	
	int disk_umount_cnt = 0;
	int disk_umount_pos[PARTITION_CNT_MAX];
	for (int i = 0; i < PARTITION_CNT_MAX; i++)
	{
		disk_umount_pos[i] = -1;
	}

	while(1)
	{
		//check the /proc/partition
		disk_num_temp = check_Disk_Num();
		
		if (g_disk_mount_cnt != 0)
			run_System_Cmd("sync");
		
		if (disk_num != disk_num_temp)		
		{
			#ifdef DEBUG
			printf("different disk info\n");
			#endif

			//get partition buff
			memset(buff,0,BUFF_SIZE);			
			if (0 != get_Partition_Info(buff))
			{
				usleep(SLEEP_TIME_US);
				continue;
			}

			//disk add mount
			if (disk_num < disk_num_temp)
			{
				#ifdef DEBUG
				printf("disk add action\n");
				#endif	
				
				char *p = strstr(buff,LAST_DISK_POINT);
				if(p != NULL)
				{
					disk_partition_cnt = 0;
					while(1)
					{
						if (disk_partition_cnt >= PARTITION_CNT_MAX)
							break;
							
						p = strstr(p + 4,"sd");
						if(p != NULL)
						{
							//get mount disk list
							memset(disk[disk_partition_cnt], 0, PARTITION_LEN_SIZE);
							memcpy(disk[disk_partition_cnt], p, 4); 
							change_Enter(disk[disk_partition_cnt]);
							disk_partition_cnt++;
						}
						else
						{
							break;
						}
					}
				}
				
				//judge and add to global
				disk_mount_cnt_temp = g_disk_mount_cnt;
				for (int i = 0; i < disk_partition_cnt; i++)
				{
					if (disk_Is_Exit(disk[i]))
						continue;

					//if len=3 disk have no partition
					if (strlen(disk[i]) == 3)
					{
						if ( !disk_Is_Single_Partition(disk[i]))
							continue;
					}
						
					memcpy(g_disk_mount[g_disk_mount_cnt], disk[i], strlen(disk[i]));
					g_disk_mount_cnt++;
				}
				run_Mount(g_disk_mount_cnt - disk_mount_cnt_temp);
			}
			else
			{
				//find the umount disk list and umount
				for (int i = 0; i < PARTITION_CNT_MAX; i++)
				{
					disk_umount_pos[i] = -1;
				}
				disk_umount_cnt = 0;
				for (int i = 0; i < g_disk_mount_cnt; i++)
				{
					if (strstr(buff,g_disk_mount[i]) == NULL)
					{	
						memset(cmd, 0, CMD_SIZE);
						sprintf(cmd,"umount /media/%s",g_disk_mount[i]);
						if ( 0 != run_System_Cmd(cmd))
						{
							memset(cmd, 0, CMD_SIZE);
							sprintf(cmd,"umount /media/%s -l",g_disk_mount[i]);
							run_System_Cmd(cmd);
						}
						
						memset(cmd, 0, CMD_SIZE);
						sprintf(cmd, "rm /media/%s -rf", g_disk_mount[i]);
						run_System_Cmd(cmd);
	
						disk_umount_pos[disk_umount_cnt] = i;
						disk_umount_cnt++;
					}
				}
				
				#ifdef DEBUG
				printf("get g_disk_umount_cnt: %d\n", disk_umount_cnt);
				#endif
				
				//clear the umount disk from global
				for (int i = 0; i < disk_umount_cnt; i++)
				{
					if (disk_umount_pos[i] == -1)
						continue;
						
					memset(g_disk_mount[disk_umount_pos[i]], 0, PARTITION_LEN_SIZE);
				}
				
				
				//reset the global
				g_disk_mount_cnt = g_disk_mount_cnt - disk_umount_cnt;
				int temp_cnt = 0;
				for (int i = 0; i < PARTITION_CNT_MAX; i++)
				{
					if (temp_cnt == g_disk_mount_cnt)
						break;
						
					if (strlen(g_disk_mount[i]) != 0)
					{
						memcpy(g_disk_mount[temp_cnt], g_disk_mount[i], PARTITION_LEN_SIZE);
						temp_cnt++;
					}
				}
				for (int i = temp_cnt; i < PARTITION_CNT_MAX; i++)
				{
					memset(g_disk_mount[i], 0, PARTITION_LEN_SIZE);
				}	
			}
			disk_num = disk_num_temp;
		}
		else if (disk_num_temp != NORMAL_DISK_NUM)
		{
			if (true != check_Disk_Mount(buff))
			{
				//refresh
				disk_num = 0;
			}
		}
		
		#ifdef DEBUG
		printf("get g_disk_mount_cnt: %d\n", g_disk_mount_cnt);
		for (int i = 0; i < g_disk_mount_cnt; i++)
		{
			printf("mount disk[%d]: %s\n", i, g_disk_mount[i]);
		}
		#endif	
		
		usleep(SLEEP_TIME_US);
	}
}

 

小狸猫扑通扑通
关注
  • 0
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
linux 使用udev 自动挂载U盘
qq_51355375的博客
04-24 760
在linux下，插入u盘，使用 dmesg -T 命令显示内核缓冲区中的系统启动信息和内核运行时的通知。它可以帮助用户查看系统启动时的硬件信息、设备驱动加载信息、内核模块加载信息等。-T可显示时间戳使用上述命令可以看到最新的设备信息是一个可移动磁盘，通常使用方法是使用mount 挂载并查看，因为这里使用的U盘中下载了linux镜像系统，所以sda2其为linux启动盘的根文件分区。
用c语言实现对u盘的操作
10-19
介绍了在嵌入式系统利用CH735对u盘的操作，同时介绍了USB总线接口CH735的特点及FAT系统的组成，给出了USB的接口电路及软件流程
linux 下C语言挂载U盘
weed_hz的专栏
02-11 7683
能定时主动的检查u盘 移动硬盘 usb光驱 除光驱外能实现自动mount到指定的路径 对于u盘能区分有分区表的和没有分区表 光驱提供了两个函数mount 和umount，并能检测vcd和cd 并使用cdfs格式进行mount。 对于分区格式的支持要看大家内核的支持情况具体修改代码 下面代码仅仅支持fat32的。#include #include #include #i
liunx下判断c语言是否挂载U盘
逼哥很疯狂的博客
05-14 2527
//判断是否插入U盘 char* cmd1 = "ls /sys/class/scsi_device/"; fp = popen( cmd1 , "r"); fread(buf, 1, 7, fp); printf("USB drive buf now. buf = %s \n",buf); // 未查出U盘信息，判空 if(buf != NULL){ ...
Linux脚本区分硬盘和u盘,Linux下C语言来检测USB设备以及自动区分U盘和硬盘并自动挂载...
weixin_30181209的博客
05-02 522
别的不说直接上代码/*************************************************************************> File Name: test.c> Author: lizhu> Mail: 1489306911@qq.com> Created Time: 2015年11月28日 星期六 11时05分05秒*****...
linux下检测U盘挂载成功demo
11-08
检测U盘是否挂载成功c语言实现，检测时间5s，通过打开路径，写入和读取同一文件实现
傻瓜式制作U盘启动盘
05-06
要是这个启动盘里，带有GHOST各个版本，又带有网吧所需的各种实用工具、网克工具，还有一个miniPE系统，可以轻松的进行数据转移和系统恢复、甚至全新安装系统，那是不是能完美的解决这些烦恼？ U盘是个不错的选择！...
大白菜U盘傻瓜式制作工具
10-09
大白菜U盘制作工具，可以导入windows7和XP镜像文件，PE操作，简单明了。
傻瓜式制作OS-X-10.7-10.10各版本安装U盘——DiskMaker-X.doc编程资料
04-02
傻瓜式制作OS-X-10.7-10.10各版本安装U盘——DiskMaker-X.doc编程资料
防止U盘被攻击傻瓜版程序
04-06
防止U盘被攻击傻瓜版程序，请按程序内指引操作哦！
基于linux的贪吃蛇 C语言版,超详细备注，傻瓜式教程
10-11
void initalGameArea(void); // 初始化游戏区域 void drawBlock(char block[NR][NR]); // 画方块 void cleanBlock(char block[NR][NR]);... // 游戏自动运行 void checkDeleteLine(void); // 检查是否满一行
嵌入式Linux利用udev实现自动检测挂载U盘
cfl927096306的博客
07-09 2301
udev配置文件是/etc/udev/udev.conf，也许长这样： # udev.conf # The initial syslog(3) priority: "err", "info", "debug" or its # state can be changed with: "udevcontrol log_priority=<value>". udev_root="/dev...
嵌入式Linux驱动学习【14】—— U盘自动挂载
chen06130的博客
08-23 288
1 源码流程   实现U盘的自动挂接，在/etc/mdev.conf文件里加入一行语句就能实现自动装载u盘。   如何调用到/etc/mdev.conf，以之前的驱动为例，创建设备 device_create ---> device_create_vargs ---> device_register ---> device_add ---> kobject_uevent ---> kobject_uevent_env int kobject_ue
C语言中linux下查看sd卡mount的位置
伴剑走江湖
03-02 5071
linux 查找sd卡mount的位置： #include //std::istringstream #include //FILE and popen #include ......其他头文件...... std::string getSDCardPath(); 主函数(getSDFCardPath); ......其他函数...... std::string getSD
检测u盘是否挂载上方法
weixin_30437337的博客
03-22 309
打开内核log：echo "8" > /proc/sys/kernel/printk 关闭内核log：echo "1" > /proc/sys/kernel/printk 转载于:https://www.cnblogs.com/senior-engineer/p/8626046.html
C/C++执行cmd命令-system()
baidu_28342107的博客
09-14 2713
cmd常用命令 calc：启动计算器notepad：打开记事本netstat -a:查看所有的端口tasklist：查看所有的进程d: : 切换到D盘dir(directory) 列出当前目录下的文件以及文件夹md (make directory) 创建目录rd (remove directory) 删除目录(带内容的文件或者文件夹不能直接删除，必须先删除里面，再删除外面)。如果要删除非空目录，...
linux系统可以做到傻瓜式安装mysql吗
最新发布
05-10
在Linux系统上，可以通过包管理器来安装MySQL，以达到傻瓜式安装的效果。例如，在Ubuntu系统上，可以使用以下命令来安装MySQL： ``` sudo apt-get update sudo apt-get install mysql-server ``` 在CentOS系统上，可以使用以下命令来安装MySQL： ``` sudo yum install mysql-server ``` 这些命令将自动下载和安装MySQL，并在安装过程中提示您输入密码和其他配置信息。因此，这是一种相对简单和傻瓜式的方式来安装MySQL。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值