Blog Post 写作指南

---
title: "标题"
---

<style>
/* Mermaid diagram container */
.mermaid-container {
  position: relative;
  display: block;
  cursor: pointer;
  transition: opacity 0.2s;
  max-width: 100%;
  margin: 20px 0;
  overflow-x: auto;
}

.mermaid-container:hover {
  opacity: 0.8;
}

.mermaid-container svg {
  max-width: 100%;
  height: auto;
  display: block;
}

/* Modal overlay */
.mermaid-modal {
  display: none;
  position: fixed;
  z-index: 9999;
  left: 0;
  top: 0;
  width: 100%;
  height: 100%;
  background-color: rgba(0, 0, 0, 0.9);
  animation: fadeIn 0.3s;
}

.mermaid-modal.active {
  display: flex;
  align-items: center;
  justify-content: center;
}

@keyframes fadeIn {
  from { opacity: 0; }
  to { opacity: 1; }
}

/* Modal content */
.mermaid-modal-content {
  position: relative;
  width: 90vw;
  height: 90vh;
  overflow: hidden;
  background: white;
  padding: 20px;
  border-radius: 8px;
  box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
  display: flex;
  align-items: center;
  justify-content: center;
}

.mermaid-modal-diagram {
  transform-origin: center center;
  transition: transform 0.2s ease;
  display: inline-block;
  min-width: 100%;
  cursor: grab;
  user-select: none;
}

.mermaid-modal-diagram.dragging {
  cursor: grabbing;
  transition: none;
}

.mermaid-modal-diagram svg {
  width: 100%;
  height: auto;
  display: block;
  pointer-events: none;
}

/* Control buttons */
.mermaid-controls {
  position: absolute;
  top: 10px;
  right: 10px;
  display: flex;
  gap: 8px;
  z-index: 10000;
}

.mermaid-btn {
  background: rgba(255, 255, 255, 0.9);
  border: 1px solid #ddd;
  border-radius: 4px;
  padding: 8px 12px;
  cursor: pointer;
  font-size: 14px;
  transition: background 0.2s;
  color: #333;
  font-weight: 500;
}

.mermaid-btn:hover {
  background: white;
  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
}

/* Close button */
.mermaid-close {
  background: #f44336;
  color: white;
  border: none;
}

.mermaid-close:hover {
  background: #d32f2f;
}

/* Zoom indicator */
.mermaid-zoom-level {
  position: absolute;
  bottom: 20px;
  left: 20px;
  background: rgba(0, 0, 0, 0.7);
  color: white;
  padding: 6px 12px;
  border-radius: 4px;
  font-size: 14px;
  z-index: 10000;
}
</style>

<script type="module">
  import mermaid from 'https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs';

  mermaid.initialize({
    startOnLoad: false,
    theme: 'default',
    securityLevel: 'loose',
    htmlLabels: true,
    themeVariables: {
      fontSize: '14px'
    }
  });

  let currentZoom = 1;
  let currentModal = null;
  let isDragging = false;
  let startX = 0;
  let startY = 0;
  let translateX = 0;
  let translateY = 0;

  // Create modal HTML
  function createModal() {
    const modal = document.createElement('div');
    modal.className = 'mermaid-modal';
    modal.innerHTML = `
      <div class="mermaid-controls">
        <button class="mermaid-btn zoom-in">放大 +</button>
        <button class="mermaid-btn zoom-out">缩小 -</button>
        <button class="mermaid-btn zoom-reset">重置</button>
        <button class="mermaid-btn mermaid-close">关闭 ✕</button>
      </div>
      <div class="mermaid-modal-content">
        <div class="mermaid-modal-diagram"></div>
      </div>
      <div class="mermaid-zoom-level">100%</div>
    `;
    document.body.appendChild(modal);
    return modal;
  }

  // Show modal with diagram
  function showModal(diagramContent) {
    if (!currentModal) {
      currentModal = createModal();
      setupModalEvents();
    }

    const modalDiagram = currentModal.querySelector('.mermaid-modal-diagram');
    modalDiagram.innerHTML = diagramContent;

    // Remove any width/height attributes from SVG to make it responsive
    const svg = modalDiagram.querySelector('svg');
    if (svg) {
      svg.removeAttribute('width');
      svg.removeAttribute('height');
      svg.style.width = '100%';
      svg.style.height = 'auto';
    }

    // Setup drag functionality
    setupDrag(modalDiagram);

    currentModal.classList.add('active');
    currentZoom = 1;
    resetPosition();
    updateZoom();
    document.body.style.overflow = 'hidden';
  }

  // Hide modal
  function hideModal() {
    if (currentModal) {
      currentModal.classList.remove('active');
      document.body.style.overflow = '';
    }
  }

  // Update zoom level
  function updateZoom() {
    if (!currentModal) return;
    const diagram = currentModal.querySelector('.mermaid-modal-diagram');
    const zoomLevel = currentModal.querySelector('.mermaid-zoom-level');
    diagram.style.transform = `translate(${translateX}px, ${translateY}px) scale(${currentZoom})`;
    zoomLevel.textContent = `${Math.round(currentZoom * 100)}%`;
  }

  // Reset position when zoom changes
  function resetPosition() {
    translateX = 0;
    translateY = 0;
  }

  // Setup drag functionality
  function setupDrag(element) {
    element.addEventListener('mousedown', startDrag);
    element.addEventListener('touchstart', startDrag);
  }

  function startDrag(e) {
    if (e.type === 'mousedown' && e.button !== 0) return; // Only left click

    isDragging = true;
    const modalDiagram = currentModal.querySelector('.mermaid-modal-diagram');
    modalDiagram.classList.add('dragging');

    if (e.type === 'touchstart') {
      startX = e.touches[0].clientX - translateX;
      startY = e.touches[0].clientY - translateY;
    } else {
      startX = e.clientX - translateX;
      startY = e.clientY - translateY;
    }

    document.addEventListener('mousemove', drag);
    document.addEventListener('touchmove', drag);
    document.addEventListener('mouseup', stopDrag);
    document.addEventListener('touchend', stopDrag);
  }

  function drag(e) {
    if (!isDragging) return;
    e.preventDefault();

    if (e.type === 'touchmove') {
      translateX = e.touches[0].clientX - startX;
      translateY = e.touches[0].clientY - startY;
    } else {
      translateX = e.clientX - startX;
      translateY = e.clientY - startY;
    }

    updateZoom();
  }

  function stopDrag() {
    isDragging = false;
    const modalDiagram = currentModal?.querySelector('.mermaid-modal-diagram');
    if (modalDiagram) {
      modalDiagram.classList.remove('dragging');
    }
    document.removeEventListener('mousemove', drag);
    document.removeEventListener('touchmove', drag);
    document.removeEventListener('mouseup', stopDrag);
    document.removeEventListener('touchend', stopDrag);
  }

  // Setup modal event listeners
  function setupModalEvents() {
    if (!currentModal) return;

    // Close button
    currentModal.querySelector('.mermaid-close').addEventListener('click', hideModal);

    // Zoom buttons
    currentModal.querySelector('.zoom-in').addEventListener('click', () => {
      currentZoom = Math.min(currentZoom + 0.25, 3);
      updateZoom();
    });

    currentModal.querySelector('.zoom-out').addEventListener('click', () => {
      currentZoom = Math.max(currentZoom - 0.25, 0.5);
      updateZoom();
    });

    currentModal.querySelector('.zoom-reset').addEventListener('click', () => {
      currentZoom = 1;
      resetPosition();
      updateZoom();
    });

    // Close on background click
    currentModal.addEventListener('click', (e) => {
      if (e.target === currentModal) {
        hideModal();
      }
    });

    // Close on ESC key
    document.addEventListener('keydown', (e) => {
      if (e.key === 'Escape' && currentModal.classList.contains('active')) {
        hideModal();
      }
    });
  }

  // Convert Jekyll-rendered code blocks to mermaid divs
  document.addEventListener('DOMContentLoaded', async function() {
    const codeBlocks = document.querySelectorAll('code.language-mermaid');

    for (const codeBlock of codeBlocks) {
      const pre = codeBlock.parentElement;
      const container = document.createElement('div');
      container.className = 'mermaid-container';

      const mermaidDiv = document.createElement('div');
      mermaidDiv.className = 'mermaid';
      mermaidDiv.textContent = codeBlock.textContent;

      container.appendChild(mermaidDiv);
      pre.replaceWith(container);
    }

    // Render all mermaid diagrams
    try {
      await mermaid.run({
        querySelector: '.mermaid'
      });
      console.log('Mermaid diagrams rendered successfully');
    } catch (error) {
      console.error('Mermaid rendering error:', error);
    }

    // Add click handlers to rendered diagrams
    document.querySelectorAll('.mermaid-container').forEach((container, index) => {
      // Find the rendered SVG inside the container
      const svg = container.querySelector('svg');
      if (!svg) {
        console.warn(`No SVG found in container ${index}`);
        return;
      }

      // Make the container clickable
      container.style.cursor = 'pointer';
      container.title = '点击查看大图';

      container.addEventListener('click', function(e) {
        e.preventDefault();
        e.stopPropagation();

        // Clone the SVG for the modal
        const svgClone = svg.cloneNode(true);
        const tempDiv = document.createElement('div');
        tempDiv.appendChild(svgClone);

        console.log('Opening modal for diagram', index);
        showModal(tempDiv.innerHTML);
      });

      console.log(`Click handler added to diagram ${index}`);
    });
  });
</script>


> 副标题或引言性问题

## 引言：吸引读者

简短的场景描述或问题陈述...

## 一、第一个主要部分

### 子标题

内容...

## 二、第二个主要部分

...

## References

[^1]: 引用1
[^2]: 引用2

## 引言：从"完美运行"到"性能腰斩"

想象一下这样的场景：你的数据库服务器刚刚升级了最新的Linux Kernel 7.0，
期待着更好的性能和安全性。然而，上线后监控图表却显示了一个触目惊心的画面
——PostgreSQL的吞吐量在毫无征兆的情况下**骤降了将近一半**。

这不是虚构的故障演练，而是在Kernel 7.0发布前测试中被多次报告的真实问题[^1]。

```c
// C语言代码
int main() {
    return 0;
}
```

```
# 配置文件或无特定语言的代码块
config PREEMPT_VOLUNTARY
    bool "Voluntary Kernel Preemption"
```

# ✅ 正确 - 使用GitHub链接
在[`kernel/sched/core.c`](https://github.com/torvalds/linux/blob/master/kernel/sched/core.c)中

PostgreSQL的源代码[`src/backend/storage/lmgr/s_lock.c`](https://github.com/postgres/postgres/blob/master/src/backend/storage/lmgr/s_lock.c)

# ❌ 错误 - 本地路径
在`/Users/weli/works/linux/kernel/sched/core.c`中

在commit [`7dadeaa6e851`](https://github.com/torvalds/linux/commit/7dadeaa6e851)中，
Peter Zijlstra详细解释了引入这一机制的三个核心原因[^2]：

> The introduction of PREEMPT_LAZY was for multiple reasons:
> 
> - PREEMPT_RT suffered from over-scheduling...
> - the endless and uncontrolled sprinkling of cond_resched()...

内核在[`kernel/sched/core.c`](https://github.com/torvalds/linux/blob/master/kernel/sched/core.c)中实现了这一机制：

```c
// kernel/sched/core.c: 1172-1183
static __always_inline int get_lazy_tif_bit(void)
{
    if (dynamic_preempt_lazy())
        return TIF_NEED_RESCHED_LAZY;
    return TIF_NEED_RESCHED;
}
\```

下图展示了两种模式的关键差异：

```mermaid
sequenceDiagram
    ...
\```

简单来说，**内核将抢占决策权从"代码中的分散检查点"收拢到了"调度器的时钟中断"中**。

这是第一个引用[^1]，这是第二个引用[^2]。

## References

[^1]: 第一个引用的详细信息
[^2]: 第二个引用的详细信息

[^2]: Peter Zijlstra，Linux内核提交 [`7dadeaa6e851`](https://github.com/torvalds/linux/commit/7dadeaa6e851) — *sched: Further restrict the preemption modes*。详细说明了引入PREEMPT_LAZY的三个核心原因，以及为何限制PREEMPT_NONE和PREEMPT_VOLUNTARY。完整提交信息：<https://patch.msgid.link/20251219101502.GB1132199@noisy.programming.kicks-ass.net>

[^11]: Tomas Vondra，PostgreSQL提交 [`7fe2f67c7c9`](https://github.com/postgres/postgres/commit/7fe2f67c7c9) — *Limit the size of numa_move_pages requests*。PostgreSQL侧对内核bug的规避措施。讨论：<https://postgr.es/m/aEtDozLmtZddARdB@msg.df7cb.de>

[^13]: LKML patch series：《[PATCH 00/14] Restartable Sequences: selftests, time-slice extension》，Thomas Gleixner提出RSEQ时间片扩展机制，共14个补丁。链接：<https://lkml.kernel.org/r/20251215155615.870031952@linutronix.de>

[^3]: Linux内核文档，《preempt-locking.rst》，详细说明了内核抢占模型的演化和`cond_resched()`的使用。参见：[Documentation/locking/preempt-locking.rst](https://github.com/torvalds/linux/blob/master/Documentation/locking/preempt-locking.rst)

# ✅ 好 - 有明确来源
在commit [`7c70cb94d29c`](https://github.com/torvalds/linux/commit/7c70cb94d29c)中，
Peter Zijlstra说明了工作机制[^6]：

> This LAZY bit will be promoted to the full NEED_RESCHED bit on tick.

# ❌ 差 - 无来源的断言
LAZY标志会在时钟中断时被升级。（读者会问：你怎么知道的？）

# ❌ 差 - 没有具体来源的转述
有人提出了一个方案：恢复PREEMPT_VOLUNTARY模式。
（谁提出的？在哪里提出的？什么时候？）

# ✅ 好 - 有具体人名、commit和链接
Peter Zijlstra在commit [`476e8583ca16`](https://github.com/torvalds/linux/commit/476e8583ca16)中
果断地在x86架构上启用了PREEMPT_LAZY[^12]。

# ✅ 生动
让我们一步步推演这个灾难场景：

1. **CPU 0**上的进程A获得自旋锁L，开始执行临界区代码。
2. **此时**，调度器为CPU 0设置了`TIF_NEED_RESCHED_LAZY`标志。
3. 进程A继续执行，它并不知道自己被标记了。

# ❌ 枯燥
当一个进程持有自旋锁时，如果被抢占，会导致性能下降。

这就像在高速公路上设置的临时检查站——内核线程运行到这里时，
会主动"看一眼"是否有更高优先级的任务需要CPU。

## 一、问题背景（宏观）
Linux抢占模型的演化...

## 二、技术细节（中观）
两个标志位的实现...

## 三、代码实现（微观）
```c
static __always_inline int get_lazy_tif_bit(void) {
    ...
}
\```

# ✅ C代码
```c
int main() {}
```

# ✅ Kconfig（使用空标识符）
```
config PREEMPT_LAZY
```

# ❌ 不存在的语言
```kconfig  # Rouge不支持
```