free -h
swapon --show

# 方法一：使用 fallocate 快速创建（推荐）
sudo fallocate -l 2G /swapfile

# 方法二：如果 fallocate 命令不可用，使用 dd 命令
sudo dd if=/dev/zero of=/swapfile bs=1G count=2

sudo chmod 600 /swapfile

sudo mkswap /swapfile

sudo swapon /swapfile

free -h

              total        used        free      shared  buff/cache   available
Mem:           2.0G        1.2G        100M         10M        700M        600M
Swap:          2.0G          0B        2.0G

echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

cat /etc/fstab

# 查看当前 swappiness 值
cat /proc/sys/vm/swappiness

# 临时修改（重启后失效）
sudo sysctl vm.swappiness=10

# 永久修改
echo 'vm.swappiness=10' | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

# 查看内存使用情况
free -h

# 持续监控（每 2 秒刷新一次）
watch -n 2 free -h

for file in /proc/*/status ; do awk '/VmSwap|Name/{printf $2 " " $3}END{ print ""}' $file; done | sort -k 2 -n -r | head -10

# 1. 关闭 Swap
sudo swapoff /swapfile

# 2. 从 /etc/fstab 中删除对应行
sudo sed -i '/\/swapfile/d' /etc/fstab

# 3. 删除 Swap 文件
sudo rm /swapfile

{
    "name": "我的服务器",
    "host": "192.168.1.100",
    "protocol": "sftp",
    "port": 22,
    "username": "root",
    "password": "your_password",
    "remotePath": "/var/www/project",
    "uploadOnSave": true,
    "useTempFile": false,
    "openSsh": false
}

{
    "name": "生产环境服务器",
    "host": "192.168.1.100",
    "protocol": "sftp",
    "port": 22,
    "username": "deployer",
    "password": "your_password",
    "remotePath": "/home/deployer/project",
    "context": "./",
    "uploadOnSave": true,
    "useTempFile": false,
    "openSsh": false,
    "downloadOnOpen": false,
    "ignore": [
        ".vscode",
        ".git",
        ".DS_Store",
        "node_modules",
        "*.log",
        "*.tmp"
    ],
    "watcher": {
        "files": "**/*",
        "autoUpload": true,
        "autoDelete": false
    },
    "syncOption": {
        "delete": false,
        "skipCreate": false,
        "ignoreExisting": false,
        "update": true
    },
    "sshConfigPath": null,
    "concurrency": 4
}

{
    "username": "root",
    "password": "your_password"
}

{
    "username": "root",
    "privateKeyPath": "C:\\Users\\YourName\\.ssh\\id_rsa",
    "passphrase": "密钥密码（如果有的话）"
}

{
    "sshConfigPath": "~/.ssh/config",
    "host": "myserver"
}

Host myserver
    HostName 192.168.1.100
    User deployer
    Port 22
    IdentityFile ~/.ssh/id_rsa

project/
├── src/
│   ├── index.js
│   └── utils.js
├── tests/
└── .vscode/
    └── sftp.json

{
    "ignore": [
        "**/.vscode/**",
        "**/.git/**",
        "**/.DS_Store",
        "**/node_modules/**",
        "**/*.log",
        "**/*.tmp",
        "**/dist/**",
        "**/coverage/**"
    ]
}

{
    "watcher": {
        "files": "**/*",
        "autoUpload": true,
        "autoDelete": false
    }
}

{
    "syncOption": {
        "delete": false,
        "skipCreate": false,
        "ignoreExisting": false,
        "update": true
    }
}

{
    "concurrency": 8,
    "connectTimeout": 15000,
    "keepalive": 5000
}

[
    {
        "name": "开发环境",
        "host": "192.168.1.101",
        "port": 22,
        "username": "developer",
        "password": "dev_password",
        "protocol": "sftp",
        "remotePath": "/home/developer/project",
        "uploadOnSave": true,
        "ignore": [
            ".vscode/**",
            ".git/**",
            "node_modules/**"
        ]
    },
    {
        "name": "测试环境",
        "host": "192.168.1.102",
        "port": 22,
        "username": "tester",
        "password": "test_password",
        "protocol": "sftp",
        "remotePath": "/var/www/test",
        "uploadOnSave": false,
        "ignore": [
            ".vscode/**",
            ".git/**",
            "node_modules/**"
        ]
    },
    {
        "name": "生产环境",
        "host": "192.168.1.103",
        "port": 22,
        "username": "deployer",
        "privateKeyPath": "~/.ssh/production_key",
        "protocol": "sftp",
        "remotePath": "/var/www/production",
        "uploadOnSave": false,
        "ignore": [
            ".vscode/**",
            ".git/**",
            "node_modules/**",
            "*.log"
        ]
    }
]

{
    "username": "${env.SFTP_USER}",
    "password": "${env.SFTP_PASSWORD}"
}

{
    "username": "deployer",
    "privateKeyPath": "~/.ssh/id_rsa"
}

.vscode/sftp.json

{
    "name": "示例配置",
    "host": "your_server_ip",
    "username": "your_username",
    "password": "your_password",
    "remotePath": "/path/to/project"
}

{
    "uploadOnSave": true,
    "downloadOnOpen": false,
    "watcher": {
        "autoUpload": true
    }
}

{
    "uploadOnSave": false,
    "syncOption": {
        "update": true,
        "delete": false
    }
}

{
    "name": "团队开发服务器",
    "host": "${env.DEV_SERVER}",
    "username": "${env.DEV_USER}",
    "password": "${env.DEV_PASSWORD}",
    "remotePath": "/home/${env.DEV_USER}/project",
    "uploadOnSave": true,
    "ignore": [
        ".vscode/**",
        ".git/**",
        ".env",
        "node_modules/**",
        "*.log"
    ]
}

{
    "concurrency": 8,
    "ignore": [
        "node_modules/**",
        "dist/**",
        "build/**",
        ".git/**",
        "**/*.log"
    ],
    "syncOption": {
        "update": true
    }
}

df -h

# 清理旧版本缓存
apt-get autoclean
# 清理所有缓存
apt-get clean
# 移除孤立软件
apt-get autoremove

# 查看 journal 日志占用的硬盘空间
journalctl -x --disk-usage
# 清理日志到只剩下 10M
journalctl --vacuum-size=10M
# 清理一天前的日志
journalctl --vacuum-time=1d
# 永久限制 journal 日志的大小：
[Journal]
SystemMaxUse=10M   # 硬盘中只保留最近 10M 的日志
RuntimeMaxUse=10M  # 内存中只保留最近 10M 的日志

# 清理所有停止的容器
docker container prune
# 清理所有未使用的镜像
docker image prune
# 清理所有未使用的卷
docker volume prune
# 清理所有未使用的网络
docker network prune
# 清理所有未使用的镜像、容器、网络、卷，如果你使用docker的话，这一步会释放大量的空间
docker system prune --volumes
WARNING! This will remove:
  - all stopped containers
  - all networks not used by at least one container
  - all volumes not used by at least one container
  - all dangling images
  - all dangling build cache

# 清理 pip 缓存
pip cache purge
rm -r ~/.cache/pip

# 查找大于 100M 的文件
find / -type f -size +100M
# 删除大于 100M 的文件
find / -type f -size +100M -delete

Missed xxx kernel messages

sudo vim /etc/systemd/journald.conf

# RuntimeMaxUse: 设置运行时日志文件的最大使用空间。
# 可以将此值设为较大的值，例如 100M。
RuntimeMaxUse=100M

# SystemMaxUse: 设置系统日志文件的最大使用空间。
# 可以将此值设为 500M。
SystemMaxUse=500M

# RateLimitInterval: 限制日志接收速率的时间间隔。
# 可以适当延长此时间，例如 10s。
RateLimitInterval=10s

# RateLimitBurst: 限制日志接收速率的最大突发数。
# 增加突发限制，比如 10000。
RateLimitBurst=10000

sudo systemctl restart systemd-journald

sudo vim /etc/default/grub

GRUB_CMDLINE_LINUX_DEFAULT="log_buf_len=16M"

sudo update-grub

sudo reboot

sudo vim /etc/systemd/journald.conf

RateLimitInterval=0
RateLimitBurst=0

sudo systemctl restart systemd-journald

OMV\ExecException: Failed to execute command 'export PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin; export LANG=C.UTF-8; omv-salt deploy run --no-color fstab 2>&1' with exit code '1': /usr/lib/python3/dist-packages/requests/__init__.py:91: RequestsDependencyWarning: urllib3 (1.26.18) or chardet (3.0.4) doesn't match a supported version!
  RequestsDependencyWarning)

lsblk
NAME        MAJ:MIN RM   SIZE RO TYPE  MOUNTPOINT
nvme0n1     259:0    0 931.5G  0 disk  

fdisk /dev/nvme0n1
Welcome to fdisk (util-linux 2.39.1).
Changes will remain in memory only, until you decide to write them.
Be careful before using the write command.


# 输入n表示新建分区
Command (m for help): n
Partition type
   p   primary (2 primary, 0 extended, 2 free)
   e   extended (container for logical partitions)
# 输入p表示主分区
Select (default p): p
# 分区号直接回车使用默认的，新硬盘应该为1
Partition number (2-128, default 2):
# 输入两次回车使用默认的，从第一个扇区开始，到最后一个扇区结束，即整个硬盘
# 我因为已经分区完了，所以找了以前的笔记，所以扇区号和实际的大小，你们只需要两次回车就行了
First sector (1001472-452984798, default 1001472):
Last sector, +/-sectors or +/-size{K,M,G,T,P} (1001472-452984798, default 452982783):

# 输入w保存退出
Command (m for help): w
The partition table has been altered.
Calling ioctl() to re-read partition table.
Syncing disks.
# 分区完成了

mkfs.ext4 /dev/nvme0n1p1
mke2fs 1.44.5 (15-Dec-2018)
Creating filesystem with 244189696 4k blocks and 61054976 inodes
Filesystem UUID: 1b1b1b1b-1b1b-1b1b-1b1b-1b1b1b1b1b1b
Superblock backups stored on blocks: 
    32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208, 
    4096000, 7962624, 11239424, 20480000, 23887872, 71663616, 78675968, 
    102400000, 214990848

# 在NAS上创建一个目录，用来挂载新硬盘，我的硬盘都挂载在了srv目录下，所以这里也挂载在srv下
mkdir /srv/download-disk

mount /dev/nvme0n1p1 /srv/download-disk

$ df -h
Filesystem      Size  Used Avail Use% Mounted on
udev            7.6G     0  7.6G   0% /dev
tmpfs           1.6G   13M  1.5G   1% /run
/dev/sda1       116G   97G   14G  88% /
tmpfs           7.6G     0  7.6G   0% /dev/shm
tmpfs           5.0M     0  5.0M   0% /run/lock
tmpfs           7.6G     0  7.6G   0% /sys/fs/cgroup
/dev/nvme0n1p1  916G   28K  870G   1% /srv/download-disk

e2label /dev/nvme0n1p1 Kingston1tb

$ blkid

echo "/dev/nvme0n1p1 /srv/download-disk ext4 defaults 0 0" >> /etc/fstab

sudo apt-get install xclock

export DISPLAY=localhost:10.0
# 或者
export DISPLAY=:0

#generic-repos is licensed under the Mulan PSL v2.
#You can use this software according to the terms and conditions of the Mulan PSL v2.
#You may obtain a copy of Mulan PSL v2 at:
#    http://license.coscl.org.cn/MulanPSL2
#THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
#IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
#PURPOSE.
#See the Mulan PSL v2 for more details.

[OS]
name=OS
baseurl=http://repo.openeuler.org/openEuler-23.09/OS/$basearch/
metalink=https://mirrors.openeuler.org/metalink?repo=$releasever/OS&arch=$basearch
metadata_expire=1h
enabled=1
gpgcheck=1
gpgkey=http://repo.openeuler.org/openEuler-23.09/OS/$basearch/RPM-GPG-KEY-openEuler

[source]
name=source
baseurl=http://repo.openeuler.org/openEuler-23.09/source/
metalink=https://mirrors.openeuler.org/metalink?repo=$releasever&arch=source
metadata_expire=1h
enabled=1
gpgcheck=1
gpgkey=http://repo.openeuler.org/openEuler-23.09/source/RPM-GPG-KEY-openEuler

insmod: ERROR: could not insert module kvm.ko: Invalid module format 

// kernel/module.c
static int check_version(const struct load_info *info,
    const char *symname,
    struct module *mod,
    const s32 *crc)
{
 Elf_Shdr *sechdrs = info->sechdrs;
 unsigned int versindex = info->index.vers;
 unsigned int i, num_versions;
 struct modversion_info *versions;

 /* Exporting module didn't supply crcs?  OK, we're already tainted. */
 if (!crc)
  return 1;

 /* No versions at all?  modprobe --force does this. */
 if (versindex == 0)
  return try_to_force_load(mod, symname) == 0;

 versions = (void *) sechdrs[versindex].sh_addr;
 num_versions = sechdrs[versindex].sh_size
  / sizeof(struct modversion_info);

 for (i = 0; i < num_versions; i++) {
  u32 crcval;

  if (strcmp(versions[i].name, symname) != 0)
   continue;

  if (IS_ENABLED(CONFIG_MODULE_REL_CRCS))
   crcval = resolve_rel_crc(crc);
  else
   crcval = *crc;
  if (versions[i].crc == crcval)
   return 1;
  pr_debug("Found checksum %X vs module %lX\n",
    crcval, versions[i].crc);
  goto bad_version;
 }

 /* Broken toolchain. Warn once, then let it go.. */
 pr_warn_once("%s: no symbol version for %s\n", info->name, symname);
 return 1;

bad_version:
 pr_warn("%s: disagrees about version of symbol %s\n",
        info->name, symname);
 return 0;
}

MODULE_INFO(vermagic, VERMAGIC_STRING);
MODULE_INFO(name, KBUILD_MODNAME);

__visible struct module __this_module
__section(.gnu.linkonce.this_module) = {
 .name = KBUILD_MODNAME,
 .init = init_module,
#ifdef CONFIG_MODULE_UNLOAD
 .exit = cleanup_module,
#endif
 .arch = MODULE_ARCH_INIT,
};

#ifdef CONFIG_RETPOLINE
MODULE_INFO(retpoline, "Y");
#endif

static const struct modversion_info ____versions[]
__used __section(__versions) = {
 { 0x3e549f1d, "module_layout" },
 { 0x5138e6ba, "param_ops_int" },
 { 0x183b57f9, "phy_ethtool_nway_reset" },
 { 0x6e5363eb, "eth_validate_addr" },
 { 0x4df55e5b, "usb_deregister" },
 { 0x8e48f69b, "usb_register_driver" },
}

// kernel/module.c
static inline int check_modstruct_version(const struct load_info *info,
       struct module *mod)
{
 const s32 *crc;

 /*
  * Since this should be found in kernel (which can't be removed), no
  * locking is necessary -- use preempt_disable() to placate lockdep.
  */
 preempt_disable();
 if (!find_symbol("module_layout", NULL, &crc, true, false)) {
  preempt_enable();
  BUG();
 }
 preempt_enable();
 return check_version(info, "module_layout", mod, crc);
}

// 获取当前运行内核 module_layout 函数的 crc 值
find_symbol("module_layout", NULL, &crc, true, false)
    each_symbol_section(find_exported_symbol_in_section, &fsa)
        // 遍历内核三个导出符号表段__start___ksymtab，__start___ksymtab_gpl 和__start___ksymtab_gpl_future，为每段调用 find_symbol_in_section
        each_symbol_in_section(arr, ARRAY_SIZE(arr), NULL, fn, data)
        // 遍历内核每个已加载模块的三个导出符号表段 mod->syms,mod->gpl_syms,mod->gpl_future_syms，为每段调用 find_symbol_in_section
        each_symbol_in_section(arr, ARRAY_SIZE(arr), mod, fn, data)
            // 对导出符号表进行二分查找，按照字符串排序，符号表的地址按照地址排序
            find_exported_symbol_in_section(const struct symsearch *syms,struct module *owner,void *data)

// kernel/module.c
static int check_modinfo(struct module *mod, struct load_info *info, int flags)
{
 const char *modmagic = get_modinfo(info, "vermagic");
 int err;

 if (flags & MODULE_INIT_IGNORE_VERMAGIC)
  modmagic = NULL;

 /* This is allowed: modprobe --force will invalidate it. */
 if (!modmagic) {
  err = try_to_force_load(mod, "bad vermagic");
  if (err)
   return err;
 } else if (!same_magic(modmagic, vermagic, info->index.vers)) {
  pr_err("%s: version magic '%s' should be '%s'\n",
         info->name, modmagic, vermagic);
  return -ENOEXEC;
 }
...

 return 0;
}

# 输出kernel发行版本号
uname -r
6.4.0-10.1.0.20.oe2309.riscv64
# 输出所有信息
uname -a
Linux openeuler 6.4.0-10.1.0.20.oe2309.riscv64 #1 SMP Sat Oct  7 06:19:28 UTC 2023 riscv64 riscv64 riscv64 GNU/Linux

modinfo kvm.ko
filename:       /root/build-kernel/kernel/./arch/riscv/kvm/kvm.ko
license:        GPL
author:         Qumranet
srcversion:     5DA13DC0E55100B5FE1D56A
depends:
intree:         Y
name:           kvm
vermagic:       6.4.0 SMP mod_unload modversions riscv
parm:           halt_poll_ns:uint
parm:           halt_poll_ns_grow:uint
parm:           halt_poll_ns_grow_start:uint
parm:           halt_poll_ns_shrink:uint

# SPDX-License-Identifier: GPL-2.0
VERSION = 6
PATCHLEVEL = 4
SUBLEVEL = 0
EXTRAVERSION =

/* Simply sanity version stamp for modules. */
#ifdef CONFIG_SMP
#define MODULE_VERMAGIC_SMP "SMP "
#else
#define MODULE_VERMAGIC_SMP ""
#endif
#ifdef CONFIG_PREEMPT_BUILD
#define MODULE_VERMAGIC_PREEMPT "preempt "
#elif defined(CONFIG_PREEMPT_RT)
#define MODULE_VERMAGIC_PREEMPT "preempt_rt "
#else
#define MODULE_VERMAGIC_PREEMPT ""
#endif
#ifdef CONFIG_MODULE_UNLOAD
#define MODULE_VERMAGIC_MODULE_UNLOAD "mod_unload "
#else
#define MODULE_VERMAGIC_MODULE_UNLOAD ""
#endif
#ifdef CONFIG_MODVERSIONS
#define MODULE_VERMAGIC_MODVERSIONS "modversions "
#else
#define MODULE_VERMAGIC_MODVERSIONS ""
#endif
#ifdef RANDSTRUCT
#include <generated/randstruct_hash.h>
#define MODULE_RANDSTRUCT "RANDSTRUCT_" RANDSTRUCT_HASHED_SEED
#else
#define MODULE_RANDSTRUCT
#endif

#define VERMAGIC_STRING                                                 \
        UTS_RELEASE " "                                                 \
        MODULE_VERMAGIC_SMP MODULE_VERMAGIC_PREEMPT                     \
        MODULE_VERMAGIC_MODULE_UNLOAD MODULE_VERMAGIC_MODVERSIONS       \
        MODULE_ARCH_VERMAGIC                                            \
        MODULE_RANDSTRUCT

#defineUTS_RELEASE "6.4.0"

make -C /root/build-kernel/kernel M=/driver_study/ modules -j22

make  M=./arch/riscv/kvm modules -j22

# kernel.ld
BASE_ADDRESS = 0x80200000;
SECTIONS
{
   . = BASE_ADDRESS;
   skernel = .;

   stext = .;
   .text : {
      *(.text.entry)   # 第一行代码
      *(.text .text.*)
   }

   ...
}

enum LOG_COLOR {
	RED = 31,
	GREEN = 32,
	BLUE = 34,
	GRAY = 90,
	YELLOW = 93,
};

#if defined(USE_LOG_ERROR)
#define errorf(fmt, ...)                                               \
	do {                                                               \
		int tid = threadid();                                          \
		printf("\x1b[%dm[%s %d]" fmt "\x1b[0m\n", RED, "ERROR", tid,   \
		       ##__VA_ARGS__);                                         \
	} while (0)
#else

// uCore-Tutorial-Code-2023S/os/sbi.c
const uint64 SBI_CONSOLE_PUTCHAR = 1;

void console_putchar(int c)
{
	sbi_call(SBI_CONSOLE_PUTCHAR, c, 0, 0);
}

// uCore-Tutorial-Code-2023S/os/sbi.c
int inline sbi_call(uint64 which, uint64 arg0, uint64 arg1, uint64 arg2)
{
    // 使用寄存器变量来保存参数值和系统调用编号
    register uint64 a0 asm("a0") = arg0;  // 将 'arg0' 的值保存在寄存器 'a0' 中
    register uint64 a1 asm("a1") = arg1;  // 将 'arg1' 的值保存在寄存器 'a1' 中
    register uint64 a2 asm("a2") = arg2;  // 将 'arg2' 的值保存在寄存器 'a2' 中
    register uint64 a7 asm("a7") = which; // 将 'which' 的值保存在寄存器 'a7' 中
    // 内联汇编代码使用 ecall 指令进行系统调用
    asm volatile(
        "ecall"  // 使用 ecall 指令进行系统调用
        // 在这段代码中，指令 "ecall" 的输入参数是寄存器 a0 a1 a2 和 a7，输出参数是寄存器 a0
        : "=r"(a0)  // 输出操作数：将返回值存储在变量 'a0' 中
        : "r"(a0), "r"(a1), "r"(a2), "r"(a7)  // 输入操作数：传递参数和系统调用编号
        : "memory"  //  "memory" 标志告诉编译器，这条指令可能会修改内存中的数据，需要进行内存屏障操作来保证数据的正确性。 
    );
    return a0;  // 返回存储在变量 'a0' 中的值
}

//include/sbi/sbi_ecall.h
extern struct sbi_ecall_extension ecall_base;
extern struct sbi_ecall_extension ecall_legacy;
extern struct sbi_ecall_extension ecall_time;
extern struct sbi_ecall_extension ecall_rfence;
extern struct sbi_ecall_extension ecall_ipi;
extern struct sbi_ecall_extension ecall_vendor;
extern struct sbi_ecall_extension ecall_hsm;
extern struct sbi_ecall_extension ecall_srst;

int sbi_ecall_init(void)
{
	int ret;
	struct sbi_ecall_extension *ext;
	unsigned long i;

	for (i = 0; i < sbi_ecall_exts_size; i++) {
		ext = sbi_ecall_exts[i];
		ret = sbi_ecall_register_extension(ext);
		if (ret)
			return ret;
	}

	return 0;
}
int sbi_ecall_register_extension(struct sbi_ecall_extension *ext)
{
	struct sbi_ecall_extension *t;

	if (!ext || (ext->extid_end < ext->extid_start) || !ext->handle)
		return SBI_EINVAL;

	sbi_list_for_each_entry(t, &ecall_exts_list, head) {
		unsigned long start = t->extid_start;
		unsigned long end = t->extid_end;
		if (end < ext->extid_start || ext->extid_end < start)
			/* no overlap */;
		else
			return SBI_EINVAL;
	}

	SBI_INIT_LIST_HEAD(&ext->head);
	sbi_list_add_tail(&ext->head, &ecall_exts_list);

	return 0;
}

/**
 * Iterate over list of given type
 * @param pos the type * to use as a loop cursor.
 * @param head the head for your list.
 * @param member the name of the list_struct within the struct.
 */
#define sbi_list_for_each_entry(pos, head, member) \
	for (pos = sbi_list_entry((head)->next, typeof(*pos), member);	\
	     &pos->member != (head); 	\
	     pos = sbi_list_entry(pos->member.next, typeof(*pos), member))

// include/sbi/sbi_ecall.h: 23
struct sbi_ecall_extension {
	struct sbi_dlist head;
	unsigned long extid_start;
	unsigned long extid_end;
	int (* probe)(unsigned long extid, unsigned long *out_val);
	int (* handle)(unsigned long extid, unsigned long funcid,
		       const struct sbi_trap_regs *regs,
		       unsigned long *out_val,
		       struct sbi_trap_info *out_trap);
};

// lib/sbi/sbi_ecall_legacy.c
struct sbi_ecall_extension ecall_legacy = {
	.extid_start = SBI_EXT_0_1_SET_TIMER,
	.extid_end = SBI_EXT_0_1_SHUTDOWN,
	.handle = sbi_ecall_legacy_handler,
};

static int sbi_ecall_legacy_handler(unsigned long extid, unsigned long funcid,
				    const struct sbi_trap_regs *regs,
				    unsigned long *out_val,
				    struct sbi_trap_info *out_trap)
{
	int ret = 0;
	struct sbi_tlb_info tlb_info;
	u32 source_hart = current_hartid();
	ulong hmask = 0;

	switch (extid) {
	case SBI_EXT_0_1_SET_TIMER:
		sbi_timer_event_start((u64)regs->a0);
		break;
	case SBI_EXT_0_1_CONSOLE_PUTCHAR:
		sbi_putc(regs->a0);
		break;
	case SBI_EXT_0_1_CONSOLE_GETCHAR:
		ret = sbi_getc();
		break;
	// ...
	};

	return ret;
}

// include/sbi/sbi_ecall_interface.h
/* SBI Extension IDs */
#define SBI_EXT_0_1_CONSOLE_PUTCHAR		0x1

.PHONY: clean build user
# 设置伪目标clean、build和user，可以通过命令make来执行这些目标

all: build_kernel
# 默认目标为build_kernel，即执行build_kernel目标下的指令

LOG ?= error
# 定义一个变量LOG，默认值是error

K = os
TOOLPREFIX = riscv64-unknown-elf-

CC = $(TOOLPREFIX)gcc
AS = $(TOOLPREFIX)gcc
LD = $(TOOLPREFIX)ld
OBJCOPY = $(TOOLPREFIX)objcopy
OBJDUMP = $(TOOLPREFIX)objdump
PY = python3
GDB = $(TOOLPREFIX)gdb
CP = cp

MKDIR_P = mkdir -p

BUILDDIR = build

C_SRCS = $(wildcard $K/*.c)
# 定义一个变量C_SRCS，使用wildcard函数匹配所有以.c为后缀的文件，并存储在$K目录下

AS_SRCS = $(wildcard $K/*.S)
# 定义一个变量AS_SRCS，使用wildcard函数匹配所有以.S为后缀的文件，并存储在$K目录下

C_OBJS = $(addprefix $(BUILDDIR)/, $(addsuffix .o, $(basename $(C_SRCS))))
# 定义一个变量C_OBJS，通过addprefix和addsuffix函数将$(C_SRCS)中的路径替换为$(BUILDDIR)，并将后缀修改为.o

AS_OBJS = $(addprefix $(BUILDDIR)/, $(addsuffix .o, $(basename $(AS_SRCS))))
# 定义一个变量AS_OBJS，通过addprefix和addsuffix函数将$(AS_SRCS)中的路径替换为$(BUILDDIR)，并将后缀修改为.o

OBJS = $(C_OBJS) $(AS_OBJS)
# 定义一个变量OBJS，其值为$(C_OBJS)和$(AS_OBJS)的组合

HEADER_DEP = $(addsuffix .d, $(basename $(C_OBJS)))
# 定义一个变量HEADER_DEP，通过addsuffix函数将$(C_OBJS)中的后缀修改为.d

-include $(HEADER_DEP)
# 包含$(HEADER_DEP)中的.d文件

CFLAGS = -Wall -Werror -O -fno-omit-frame-pointer -ggdb
# 定义一个变量CFLAGS，并赋值为-Wall -Werror -O -fno-omit-frame-pointer -ggdb

CFLAGS += -MD
# 将-MD选项追加到CFLAGS变量中，用于自动生成依赖关系文件

CFLAGS += -mcmodel=medany
# 将-mcmodel=medany选项追加到CFLAGS变量中，用于指定内存模型

CFLAGS += -ffreestanding -fno-common -nostdlib -mno-relax
# 将-ffreestanding -fno-common -nostdlib -mno-relax选项追加到CFLAGS变量中，用于编译无操作系统环境下的程序

CFLAGS += -I$K
# 将-I$K选项追加到CFLAGS变量中，用于指定头文件搜索路径为$K目录下

CFLAGS += $(shell $(CC) -fno-stack-protector -E -x c /dev/null >/dev/null 2>&1 && echo -fno-stack-protector)
# 将$(CC) -fno-stack-protector -E -x c /dev/null >/dev/null 2>&1 && echo -fno-stack-protector命令执行结果追加到CFLAGS变量中，用于禁用栈保护机制

ifeq ($(LOG), error)
CFLAGS += -D LOG_LEVEL_ERROR
else ifeq ($(LOG), warn)
CFLAGS += -D LOG_LEVEL_WARN
else ifeq ($(LOG), info)
CFLAGS += -D LOG_LEVEL_INFO
else ifeq ($(LOG), debug)
CFLAGS += -D LOG_LEVEL_DEBUG
else ifeq ($(LOG), trace)
CFLAGS += -D LOG_LEVEL_TRACE
endif
# 根据$(LOG)变量的值，向CFLAGS变量追加相应的预处理器选项，相当于添加了一个宏定义，log.h中的LOG_LEVEL_ERROR等宏定义会根据这个宏定义来决定是否生效

# Disable PIE when possible (for Ubuntu 16.10 toolchain)
ifneq ($(shell $(CC) -dumpspecs 2>/dev/null | grep -e '[^f]no-pie'),)
CFLAGS += -fno-pie -no-pie
endif
ifneq ($(shell $(CC) -dumpspecs 2>/dev/null | grep -e '[^f]nopie'),)
CFLAGS += -fno-pie -nopie
endif
# 根据系统环境判断是否支持PIE（位置无关执行）选项，并根据情况向CFLAGS变量追加相应的选项

LDFLAGS = -z max-page-size=4096
# 定义一个变量LDFLAGS，并赋值为-z max-page-size=4096

$(AS_OBJS): $(BUILDDIR)/$K/%.o : $K/%.S
    @mkdir -p $(@D)
    $(CC) $(CFLAGS) -c $< -o $@
# 规则：生成$(AS_OBJS)目标所需的依赖文件$(BUILDDIR)/$K/%.o，依赖于$K/%.S，并通过$(CC)命令编译生成目标文件

$(C_OBJS): $(BUILDDIR)/$K/%.o : $K/%.c  $(BUILDDIR)/$K/%.d
    @mkdir -p $(@D)
    $(CC) $(CFLAGS) -c $< -o $@
# 规则：生成$(C_OBJS)目标所需的依赖文件$(BUILDDIR)/$K/%.o，依赖于$K/%.c和$(BUILDDIR)/$K/%.d，并通过$(CC)命令编译生成目标文件

$(HEADER_DEP): $(BUILDDIR)/$K/%.d : $K/%.c
    @mkdir -p $(@D)
    @set -e; rm -f $@; $(CC) -MM $< $(INCLUDEFLAGS) > $@.$$$$; \
        sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \
        rm -f $@.$$$$
# 规则：生成$(HEADER_DEP)目标所需的依赖文件$(BUILDDIR)/$K/%.d，依赖于$K/%.c，并通过$(CC)命令生成依赖关系文件

build: build/kernel
# 定义一个目标build，其依赖于build/kernel

build/kernel: $(OBJS)
    $(LD) $(LDFLAGS) -T os/kernel.ld -o $(BUILDDIR)/kernel $(OBJS)
    $(OBJDUMP) -S $(BUILDDIR)/kernel > $(BUILDDIR)/kernel.asm
    $(OBJDUMP) -t $(BUILDDIR)/kernel | sed '1,/SYMBOL TABLE/d; s/ .* / /; /^$$/d' > $(BUILDDIR)/kernel.sym
    @echo 'Build kernel done'
# 规则：生成build/kernel目标，依赖于$(OBJS)，通过$(LD)命令连接生成kernel，并通过$(OBJDUMP)命令生成汇编文件和符号表

clean:
    rm -rf $(BUILDDIR)

# BOARD
BOARD		?= qemu
SBI			?= rustsbi
BOOTLOADER	:= ./bootloader/rustsbi-qemu.bin

QEMU = qemu-system-riscv64
QEMUOPTS = \
	-nographic \
	-machine virt \
	-bios $(BOOTLOADER) \
	-kernel build/kernel	\

run: build/kernel
	$(QEMU) $(QEMUOPTS)

# QEMU's gdb stub command line changed in 0.11
QEMUGDB = $(shell if $(QEMU) -help | grep -q '^-gdb'; \
	then echo "-gdb tcp::15234"; \
	else echo "-s -p 15234"; fi)

# 启动QEMU并通过GDB调试，此时QEMu会进入后台运行，并暂停执行，等待GDB连接
# 连接的GDB端口为15234
debug: build/kernel .gdbinit
	$(QEMU) $(QEMUOPTS) -S $(QEMUGDB) &
	sleep 1
	$(GDB)

make run
make debug
make clean
# 编译测试用例的前四章
make user CHAPTER=4 LOG=trace
# 编译测试用例的第四章
make user CHAPTER=4_only LOG=trace
# 只运行测试用例的第四章
make test CHAPTER=4_only    

scheduler()
    fetch_task() // 获取下一个要执行的进程
    swtch(&curenv->context, nextenv->context) // 切换到下一个进程上下文

// Per-process state
struct proc {
    enum procstate    state;     // 进程状态
    int               pid;       // 进程 ID
    uint64            ustack;    // 进程用户栈虚拟地址 (用户页表)
    uint64            kstack;    // 进程内核栈虚拟地址 (内核页表)
    struct trapframe *trapframe; // 进程中断帧
    struct context    context; // 用于保存进程内核态的寄存器信息，进程切换时使用
    pagetable_t       pagetable; // User page table
    uint64            max_page;
    uint64            program_brk;
    uint64            heap_bottom;
    struct proc *     parent; // Parent process
    uint64            exit_code;
    struct file *     files[FD_BUFFER_SIZE];
    uint32     syscall_times[MAX_SYSCALL_NUM]; // 系统调用次数统计
    uint64     start_time;                     // 进程开始运行时间
    struct vma vmas[NVMA];                     // 虚拟内存区域
};

#define PTE2PA(pte) (((pte) >> 10) << 12)
// 从虚拟地址中提取三个 9 位的页表索引
#define PXMASK 0x1FF // 9
// PGSHIFT = 12，这段宏定义用于定位 VPNx 的位置
#define PXSHIFT(level) (PGSHIFT + (9 * (level)))
// 从虚拟地址 VA 中提取出第 level 级页表的索引
#define PX(level, va) ((((uint64)(va)) >> PXSHIFT(level)) & PXMASK)

// 返回页表 pagetable 中与虚拟地址 va 对应的 PTE 的地址。
// 如果 alloc != 0，则创建所需的页表页。
//
// RISC-V Sv39 方案有三级页表页。一个页表页包含 512 个 64 位的 PTEs。
// 一个 64 位的虚拟地址被分为五个字段：
//   39..63 -- 必须为零。
//   30..38 -- 2 级索引的 9 位。
//   21..29 -- 1 级索引的 9 位。
//   12..20 -- 0 级索引的 9 位。
//    0..11 -- 页面内的 12 位字节偏移量。
// pagetable 页表
// va 虚拟地址
// alloc 页表项不存在时是否分配
pte_t *walk(pagetable_t pagetable, uint64 va, int alloc)
{
    if (va >= MAXVA)
        panic("walk");

    for (int level = 2; level > 0; level--) {
        pte_t *pte = &pagetable[PX(level, va)];
        // 通过 PTE 的标志位判断每一级的 pte 是否是有效的（V 位）
        if (*pte & PTE_V) {
            pagetable = (pagetable_t)PTE2PA(*pte);
        } else {
            // 如果该项无效且 alloc 标志被设置，则分配一个新的页表
            // 如果 alloc 参数=0 或者已经没有空闲的内存了，那么遇到中途 V=0 的 pte 整个 walk 过程就会直接退出
            if (!alloc || (pagetable = (pde_t *)kalloc()) == 0) {
                return 0;
            }
            // 清空分配的页表
            memset(pagetable, 0, PGSIZE);
            // 更新页表项，将其指向新分配的页表，并设置有效位 PTE_V
            *pte = PA2PTE(pagetable) | PTE_V;
        }
    }
    // 返回最低级和虚拟地址的页表项，不是返回物理地址
    return &pagetable[PX(0, va)];
}

#define PA2PTE(pa) ((((uint64)pa) >> 12) << 10)

/**
 * 为从虚拟地址 va 开始的页面创建指向物理地址 pa 开始的页表项（PTE）
 * 注意：va 和 size 可能不是页面对齐的
 * 如果无法分配所需的页表，则返回 0，否则返回 -1
 * 
 * @param pagetable 根页表地址
 * @param va        虚拟地址
 * @param size      映射的字节数
 * @param pa        物理地址
 * @param perm      权限位
 * @return          成功返回 0，否则返回 -1
 */
int mappages(pagetable_t pagetable, uint64 va, uint64 size, uint64 pa, int perm)
{
    uint64 virtualAddress, lastVirtualAddress;
    pte_t *pte;

    // 地址必须是页面对齐的
    virtualAddress     = PGROUNDDOWN(va);
    lastVirtualAddress = PGROUNDDOWN(va + size - 1);
    for (;;) {
        // 返回最低级的虚拟地址的页表项，如果不存在会创建一个新的页表项
        // 页表项可能会因为内存不足创建失败，如果创建失败，则返回 -1
        if ((pte = walk(pagetable, virtualAddress, 1)) == 0) {
            return -1;
        }
        // 如果 PTE 已经有效，则输出错误信息并返回 -1
        if (*pte & PTE_V) {
            errorf("remap");
            return -1;
        }
        // 将物理地址 pa 转换为页表项，并设置权限位 perm 和 有效位 PTE_V
        *pte = PA2PTE(pa) | perm | PTE_V;
        // 如果当前是最后一个地址，则结束循环
        if (virtualAddress == lastVirtualAddress) {
            break;
        }
        virtualAddress += PGSIZE;
        pa += PGSIZE;
    }
    return 0;
}

// 调度程序永不返回。它循环执行以下操作：
//  - 选择要运行的进程。
//  - 切换以启动运行该进程。
//  - 最终，该进程通过切换将控制权
//    传递回调度程序。
void scheduler(void)
{
    struct proc *p;
    struct proc *last_checked_proc = pool; // 初始化指针为 pool

    for (;;) {
        for (p = last_checked_proc; p < &pool[NPROC];
             p++) { // 将 p 初始化为 last_checked_proc
            if (p->state == RUNNABLE) {
                /*
                * LAB1：你可能需要在这里初始化进程的起始时间
                */
                p->state     = RUNNING;
                current_proc = p;
                swtch(&idle.context, &p->context);
            }
        }
        last_checked_proc = pool + 1; // 更新 last_checked_proc 的值为下一个位置
    }
}

---
 os/loader.c           |   5 +-
 os/proc.c             |  15 +-
 os/proc.h             |  23 +-
 os/syscall.c          |  55 ++++-
 os/syscall_ids.h      |   5 +-
 os/timer.h            |   2 +
 9 files changed, 374 insertions(+), 291 deletions(-)

diff --git a/os/loader.c b/os/loader.c
index b45e85d..b21b0a4 100644
--- a/os/loader.c
+++ b/os/loader.c
@@ -1,6 +1,7 @@
 #include "loader.h"
 #include "defs.h"
 #include "trap.h"
+#include <string.h>
 
 static uint64  app_num;
 static uint64 *app_info_ptr;
@@ -49,8 +50,10 @@ int run_all_app()
         trapframe->sp  = (uint64)p->ustack + USER_STACK_SIZE;
         p->state       = RUNNABLE;
         /*
-		* LAB1: you may need to initialize your new fields of proc here
+		* LAB1: 初始化系统调用数以及进程开始时间
 		*/
+        memset(p->syscall_times, 0, MAX_SYSCALL_NUM * sizeof(uint32));
+        p->start_time = 0;
     }
     return 0;
 }
\ No newline at end of file
diff --git a/os/proc.c b/os/proc.c
index fee3886..0c69ae5 100644
--- a/os/proc.c
+++ b/os/proc.c
@@ -2,6 +2,7 @@
 #include "defs.h"
 #include "loader.h"
 #include "trap.h"
+#include "timer.h"
 
 struct proc pool[NPROC];
 char        kstack[NPROC][PAGE_SIZE];
@@ -33,9 +34,8 @@ void proc_init(void)
         p->kstack    = (uint64)kstack[p - pool];
         p->ustack    = (uint64)ustack[p - pool];
         p->trapframe = (struct trapframe *)trapframe[p - pool];
-        /*
-		* LAB1: you may need to initialize your new fields of proc here
-		*/
+        memset(p->syscall_times, 0, MAX_SYSCALL_NUM * sizeof(uint32));
+        p->start_time = 0;
     }
     idle.kstack  = (uint64)boot_stack_top;
     idle.pid     = 0;
@@ -47,6 +47,7 @@ int allocpid()
     static int PID = 1;
     return PID++;
 }
+
 // 在进程表中寻找一个未使用的进程。
 // 如果找到，则初始化在内核中运行所需的状态。
 // 如果没有空闲的进程，或者内存分配失败，则返回 0。
@@ -80,14 +81,18 @@ void scheduler(void)
 {
     struct proc *p;
     struct proc *last_checked_proc = pool; // 初始化指针为 pool
-
     for (;;) {
         for (p = last_checked_proc; p < &pool[NPROC];
              p++) { // 将 p 初始化为 last_checked_proc
             if (p->state == RUNNABLE) {
                 /*
-                * LAB1：你可能需要在这里初始化进程的起始时间
+                * LAB1：在这里初始化进程的开始时间
                 */
+                if (p->start_time == 0) {
+                    uint64 cycle = get_cycle();
+                    p->start_time =
+                        (cycle % CPU_FREQ) * MILLISECONDS_PER_SECOND / CPU_FREQ;
+                }
                 p->state     = RUNNING;
                 current_proc = p;
                 swtch(&idle.context, &p->context);
diff --git a/os/proc.h b/os/proc.h
index d208c5d..53576bf 100644
--- a/os/proc.h
+++ b/os/proc.h
@@ -3,7 +3,8 @@
 
 #include "types.h"
 
-#define NPROC (16)
+#define NPROC           (16)  // 最大进程数
+#define MAX_SYSCALL_NUM (500) // 最大系统调用数
 
 // Saved registers for kernel context switches.
 struct context {
@@ -42,14 +43,28 @@ struct proc {
     uint64            kstack;    // 进程内核栈虚拟地址 (内核页表)
     struct trapframe *trapframe; // 进程中断帧
     struct context    context; // 用于保存进程内核态的寄存器信息，进程切换时使用
-                               /*
-	* LAB1: you may need to add some new fields here
+    /*
+	* LAB1: 添加一些新的成员用于新的 sys_task_info 系统调用
 	*/
+    uint32 syscall_times[MAX_SYSCALL_NUM]; // 系统调用次数统计 TODO: 后续改为指针
+    uint64 start_time;                     // 进程开始运行时间
 };
 
 /*
-* LAB1: you may need to define struct for TaskInfo here
+* LAB1: 定义 TaskInfo 结构体
 */
+typedef enum {
+    UnInit,
+    Ready,
+    Running,
+    Exited,
+} TaskStatus;
+
+typedef struct {
+    TaskStatus status;
+    uint32     syscall_times[MAX_SYSCALL_NUM];
+    int        time; // 进程运行时间统计
+} TaskInfo;
 
 struct proc *curr_proc();
 void         exit(int);
diff --git a/os/syscall.c b/os/syscall.c
index 1cc5aeb..f54ed86 100644
--- a/os/syscall.c
+++ b/os/syscall.c
@@ -4,6 +4,7 @@
 #include "syscall_ids.h"
 #include "timer.h"
 #include "trap.h"
+#include "proc.h"
 
 uint64 sys_write(int fd, char *str, uint len)
 {
@@ -31,14 +32,46 @@ uint64 sys_sched_yield()
 uint64 sys_gettimeofday(TimeVal *val, int _tz)
 {
     uint64 cycle = get_cycle();
-    val->sec     = cycle / CPU_FREQ;
-    val->usec    = (cycle % CPU_FREQ) * MICROSECONDS_PER_SECOND / CPU_FREQ;
+    tracef("sys_gettimeofday cycle = %d", cycle);
+    val->sec  = cycle / CPU_FREQ;
+    val->msec = (cycle % CPU_FREQ) * MILLISECONDS_PER_SECOND / CPU_FREQ;
+    val->usec = (cycle % CPU_FREQ) * MICROSECONDS_PER_SECOND / CPU_FREQ;
     return 0;
 }
 
-/*
-* LAB1: you may need to define sys_task_info here
-*/
+/** 
+ * LAB1：此处定义 sys_task_info 函数
+ * 查询当前正在执行的任务信息，任务信息包括任务控制块相关信息（任务状态）、任务使用的系统调用次数、任务总运行时长。 
+ */
+int sys_task_info(TaskInfo *ti)
+{
+    struct proc *proc = curr_proc();
+    // TODO: proc 检查为空
+    for (int i = 0; i < MAX_SYSCALL_NUM; i++) {
+        ti->syscall_times[i] = proc->syscall_times[i];
+    }
+    uint64 cycle = get_cycle();
+    uint64 current_time =
+        (cycle % CPU_FREQ) * MILLISECONDS_PER_SECOND / CPU_FREQ;
+    infof("sys_task_info current_time = %d", current_time);
+    infof("proc->start_time = %d", proc->start_time);
+    infof("ti->time = %d", current_time - proc->start_time);
+
+    if (proc->state == RUNNING) {
+        ti->status = Running;
+    } else if (proc->state == RUNNABLE) {
+        ti->status = Ready;
+    } else if (proc->state == SLEEPING) {
+        ti->status = Ready;
+    } else if (proc->state == ZOMBIE) {
+        ti->status = Exited;
+    } else if (proc->state == UNUSED) {
+        ti->status = UnInit;
+    }
+
+    ti->time = current_time - proc->start_time;
+    return 0;
+}
 
 extern char trap_page[];
 
@@ -51,8 +84,9 @@ void syscall()
     tracef("syscall %d args = [%x, %x, %x, %x, %x, %x]", id, args[0], args[1],
            args[2], args[3], args[4], args[5]);
     /*
-	* LAB1: you may need to update syscall counter for task info here
+	* LAB1: 更新系统调用次数
 	*/
+    curr_proc()->syscall_times[id]++;
     switch (id) {
     case SYS_write:
         ret = sys_write(args[0], (char *)args[1], args[2]);
@@ -67,8 +101,15 @@ void syscall()
         ret = sys_gettimeofday((TimeVal *)args[0], args[1]);
         break;
     /*
-	* LAB1: you may need to add SYS_taskinfo case here
+	* LAB1: 在此处添加 SYS_task_info 的系统调用处理情况
 	*/
+    case SYS_task_info:
+        ret = sys_task_info((TaskInfo *)args[0]);
+        break;
+    case SYS_getpid:
+        infof("SYS_getpid %d", SYS_getpid);
+        ret = curr_proc()->pid;
+        break;
     default:
         ret = -1;
         errorf("unknown syscall %d", id);
diff --git a/os/syscall_ids.h b/os/syscall_ids.h
index 05a6cb9..3c1a5a9 100644
--- a/os/syscall_ids.h
+++ b/os/syscall_ids.h
@@ -277,9 +277,8 @@
 #define SYS_io_pgetevents          292
 #define SYS_rseq                   293
 #define SYS_kexec_file_load        294
-/*
-* LAB1: you may need to define SYS_task_info here
-*/
+// LAB1：添加 SYS_task_info 的系统调用号
+#define SYS_task_info          410
 #define SYS_pidfd_send_signal  424
 #define SYS_io_uring_setup     425
 #define SYS_io_uring_enter     426
diff --git a/os/timer.h b/os/timer.h
index c6ebd14..63ab45c 100644
--- a/os/timer.h
+++ b/os/timer.h
@@ -6,6 +6,7 @@
 #define TICKS_PER_SEC (100)
 // QEMU
 #define CPU_FREQ                (12500000)
+#define MILLISECONDS_PER_SECOND (1000)
 #define MICROSECONDS_PER_SECOND (1000000)
 
 uint64 get_cycle();
@@ -14,6 +15,7 @@ void   set_next_timer();
 
 typedef struct {
     uint64 sec;  // 自 Unix 纪元起的秒数
+    uint64 msec; // 毫秒数
     uint64 usec; // 微秒数
 } TimeVal;
 
-- 
2.34.1