memory

心中的内核

Sat, 27 Jun 2026 00:00:00 +0000

心中的内核 —— 在阅读内核代码之前先理解内核

原文：The Kernel in the Mind

[TOC]

介绍

这并非一部教你编写内核代码的指南，而是一场探寻Linux内核设计思维的思想之旅。

在系统编程的世界里，人们常常迷失于符号定义、头文件结构与实现细节的丛林中。然而剥离代码表象，内核实则是一个井然有序的响应式系统——它受上下文环境所规约，以分离原则为基石，从内存管理到任务调度的每一处设计，都浸透着精准的设计意图。

riscv体系结构

Mon, 22 Jun 2026 00:00:00 +0000

指令集(ISA)，微架构，操作系统

指令集简单来说就是一套语言规范，定义指令类型，寄存器，数据类型，还有cpu的管理模式等。而微架构是依据指令集设计出的处理器硬件结构与实现方案。相同的指令集设计出来的微架构可能完全不同，比如Intel和amd的芯片都是x86指令集。但是设计出来的cpu结构完全不同，性能和能耗也天差地别。影响cpu性能的大部分是微架构设计，工艺制程，系统级整合等，而指令集带来的差异往往只是小头。指令集的流行主要是商业和生态决定的。

xv6 分析与总结

Sat, 13 Jun 2026 00:00:00 +0000

系统概述与启动流程

(关注宏观状态流转：从 Machine Mode 到 Supervisor Mode，再到第一个用户进程的诞生)

核心概念

启动流程的本质是特权级的逐级让渡：从硬件最高特权（Machine Mode）出发，经过层层初始化和降权，最终将控制权交给最不信任的用户程序。整个过程是一条从"全权控制"到"受限执行"的信任链——每一步都在缩小 CPU 的权限范围，同时建立更多的软件抽象层。

cpp的理解

Thu, 11 Jun 2026 00:00:00 +0000

cpp这门语言与其他语言设计上的不同之处,在于cpp为了高效运行,没有采用在堆上分配对象通过GC管理对象。而是选择了一种更加高效但是更加困难的方式，通过尽量在栈上分配内存。因为栈上分配和释放内存只需要几条cpu指令就能完成，而在栈上则需要调用分配函数这需要更多的时间。而且栈的内存布局更加紧凑，对缓存更加的友好。但是也因为栈的先进先出的特性，这让对象的生命周期更加的难以管理，因为栈帧返回后直接就释放了。而且函数参数的传参也变得复杂，有很多的方式减少传参带来的开销，许多cpp特性就是为了解决这个问题产生的。

cpp线程的创建

Thu, 11 Jun 2026 00:00:00 +0000

线程

线程的创建

在cpp中线程的创建有两种形式

默认构造
传入可调用对象如: 函数, 函数对象, 对象的成员函数, 对象的静态函数, lambda表达式

线程的构造函数会按值复制所有参数,这点很重要, 对于想要传递引用的变量时,要使用std::ref()

gdb/git的一些使用

Thu, 11 Jun 2026 00:00:00 +0000

为ide配置代码转跳

所有的ide或者实现代码转跳,语法检查的功能都是依赖cmake,Makefile等构建脚本中的编译选项的, 因为这些功能的实现需要知道项目的完整构建流程, 包括文件之间的依赖关系, 已经特殊的编译选项如不同的平台.

Hash

Thu, 11 Jun 2026 00:00:00 +0000

Hash

【C++ 哈希表查找口诀】

想知道有没有 key？ → 用 count: if (map.count(key))

想查并用它的 value？ → 用 find: if (map.find(key) != map.end())

口诀：

count 大于 0，就说明有

find 不等于 end，就说明找到了

两数之和

 vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> hashtable;
        for (int i = 0; i < nums.size(); i++){
            auto it  = hashtable.find(target - nums[i]);//判断是否存在
            if (it != hashtable.end()){
                return {i, it->second};
            }
            hashtable[nums[i]] = i;// 添加元素,  这里的添加顺序不可提前,因为我想做的是先查找,如果先添加会影响这一次查找
        }
        return {};
    }

IO设备

Thu, 11 Jun 2026 00:00:00 +0000

计算机与物理世界交互的方式，通过各种io设备，能够使用计算机做任何事

就像人操作各种机器一样，机器提供各种开关和按钮，仪表和指示灯，进料口和出料口。计算机中的io设备将这些物理操作抽象成了寄存器和地址，通过访问或设置不同的寄存器和地址实现和io设备的交互

OS

Thu, 11 Jun 2026 00:00:00 +0000

计算机中的硬件, 软件,操作系统都是可以看作一个状态机

先讲os, os的模型简单说就是一个管理多个软件(状态机)的一个状态机.

os的每个状态就是当前时间下的所有其他进程的状态, 在单核处理器下, 每次os的状态转移时会随机选择一个程序运行下一步,这就是调度. os的状态机中除了进程外,还有为了进程通信的缓冲区.

OS简介

Thu, 11 Jun 2026 00:00:00 +0000

这是一个关于linux的一种自我的想象, 是我自己为了更好的理解linux而写的一种笔记, 我通过不同的视角,来描述这个程序的世界, 主要的目的不是为了完全掌握或者完整的类比操作系统的所有结构. 我的目的只是在于对os的各个部分有一个更加直观的理解, 这种理解是一种直观的, 表面的理解, 因此他并不能提高自己的linux编程水平, 就像来到一个新的城市, 我可以直观的了解城市的大致样貌, 但是关于城市是如何事无巨细的运行的, 这必须要真实的去体验才能真正了解.

RISC-V trap / syscall / trampoline 机制完整解析

Thu, 11 Jun 2026 00:00:00 +0000

RISC-V Trap / Syscall / Trampoline 机制完整解析

一、整体流程概览

1.1 总览

用户态通过 ecall 触发异常 → 硬件最小保存 → 跳转到 stvec → trampoline 完成上下文保存 + 切页表 → 进入内核 → 执行 syscall → 再通过 trampoline 返回用户态。

tmux的常用指令

Thu, 11 Jun 2026 00:00:00 +0000

tmux的常用指令(自己配置)

prefix

Prefix = Ctrl+a（因为我们把默认 Ctrl+b 改了）
“Prefix + x”意思是先按 Ctrl+a，松开后再按 x

常用操作

新建窗口

Prefix + c
作用：开一个新窗口，并且继承当前目录

水平/垂直分屏

Prefix + -
作用：上下分屏（vertical split）
Prefix + |
作用：左右分屏（horizontal split）
另外你配置里还保留了：
- Prefix + "
- Prefix + % 这两个也会在当前目录分屏

面板间移动（Vim 风格）

Prefix + h：切到左边 pane
Prefix + j：切到下边 pane
Prefix + k：切到上边 pane
Prefix + l：切到右边 pane

切换窗口

Alt + Left：上一个窗口
Alt + Right：下一个窗口

重命名窗口

Prefix + ,
然后输入新名字回车

进入复制模式（Vi）

Prefix + Enter：进入 copy-mode
在 copy-mode 里：
- v：开始选择
- y：复制并退出 copy-mode
- Y：复制到系统剪贴板并退出（前提装了 wl-copy 或 xclip）

重载配置

Prefix + r
作用：不重启 tmux，立即重新加载配置

发送前缀给程序（很少用）

Prefix + Ctrl+a
作用：把 Ctrl+a 传给 pane 里的程序（比如你在嵌套 tmux 时会用到）

你这份配置里“自动生效”的项（不需要按键）

travel_xv6

Thu, 11 Jun 2026 00:00:00 +0000

系统调用syscall(ecall)

1.用户态的准备工作

cpu核心在用户线程(进程)上工作, pc(程序计数器寄存器)指向下一个执行的用户态指令(.text), sp(栈指针寄存器)指向当前用户态线程的栈顶,用于分割栈帧和栈帧中变量的定位.

tty

Thu, 11 Jun 2026 00:00:00 +0000

tty 所有终端设备的泛称 pty 伪终端 pts 伪终端从属 terminal 终端模拟器

terminal,一个输入输出设备, 在现代os中已经抽象成了控制终端**(controlling terminal), 可以由伪终端,虚拟控制台,串口终端,usb串口担任控制终端**. 它可以

xv6总览图

Thu, 11 Jun 2026 00:00:00 +0000

系统总览

进程管理

内存管理

文件系统

trap

系统调用

驱动

用户函数

三个基础排序

Thu, 11 Jun 2026 00:00:00 +0000

选择排序

在i~n-1范围内,找到最小值并放在i的位置上, 然后在i+1 ~ n-1范围内继续

for(int i = 0; i < n - 1; i++){
    int min = i;
    for (int j = i + 1; j < n; j++){
        if (arr[j] < arr[min]){
			min = j;
		}
    }
	swap(arr[i], arr[j]);
}

冒泡排序

在0~i范围内, 相邻位置较大的数向下滚动, 最大值最终来到i的位置,然后0 ~ i-1范围继续

二分查找

Thu, 11 Jun 2026 00:00:00 +0000

二分查找

在有序数组中确定num的存在

二分查找的两种写法

// 左闭右开
//更适合找边界、插入位置等复杂问题
int searchInsert(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size();// !!
        while (left < right) {// !!
            int mid = left + ((right - left) >> 1);// >>运算的优先级低于+
            if (nums[mid] == target)
                return mid;
            else if (nums[mid] < target)
                left = mid + 1;// !!
            else
                right = mid;// !!
        }
        return left;
    }

// 闭区间
//更适合标准查找、简单理解
int searchInsert(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1;// !!
        while (left <= right) {// !!
            int mid = left + ((right - left) >> 1);
            if (nums[mid] == target)
                return mid;
            else if (nums[mid] < target)
                left = mid + 1;// !!
            else
                right = mid - 1;// !!
        }
        return left;
    }

在有序数组中找到>=num的最左位置

int findLeft(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1;// !!
    	int ans = -1;
        while (left <= right) {// !!
            int mid = left + ((right - left) >> 1);
            if (nums[mid] >= target)
                ans = mid;
                right = mid - 1;
            else
                left = mid + 1;// !!
        }
        return ans;
    }

在有序数组中找到<=num的最右位置

int findRight(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1;// !!
    	int ans = -1;
        while (left <= right) {// !!
            int mid = left + ((right - left) >> 1);
            if (nums[mid] <= target)
                ans = mid;
                left = mid + 1;
            else
                right = mid - 1;// !!
        }
        return ans;
    }

内核存储栈

Thu, 11 Jun 2026 00:00:00 +0000

内核结构图

Thu, 11 Jun 2026 00:00:00 +0000

内核网络

Thu, 11 Jun 2026 00:00:00 +0000

重要的数据结构

struct sockaddr

通信用的地址表, 记录了使用什么来通信和目的地址

这是一个在套接字编程中用来表示"地址"的通用结构, 核心作用是为不同的通行提供一个统一的地址表示接口

双指针

Thu, 11 Jun 2026 00:00:00 +0000

双指针

快慢指针

删除有序数组中的重复项

一个有序数组nums，原地删除重复出现的元素，使得出现次数超过两次的元素只出现两次，返回删除后数组的新长度

int removeDuplicates(vector<int>& nums) {
        int n = nums.size();
        if (n <= 2) {
            return n;
        }
        int slow = 2;
        for (int fast = 2; fast < n; ++fast){
            if (nums[fast] != nums[slow-2]){// fast 是读指针，不是写指针。我们无法知道前面已经写了多少个相同的值。只有 slow 才能记录我们已经保留了多少个相同的值。
                nums[slow++] = nums[fast];
            }
        }
        return slow;
    }

移除元素

在数组中,原地移除所有数值等于val的元素

基数与序数的规律

Thu, 11 Jun 2026 00:00:00 +0000

基数与序数的规律

对于一个数据, 要先判断是基数还是序数, 如果要计数,还要考虑是否包括边界

基数: 绝对的,有一个基底数, 日常生活中基底是1; 编程中一般是0; 常见的基数概念有数量, 个数, 体积, 面积, 时间段, 年龄(周岁), 分数
序数: 相对的, 表示先后顺序, 常见的概念: 位次, 时间点
- 端点的开闭规律: 全开

基本的转换规律: 基数 = 序数 - based + 1

堆的核心算法解析

Thu, 11 Jun 2026 00:00:00 +0000

堆的核心算法解析

核心要点

这个精简版堆只保留了最核心的两个算法：

节点索引计算公式（堆的基础）

父节点索引 = (当前索引 - 1) / 2
左子节点索引 = 当前索引 * 2 + 1  
右子节点索引 = 当前索引 * 2 + 2

核心算法1: 上浮调整 (heapifyUp)

用途: 插入新元素后维护堆性质原理: 新元素从末尾开始，与父节点比较，如果优先级更高就向上交换

并发

Thu, 11 Jun 2026 00:00:00 +0000

每个线程会在进程的堆上创建的，栈之间有隔离区。

栈是默认线程独占的，而堆是共享资源，很多函数会有的缓冲区就在堆中的他是共享的。

每个线程栈和共享资源都可以看作是一个状态机。

并发架构与同步原语

Thu, 11 Jun 2026 00:00:00 +0000

为了追求极限性能，cpu硬件搞出了独立缓存(L1/L2)和乱序执行，但也留下了“数据不同步”和“顺序错乱”的烂摊子。硬件用MESI协议和内存屏障指令来修补。编程语言为了抹平不同平台(xv6/arm)的差异，制定了内存模型契约，让程序员通过指定内存序(relaxed/acquire/release/sc)来指挥编译器和cpu自动插入屏障。而程序员利用这些契约和底层的硬件CAS指令，最终构建出了无锁算法以及互斥锁等同步原语，为多线程并发提供了正确同步的基础设施。

循环数组

Thu, 11 Jun 2026 00:00:00 +0000

循环数组

需要三个变量:头下标l,尾下标r,队列的size

范围[l, r), size== r-l

加入元素: 判断size<capacity, 将x放入尾部, 尾部++(如果超过数组边界,返回到数组开头) size++

调试记录：xv6 用户程序内存布局冲突异常

Thu, 11 Jun 2026 00:00:00 +0000

🛠️ 调试记录：xv6 用户程序内存布局冲突异常

1. 问题描述 (Description)

在 xv6 实验环境中，向内核添加自定义系统调用（Syscall）并编写用户态测试程序（Test Case）时，程序在系统调用逻辑执行完毕后，无法正常返回用户态继续执行。表现为进程卡死或触发硬件级页错误（Page Fault），而代码逻辑本身（内核实现）经检查无误。

进程与通信

Thu, 11 Jun 2026 00:00:00 +0000

不同的进程在各自的房间内运行, 每个房间有自己的编号pid, 进程之间互不干涉, 房间内有许多种与外界通信的方式, 他们有各自的用途和特性, 分布在墙壁上; 房间内还分成多个区域, 分别是: 代码区(.text), 已初始化的全局/静态数据区(.data), 未初始化的全局/静态数据区(.bss), 堆, 栈, 内存映射区, 环境变量与命令行参数区, 内核空间

链表

Thu, 11 Jun 2026 00:00:00 +0000

链表

删除特定节点

ListNode* removeElements(ListNode* head, int val) {
        ListNode dummy(0, head);
        ListNode* cur = &dummy;
        while (cur->next) {//
            if (cur->next->val == val) {
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;//比条件可以多一个next
                delete tmp;
            } else
                cur = cur->next;
        }
        return dummy.next;
    }

两两交换相邻节点

在改变单链表时,优先改变上游的指针

ListNode* swapPairs(ListNode* head) {
        if (!head || !head->next)
            return head;

        ListNode dummy(0, head);
        ListNode* cur = &dummy;

        while (cur->next && cur->next->next) {
            ListNode* p1 = cur->next;
            ListNode* p2 = cur->next->next;
            cur->next = p2;//先改头->p2  cur-->p1-->p2-->other
            p1->next = p2->next;//在改p1->other
            p2->next = p1;//最后在p2->p1;
            cur = p1;
        }
        return dummy.next;
    }

合并有序链表

struct ListNode {
    int val;
    ListNode *next;
    ListNode() : val(0), next(nullptr) {}
    ListNode(int x) : val(x), next(nullptr) {}
    ListNode(int x, ListNode *next) : val(x), next(next) {}
};
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        // 创建一个哑节点作为新链表的起点
        ListNode dummy(0);
        ListNode* curr = &dummy;  // 当前指针用于构建新链表

        // 同时遍历两个链表
        while (l1 && l2) {
            if (l1->val <= l2->val) {
                curr->next = l1;
                l1 = l1->next;
            } else {
                curr->next = l2;
                l2 = l2->next;
            }
            curr = curr->next;  // 移动当前指针
        }

        // 将剩余部分直接连接到新链表末尾
        curr->next = (l1 != nullptr) ? l1 : l2;

        // 返回合并后的头节点
        return dummy.next;
    }
};

环形链表

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(nullptr) {}
};

class Solution {
public:
    bool hasCycle(ListNode *head) {
        // 边界情况：空链表或只有一个节点且无环
        if (head == nullptr || head->next == nullptr) {
            return false;
        }

        // 初始化快慢指针
        ListNode *slow = head;
        ListNode *fast = head;

        // 快指针及其下一个节点都非空时继续循环
        while (fast != nullptr && fast->next != nullptr) {
            slow = slow->next;                  // 慢指针每次走一步
            fast = fast->next->next;            // 快指针每次走两步

            if (slow == fast) {
                // 快慢指针相遇，说明存在环
                return true;
            }
        }

        // 遍历结束未相遇，说明没有环
        return false;
    }
};

在有序链表中删除相同元素

在链表的循环中, 判断条件一般是所有指针中最前面的指针

网络协议栈

Mon, 26 May 2025 00:00:00 +0000

现代操作系统的内核（如 Linux 内核）中有一个专门的模块叫做：

网络协议栈（Network Stack)

主要职责详解

职责	类比说明	技术术语
1. 接收和发送数据包	公司前台接收快递 & 发送包裹	数据链路层、IP 层、传输层
2. IP 地址管理	给每个员工分配邮箱地址	IPv4 / IPv6 地址配置
3. 路由选择	快递要走哪条路线最短最快	路由表（Routing Table）
4. 封装与解封装	包裹加标签 / 拆标签	数据封装（Encapsulation）与解封装（Decapsulation）
5. 传输控制（TCP）	控制文件是否完整送达	TCP 流量控制、拥塞控制
6. 端口号管理	不同部门接收不同类型的快递	端口绑定、监听、转发
7. 安全防护（防火墙）	保安检查包裹内容	Netfilter / iptables / nftables
8. NAT 转换	公司统一出口代理	Network Address Translation
9. 域名解析支持	内部电话簿查询联系方式	DNS 解析缓存、本地 hosts
10. 支持多种协议	公司支持各种沟通方式（电话、邮件、视频会议）	支持 TCP、UDP、ICMP、HTTP、HTTPS、FTP 等

类比图：操作系统网络部门的组织架构

小组	类比角色	职责
套接字接口组（Socket Layer）	客户接待员	接收进程请求（如浏览器访问网页）
传输组（TCP / UDP）	快递打包组	控制可靠传输或快速发送
网络组（IP 层）	邮政分拣中心	决定发往哪个城市（IP 地址）
链路组（MAC 层）	快递站	决定发给哪个局域网内的目标主机
路由组（Routing）	导航调度中心	选择最优路径（下一跳）
设备驱动组（NIC Driver）	快递员	实际把包裹送出去（通过网卡）
安全组（Netfilter / Firewall）	保安检查岗	检查是否允许通行
NAT 组	公司代理出口	统一管理内部员工对外通信
DNS 缓存组	内部电话簿管理员	记录域名与 IP 的对应关系

Linux 的网络部分是一个庞大的子系统，主要包括以下几个关键模块：

为什么叫补码

Mon, 17 Mar 2025 00:00:00 +0000

为什么叫补码(Two’s complement)

计算机的加减法运算天生是一个模2^N的同余类上的运算，满2^N会抛弃进位，那表示有符号数时使用同余类代表很正常吧，比如-1 = 2^N -1 (mod 2^N)，-2 = 2^N-2 (mod 2^N)，这实际上就是补码了。

关于位图存储与数组下标存储的探讨

Mon, 17 Mar 2025 00:00:00 +0000

关于位图存储与数组下标存储的探讨

最近在看《编程珠玑》，书中的第一章提到了位图。位图存储使用二进制位的位数信息，来表示数字。例如，存储1、3、4、6、8，这五个数字，可以使用<1, 0, 1, 1, 0, 1, 0, 1>这样的向量来表示，这样可以大大减少存储空间，只用了一个字节（8bit），就可以存储原来需要的8个数字才能表示的信息。

集合列表数组

Mon, 17 Mar 2025 00:00:00 +0000

集合

集合一般被定义为：由一个或多个确定的元素所构成的整体。集合有什么特性呢？

首先，集合里的元素类型不一定相同。你可以将商品看作一个集合，也可以将整个商店看作一个集合，这个商店中有人或者其他物品也没有关系。

file descriptor

Mon, 20 Jan 2025 00:00:00 +0000

理解Linux的file descriptor(文件描述符)

我们知道在Linux系统中一切皆可以看成是文件，文件又可分为：普通文件、目录文件、链接文件和设备文件。在操作这些所谓的文件的时候，我们每操作一次就找一次名字，这会耗费大量的时间和效率。所以Linux中规定每一个文件对应一个索引，这样要操作文件的时候，我们直接找到索引就可以对其进行操作了。

linux select函数

Mon, 20 Jan 2025 00:00:00 +0000

linux select函数

在Linux中，我们可以使用select函数实现I/O端口的复用，传递给 select函数的参数会告诉内核：

我们所关心的文件描述符

Makefile 的基本概念

Mon, 20 Jan 2025 00:00:00 +0000

Makefile 是 make 工具的配置文件，主要用于定义如何构建和管理项目的编译过程。Makefile 是 C/C++ 编译项目中的重要工具，尤其在多文件、多模块的项目中，为了方便复杂项目的管理，可以通过自动化规则提高编译效率。

一些网站

Mon, 20 Jan 2025 00:00:00 +0000

为什么Lisp语言如此先进?

一个前辈的官网

文件控制函数

Mon, 20 Jan 2025 00:00:00 +0000

文件控制函数 file control

功能描述

fcntl函数可以用来对已打开的文件描述符进行各种控制操作, 以改变已打开文件的的各种属性

头文件

#include <unistd.h>
#include <fcntl.h>

函数原型

int fcntl(int fd, int cmd);

int fcntl(int fd, int cmd, long arg);         
c
int fcntl(int fd, int cmd, struct flock *lock);

描述

fcntl()针对(文件)描述符提供控制.参数fd是被参数cmd操作(如下面的描述)的描述符.