Bulk of updates.

Signed-off-by: Leon <[email protected]>

Author: freelancer-leon

README.md

@@ -36,6 +36,7 @@
 - [内存管理](https://github.com/freelancer-leon/notes/blob/master/kernel/mm/mm.md)
 - [分页管理](https://github.com/freelancer-leon/notes/blob/master/kernel/mm/mm_pagetable.md)
 - [进程地址空间](https://github.com/freelancer-leon/notes/blob/master/kernel/mm/mm-1-process_addr_spc.md)
+- [slab](https://github.com/freelancer-leon/notes/blob/master/kernel/mm/slab.md)
 - [slub](https://github.com/freelancer-leon/notes/blob/master/kernel/mm/slub.md)
 
 ## 网络

kernel/Bottom_Half.md

@@ -92,9 +92,9 @@ struct softirq_action
 ```c
 asmlinkage __visible void __softirq_entry __do_softirq(void)
 {
-    unsigned long end = jiffies + MAX_SOFTIRQ_TIME;
+    unsigned long end = jiffies + MAX_SOFTIRQ_TIME; /*默认为 2ms*/
     unsigned long old_flags = current->flags;
-    int max_restart = MAX_SOFTIRQ_RESTART;
+    int max_restart = MAX_SOFTIRQ_RESTART; /*默认为 10 次*/
     struct softirq_action *h;
     bool in_hardirq;
     __u32 pending;
@@ -147,13 +147,13 @@ restart:
 
     rcu_bh_qs();
     local_irq_disable(); /*返回之前恢复中断的关闭状态。*/
-
-    pending = local_softirq_pending();
-    if (pending) {
+    /*以上为在软中断上下文中调用软中断处理函数的部分，下面是考虑是否还要继续在软中断上下文中处理软中断*/
+    pending = local_softirq_pending(); /*如果此时还有未处理完的软中断*/
+    if (pending) { /*软中断处理未超过 2ms，且没有进程需要调度，且以上过程未重复执行超过 10次*/
         if (time_before(jiffies, end) && !need_resched() &&
             --max_restart)
-            goto restart;
-
+            goto restart; /*仍然在软中断上下文中执行软中断*/
+        /*否则唤醒 ksoftirqd 去执行剩下的软中断*/
         wakeup_softirqd();
     }
 

kernel/RCU/stallwarn.md

@@ -1,3 +1,11 @@
+* RCU是基于其原理命名的，Read-Copy Update
+  * **Read** 指的是对于被 RCU 保护的共享数据，reader 可以直接访问，不需要获得任何锁；
+  * **Copy Update** 指的是 writer 修改数据前首先拷贝一个副本，然后在副本上进行修改，修改完毕后向reclaimer(垃圾回收器)注册一个回调函数(callback)，在适当的时机完成真正的修改操作 – 把原数据的指针重新指向新的被修改的数据，
+  * 这里所说的适当的时机就是当既有的reader全都退出临界区的时候，而等待恰当时机的过程被称为 **grace period**。
+* 在RCU机制中，writer 不需要和 reader 竞争任何锁，只在有多个 writer 的情况下它们之间需要某种锁进行同步作，如果写操作频繁的话RCU的性能会严重下降，所以 RCU 只适用于读多写少的情况。
+
+* /sys/module/rcupdate/parameters/rcu_cpu_stall_suppress
+* /sys/module/rcupdate/parameters/rcu_cpu_stall_timeout
 
 # 导致 RCU Warning 的原因
 * CPU 在 RCU read-side 临界区内忙循环

kernel/debug/debug.md

@@ -139,6 +139,7 @@ static int __init loglevel(char *str)
 }
 
 early_param("loglevel", loglevel);
+...*```
 ```
 ### 调整
 
@@ -169,7 +170,7 @@ log_buf_len=n[KMG]  Sets the size of the printk ring buffer,
 
 ## sysrq
 
-* 开启sysrq特性
+* 开启 sysrq 特性
   ```
   echo 1 > /proc/sys/kernel/sysrq
   ```
@@ -190,6 +191,7 @@ log_buf_len=n[KMG]  Sets the size of the printk ring buffer,
   ...
   Jun  5 16:23:33 hostdomain kernel: [26953.774424] SysRq : HELP : loglevel(0-9) reboot(b) crash(c) terminate-all-tasks(e) memory-full-oom-kill(f) kill-all-tasks(i) thaw-filesystems(j) sak(k) show-backtrace-all-active-cpus(l) show-memory-usage(m) nice-all-RT-tasks(n) poweroff(o) show-registers(p) show-all-timers(q) unraw(r) sync(s) show-task-states(t) unmount(u) force-fb(V) show-blocked-tasks(w) dump-ftrace-buffer(z)
   ```
+* sysrq 的键映射表见 drivers/tty/sysrq.c 的`struct sysrq_key_op *sysrq_key_table[]`数组
 
 ## git二分法查找
 ```

kernel/mm/mm.md

@@ -360,302 +360,6 @@ Need DMA-able memory, cannot sleep | Use `(GFP_DMA | GFP_ATOMIC)`, or perform yo
 
 > **TLB (translation lookside buffer)** 是一种 **硬缓冲区**，很多体系结构用它来缓冲 **虚拟地址到物理地址的映射关系**。它极大地提高了系统性能，因为大多数内存都要进行虚拟寻址。
 
-# slab层（Slab Layer）
-
-* slab分配器扮演了 **通用数据结构缓存** 的角色。
-* slab分配器试图在几个基本原则之间寻求一种平衡：
-  * 频繁使用的数据结构也会频繁分配和释放，因此应当缓存它们。
-  * 频繁地分配和回收必然会导致内存碎片（难以找到大块连续可用的内存）。为了避免这种现象，空闲链表的缓存会连续地存放。因为已经释放的数据结构又会放回空闲链表，因此不会导致碎片。
-  * 回收的对象可以立即投入下一次分配，因此，对于频繁的分配和释放，空闲链表能够提高其性能。
-  * 如果分配器知道对象大小，页大小和总的高速缓存的大小这样的概念，它会作出更明智的决策。
-  * 如果让部分缓存专属于单个处理器（对系统上的每个处理器独立而唯一），那么，分配和释放就可以在不加SMP锁的情况下运行。
-  * 如果分配器是与NUMA相关的，它就可以从相同的内存结点为请求者进行分配。
-  * 对存放的对象进行着色（color），以防止多个对象映射到相同的高速缓存行（cache line）。
-
-## slab层的设计
-![mm_slab](pic/mm_slab_1.gif)
-* 不同对象划分为 **高速缓存组**，其中每个高速缓存组都存放 **不同类型** 的对象。**每种对象类型** 对应一个高速缓存。
-* `kmalloc()`接口建立在slab层之上，使用了一组通用高速缓存。
-* 高速缓存被划分为 **slab**，slab由一个或多个物理上连续的页组成。
-* 一般情况下，slab也就仅仅由一页组成。每个高速缓存可以由多个slab组成。
-* 每个slab都包含一些被缓存的数据结构。
-* 每个slab处于三种状态之一：满，部分满，空。
-* 当内核某一部分需要一个新对象时：
-  * 先从 *部分满* 的slab中进行分配。
-  * 没有 *部分满*，则从 *空* slab中进行分配。
-  * 没有 *空* slab，则创建一个slab。
-* 注意 slabs_empty 列表中的 slab 是进行 **回收（reaping）** 的主要备选对象。正是通过此过程，slab 所使用的内存被返回给操作系统供其他用户使用。
-* slab 列表中的每个 slab 都是一个连续的内存块（一个或多个连续页），它们被划分成一个个对象。这些对象是从特定缓存中进行分配和释放的基本元素。
-* 注意 slab 是 slab 分配器进行操作的最小分配单位，因此如果需要对 slab 进行扩展，这也就是所扩展的最小值。
-* 由于对象是从 slab 中进行分配和释放的，因此单个 slab 可以在 slab 列表之间进行移动。
-  * 例如，当一个 slab 中的所有对象都被使用完时，就从 slabs_partial 列表中移动到 slabs_full 列表中。
-  * 当一个 slab 完全被分配并且有对象被释放后，就从 slabs_full 列表中移动到 slabs_partial 列表中。
-  * 当所有对象都被释放之后，就从 slabs_partial 列表移动到 slabs_empty 列表中。
-
-### slab 背后的动机
-与传统的内存管理模式相比， slab 缓存分配器提供了很多优点。
-* 首先，内核通常依赖于对小对象的分配，它们会在系统生命周期内进行无数次分配。slab 缓存分配器通过对类似大小的对象进行缓存而提供这种功能，从而避免了常见的碎片问题。
-* slab 分配器还支持通用对象的初始化，从而避免了为同一目而对一个对象重复进行初始化。
-* 最后，slab 分配器还可以支持硬件缓存对齐和着色，这允许不同缓存中的对象占用相同的缓存行，从而提高缓存的利用率并获得更好的性能。
-
-#### 高速缓存结构 kmem_cache
-* 每个高速缓存都用`kmem_cache`结构表示。
-* include/linux/slab_def.h
-```c
-/*
- * Definitions unique to the original Linux SLAB allocator.
- */
-
-struct kmem_cache {
-    /*per-cpu数据，每次分配/释放期间都会访问*/
-    struct array_cache __percpu *cpu_cache;
-
-/* 1) Cache tunables. Protected by slab_mutex */
-    unsigned int batchcount;
-    unsigned int limit;
-    unsigned int shared;
-
-    unsigned int size;
-    struct reciprocal_value reciprocal_buffer_size;
-/* 2) touched by every alloc & free from the backend */
-
-    unsigned int flags;     /* constant flags */
-    unsigned int num;       /* # of objs per slab */
-
-/* 3) cache_grow/shrink */
-    /* order of pgs per slab (2^n) */
-    unsigned int gfporder;
-
-    /* force GFP flags, e.g. GFP_DMA */
-    gfp_t allocflags;
-
-    size_t colour;          /* cache colouring range */
-    unsigned int colour_off;    /* colour offset */
-    struct kmem_cache *freelist_cache;
-    unsigned int freelist_size;
-
-    /* constructor func */
-    void (*ctor)(void *obj);
-
-/* 4) cache creation/removal */
-    const char *name;
-    struct list_head list;
-    int refcount;
-    int object_size;
-    int align;
-
-/* 5) statistics */
-...
-
-    struct kmem_cache_node *node[MAX_NUMNODES];
-};
-...
-```
-
-#### 三个 slab 链表和 Per-CPU 的 array_cache
-
-* mm/slab.h
-```c
-/*
- * struct array_cache
- *
- * Purpose:
- * - LIFO ordering, to hand out cache-warm objects from _alloc
- * - reduce the number of linked list operations
- * - reduce spinlock operations
- *
- * The limit is stored in the per-cpu structure to reduce the data cache
- * footprint.
- *
- */
-struct array_cache {
-    unsigned int avail;
-    unsigned int limit;
-    unsigned int batchcount;
-    unsigned int touched;
-    void *entry[];  /*
-             * Must have this definition in here for the proper
-             * alignment of array_cache. Also simplifies accessing
-             * the entries.
-             */
-};
-...
-/*
- * The slab lists for all objects.
- */
-struct kmem_cache_node {
-    spinlock_t list_lock;
-
-#ifdef CONFIG_SLAB
-    struct list_head slabs_partial; /* partial list first, better asm code */
-    struct list_head slabs_full;
-    struct list_head slabs_free;
-    unsigned long free_objects;
-    unsigned int free_limit;
-    unsigned int colour_next;   /* Per-node cache coloring */
-    struct array_cache *shared; /* shared per node */
-    struct alien_cache **alien; /* on other nodes */
-    unsigned long next_reap;    /* updated without locking */
-    int free_touched;       /* updated without locking */
-#endif
-
-#ifdef CONFIG_SLUB
-    unsigned long nr_partial;
-    struct list_head partial;
-#ifdef CONFIG_SLUB_DEBUG
-    atomic_long_t nr_slabs;
-    atomic_long_t total_objects;
-    struct list_head full;
-#endif
-#endif
-
-};
-```
-
-* `kmem_getpages()`创建新的slab。
-  * `kmem_getpages()`和`alloc_pages()`都会调用`__alloc_pages_nodemask()`来分配页。
-* `kmem_freepages()`释放内存。
-* slab层只有当给定高速缓存部分中即 **没有满** 也 **没有空** 的slab的时才会调用页分配函数。
-* 只有在下列情况下才会调用 *释放函数*：
-  * 当可用内存变得紧缺时，系统试图释放出更多的内存以供使用；
-  * 当高速缓存显示撤销时。
-* slab层的管理是在每个高速缓存的基础上，通过提供给整个系统一个简单的接口来完成的。通过接口就可以：
-  * 创建和撤销新的高速缓存。
-  * 在高速缓存内分配和释放对象。
-* 创建一个高速缓存后，slab层所起的作用就像一个专用的分配器，可以为具体的对象类型进行分配。
-
-#### __SetPageSlab()宏
-* include/linux/page-flags.h
-```c
-enum pageflags {
-  PG_locked,      /* Page is locked. Don't touch. */
-  PG_error,
-  PG_referenced,
-  PG_uptodate,
-  PG_dirty,
-  PG_lru,
-  PG_active,
-  PG_slab,
-...
-};
-...
-static inline struct page *compound_head(struct page *page)
-{
-    unsigned long head = READ_ONCE(page->compound_head);
-
-    if (unlikely(head & 1))
-        return (struct page *) (head - 1);
-    return page;
-}
-
-static __always_inline int PageTail(struct page *page)
-{
-    return READ_ONCE(page->compound_head) & 1;
-}
-...
-/*
- * Page flags policies wrt compound pages
- *
- * PF_ANY:
- *     the page flag is relevant for small, head and tail pages.
- *
- * PF_HEAD:
- *     for compound page all operations related to the page flag applied to
- *     head page.
- *
- * PF_NO_TAIL:
- *     modifications of the page flag must be done on small or head pages,
- *     checks can be done on tail pages too.
- *
- * PF_NO_COMPOUND:
- *     the page flag is not relevant for compound pages.
- */
-#define PF_ANY(page, enforce)   page
-#define PF_HEAD(page, enforce)  compound_head(page)
-#define PF_NO_TAIL(page, enforce) ({                    \
-        VM_BUG_ON_PGFLAGS(enforce && PageTail(page), page); \
-        compound_head(page);})
-#define PF_NO_COMPOUND(page, enforce) ({                \
-        VM_BUG_ON_PGFLAGS(enforce && PageCompound(page), page); \
-        page;})
-
-/*
- * Macros to create function definitions for page flags
- */
-#define TESTPAGEFLAG(uname, lname, policy)              \
-static __always_inline int Page##uname(struct page *page)       \
-    { return test_bit(PG_##lname, &policy(page, 0)->flags); }
-...
-#define __SETPAGEFLAG(uname, lname, policy)             \
-static __always_inline void __SetPage##uname(struct page *page)     \
-    { __set_bit(PG_##lname, &policy(page, 1)->flags); }
-
-#define __CLEARPAGEFLAG(uname, lname, policy)               \
-static __always_inline void __ClearPage##uname(struct page *page)   \
-    { __clear_bit(PG_##lname, &policy(page, 1)->flags); }
-...
-#define __PAGEFLAG(uname, lname, policy)                \
-    TESTPAGEFLAG(uname, lname, policy)              \
-    __SETPAGEFLAG(uname, lname, policy)             \
-    __CLEARPAGEFLAG(uname, lname, policy)
-
-...
-__PAGEFLAG(Slab, slab, PF_NO_TAIL)
-```
-* 宏展开后的函数定义
-```c
-/*__ arch/x86/include/asm/bitops.h*/
-/**
- * __set_bit - Set a bit in memory
- * @nr: the bit to set
- * @addr: the address to start counting from
- *
- * Unlike set_bit(), this function is non-atomic and may be reordered.
- * If it's called on the same region of memory simultaneously, the effect
- * may be that only one operation succeeds.
- */
-static __always_inline void __set_bit(long nr, volatile unsigned long *addr)
-{
-    asm volatile("bts %1,%0" : ADDR : "Ir" (nr) : "memory");
-}
-
-static __always_inline void __SetPageSlab(struct page *page)
-    { __set_bit(PG_slab, &({
-      do {
-        if (unlikely(1 && PageTail(page))) {
-            dump_page(page, "VM_BUG_ON_PAGE(" __stringify(1 && PageTail(page))")");
-            BUG();
-        }
-      } while (0);
-      compound_head(page);})->flags); }
-```
-
-## slab分配器的接口
-
-* `kmem_cache_create()`创建一个新的高速缓存。
-  * `SLAB_HWCACHE_LINE` slab层把一个slab内的所有对象和硬件cache line对齐。可以提高性能，但增加了内存开销，空间换时间。
-  * `SLAB_POISON` 内存毒化标志，用已知的值填充slab。
-  * `SLAB_RED_ZONE` 在已分配的内存周围插入“红色警界区”以探测缓冲越界。
-  * `SLAB_PANIC` 分配失败时提醒slab层。这在要求分配只能成功的时候非常有用。
-  * `SLAB_CACHE_DMA` 命令slab层用 *可以执行DMA的内存* 给每个slab分配空间。
-    * 只在 *分配的对象用于DMA*，且 *必须驻留在`ZONE_DMA`区`时* 才需要这个标志。
-    * 否则不需要，也不应该设置。
-  * **不能用于中断上下文**，会睡眠。
-* `kmem_cache_destory()`撤销给定的高速缓存。
-  * **不能用于中断上下文**，会睡眠。
-  * 除此之外还需确保：
-    * 高速缓存中所有的slab都必须为空。
-    * 在调用`kmem_cache_destory()`过程中（更别提之后了）不再访问这个高速缓存。调用者必须确保同步。
-* `kmem_cache_alloc()`从给定的高速缓存中分配对象。
-  * 如果高速缓存中所有的slab中都没有空闲对象，slab层必须通过`kmem_getpages()`获取新的页。
-* `kmem_cache_free()`释放一个对象，并返还给原先的slab。
-* slab层负责内存紧缺情况下所有底层的对齐，着色，分配，释放，回收等。
-* 如果要频繁创建很多相同类型的对象，应该考虑使用slab高速缓存，而不是自己实现空闲链表。
-
-## 查看slab信息
-* [`cat /proc/slabinfo`](http://man7.org/linux/man-pages/man5/slabinfo.5.html)
-* [`slbtop`](http://man7.org/linux/man-pages/man1/slabtop.1.html)
-
 # 栈上的静态分配
 * 每个进程的 **内核栈** 大小即依赖 *体系结构*，也与 *编译选项* 有关。
 * 历史上，每个进程都有 **两页** 的内核栈。
@@ -822,9 +526,8 @@ static inline void __kunmap_atomic(void *addr)
 * 注意：**不能在访问 Per-CPU 数据过程中睡眠**，否则，醒来可能在其他CPU上。
 * Per-CPU 的新接口并不兼容之前的内核。
 
-
 # 参考资料
-* https://www.ibm.com/developerworks/cn/linux/l-linux-slab-allocator/
+* [Linux slab 分配器剖析](https://www.ibm.com/developerworks/cn/linux/l-linux-slab-allocator/)
 * [/PROC/MEMINFO之谜](http://linuxperf.com/?p=142)
 * [怎样诊断SLAB泄露问题](http://linuxperf.com/?p=148)
 * [Linux内核高端内存](http://ilinuxkernel.com/?p=1013)