update so much thing but not complete

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

Author: freelancer-leon

kernel/bpf/bpf.md

@@ -0,0 +1,6 @@
+# eBPF
+![https://www.ibm.com/developerworks/cn/linux/l-lo-eBPF-history/image005.png](pic/arch_of_ebpf.png)
+
+# References
+- [eBPF 简史](https://www.ibm.com/developerworks/cn/linux/l-lo-eBPF-history/index.html)
+- [ebpf 学习梳理和测试使用](https://cloud.tencent.com/developer/article/1605659)

kernel/bpf/pic/arch_of_ebpf.png

@@ -0,0 +1,145 @@
+### BITS_TO_LONGS()
+* 除法，余数向上取整
+  ```c
+  ...
+  #define __KERNEL_DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d))
+  #define DIV_ROUND_UP __KERNEL_DIV_ROUND_UP
+  ...___```
+  ```
+* include/linux/bitops.h
+  ```c
+  #define BITS_PER_TYPE(type) (sizeof(type) * BITS_PER_BYTE)
+  #define BITS_TO_LONGS(nr)       DIV_ROUND_UP(nr, BITS_PER_TYPE(long))
+  ```
+* `BITS_PER_BYTE` 按规定每字节为 8 位
+* `BITS_PER_TYPE(long)` 在 64 位机器上为`64`
+* `BITS_TO_LONGS(nr)` 为`nr`除以`64`向上取整的结果
+
+### cpu_bit_bitmap[]
+* kernel/cpu.c
+  ```c
+  /* cpu_bit_bitmap[0] is empty - so we can back into it */
+  #define MASK_DECLARE_1(x)       [x+1][0] = (1UL << (x))
+  #define MASK_DECLARE_2(x)       MASK_DECLARE_1(x), MASK_DECLARE_1(x+1)
+  #define MASK_DECLARE_4(x)       MASK_DECLARE_2(x), MASK_DECLARE_2(x+2)
+  #define MASK_DECLARE_8(x)       MASK_DECLARE_4(x), MASK_DECLARE_4(x+4)
+
+  const unsigned long cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)] = {
+
+          MASK_DECLARE_8(0),      MASK_DECLARE_8(8),
+          MASK_DECLARE_8(16),     MASK_DECLARE_8(24),
+  #if BITS_PER_LONG > 32
+          MASK_DECLARE_8(32),     MASK_DECLARE_8(40),
+          MASK_DECLARE_8(48),     MASK_DECLARE_8(56),
+  #endif
+  };
+  EXPORT_SYMBOL_GPL(cpu_bit_bitmap);
+  ```
+* `cpu_bit_bitmap`为二维数组，元素类型为`unsigned long`
+  - 一维有`65`项，一维第一项为空
+  - 二维由`NR_CPUS`决定，例如 72 核 CPU 二维数组会有 2 个元素，总共有`65 x 2 = 130`个`unsigned long`元素
+
+#### 展开`MASK_DECLARE_8(0)`
+* `MASK_DECLARE_8(0)`
+* `MASK_DECLARE_4(0), MASK_DECLARE_4(0+4)`
+* `MASK_DECLARE_2(0), MASK_DECLARE_2(0+2), MASK_DECLARE_2(0+4), MASK_DECLARE_2(0+4+2)`
+* `MASK_DECLARE_1(0), MASK_DECLARE_1(0+1),`
+  `MASK_DECLARE_1(0+2), MASK_DECLARE_1(0+2+1),`
+  `MASK_DECLARE_1(0+4), MASK_DECLARE_1(0+4+1),`
+  `MASK_DECLARE_1(0+4+2), MASK_DECLARE_1(0+4+2+1)`
+* `[1][0] = (1UL << (0)), [2][0] = (1UL << (1)),`
+  `[3][0] = (1UL << (2)), [4][0] = (1UL << (3)),`
+  `[5][0] = (1UL << (4)), [6][0] = (1UL << (5)),`
+  `[7][0] = (1UL << (6)), [8][0] = (1UL << (7))`
+* `MASK_DECLARE_8(0)`就是给数组的一维的 1~8 项，二维的第 0 项，赋初值为 `1UL << n`
+
+### cpumask_of()
+* include/linux/types.h
+  ```c
+  #define DECLARE_BITMAP(name,bits) \
+        unsigned long name[BITS_TO_LONGS(bits)]
+  ```
+* include/linux/cpumask.h
+  ```c
+  /**
+   * to_cpumask - convert an NR_CPUS bitmap to a struct cpumask *
+   * @bitmap: the bitmap
+   *
+   * There are a few places where cpumask_var_t isn't appropriate and
+   * static cpumasks must be used (eg. very early boot), yet we don't
+   * expose the definition of 'struct cpumask'.
+   *
+   * This does the conversion, and can be used as a constant initializer.
+   */
+  #define to_cpumask(bitmap)                                              \
+          ((struct cpumask *)(1 ? (bitmap)                                \
+                              : (void *)sizeof(__check_is_bitmap(bitmap))))
+
+  static inline int __check_is_bitmap(const unsigned long *bitmap)
+  {
+          return 1;
+  }
+
+  /* Don't assign or return these: may not be this big! */
+  typedef struct cpumask { DECLARE_BITMAP(bits, NR_CPUS); } cpumask_t;
+  ...
+  /*
+   * Special-case data structure for "single bit set only" constant CPU masks.
+   *
+   * We pre-generate all the 64 (or 32) possible bit positions, with enough
+   * padding to the left and the right, and return the constant pointer
+   * appropriately offset.
+   */
+  extern const unsigned long
+          cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)];
+
+  static inline const struct cpumask *get_cpu_mask(unsigned int cpu)
+  {
+          const unsigned long *p = cpu_bit_bitmap[1 + cpu % BITS_PER_LONG];
+          p -= cpu / BITS_PER_LONG;
+          return to_cpumask(p);
+  }
+  ...
+  /**
+   * cpumask_of - the cpumask containing just a given cpu
+   * @cpu: the cpu (<= nr_cpu_ids)
+   */
+  #define cpumask_of(cpu) (get_cpu_mask(cpu))
+  ...*```
+  ```
+* `BITS_PER_LONG` 在 64 位机器上为 64
+* 用如下函数可以 dump `cpu_bit_bitmap`数组
+  ```c
+  void dump_cpu_bit_bitmap(void)
+  {
+      int i = 0 , j = 0;
+      const unsigned long *p = NULL;
+      size_t row = sizeof(cpu_bit_bitmap)/sizeof(cpu_bit_bitmap[0]);
+      size_t column = sizeof(cpu_bit_bitmap[0])/sizeof(unsigned long);
+
+      printf("cpu_bit_bitmap[%zd][%zd]\n", row, column);
+
+      for (i = 0; i < row; i++)
+      {   
+          printf("[%02d] ", i);
+          for (j = 0; j < column; j++)
+          {   
+              p = &cpu_bit_bitmap[i][j];
+              printf("%p(%016lx) ", p, *p);
+          }   
+          printf("\n");
+      }   
+  }
+  ```
+* 假设有 256 个逻辑核，得到的数组如下：
+
+  bitmap | 0 | 1 | 2 | 3
+  ---|---|---|---|---
+  0  | x |192|128|64
+  1  | 0 |193|129|65
+  2  | 1 |194|130|66
+  ...|...|...|...|...
+  63 |62 |255|   |127
+  64 |63 | x | x | x
+  * 第一列为一维数组索引，第一行为二维数组索引
+  * 中间的数为 cpu 取不同的值在数组中的位置

kernel/cpumask.md

@@ -206,5 +206,8 @@ git bisect bad
 git bisect start - arch/x86
 ```
 
+# Dynamic Debug
+* CONFIG_DYNAMIC_DEBUG
+
 # References
 * [Debugging by printing](https://elinux.org/Debugging_by_printing)

kernel/debug/debug.md

@@ -258,7 +258,7 @@ static __always_inline unsigned long ffz(unsigned long word);
 * 单处理器（UP）编译的时候不会加入自旋锁。如果禁止内核抢占，则在编译时自旋锁会被完全剔除
 * 注意：Linux的自旋锁实现是**不可递归**的！所以千万小心不要自死锁
 * 自旋锁可用于中断处理程序（中断上下文）中
-* 在**中断处理程序中使用自旋锁时，一定要在获取锁之前首先禁止本地中断**（在当前处理器上的中断请求）。
+* 对于可中断嵌套的内核，在**中断处理程序中使用自旋锁时，一定要在获取锁之前首先禁止本地中断**（在当前处理器上的中断请求）。
   * 原因：（发生在本地的）中断处理程序可能会打断正持有锁的内核代码，又去争用同一个自旋锁，造成死锁。
   * 注意，需关闭的只是本地中断。如果中断发生在其他的处理器上，即使中断处理程序在同一锁上自旋，也不会妨碍锁的持有者（在不同处理器上）最终释放锁。
 * 自旋锁使用示例

kernel/lock/Lock-1.md

@@ -349,10 +349,13 @@ static __always_inline int arch_spin_trylock(arch_spinlock_t *lock)
     /* cmpxchg is a full barrier, so nothing can move before it */
     /*cmpxchg族指令实现原子地比较并交换，由于前面插入了lock指令，因此cmpxchg指令
       执行时锁内存总线，别的线程无法更新锁。
-      cmpxchg 比较 old.head_tail 与 lock->head_tail地址里的值：
-      如果相等，将 new.head_tail 的值存入 lock->head_tail地址指向的内存，返回原来 lock->head_tail 地址里的值。
-      故返回值如果等于 old.head_tail 表示成功。执行线程由此获得锁，返回true。
-      此举原子地完成了比较和更新 Next （占用锁）的过程。
+      cmpxchg 比较 old.head_tail 与 lock->head_tail地址里的值，返回原来
+      lock->head_tail 地址里的值：
+      1）如果相等，将 new.head_tail 的值存入 lock->head_tail地址指向的内存。
+         故返回值如果等于 old.head_tail 表示成功。执行线程由此获得锁，返回true。
+         此举原子地完成了比较和更新 Next （占用锁）的过程。
+      2）如果不等，返回 lock->head_tail 地址里的值 == old.head_tail 表达式必然不成立，
+         尝试获取锁失败。
      */
     return cmpxchg(&lock->head_tail, old.head_tail, new.head_tail) == old.head_tail;
 }

kernel/lock/Lock-2-Linux_x86_Spin_Lock.md

@@ -743,9 +743,9 @@ static inline void __kunmap_atomic(void *addr)
 # Per-CPU
 
 * 对于给定处理器，Per-CPU的数据是唯一的。
-* 虽然访问Per-CPU数据不需要锁同步，但是禁止内核抢占还是需要的，防止出现伪并发。
+* 虽然访问 Per-CPU 数据不需要锁同步，但是禁止内核抢占还是需要的，防止出现伪并发。
 * `get_cpu()`和`put_cpu()`包含了对内核抢占的禁用和重新激活。
-* 2.6 Per-CPU相关文件：
+* 2.6 Per-CPU 相关文件：
   * include/linux/percpu.h
   * arch/x86/include/asm/percpu.h
   * include/linux/percpu-defs.h
@@ -754,11 +754,11 @@ static inline void __kunmap_atomic(void *addr)
 
 ## 编译时Per-CPU数据
 
-* 声明Per-CPU变量
+* 声明 Per-CPU 变量
   ```c
   DECLARE_PER_CPU(type, name)
   ```
-* 定义Per-CPU变量
+* 定义 Per-CPU 变量
   ```c
   DEFINE_PER_CPU(type, name)
   ```
@@ -785,11 +785,12 @@ static inline void __kunmap_atomic(void *addr)
       (void)&(var);                           \
       preempt_enable();                       \
   } while (0)
+  ...'
   ```
-#### 注意
+### 注意
 * `per_cpu(name, cpu)`既不禁止抢占，也不提供锁保护。
 
-> Another subtle note:These compile-time per-CPU examples **do not work for modules** because the linker actually creates them in a unique executable section (for the curious, `.data.percpu` ). If you need to access per-CPU data from modules, or if you need to create such data dynamically, there is hope.
+  > Another subtle note:These compile-time per-CPU examples **do not work for modules** because the linker actually creates them in a unique executable section (for the curious, `.data.percpu` ). If you need to access per-CPU data from modules, or if you need to create such data dynamically, there is hope.
 
 ## 运行时Per-CPU数据
 
@@ -799,9 +800,9 @@ static inline void __kunmap_atomic(void *addr)
   void *__alloc_percpu(size_t size, size_t align);
   void free_percpu(const void *);
   ```
-* `__alignof__` 是gcc的一个功能，它返回指定类型或lvalue所需的（或建议的，要知道有些古怪的体系结构并没有字节对齐的要求） 对齐 **字节数**。
-  * 如果指定一个lvalue，那么将返回lvalue的最大对齐字节数。
-* 使用运行时的Per-CPU数据
+* `__alignof__` 是gcc的一个功能，它返回指定类型或 lvalue 所需的（或建议的，要知道有些古怪的体系结构并没有字节对齐的要求） 对齐 **字节数**。
+  * 如果指定一个 lvalue，那么将返回 lvalue 的最大对齐字节数。
+* 使用运行时的 Per-CPU 数据
   ```c
   get_cpu_var(ptr); /* return a void pointer to this processor’s copy of ptr */
   put_cpu_var(ptr); /* done; enable kernel preemption */
@@ -816,14 +817,15 @@ static inline void __kunmap_atomic(void *addr)
   * 失效发生在处理器试图使它们的缓存保持同步时。
     * 如果一个处理器操作某个数据，而该数据又存放在其他处理器缓存中，那么存放该数据的那个处理器必须清理或刷新自己的缓存。
     * 持续不断的缓存失效称为 **缓存抖动**。这样对系统性能影响颇大。
-  * 使用Per-CPU将使得缓存影响降至最低，因为理想情况下只会访问自己的数据。
+  * 使用 Per-CPU 将使得缓存影响降至最低，因为理想情况下只会访问自己的数据。
   * *percpu* 接口 **cache-align** 所有数据，以便确保在访问一个处理器的数据时，不会将另一个处理器的数据带入同一个cache line上。
-* 注意：**不能在访问Per-CPU数据过程中睡眠**，否则，醒来可能在其他CPU上。
-* Per-CPU的新接口并不兼容之前的内核。
+* 注意：**不能在访问 Per-CPU 数据过程中睡眠**，否则，醒来可能在其他CPU上。
+* Per-CPU 的新接口并不兼容之前的内核。
 
 
 # 参考资料
 * 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)
+* [Per-CPU variables](https://0xax.gitbooks.io/linux-insides/content/Concepts/linux-cpu-1.html)

kernel/mm/mm.md

@@ -0,0 +1,76 @@
+# SCTP
+
+# GSO
+![no gso](pic/no-gso.png)
+![gso](pic/gso.png)
+
+## SCTP vs TCP
+### TCP是以字节为单位传输的，SCTP是以数据块为单位传输的
+
+TCP接收端确认的是收到的字节数，SCTP接收端确认的是接收到的数据块。SCTP的这种数据块（被称为 **data chunk**）通常会携带应用的一个数据包，或者说是应用要发送的一个消息。
+
+在实际的应用中，TCP发送方的可以将应用程序需要发送的多个消息打包到一个TCP包里面发出去。比如，应用程序连续调用两次send()向对端发送两条消息，TCP协议可能把这两条消息都打包放在同一个TCP包中。接收端在收到这个TCP包时，回给对端的ACK只是表明自己接收到了多少个字节，TCP协议本身并不会把收到的数据重新拆散分成两条应用层消息并通知应用程序去接收。事实上，应用程序可能只需要调用一次 `receive()`，就会把两条消息都收上来，然后应用需要根据应用程序自己定义的格式去拆成两条消息。
+
+与TCP不同，SCTP是将应用程序的每次调用`sendmsg()`发送的数据当作一个整体，放到一个被称为 data chunk 的数据块里面，接收端也是以 data chunk 为单位接收数据，并重新组包，通知应用程序接收。通常，应用程序每次调用`recvmesg()`都会收到一条完整的消息。
+
+在 SCTP 的发送端，多条短的应用层消息可以被 SCTP 协议打包放在同一个 SCTP 包中，此时在 SCTP 包中可以看到多个 data chunk。另一方面，一条太长（比如，超过了路径MTU）的应用层消息也可能被 SCTP 协议拆分成多个片段，分别放在多个 data chunk 并通过不同的 SCTP 包发送给对端。这两种情况下，SCTP 的接收端都能重新组包，并通知应用程序去接收。
+
+### TCP通常是单路径传输，SCTP可以多路径传输
+* TCP的两端都只能用一个IP来建立连接，连接建立之后就只能用这一对IP来相互收发消息了。如果这一对IP之间的路径出了问题，那这条TCP连接就不可用了。
+* SCTP不一样的地方是，两端都可以绑定到多个IP上，只要有其中一对IP能通，这条SCTP连接就还可以用。
+* 体现在 socket API 中，TCP 只能 bind 一个 IP，而 SCTP 可以 bind 到多个IP。
+
+### TCP是单流有序传输，SCTP可以多流独立有序/无序传输
+* 一条 SCTP 连接里面，可以区分多条不同的流（stream），不同的流之间的数据传输互不干扰。
+  * 这样做理论上的好处是，如果其中某一条流由于丢包阻塞了，那只会影响到这一条流，其他的流并不会被阻塞。
+  * 但是实际上，如果某一条流由于丢包阻塞，其他的流通常也会丢包，被阻塞，最后导致所有的流都被阻塞，SCTP连接中断。
+* 在同一条 stream 里面，SCTP 支持有序/无序两种传输方式。应用程序在调用`sendmsg()`的时候，需要指定
+  * 用哪一条 stream 传输
+  * 指定这条要发送的消息是需要有序传输还是无序传输的
+* 如果在传输过程中丢包，
+  * 有序传递模式可能会在接收端被阻塞
+  * 无序传输模式不会在接收端被阻塞
+
+### TCP连接的建立过程需要三步握手，SCTP连接的建立过程需要四步握手
+
+* TCP 连接建立过程，容易受到DoS攻击。在建立连接的时候，client 端需要发送`SYN`给 server 端，server 端需要将这些连接请求缓存下来。通过这种机制，攻击者可以发送大量伪造的`SYN`包到一个 server 端，导致 server 端耗尽内存来缓存这些连接请求，最终无法服务。
+* SCTP 的建立过程需要四步握手，
+  1. client 端发送连接请求
+  2. server 端在收到连接请求时，不会立即分配内存缓存起来，而是返回一个 cookie
+  3. client 端需要回送这个 cookie
+  4. server 端校验之后，从 cookie 中重新获取有效信息（比如对端地址列表），才会最终建立这条连接。
+  这样，可以避免类似 TCP 的 SYN 攻击。
+* 应用程序对此感知不到，对应用程序来说，不管是 TCP 还是 SCTP，都只需要在 server 端 listen 一个 socket，client 调用`connect()`去连接到一个 server 端。
+
+###  SCTP有heartbeat机制来管理路径的可用性
+
+* SCTP协议本身有 heartbeat 机制来监控连接/路径的可用性。
+* 前面说过，SCTP 两端都可以 bind 多个 IP，因此同一条 SCTP 连接的数据可以采用不同的 IP 来传输。不同的 IP 传输路径对应一条 path，不同的 path 都可以由 heartbeat 或者是数据的传输/确认来监控其状态。
+  * 如果 heartbeat 没响应，或者是数据在某条 path 超时没收到确认导致重传，则认为该 path 有一次传输失败。
+  * 如果该 path 的连续传输失败次数超过 path 的连续重传次数，则认为该 path 不可用，并通知应用程序。
+  * 如果一条连接的连续传输次数超过设定的 **“连接最大重传次数”**，则该连接被认为不可用，该连接会被关闭并通知应用程序。
+
+## 用 GSO 加速 SCTP
+尽管缺乏硬件的支持，SCTP 仍然能够用 GSO 给网络栈传递一个大的包，而不是多个小的包。
+
+这需要和其他 offloads 不同的方式，因为 SCTP 包不能只根据 (P)MTU 来分片。当然，chucks 必须包含在 IP 分段中，并且做相应的填充。所以不像常规的 GSO，SCTP 不能只是生成一个大`skb`，设置`gso_size`为分片点并交付给 IP 层。
+
+SCTP 协议层构建一个正确填充的分片的`skb`，并且以链式 skbs 的方式存储，`skb_segment()`以此作为拆分的依据。为了标识，`gso_size`设置为特定的值`GSO_BY_FRAGS`。
+
+Therefore, any code in the core networking stack must be aware of the possibility that gso_size will be GSO_BY_FRAGS and handle that case appropriately.
+
+There are some helpers to make this easier:
+
+* skb_is_gso(skb) && skb_is_gso_sctp(skb) is the best way to see if an skb is an SCTP GSO skb.
+* For size checks, the `skb_gso_validate_*_len` family of helpers correctly considers GSO_BY_FRAGS.
+* For manipulating packets, skb_increase_gso_size and skb_decrease_gso_size will check for GSO_BY_FRAGS and WARN if asked to manipulate these skbs.
+
+This also affects drivers with the NETIF_F_FRAGLIST & NETIF_F_GSO_SCTP bits set. Note also that NETIF_F_GSO_SCTP is included in NETIF_F_GSO_SOFTWARE.
+
+# References
+- [SCTP协议详解](https://www.zybuluo.com/ju1900/note/803645)
+- [Stream Control Transmission Protocol - Wikipedia](https://en.wikipedia.org/wiki/Stream_Control_Transmission_Protocol)
+- [SCTP报文格式](http://www.023wg.com/message/message/cd_feature_sctp.html)
+- [SCTP协议详解 - CSDN](https://blog.csdn.net/wuxing26jiayou/article/details/79743683)
+- [Segmentation and Checksum Offloading: Turning Off with ethtool](https://sandilands.info/sgordon/segmentation-offloading-with-wireshark-and-ethtool)
+- [Segmentation Offloads](https://01.org/linuxgraphics/gfx-docs/drm/networking/segmentation-offloads.html#)

kernel/networking/pic/gso.png

@@ -1000,4 +1000,3 @@ CPU1                 13365      branch-misses             #    4.69% of all bran
 * [Branch predictor](https://en.wikipedia.org/wiki/Branch_predictor)
 * [Branch misprediction](https://en.wikipedia.org/wiki/Branch_misprediction)
 * [Hardware performance counter](https://en.wikipedia.org/wiki/Hardware_performance_counter)
-* [Superscalar processor](https://en.wikipedia.org/wiki/Superscalar_processor)