Linux Kernel Development 3rd Edition 读书笔记(6)

第十一章 Timers and Time Management
1. Frequency of the Timer Interrupt

2. 全局变量jiffies系统启动后的tick数值.
jiffies变量声明在 <linux/jiffies.h> :
extern unsigned long volatile jiffies;
jiffies是jiffies_64的低32位,大部分情况用jiffies,只有时间管理才用jiffies_64,不会溢出.

避免溢出计算出错,采用的宏:
#define time_after(unknown, known) ((long)(known) - (long)(unknown) < 0)
#define time_before(unknown, known) ((long)(unknown) - (long)(known) < 0)
#define time_after_eq(unknown, known) ((long)(unknown) - (long)(known) >= 0)
#define time_before_eq(unknown, known) ((long)(known) - (long)(unknown) >= 0)

3.Timer中断函数分为平台相关和平台无关部分( tick_periodic()).

4. 当前时间(the wall time)定义在 kernel/time/timekeeping.c:

struct timespec xtime;
The timespec  data structure is defined in <linux/time.h>  as:
struct timespec { 
__kernel_time_t tv_sec;      /* seconds */ 
long tv_nsec;                /* nanoseconds */
};

xtime.tv_sec保存了从1970年1月1日(UTC)以来的秒数,叫做epoch,
读写变量xtime需要seqlock类型的spinlock.
写xtime:
write_seqlock(&xtime_lock);
/* update xtime ... */
write_sequnlock(&xtime_lock);
读xtime:

unsigned long seq;
do {
unsigned long lost; 
seq = read_seqbegin(&xtime_lock);
usec = timer->get_offset(); 
lost = jiffies - wall_jiffies; 
if (lost)
usec += lost * (1000000 / HZ); 
sec = xtime.tv_sec;
usec += (xtime.tv_nsec / 1000); 
} while (read_seqretry(&xtime_lock, seq));

Userspace获得xtime的方法是 gettimeofday(),  由sys_gettimeofday()实现(kernel/time.c):

asmlinkage long sys_gettimeofday(struct timeval *tv, struct timezone *tz) 
{
if (likely(tv)) { 
struct timeval ktv; 
do_gettimeofday(&ktv); 
if (copy_to_user(tv, &ktv, sizeof(ktv)))
return -EFAULT;
} 
if (unlikely(tz)) {
if (copy_to_user(tz, &sys_tz, sizeof(sys_tz))) 
return -EFAULT;
} 
return 0;
}

settimeofday()用来设置wall time(需定义 CAP_SYS_TIME).

5. Timers
Timers由结构体timer_list表示, 定义在 <linux/timer.h>:

struct timer_list { 
struct list_head entry;           /* entry in linked list of timers */ 
unsigned long expires;            /* expiration value, in jiffies */ 
void (*function)(unsigned long);  /* the timer handler function */ 
unsigned long data;               /* lone argument to the handler */ 
struct tvec_t_base_s *base;       /* internal timer field, do not touch */
};

创建timer第一步:
struct timer_list my_timer;
初始化timer:
init_timer(&my_timer);
然后填充需要数据:
my_timer.expires = jiffies + delay;    /* timer expires in delay ticks */
my_timer.data = 0;                     /* zero is passed to the timer handler */
my_timer.function = my_function;       /* function to run when timer expires */

时间到了执行函数的原型:
void my_timer_function(unsigned long data);
最后激活timer:
add_timer(&my_timer);

mod_timer()用来操作已经初始化但还没激活的timer.运行后timer被激活.
在timer到期前取消timer:
del_timer(&my_timer);

取消并等待执行函数完成:
del_timer_sync(&my_timer);//和del_timer不同,不能用在中断上下文.

内核在时间中断完成在bottom-half执行timers,softirqs类型,时间中断运行update_process_times(),会调用run_local_timers():

void run_local_timers(void) 
{
hrtimer_run_queues(); 
raise_softirq(TIMER_SOFTIRQ);   /* raise the timer softirq */ 
softlockup_tick();
}

 TIMER_SOFTIRQ  softirq由run_timer_softirq()处理.执行所有到期的timer.timer存储在链表中,kernel根据expired value讲timers分为5组来提高效率.

6.delay
Busy looping:

unsigned long timeout = jiffies + 10;        /* ten ticks */
while (time_before(jiffies, timeout)) 
;

这样系统会死等,下面的方法在等待时候允许其他进程运行:

unsigned long delay = jiffies + 5*HZ;
while (time_before(jiffies, delay)) 
cond_resched();

不使用jiffies的delay方法,可以获得更短的delay:
void udelay(unsigned long usecs)
void ndelay(unsigned long nsecs)
void mdelay(unsigned long msecs)

udelay使用busy looping实现,通过BogoMIPS获取.

更优化的delay'方法:
schedule_timeout(),delay时任务进入sleep状态直至到期被唤醒.使用方法:

/* set task’s state to interruptible sleep */ 
set_current_state(TASK_INTERRUPTIBLE);
/* take a nap and wake up in “s” seconds */ 
schedule_timeout(s * HZ);

等待一定时间或事件被唤醒可调用schedule_timeout() 而不是schedule().

第十二章: Memory Management
1. 页是虚拟内存的最小单元. 大部分32位处理器使用4KB的页,64位使用8KB的页.
2. 页由struct page来表示,定义在 <linux/mm_types.h>.原型:

struct page { 
unsigned long         flags;
atomic_t              _count; 
atomic_t              _mapcount; 
unsigned long         private; 
struct address_space  *mapping; 
pgoff_t               index; 
struct list_head      lru; 
void                  *virtual;
};

flags: 保存页的状态,共32个bit用来表示状态,定义在<linux/page-flags.h>.
_count: 保存页使用的数目.-1时没有被使用.可以被用来新的分配.kernel使用page_count()而不是直接访问该成员.page_count()返回0表示free,非0表示在使用.page可以被page cache使用(mapping指向关联该页的 address_space对象).作为private data(private指向), 或者进程页表的映射.
virtual: 是页的虚拟地址.

page结构关联的是物理页,不是虚拟页.用来表示物理内存,而不是其中的数据.

3. kernel将页分成不同zones. Linux有4个基本的么memory zones(定义在<linux/mmzone.h>):
ZONE_DMA: 包含的页可以进行DMA.
ZONE_DMA32: 包含的页可以进行DMA, 但只能被32位设备访问.
ZONE_NORMAL: 包含普通的,可被映射的页.
ZONE_HIGHMEM: 包含high memory,这些内容不能永久被内核地址空间映射.


zones结构( <linux/mmzone.h>):

struct zone { 
unsigned long            watermark[NR_WMARK]; 
unsigned long            lowmem_reserve[MAX_NR_ZONES]; 
struct per_cpu_pageset   pageset[NR_CPUS]; 
spinlock_t               lock;
struct free_area         free_area[MAX_ORDER] 
spinlock_t               lru_lock; 
struct zone_lru {
struct list_head list; 
unsigned long    nr_saved_scan;
} lru[NR_LRU_LISTS]; 
struct zone_reclaim_stat reclaim_stat; 
unsigned long            pages_scanned; 
unsigned long            flags; 
atomic_long_t            vm_stat[NR_VM_ZONE_STAT_ITEMS]; 
int                      prev_priority; 
unsigned                 int inactive_ratio; 
wait_queue_head_t        *wait_table; 
unsigned long            wait_table_hash_nr_entries; 
unsigned long            wait_table_bits; 
struct pglist_data       *zone_pgdat; 
unsigned long            zone_start_pfn; 
unsigned long            spanned_pages; 
unsigned long            present_pages; 
const char               *name;
};

lock: 用来保护该结构避免被并发进程访问.用来保护该结构而不是其代表的zones的内容.
watermark: 表示该zone消耗的情况,用minimum, low, and high来表示.
name: zones的名字,在 mm/page_alloc.c中被初始化,其中三个名字为DMA, Normal, and HighMem.

4. 分配页内存(<linux/gfp.h>):
struct page * alloc_pages(gfp_t gfp_mask, unsigned int order)
 该函数分配2的order次幂的page,返回指向第一个page的指针.
page转换逻辑地址:
void * page_address(struct page *page)
只获得一页内存的方法:
unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order)
只获得一页内存的简单方法:
struct page * alloc_page(gfp_t gfp_mask)
unsigned long __get_free_page(gfp_t gfp_mask)
返回page被填充为0的函数:
unsigned long get_zeroed_page(unsigned int gfp_mask)



释放内存:
void __free_pages(struct page *page, unsigned int order)
void free_pages(unsigned long addr, unsigned int order)
void free_page(unsigned long addr)

分配内存的例子:

unsigned long page;
page = __get_free_pages(GFP_KERNEL, 3); 
if (!page) {
/* insufficient memory: you must handle this error! */ 
return –ENOMEM;
}
/* ‘page’ is now the address of the first of eight contiguous pages ... */

释放内存例子:

free_pages(page, 3);
/*
* our pages are now freed and we should no
* longer access the address stored in ‘page’
*/

5.  kmalloc()

kmalloc()用来分配基于字节数目的内核内存.定义在 <linux/slab.h>,成功返回分配的内存地址,否则返回NULL.
void * kmalloc(size_t size, gfp_t flags);
例子:

struct dog *p;
p = kmalloc(sizeof(struct dog), GFP_KERNEL); 
if (!p)
/* handle error ... */

gfp_t,定义在 <linux/types.h>,是如何分配内存的标志,有Action Modifiers,Zone Modifiers和Type Flags之分.
Action modifiers:定义内核如何分配所需的内存.

Zone Modifiers:指明内存从哪个zone开始分配.

Type flags:是上两种类型的组合.使用时使用这种标志.




 kfree(), 声明在 <linux/slab.h>:
void kfree(const void *ptr)
例子:

char *buf;
buf = kmalloc(BUF_SIZE, GFP_ATOMIC); 
if (!buf)
/* error allocating memory ! */
....
kfree(buf);

6. vmalloc()(声明在 <linux/vmalloc.h>,定义在mm/vmalloc.c)
void * vmalloc(unsigned long size)
vmalloc()和kmalloc()类似,但分配的是连续的虚拟内存,而不必是连续的物理内存.内核中一般用kmalloc(),开销比vmalloc()小,因为vmalloc()要进行内存映射.
vmalloc()能够sleep,因此不能被中断及其他阻塞不允许的情况.

释放内存:void vfree(const void *addr)
例子:

char *buf;
buf = vmalloc(16 * PAGE_SIZE); /* get 16 pages */ 
if (!buf)
/* error! failed to allocate memory */
/*
* buf now points to at least a 16*PAGE_SIZE bytes
* of virtually contiguous block of memory
*/
After you finish with the memory, make sure to free it by using
vfree(buf);

7. slab layer
slab layer是通用的数据结构缓存层.频繁使用的数据需要缓存.可以避免内存碎片.对于频繁的内存分配释放操作提高性能.
slab layer将不同的对象分组,每个组叫一个cache,每个对象类型对应一个cache.cache然后分组成slab,slabs包含一个或多个连续的物理内存页.cache包含多个slab.
每个slab有3种状态:: full, partial, or empty.

每个cache由 kmem_cache结构表示,包含3个链表:slabs_full, slabs_partial, slabs_empty.
slab结构:

struct slab { 
struct list_head  list;       /* full, partial, or empty list */ 
unsigned long     colouroff;  /* offset for the slab coloring */ 
void              *s_mem;     /* first object in the slab */ 
unsigned int      inuse;      /* allocated objects in the slab */
kmem_bufctl_t     free;       /* first free object, if any */ 
};

使用kmem_getpages通过调用__get_free_pages()来分配新的slab.
static void *kmem_getpages(struct kmem_cache *cachep, gfp_t flags, int nodeid)
kmem_freepages()进行释放.

新的cache通过以下函数创建:

struct kmem_cache * kmem_cache_create(const char *name,
size_t size,
size_t align,
unsigned long flags,
void (*ctor)(void *));

成功返回创建的cache的指针,失败返回NULL.该函数不能在interrupt上下午中调用,因为会睡眠.
销毁cache:

int kmem_cache_destroy(struct kmem_cache *cachep);
成功返回0,失败返回非0值.

cache创建完成后,object可以通过以下函数来获得.

void * kmem_cache_alloc(struct kmem_cache *cachep, gfp_t flags);

Example:
一个全局指针指向task  struct cache

struct kmem_cache *task_struct_cachep;

在 fork_init()中创建:

task_struct_cachep = kmem_cache_create(“task_struct”, 
sizeof(struct task_struct), 
ARCH_MIN_TASKALIGN, 
SLAB_PANIC | SLAB_NOTRACK, 
NULL);

进程调用 fork()创建新的进程时,新的进程描述被创建, do_fork()- dup_task_struct():

struct task_struct *tsk;
tsk = kmem_cache_alloc(task_struct_cachep, GFP_KERNEL); 
if (!tsk)
return NULL;

任务终止后,如果没有子任务等待,进程描述符被释放回 task_struct_cachep  slab cache, free_task_struct()调用:

kmem_cache_free(task_struct_cachep, tsk);

进程描述符是内核核心部分一直被需要,因而不会销毁.

8. Statically Allocating on the Stack
栈上的静态分配,内核进程使用2个页的栈, 也就是32位系统8KB,64位系统16KB.
在编译时可以选择1个页的栈,中断进程使用单独的栈.

9.High Memory Mappings
将high memory内存永久映射到内核地址空间,
void *kmap(struct page *page);( <linux/highmem.h>)
high memory或low memory都可以实用该函数,不使用时应释放:
void kunmap(struct page *page);
临时映射:
可以使用在无法睡眠,如中断处理函数
void *kmap_atomic(struct page *page, enum km_type type);
void kunmap_atomic(void *kvaddr, enum km_type type);

10.The New percpu  Interface
2.6内核新的接口percpu,声明在 <linux/percpu.h> ,实现在 mm/slab.c和<asm/percpu.h>.
编译时定义percpu数据:
DEFINE_PER_CPU(type, name);
引用其他地方声明的数据:
DECLARE_PER_CPU(type, name);
使用get_cpu_var()和put_cpu_var()来操作数据:
get_cpu_var(name)++;    /* increment name on this processor */
put_cpu_var(name);      /* done; enable kernel preemption */
获得其他处理器的数据:
per_cpu(name, cpu)++;   /* increment name on the given processor */

动态数据:
void *alloc_percpu(type);  /* a macro */
void *__alloc_percpu(size_t size, size_t align);
void free_percpu(const void *);

get_cpu_var(ptr);    /* return a void pointer to this processor’s copy of ptr */
put_cpu_var(ptr);    /* done; enable kernel preemption */

Example:

void *percpu_ptr; 
unsigned long *foo;
percpu_ptr = alloc_percpu(unsigned long); 
if (!ptr)
/* error allocating memory .. */
foo = get_cpu_var(percpu_ptr); 
/* manipulate foo .. */ 
put_cpu_var(percpu_ptr);