// 源码路径：linux/mm/filemap.c
// write 系统调用最终落脚页缓存写入，标记脏页核心函数
static ssize_t generic_perform_write(struct file *file,
                struct iov_iter *i, loff_t pos)
{
        struct page *page;
        // 1. 分配/映射页缓存页面
        page = pagecache_get_page(mapping, index, FGP_LOCK|FGP_CREAT, 0);
        // 2. 用户态数据拷贝至页缓存
        copy_page_from_iter(page_address(page), offset, bytes, i);
        // 3. 核心：标记页面为脏页，纳入回写管理链表
        set_page_dirty(page);
        ...
}

// 源码路径：linux/include/linux/page-flags.h
// 脏页核心标识位定义
#define PG_dirty        11      /* Page is dirty */

// 源码路径：linux/mm/page-writeback.c
// 脏页纳入全局回写队列，完成生命周期绑定
int set_page_dirty(struct page *page)
{
        if (!PageDirty(page)) {
                // 标记脏页标志位
                SetPageDirty(page);
                // 加入inode脏页链表，等待flusher workqueue调度回写
                __mark_inode_dirty(page->mapping->host);
        }
        return 0;
}

// 源码路径：linux/mm/backing-dev.c
// Linux 5.15：flusher 不再由 kthread_run 创建，而是注册到 bdi_wq 工作队列
static int wb_init(struct bdi_writeback *wb, struct backing_dev_info *bdi,
                   gfp_t gfp)
{
        ...
        wb->bdi = bdi;
        wb->last_old_flush = jiffies;
        INIT_LIST_HEAD(&wb->b_dirty);
        INIT_LIST_HEAD(&wb->b_io);
        INIT_LIST_HEAD(&wb->b_more_io);
        INIT_LIST_HEAD(&wb->b_dirty_time);
        spin_lock_init(&wb->list_lock);
        atomic_set(&wb->writeback_inodes, 0);
        wb->bw_time_stamp = jiffies;
        wb->balanced_dirty_ratelimit = INIT_BW;
        wb->dirty_ratelimit = INIT_BW;
        wb->write_bandwidth = INIT_BW;
        wb->avg_write_bandwidth = INIT_BW;
        spin_lock_init(&wb->work_lock);
        INIT_LIST_HEAD(&wb->work_list);
        // 核心：回写任务作为 delayed_work 挂入 bdi_wq，由工作队列动态调度
        INIT_DELAYED_WORK(&wb->dwork, wb_workfn);
        INIT_DELAYED_WORK(&wb->bw_dwork, wb_update_bandwidth_workfn);
        ...
}

// 源码路径：linux/mm/page-writeback.c
// 1. 内存阈值触发：balance_dirty_pages() 中脏页占比超标时唤醒后台回写
static void balance_dirty_pages(struct bdi_writeback *wb,
                                unsigned long pages_dirtied)
{
        ...
        if (dirty > bg_thresh)
                wb_start_background_writeback(wb);  // 后台阈值超标，提交 flusher 工作项
        ...
}

// 源码路径：linux/fs/fs-writeback.c
// wb_workfn 为实际执行回写的工作函数
void wb_workfn(struct work_struct *work)
{
        struct bdi_writeback *wb = container_of(to_delayed_work(work),
                                                struct bdi_writeback, dwork);
        ...
        // 根据 reason（周期 / 阈值 / 内存压力等）执行 writeback_inodes_wb()
        writeback_inodes_wb(wb, &wbc);
        ...
}

// 2. 时间阈值触发：周期性回写定时器
static void wb_wakeup_delayed(struct bdi_writeback *wb)
{
        unsigned long timeout;
        timeout = msecs_to_jiffies(dirty_writeback_interval * 10);
        spin_lock_bh(&wb->work_lock);
        if (test_bit(WB_registered, &wb->state))
                queue_delayed_work(bdi_wq, &wb->dwork, timeout);
        spin_unlock_bh(&wb->work_lock);
}

// 源码路径：linux/fs/fs-writeback.c
// writeback_inodes_wb 控制单次回写规模的核心结构
struct writeback_control wbc = {
        .sync_mode        = WB_SYNC_NONE,
        .older_than_this  = NULL,
        .nr_to_write      = MAX_WRITEBACK_PAGES,  // 单次最大回写页数上限
        .range_cyclic     = 1,
};

/*
 * 在 wb_writeback() 中，内核还会根据当前 bdi 带宽估算
 * （wb->dirty_ratelimit / wb->avg_write_bandwidth）动态决定
 * 本次实际可写回的页数，避免一次性打爆磁盘 IO 队列。
 */
static long wb_writeback(struct bdi_writeback *wb,
                         struct writeback_control *wbc)
{
        ...
        // 按 inode 脏页链表逐批刷盘，wbc->nr_to_write 为本次硬上限
        writeback_sb_inodes(sb, wb, wbc);
        ...
}

// 源码路径：linux/mm/page-writeback.c
// 入口函数：仅做 rate-limit，真正判断在 balance_dirty_pages()
void balance_dirty_pages_ratelimited(struct address_space *mapping)
{
        struct backing_dev_info *bdi = inode_to_bdi(mapping->host);
        int ratelimit;
        int *p;

        if (!bdi_cap_account_dirty(bdi))
                return;

        // 按当前任务脏页速率决定何时进入平衡逻辑
        ratelimit = current->nr_dirtied_pause;
        if (bdi->dirty_exceeded)
                ratelimit = min(ratelimit, 32 >> (PAGE_SHIFT - 10));

        preempt_disable();
        p = this_cpu_ptr(&bdp_ratelimits);
        if (unlikely(current->nr_dirtied >= ratelimit))
                *p = 0;
        else if (unlikely(*p >= ratelimit_pages)) {
                *p = 0;
                ratelimit = 0;
        }

        // 回收已退出任务泄漏的脏页计数
        p = this_cpu_ptr(&dirty_throttle_leaks);
        if (*p > 0 && current->nr_dirtied < ratelimit) {
                unsigned long nr_pages_dirtied;
                nr_pages_dirtied = min(*p, ratelimit - current->nr_dirtied);
                *p -= nr_pages_dirtied;
                current->nr_dirtied += nr_pages_dirtied;
        }
        preempt_enable();

        // 触发真正的脏页平衡与后台回写
        if (unlikely(current->nr_dirtied >= ratelimit))
                balance_dirty_pages(bdi, current->nr_dirtied);
}

// 源码路径：linux/mm/page-writeback.c
// 高吞吐卡顿核心：balance_dirty_pages() 在循环中根据脏页量动态休眠当前进程
static void balance_dirty_pages(struct bdi_writeback *wb,
                                unsigned long pages_dirtied)
{
        struct dirty_throttle_control gdtc_stor = { GDTC_INIT(wb) };
        struct dirty_throttle_control mdtc_stor = { MDTC_INIT(wb, &gdtc_stor) };
        ...

        for (;;) {
                unsigned long nr_reclaimable;
                unsigned long dirty_thresh;
                unsigned long bg_thresh;
                unsigned long dirty;
                long pause;
                ...

                // 1. 获取全局阈值（若开启 cgroup writeback 还会计算 memcg 阈值）
                global_dirty_limits(&bg_thresh, &dirty_thresh);
                nr_reclaimable = global_node_page_state(NR_FILE_DIRTY) +
                                 global_node_page_state(NR_UNSTABLE_NFS);
                dirty = nr_reclaimable + global_node_page_state(NR_WRITEBACK);

                // 2. 轻度堆积：超过 background 阈值，唤醒 flusher 后台回写
                if (dirty > bg_thresh)
                        wb_start_background_writeback(wb);

                // 3. 严重堆积：脏页超过 dirty_thresh，进入比例化节流
                if (dirty >= dirty_thresh) {
                        dirty_exceeded = true;
                        // 计算本次需要暂停的时间，并进入 D 态等待回写推进
                        pause = max_pause;
                        ...
                        io_schedule_timeout(pause / HZ + 1);
                        continue;
                }

                // 4. 介于 bg_thresh 与 dirty_thresh 之间：渐进式降速
                if (dirty > dirty_freerun_ceiling(dirty_thresh, bg_thresh)) {
                        pause = dirty_poll_interval(dirty, dirty_thresh);
                        ...
                        io_schedule_timeout(pause);
                        continue;
                }
                break;  // 脏页低于自由运行水位，恢复写入
        }
}

// 源码路径：linux/mm/page-writeback.c
// 双阈值联动核心调度逻辑（简化骨架）
void balance_dirty_pages_ratelimited(struct address_space *mapping)
{
        struct backing_dev_info *bdi = inode_to_bdi(mapping->host);
        ...
        // 1. 速率限制入口：避免每个 write() 都进入昂贵的全局统计
        if (current->nr_dirtied < ratelimit && percpu_ok)
                return;

        // 2. 进入 balance_dirty_pages()：计算全局阈值，必要时阻塞当前进程
        balance_dirty_pages(bdi, current->nr_dirtied);
}

static void balance_dirty_pages(struct bdi_writeback *wb,
                                unsigned long pages_dirtied)
{
        for (;;) {
                // 2.1 计算 dirty_thresh / background_thresh
                global_dirty_limits(&background_thresh, &dirty_thresh);
                nr_dirty = global_node_page_state(NR_FILE_DIRTY) +
                           global_node_page_state(NR_UNSTABLE_NFS) +
                           global_node_page_state(NR_WRITEBACK);

                // 2.2 轻度堆积：后台异步回写（无阻塞）
                if (nr_dirty > background_thresh)
                        wb_start_background_writeback(wb);

                // 2.3 临界/严重堆积：比例化节流 → D 态阻塞（P99 卡顿根源）
                if (nr_dirty >= dirty_thresh) {
                        io_schedule_timeout(max_pause / HZ + 1);
                        continue;
                }

                // 2.4 过渡区：提前降速，避免瞬间击穿 dirty_ratio
                if (nr_dirty > dirty_freerun_ceiling(dirty_thresh, background_thresh)) {
                        io_schedule_timeout(dirty_poll_interval(nr_dirty, dirty_thresh));
                        continue;
                }
                break;
        }
}

// 源码路径：linux/mm/page-writeback.c
static void balance_dirty_pages(struct bdi_writeback *wb,
                                unsigned long pages_dirtied)
{
        struct dirty_throttle_control gdtc_stor = { GDTC_INIT(wb) };
        struct dirty_throttle_control mdtc_stor = { MDTC_INIT(wb, &gdtc_stor) };
        struct dirty_throttle_control * const mdtc = mdtc_valid(&mdtc_stor)
                                        ? &mdtc_stor : NULL;
        ...

        for (;;) {
                // 1. 全局 dirty throttle control（gdtc）
                domain_dirty_limits(gdtc);      // 计算全局 dirty_thresh / bg_thresh

                // 2. memcg dirty throttle control（mdtc）
                if (mdtc) {
                        mem_cgroup_wb_stats(wb, &filepages, &headroom,
                                            &nr_dirty, &writeback);
                        mdtc_calc_avail(mdtc);
                        domain_dirty_limits(mdtc); // 计算 memcg 级 dirty_thresh / bg_thresh
                }

                // 3. 同时满足全局与 memcg 阈值才允许自由运行；任一超限即触发节流
                if (mdtc && mdtc->dirty > mdtc->thresh) {
                        // memcg 级别的脏页超限，同样会 io_schedule_timeout()
                        pause = ...;
                        io_schedule_timeout(pause);
                        continue;
                }
                ...
        }
}

// 源码路径：linux/mm/vmstat.c
// /proc/vmstat 脏页统计内核输出接口
static int vmstat_show(struct seq_file *m, void *p)
{
        // 输出内核原生脏页、回写状态统计数据
        seq_printf(m, "nr_dirty %lu
", global_page_state(NR_FILE_DIRTY));
        seq_printf(m, "nr_writeback %lu
", global_page_state(NR_WRITEBACK));
        return 0;
}