Lab2: System calls总结

已于 2023-10-12 15:05:48 修改
阅读量98 收藏
点赞数
分类专栏： mit6.s081 文章标签： 服务器
于 2023-10-12 15:05:15 首次发布

如何创建新系统调用

首先在内核中合适的位置，实现我们的内核调用（在这里是 trace 调用）：

 // kernel/sysproc.c
 // 这里着重理解如何添加系统调用，对于这个调用的具体代码细节在后面的部分分析
 uint64
 sys_trace(void)
 {
 int mask;

 if(argint(0, &mask) < 0)
     return -1;
	
 myproc()->syscall_trace = mask;
 return 0;
 }

在 syscall.h 中加入新 system call 的序号：

 // kernel/syscall.h
 // System call numbers
 #define SYS_fork    1
 #define SYS_exit    2
 #define SYS_wait    3
 #define SYS_pipe    4
 #define SYS_read    5
 #define SYS_kill    6
 #define SYS_exec    7
 #define SYS_fstat   8
 #define SYS_chdir   9
 #define SYS_dup    10
 #define SYS_getpid 11
 #define SYS_sbrk   12
 #define SYS_sleep  13
 #define SYS_uptime 14
 #define SYS_open   15
 #define SYS_write  16
 #define SYS_mknod  17
 #define SYS_unlink 18
 #define SYS_link   19
 #define SYS_mkdir  20
 #define SYS_close  21
 #define SYS_trace  22 // here!!!!!

用 extern 全局声明新的内核调用函数，并且在 syscalls 映射表中，加入从前面定义的编号到系统调用函数指针的映射

 // kernel/syscall.c 
 extern uint64 sys_chdir(void);
 extern uint64 sys_close(void);
 extern uint64 sys_dup(void);
 extern uint64 sys_exec(void);
 extern uint64 sys_exit(void);
 extern uint64 sys_fork(void);
 extern uint64 sys_fstat(void);
 extern uint64 sys_getpid(void);
 extern uint64 sys_kill(void);
 extern uint64 sys_link(void);
 extern uint64 sys_mkdir(void);
 extern uint64 sys_mknod(void);
 extern uint64 sys_open(void);
 extern uint64 sys_pipe(void);
 extern uint64 sys_read(void);
 extern uint64 sys_sbrk(void);
 extern uint64 sys_sleep(void);
 extern uint64 sys_unlink(void);
 extern uint64 sys_wait(void);
 extern uint64 sys_write(void);
 extern uint64 sys_uptime(void);
 extern uint64 sys_trace(void);   // HERE

 static uint64 (*syscalls[])(void) = {
 [SYS_fork]    sys_fork,
 [SYS_exit]    sys_exit,
 [SYS_wait]    sys_wait,
 [SYS_pipe]    sys_pipe,
 [SYS_read]    sys_read,
 [SYS_kill]    sys_kill,
 [SYS_exec]    sys_exec,
 [SYS_fstat]   sys_fstat,
 [SYS_chdir]   sys_chdir,
 [SYS_dup]     sys_dup,
 [SYS_getpid]  sys_getpid,
 [SYS_sbrk]    sys_sbrk,
 [SYS_sleep]   sys_sleep,
 [SYS_uptime]  sys_uptime,
 [SYS_open]    sys_open,
 [SYS_write]   sys_write,
 [SYS_mknod]   sys_mknod,
 [SYS_unlink]  sys_unlink,
 [SYS_link]    sys_link,
 [SYS_mkdir]   sys_mkdir,
 [SYS_close]   sys_close,
 [SYS_trace]   sys_trace,  // AND HERE
 };

这里 [SYS_trace] sys_trace 是 C 语言数组的一个语法，表示以方括号内的值作为元素下标。比如 int arr[] = {[3] 2333, [6] 6666} 代表 arr 的下标 3 的元素为 2333，下标 6 的元素为 6666，其他元素填充 0 的数组。（该语法在 C++ 中已不可用）

在 usys.pl 中，加入用户态到内核态的跳板函数。

 # user/usys.pl

 entry("fork");
 entry("exit");
 entry("wait");
 entry("pipe");
 entry("read");
 entry("write");
 entry("close");
 entry("kill");
 entry("exec");
 entry("open");
 entry("mknod");
 entry("unlink");
 entry("fstat");
 entry("link");
 entry("mkdir");
 entry("chdir");
 entry("dup");
 entry("getpid");
 entry("sbrk");
 entry("sleep");
 entry("uptime");
 entry("trace");  # HERE

这个脚本在运行后会生成 usys.S 汇编文件，里面定义了每个 system call 的用户态跳板函数：

在用户态的头文件加入定义，使得用户态程序可以找到这个跳板入口函数。

 // user/user.h
 // system calls
 int fork(void);
 int exit(int) __attribute__((noreturn));
 int wait(int*);
 int pipe(int*);
 int write(int, const void*, int);
 int read(int, void*, int);
 int close(int);
 int kill(int);
 int exec(char*, char**);
 int open(const char*, int);
 int mknod(const char*, short, short);
 int unlink(const char*);
 int fstat(int fd, struct stat*);
 int link(const char*, const char*);
 int mkdir(const char*);
 int chdir(const char*);
 int dup(int);
 int getpid(void);
 char* sbrk(int);
 int sleep(int);
 int uptime(void);
 int trace(int);		// HERE

System call tracing (moderate)

在这里插入图片描述
首先在 proc.h 中修改 proc 结构的定义，添加 syscall_trace field，用 mask 的方式记录要 trace 的 system call。

// kernel/proc.h
// Per-process state
struct proc {
  struct spinlock lock;

  // p->lock must be held when using these:
  enum procstate state;        // Process state
  struct proc *parent;         // Parent process
  void *chan;                  // If non-zero, sleeping on chan
  int killed;                  // If non-zero, have been killed
  int xstate;                  // Exit status to be returned to parent's wait
  int pid;                     // Process ID

  // these are private to the process, so p->lock need not be held.
  uint64 kstack;               // Virtual address of kernel stack
  uint64 sz;                   // Size of process memory (bytes)
  pagetable_t pagetable;       // User page table
  struct trapframe *trapframe; // data page for trampoline.S
  struct context context;      // swtch() here to run process
  struct file *ofile[NOFILE];  // Open files
  struct inode *cwd;           // Current directory
  char name[16];               // Process name (debugging)
  uint64 syscall_trace;        // Mask for syscall tracing (新添加的用于标识追踪哪些 system call 的 mask)
};

在 proc.c 中，创建新进程的时候，为新添加的 syscall_trace 附上默认值 0（否则初始状态下可能会有垃圾数据）。

// kernel/proc.c
static struct proc*
allocproc(void)
{
  ......

  memset(&p->context, 0, sizeof(p->context));
  p->context.ra = (uint64)forkret;
  p->context.sp = p->kstack + PGSIZE;

  p->syscall_trace = 0; // (newly added) 为 syscall_trace 设置一个 0 的默认值

  return p;
}

在 sysproc.c 中，实现 system call 的具体代码，也就是设置当前进程的 syscall_trace mask：

// kernel/sysproc.c
uint64
sys_trace(void)
{
  int mask;

  if(argint(0, &mask) < 0) // 通过读取进程的 trapframe，获得 mask 参数
    return -1;
  
  myproc()->syscall_trace = mask; // 设置调用进程的 syscall_trace mask
  return 0;
}

修改 fork 函数，使得子进程可以继承父进程的 syscall_trace mask：

// kernel/proc.c
int
fork(void)
{
  ......

  safestrcpy(np->name, p->name, sizeof(p->name));

  np->syscall_trace = p->syscall_trace; // HERE!!! 子进程继承父进程的 syscall_trace

  pid = np->pid;

  np->state = RUNNABLE;

  release(&np->lock);

  return pid;
}

根据上方提到的系统调用的全流程，可以知道，所有的系统调用到达内核态后，都会进入到 syscall() 这个函数进行处理，所以要跟踪所有的内核函数，只需要在 syscall() 函数里输出就行了。

// kernel/syscall.c
void
syscall(void)
{
  int num;
  struct proc *p = myproc();

  num = p->trapframe->a7;
  if(num > 0 && num < NELEM(syscalls) && syscalls[num]) { // 如果系统调用编号有效
    p->trapframe->a0 = syscalls[num](); // 通过系统调用编号，获取系统调用处理函数的指针，调用并将返回值存到用户进程的 a0 寄存器中
	// 如果当前进程设置了对该编号系统调用的 trace，则打出 pid、系统调用名称和返回值。
    if((p->syscall_trace >> num) & 1) {
      printf("%d: syscall %s -> %d\n",p->pid, syscall_names[num], p->trapframe->a0); // syscall_names[num]: 从 syscall 编号到 syscall 名的映射表
    }
  } else {
    printf("%d %s: unknown sys call %d\n",
            p->pid, p->name, num);
    p->trapframe->a0 = -1;
  }
}

上面打出日志的过程还需要知道系统调用的名称字符串，在这里定义一个字符串数组进行映射：

// kernel/syscall.c
const char *syscall_names[] = {
[SYS_fork]    "fork",
[SYS_exit]    "exit",
[SYS_wait]    "wait",
[SYS_pipe]    "pipe",
[SYS_read]    "read",
[SYS_kill]    "kill",
[SYS_exec]    "exec",
[SYS_fstat]   "fstat",
[SYS_chdir]   "chdir",
[SYS_dup]     "dup",
[SYS_getpid]  "getpid",
[SYS_sbrk]    "sbrk",
[SYS_sleep]   "sleep",
[SYS_uptime]  "uptime",
[SYS_open]    "open",
[SYS_write]   "write",
[SYS_mknod]   "mknod",
[SYS_unlink]  "unlink",
[SYS_link]    "link",
[SYS_mkdir]   "mkdir",
[SYS_close]   "close",
[SYS_trace]   "trace",
};

编译执行：

$ trace 32 grep hello README
3: syscall read -> 1023
3: syscall read -> 966
3: syscall read -> 70
3: syscall read -> 0
$
$ trace 2147483647 grep hello README
4: syscall trace -> 0
4: syscall exec -> 3
4: syscall open -> 3
4: syscall read -> 1023
4: syscall read -> 966
4: syscall read -> 70
4: syscall read -> 0
4: syscall close -> 0
$

成功追踪并打印出相应的系统调用。

Sysinfo (moderate)

添加一个系统调用，返回空闲的内存、以及已创建的进程数量。其主要难点在如何获取空闲内存和如何获取已创建进程上面了，这两个函数根据lab给的提示进行完成。

获取空闲内存

在内核的头文件中声明计算空闲内存的函数。

// kernel/defs.h
void*           kalloc(void);
void            kfree(void *);
void            kinit(void);
uint64 			count_free_mem(void); // here

在 kalloc.c 中添加计算空闲内存的函数：

// kernel/kalloc.c
uint64
count_free_mem(void) // added for counting free memory in bytes (lab2)
{
  acquire(&kmem.lock); // 必须先锁内存管理结构，防止竞态条件出现
  
  // 统计空闲页数，乘上页大小 PGSIZE 就是空闲的内存字节数
  uint64 mem_bytes = 0;
  struct run *r = kmem.freelist;
  while(r){
    mem_bytes += PGSIZE;
    r = r->next;
  }

  release(&kmem.lock);

  return mem_bytes;
}

xv6 中，空闲内存页的记录方式是，将空虚内存页本身直接用作链表节点，形成一个空闲页链表，每次需要分配，就把链表根部对应的页分配出去。每次需要回收，就把这个页作为新的根节点，把原来的 freelist 链表接到后面。 可以根据kalloc()函数观察得到。

// kernel/kalloc.c
// Allocate one 4096-byte page of physical memory.
// Returns a pointer that the kernel can use.
// Returns 0 if the memory cannot be allocated.
void *
kalloc(void)
{
  struct run *r;

  acquire(&kmem.lock);
  r = kmem.freelist; // 获得空闲页链表的根节点
  if(r)
    kmem.freelist = r->next;
  release(&kmem.lock);

  if(r)
    memset((char*)r, 5, PGSIZE); // fill with junk
  return (void*)r; // 把空闲页链表的根节点返回出去，作为内存页使用（长度是 4096）
}

常见的记录空闲页的方法有：空闲表法、空闲链表法、位示图法（位图法）、成组链接法。这里 xv6 采用的是空闲链表法。

获取运行的进程数

同样在内核的头文件中添加函数声明：

// kernel/defs.h
......
void            sleep(void*, struct spinlock*);
void            userinit(void);
int             wait(uint64);
void            wakeup(void*);
void            yield(void);
int             either_copyout(int user_dst, uint64 dst, void *src, uint64 len);
int             either_copyin(void *dst, int user_src, uint64 src, uint64 len);
void            procdump(void);
uint64			count_process(void); // here

在 proc.c 中实现该函数：

uint64
count_process(void) { // added function for counting used process slots (lab2)
  uint64 cnt = 0;
  for(struct proc *p = proc; p < &proc[NPROC]; p++) {
    // acquire(&p->lock);
    // 不需要锁进程 proc 结构，因为我们只需要读取进程列表，不需要写
    if(p->state != UNUSED) { // 不是 UNUSED 的进程位，就是已经分配的
        cnt++;
    }
  }
  return cnt;
}

实现 sysinfo 系统调用

流程与实验 1 类似。

在 user.h 实现头文件定义，提供用户态入口：

// user.h
char* sbrk(int);
int sleep(int);
int uptime(void);
int trace(int);
struct sysinfo; // 这里要声明一下 sysinfo 结构，供用户态使用。
int sysinfo(struct sysinfo *);

在 usys.pl 加入用户态到内核态的跳板函数：

entry("sbrk");
entry("sleep");
entry("uptime");
entry("sysinfo");

在 syscall.h 中加入新 system call 的序号

#define SYS_unlink 18
#define SYS_link   19
#define SYS_mkdir  20
#define SYS_close  21
#define SYS_trace  22 // here!!!!!
#define SYS_sysinfo  22 // here!!!!!

用 extern 全局声明新的内核调用函数，并且在 syscalls 映射表中，加入从前面定义的编号到系统调用函数指针的映射

extern uint64 sys_chdir(void);
extern uint64 sys_close(void);
extern uint64 sys_dup(void);
extern uint64 sys_exec(void);
extern uint64 sys_exit(void);
extern uint64 sys_fork(void);
extern uint64 sys_fstat(void);
extern uint64 sys_getpid(void);
extern uint64 sys_kill(void);
extern uint64 sys_link(void);
extern uint64 sys_mkdir(void);
extern uint64 sys_mknod(void);
extern uint64 sys_open(void);
extern uint64 sys_pipe(void);
extern uint64 sys_read(void);
extern uint64 sys_sbrk(void);
extern uint64 sys_sleep(void);
extern uint64 sys_unlink(void);
extern uint64 sys_wait(void);
extern uint64 sys_write(void);
extern uint64 sys_uptime(void);
extern uint64 sys_trace(void);   // HERE
extern uint64 sys_sysinfo(void);   // HERE



static uint64 (*syscalls[])(void) = {
[SYS_fork]    sys_fork,
[SYS_exit]    sys_exit,
[SYS_wait]    sys_wait,
[SYS_pipe]    sys_pipe,
[SYS_read]    sys_read,
[SYS_kill]    sys_kill,
[SYS_exec]    sys_exec,
[SYS_fstat]   sys_fstat,
[SYS_chdir]   sys_chdir,
[SYS_dup]     sys_dup,
[SYS_getpid]  sys_getpid,
[SYS_sbrk]    sys_sbrk,
[SYS_sleep]   sys_sleep,
[SYS_uptime]  sys_uptime,
[SYS_open]    sys_open,
[SYS_write]   sys_write,
[SYS_mknod]   sys_mknod,
[SYS_unlink]  sys_unlink,
[SYS_link]    sys_link,
[SYS_mkdir]   sys_mkdir,
[SYS_close]   sys_close,
[SYS_trace]   sys_trace,  // AND HERE
[SYS_sysinfo] sys_sysinfo,   // AND HERE
};

在上一题实现的系统调用名映射表中加入sysinfo

const char *syscall_names[] = {
[SYS_fork]    "fork",
[SYS_exit]    "exit",
[SYS_wait]    "wait",
[SYS_pipe]    "pipe",
[SYS_read]    "read",
[SYS_kill]    "kill",
[SYS_exec]    "exec",
[SYS_fstat]   "fstat",
[SYS_chdir]   "chdir",
[SYS_dup]     "dup",
[SYS_getpid]  "getpid",
[SYS_sbrk]    "sbrk",
[SYS_sleep]   "sleep",
[SYS_uptime]  "uptime",
[SYS_open]    "open",
[SYS_write]   "write",
[SYS_mknod]   "mknod",
[SYS_unlink]  "unlink",
[SYS_link]    "link",
[SYS_mkdir]   "mkdir",
[SYS_close]   "close",
[SYS_trace]   "trace",
[SYS_sysinfo]   "sysinfo",

};

在sysproc.h添加实现函数

uint64
sys_sysinfo(void)
{
  // 从用户态读入一个指针，作为存放 sysinfo 结构的缓冲区
  uint64 addr;
  if(argaddr(0, &addr) < 0)
    return -1;
  
  struct sysinfo sinfo;
  sinfo.freemem = count_free_mem(); // kalloc.c
  sinfo.nproc = count_process(); // proc.c
  
  // 使用 copyout，结合当前进程的页表，获得进程传进来的指针（逻辑地址）对应的物理地址
  // 然后将 &sinfo 中的数据复制到该指针所指位置，供用户进程使用。
  if(copyout(myproc()->pagetable, addr, (char *)&sinfo, sizeof(sinfo)) < 0)
    return -1;
  return 0;
}

编译运行：

$ sysinfotest
sysinfotest: start
sysinfotest: OK
陌养
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Oracle Solaris 9 man pages section 2: System Calls-358
07-04
Oracle Solaris 9 man pages section 2: System Calls-358
Oracle Solaris 8 man pages section 2: System Calls-334
07-03
Oracle Solaris 8 man pages section 2: System Calls-334
Lab2: system calls 引导/详解
qq_53111905的博客
09-16 1505
Lab2: system calls 引导 System call tracing（moderate） 在本作业中，您将添加一个系统调用跟踪功能，该功能可能会在以后调试实验时对您有所帮助。您将创建一个新的trace系统调用来控制跟踪。它应该有一个参数，这个参数是一个整数“掩码”（mask），它的比特位指定要跟踪的系统调用。例如，要跟踪fork系统调用，程序调用trace(1 << SYS_fork)，其中SYS_fork是kernel/syscall.h中的系统调用编号。如果在掩码中设置了系统调
Lab2: System Call
m0_57225567的博客
10-26 397
MIT 6.S081 Lab2: 实现 trace 和 sysinfo 两个系统调用...
xv6---Lab2: system calls
zion--6135的博客
11-29 2045
执行syscall函数的时候，会将num赋值为寄存器a7的值，并通过num找到syscalls中的系统调用号对应的函数指针。至此可以去调用sys_trace函数了，这里需要关注：trace如何拿到传入的参数。而执行trace系统调用（li a7 22 和 ecall之后，），程序会跳转到syscall.c的void syscall(void)函数，这里就可理解为什么要把a7赋值为22了。具体实现如下：argint用于拿到系统调用传递的参数，0-5的参数，对应寄存器a0-a5。
[mit6.s081] 笔记 Lab2:system calls
m0_61705102的博客
08-31 816
这个实验相较于上一个实验，难度加大了好多，主要难点就在于阅读源码。刚开始做lab1时很蒙，不知道要干哈。在看了相关的xv6文档，视频课程，阅读部分源码和查阅资料后，才有头绪完成了该实验，收货还是很大的。后面实验肯定会越来越难，要继续坚持下去。...
【MIT-6.1810】Lab: system calls
weixin_46322986的博客
06-25 325
MIT-6.1810 / MIT-6.s081，Lab2：system calls
Lab2: system calls
weixin_52435933的博客
09-25 123
上周打了一场数模国赛，打前元气超人，打完葛优躺平。Lab2只有两个小实验，聚焦于如何创建系统调用命令，也并不是那么简单，实验文档戳这。 ❖ Coding ☑︎ System call tracing(moderate)我们需要创建一个trace系统调用来追踪一个命令中指定的系统调用，并打印出相应的返回值。 $ trace 2147483647 grep hello RE...
MIT 6.S081 Lab2: system calls
落队的飞行兵
11-11 1377
先看了一下所需要的系统调用方面的知识，然后花了两天时间做完了实验二，实验手册在 syscall，我的实验代码在 github。 实验二的目的是让我们实现两个系统调用函数，先来简单介绍一下前置知识。 操作系统的主要功能就是管理硬件，避免程序直接和硬件进行交互，而是通过内核来操作硬件，例如，使用CPU、读取内存和写入磁盘等操作。操作系统具有两大特性：隔离性（Isolation）和防御性（Defensive）。
[MIT 6.S081] Lab 2: system calls
LostUnravel的博客
11-14 1389
Lab 2: system calls Lab Guidance: Lab: system calls Lab Code: https://github.com/VastRock-Huang/xv6-labs-2020/tree/syscall System call tracing (moderate) 要点 int trace(int mask) 系统调用 如果在掩码 mask 中设置了系统调用的编号, 则必须修改xv6内核, 以便在每个系统调用即将返回时打印出一行, 包含进程id、系统调用的名称
MIT 6s081 lab2:system calls
厚积而薄发
01-15 350
U/_traceprocfork()1、在用户层声明接口2、在内核中，把用户调用的参数读入，然后传给进程结构体的参数3、在fork中，把父进程的参数拷贝给子进程4、在syscall统一的接口中（通过确定系统调用的编号，作为函数指针数组中的索引，进而调用到具体的函数，函数调用的参数从进程的参数中获取argint函数。
Oracle Solaris 8 man pages section 2: System Calls-336
07-03
Oracle Solaris 8 man pages section 2: System Calls-336
Oracle Solaris 11.1 man pages section2:System Calls-390
06-20
Oracle Solaris 11.1 man pages section2:System Calls-390
Oracle Solaris 11 man pages section2:System Calls-368
06-19
Oracle Solaris 11 man pages section2:System Calls-368
microsoft的azure语音，开发环境运行正常，发布到centos7线上服务器之后，无法运行
向来缘浅，奈何情深
05-08 811
microsoft的azure语音，开发环境运行正常，发布到centos7线上服务器之后，无法运行。记录下坎坷的解决过程！
Linux常见指令2️⃣
最新发布
2202_75331338的博客
05-11 292
tail命令从指定点开始将文件写到标准输出，使用tail命令的 -f 选项可以方便的查阅正在改变的日志文件，tail -f filename 会把 filename 里最尾部的内容显示在屏幕上，并且不但刷新，使你看到最新的文件内容。说明：cp指令用于复制文件或目录，如同时指定两个以上的文件或目录，且最后的目的地是一个已经存在的目录，则它会把前面指定的所有文件或目录复制到此目录中，若同时指定多个文件或目录，而最后的目的地并非一个已存在的目录，则会出现错误信息。减少网络传输的数据量。为什么要打包和压缩？
websevere服务器从零搭建到上线（三）｜IO多路复用小总结和服务器的基础框架
糖炒栗子
05-06 1090
然后通过⼀个叫 Acceptor 的模块，将具体的连接分配给到⼀些叫做 SubReactor 的 模块，在 SubReactor 中对具体的连接进⾏读、编码、计算、解码和写操作（即对 client 请求的响应）。因此，基于select模型的 服务器程序，要达到100万级别的并发访问，是一个很难完成的任务。同时，epoll_wait的效率也非常高，因为调用epoll_wait时，并没有 向操作系统复制这100万个连接的句柄数据，内核也不需要去遍历全部的连接。之后我们主要关注这四个组件的通信即可。
解决Eclipse导入项目后右键Run as无存在的服务器(显示Run Configuration)可用
qq_62571013的博客
05-05 216
解决Eclipse导入项目后右键Run as无存在的服务器(显示Run Configuration)可用
mock单元测试到INFO：SystemStatus：Starting就不往下执行了
06-07
mock_print.assert_has_calls([call("INFO:SystemStatus:Starting")]) ``` 在这个例子中，我们使用`patch`来替换`print`函数，并且在测试中检查是否调用了正确的字符串。您可以根据您的实际情况修改这个示例代码。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值