kernel-常见参数或宏

kernel-常见参数或宏

get_online_cpus

get_online_cpus();
get_online_mems();

kstrdup_const 分配内存

    cache_name = kstrdup_const(name, GFP_KERNEL);
    if (!cache_name) {
        err = -ENOMEM;
        goto out_unlock;
    }

barrier

http://www.wowotech.net/kernel_synchronization/memory-barrier.html

编译器将符合人类思考的逻辑（c代码）翻译成了符合CPU运算规则的汇编指令，编译器了解底层CPU的思维模式，因此，它可以在将c翻译成汇编的时候进行优化（例如内存访问指令的重新排序），让产出的汇编指令在CPU上运行的时候更快。然而，这种优化产出的结果未必符合程序员原始的逻辑，因此，作为程序员，作为c程序员，必须有能力了解编译器的行为，并在通过内嵌在c代码中的memory barrier来指导编译器的优化行为（这种memory barrier又叫做优化屏障，Optimization barrier），让编译器产出即高效，又逻辑正确的代码。

CPU的核心思想就是取指执行，对于in-order的单核CPU，并且没有cache（这种CPU在现实世界中还存在吗？），汇编指令的取指和执行是严格按照顺序进行的，也就是说，汇编指令就是所见即所得的，汇编指令的逻辑被严格的被CPU执行。然而，随着计算机系统越来越复杂（多核、cache、superscalar、out-of-order），使用汇编指令这样贴近处理器的语言也无法保证其被CPU执行的结果的一致性，从而需要程序员（看，人还是最不可以替代的）告知CPU如何保证逻辑正确。

综上所述，memory barrier是一种保证内存访问顺序的一种方法，让系统中的HW block（各个cpu、DMA controler、device等）对内存有一致性的视角。

linux kernel中的定义和我们的想像一样，除了barrier这个优化屏障。barrier就象是c代码中的一个栅栏，将代码逻辑分成两段，barrier之前的代码和barrier之后的代码在经过编译器编译后顺序不能乱掉。也就是说，barrier之后的c代码对应的汇编，不能跑到barrier之前去，反之亦然。之所以这么做是因为在我们这个场景中，如果编译为了榨取CPU的performace而对汇编指令进行重排，那么临界区的代码就有可能位于preempt_count_inc之外，从而起不到保护作用。

preempt_disable

preempt_disable（）

临界区

preempt_enable

cmpxchg

https://blog.csdn.net/zdy0_2004/article/details/48013829

cmpxchg(void *ptr, unsigned long old, unsigned long new);

函数完成的功能是：将old和ptr指向的内容比较，如果相等，则将new写入到ptr中，返回old，如果不相等，则返回ptr指向的内容。


1. cmpxchg(*ptr,old,new)

   如果*ptr==old,  则  把new赋值给*A ,并返回old

   如果*ptr!=old,   则 返回*ptr 

2. cmpxchg_double(p1, p2, o1, o2, n1, n2) 

类似于下面的C语言   

if(p1==o1 && p2==o2){
	p1 = n1;
	p2 = n2;
	return 1;
}else 
	return 0;

由于是原子操作，避免了使用锁.

3. this_cpu_cmpxchg_double(pcp1, pcp2, oval1, oval2, nval1, nval2)   

       类似于cmpxchg_double,能够避免禁止中断.

kmem_cache_zalloc

kmem_cache_zalloc

    struct kmem_cache *s;
    int err;

    err = -ENOMEM;
    s = kmem_cache_zalloc(kmem_cache, GFP_KERNEL);
    if (!s)
        goto out;

    s->name = name;
    s->object_size = object_size;
    s->size = size;
    s->align = align;
    s->ctor = ctor;

ilog2

set_min_partial(s, ilog2(s->size) / 2);

for_each_possible_cpu 遍历cpu

static void init_kmem_cache_cpus(struct kmem_cache *s)
{
    int cpu;

    for_each_possible_cpu(cpu)
        per_cpu_ptr(s->cpu_slab, cpu)->tid = init_tid(cpu);
}

set_cpu_partial

s->size >= PAGE_SIZE 时：  s->cpu_partial = 2; 不懂！

static void set_cpu_partial(struct kmem_cache *s)
{
#ifdef CONFIG_SLUB_CPU_PARTIAL
    if (!kmem_cache_has_cpu_partial(s))
        s->cpu_partial = 0;
    else if (s->size >= PAGE_SIZE)
        s->cpu_partial = 2;
    else if (s->size >= 1024)
        s->cpu_partial = 6;
    else if (s->size >= 256)
        s->cpu_partial = 13;
    else
        s->cpu_partial = 30;
#endif
}

this_cpu_read

https://lwn.net/Articles/366994/

this_cpu_read: 读cpu的数据
raw_cpu_ptr
IS_ENABLED

    do {
        tid = this_cpu_read(s->cpu_slab->tid);
        c = raw_cpu_ptr(s->cpu_slab);
    } while (IS_ENABLED(CONFIG_PREEMPT) &&
         unlikely(tid != READ_ONCE(c->tid)));

prefetch:

https://www.gnu.org/software/gcc/projects/prefetch.html/


static void prefetch_freepointer(const struct kmem_cache *s, void *object)
{
    if (object)
        prefetch(freelist_dereference(s, object + s->offset));
}

ALIGN

/* @a is a power of 2 value */
#define ALIGN(x, a)     __ALIGN_KERNEL((x), (a))
#define __ALIGN_KERNEL(x, a)        __ALIGN_KERNEL_MASK(x, (typeof(x))(a) - 1)
#define __ALIGN_KERNEL_MASK(x, mask)    (((x) + (mask)) & ~(mask))

#define ALIGN_DOWN(x, a)    __ALIGN_KERNEL((x) - ((a) - 1), (a))
#define __ALIGN_MASK(x, mask)   __ALIGN_KERNEL_MASK((x), (mask))
#define PTR_ALIGN(p, a)     ((typeof(p))ALIGN((unsigned long)(p), (a)))
#define IS_ALIGNED(x, a)        (((x) & ((typeof(x))(a) - 1)) == 0)


size = ALIGN(size, s->align);


#define ALIGN(x,a)    (((x)+(a)-1)&~(a-1))
就是以a為上界對齊的意思。舉個例子4k頁面邊界的例子，即：
a=4096, x = 3888,那麼以上界對齊為4096。 
        x = 4096，         结果為4096.
        x = 4222，         结果為8192. 

另外還有一種以下界對齊的方式 #define ALIGN(x,a) ((x)&~(a-1)) 
a=4096, x = 3888，结果為0.
        x = 4095，结果為0
        x = 4096，结果為4096
        x = 4222，结果為4096. 
        
        
对于正整数2^n（n>1）来说，存在这样的特性，如果整数X是2^n的整数倍，则X的二进制形式的低n位为0， 如果X不是2^n的整数倍，则X与（~(2^n-1)）进行与运算可以得到一个与X相近的是2^n整数倍的正整数。这个特性经常用于内存分配时对齐。如果是上对齐，则需要先加上2^n-1，再进行上述运算。

在linux2.6.30.4中，在include/Linux/kernel.h文件中，ALIGN宏的定义如下：

#define ALIGN(x,a)      __ALIGN_MASK(x,(typeof(x))(a)-1)  
#define __ALIGN_MASK(x,mask)    (((x)+(mask))&~(mask))  

上面代码中，typeof(x)表示取x的类型，如果x是int，则typeof(x)为int。(typeof(x))(a)-1，表明把a转化为x的类型，并减1，作为对齐掩码。不考虑类型，上述代码可以简化为如下：

#define ALIGN(x,a)    (((x)+(a)-1)&~(a-1))     


上面的计算方法在linux等代码中也常常可以看到,下面给出几个例子:
(1) 当分配地址addr时, 要将该地址以size为倍数对齐, 而且要得到是比addr大的值, 则使用_ALIGN宏：
#define _ALIGN(addr,size)(((addr)+(size)-1)&(~((size)-1)))

(2) 与页面对齐相关的宏
                #define PAGE_SIZE        4096
                #definePAGE_MASK         (~(PAGE_SIZE-1))
                #define PAGE_ALIGN(addr) -(((addr)+PAGE_SIZE-1)& PAGE_MASK)

(3) 与skb分配时对齐相关的宏
                #define SKB_DATA_ALIGN(X) (((X) + (SMP_CACHE_BYTES -1)) & ~(SMP_CACHE_BYTES - 1))

cmpxchg

in_interrupt()

in_interrupt()是判断当前进程是否处于中断上下文，这个中断上下文包括底半部和硬件中断处理过程

compound_head(page);

 static inline struct page *virt_to_head_page(const void *x)
{
    struct page *page = virt_to_page(x);

    return compound_head(page);
}

• 复合页（Compound Page）就是将物理上连续的两个或多个页看成一个
  独立的大页，它可以用来创建hugetlbfs中使用的大页（hugepage），
  也可以用来创建透明大页（transparent huge page）子系统。但是
  它不能用在页缓存（page cache）中，这是因为页缓存中管理的都是
  单个页。

• 分配一个复合页的方式是：使用alloc_pages函数，参数order至少为1，
  且设置__GFP_COMP标记。因为根据复合页的定义，它通常包括2个或多
  个连续的物理内存页，这是由它的实现决定的，因而order参数不可能
  为0。

• 通常调用alloc_pages的内存分配方式如下：

p = alloc_pages(GFP_KERNEL, 2);
```

但是这种方式和创建一个复合页有什么不同呢？不同点就是在创建复合
 页的时候会创建与这个复合页相关的元数据（metadata）。

• 表示复合页的元数据都存在于Page结构体中，Page页中的flag标记用来
  识别复合页。在复合页中，打头的第一个普通页成为“head page”，用
  PG_head标记，而后面的所有页被称为“tail pages”，用PG_tail标记。
  在64位系统中，可以有多余的标记来表示复合页的页头和页尾；但是在
  32位系统中却没有那么多的标记，因此采用了一种复用其他标记的方案，
  即将复合页中的所有页都用PG_compound标记，然后，对于尾页同时也
  使用PG_reclaim标记，这是因为PG_reclaim只有在页缓存中会用到，而
  复合页根本就不会在页缓存中使用。

• 可以使用PageCompound函数来检测一个页是否是复合页，另外函数PageHead
  和函数PageTail用来检测一个页是否是页头或者页尾。在每个尾页的page
  结构体中都包含一个指向头页的指针 - first_page，可以使用compound_head
  函数获得。

• 那么当一个复合页不再被系统使用时，我们如何知道该复合页包含多少
  个普通页，又如何知道该复合页的析构函数（destructor）存在哪里呢？
  首先，人们可能会认为这些信息存在于头页的page结构体中，但是很不
  幸，在这个结构体中已经没有可用的空间了。因此，这些信息全部存储
  在第一个尾页的lru字段中，将该复合页的大小（order）首先强制转换
  为指针类型，然后存储在lru.prev中，将析构函数存储在lru.next中。
  这里就解释了为什么复合页必须至少是两个页。

• 在内核中生命了两个复合页的析构函数，默认情况下会调用free_compound_page
  来将所有的页返回给系统的页框分配器，而hugetlbfs子系统会调用free_huge_page
  来做一些统计并释放。

• 使用复合页的最经典的一个例子就是THP（transparent huge page），
  另外一些驱动使用复合页来方便缓存的管理。

• https://lwn.net/Articles/619514/

_RET_IP_与_THIS_IP_

在 linux-3.4includelinuxkernel.h中有这两个宏的定义：

This function returns the return address of the current function, or of one of its callers. The level argument is number of frames to scan up the call stack. A value of 0 yields the return address of the current function, a value of 1 yields the return address of the caller of the current function, and so forth.

#define _RET_IP_         (unsigned long)__builtin_return_address(0)

#define _THIS_IP_  ({ __label__ __here; __here: (unsigned long)&&__here; })

可看出 _RET_IP_就是使用 __builtin_return_address来实现的，内核中也有例子：

linux-3.4mmmemblock.c中：

int __init_memblock memblock_free(phys_addr_t base, phys_addr_t size)

{
       memblock_dbg("   memblock_free: [%#016llx-%#016llx] %pF
",

                   (unsigned long long)base,

                   (unsigned long long)base + size,

                   (void *)_RET_IP_);

       return __memblock_remove(&memblock.reserved, base, size);
}

调试内核的时候，想打印当前进程的地址可使用 _THIS_IP_

ACCESS_ONCE()/WRITE_ONCE()/READ_ONCE()

http://quant67.com/post/linux/access_once.html

SLUB

struct kmem_cache_node {
    spinlock_t list_lock;

#ifdef CONFIG_SLUB
    // 一个kmem_cache_node n中,所有partial的数量:add_partial()
    unsigned long nr_partial;
    struct list_head partial;
#ifdef CONFIG_SLUB_DEBUG
    // 一个kmem_cache_node n中slab总数量: node_nr_slabs(n);
    atomic_long_t nr_slabs;
    // 一个kmem_cache_node n中object总数量: node_nr_objs(n);
    atomic_long_t total_objects;
    struct list_head full;
#endif
#endif

};

struct kmem_cache_order_objects oo
int order = oo_order(oo);