初探内核之《Linux内核设计与实现》笔记下

/* 按照16位对齐，其实就是2个long型的数据 */
struct timespec xtime __attribute__ ((aligned (16)));/* timespec结构体的定义如下， 参考 <linux/time.h> */
struct timespec {
__kernel_time_t tv_sec; /* seconds */
long tv_nsec; /* nanoseconds */
};/* _kernel_time_t 定义如下 */
typedef long __kernel_time_t;

/* 写入 xtime 参考 do_sometimeofday 方法 */
int do_settimeofday(struct timespec *tv)
{
/* 省略 。。。。 */
write_seqlock_irqsave(&xtime_lock, flags); /* 获取写锁 */
/* 更新 xtime */
write_sequnlock_irqrestore(&xtime_lock, flags); /* 释放写锁 */
/* 省略 。。。。 */
return 0;
}/* 读取 xtime 参考 do_gettimeofday 方法 */
void do_gettimeofday(struct timeval *tv)
{
struct timespec now; getnstimeofday(&now); /* 就是在这个方法中获取读锁，并读取 xtime */
tv->tv_sec = now.tv_sec;
tv->tv_usec = now.tv_nsec/1000;
}void getnstimeofday(struct timespec *ts)
{
/* 省略 。。。。 *//* 顺序锁中读锁来循环获取 xtime，直至读取过程中 xtime 没有被改变过 */
do {
seq = read_seqbegin(&xtime_lock); *ts = xtime;
nsecs = timekeeping_get_ns(); /* If arch requires, add in gettimeoffset() */
nsecs += arch_gettimeoffset(); } while (read_seqretry(&xtime_lock, seq));
/* 省略 。。。。 */
}

/* 参见文件： kernel/time.c *
//*
* Convert jiffies/jiffies_64 to clock_t and back.
*/
clock_t jiffies_to_clock_t(unsigned long x)
{
#if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
# if HZ < USER_HZ
return x * (USER_HZ / HZ);
# else
return x / (HZ / USER_HZ);
# endif
#else
return div_u64((u64)x * TICK_NSEC, NSEC_PER_SEC / USER_HZ);
#endif
}
EXPORT_SYMBOL(jiffies_to_clock_t);

/* 64bit和32bit的jiffies定义如下 */
extern u64 __jiffy_data jiffies_64;
extern unsigned long volatile __jiffy_data jiffies;

unsigned long timeout = jiffies + HZ/2; /* 设置超时时间为 0.5秒 */while (timeout < jiffies)
{
/* 还没有超时，继续执行任务 */
}/* 执行超时后的任务 */

#define time_after(a,b) \
(typecheck(unsigned long, a) && \
typecheck(unsigned long, b) && \
((long)(b) - (long)(a) < 0))
#define time_before(a,b) time_after(b,a)#define time_after_eq(a,b) \
(typecheck(unsigned long, a) && \
typecheck(unsigned long, b) && \
((long)(a) - (long)(b) >= 0))
#define time_before_eq(a,b) time_after_eq(b,a)

unsigned long timeout = jiffies + HZ/2; /* 设置超时时间为 0.5秒 */while (time_after(jiffies, timeout))
{
/* 还没有超时，继续执行任务 */
}/* 执行超时后的任务 */

static void tick_periodic(int cpu)
{
if (tick_do_timer_cpu == cpu) {
write_seqlock(&xtime_lock); /* Keep track of the next tick event */
tick_next_period = ktime_add(tick_next_period, tick_period); do_timer(1);
write_sequnlock(&xtime_lock);
} update_process_times(user_mode(get_irq_regs()));
profile_tick(CPU_PROFILING);
}

void do_timer(unsigned long ticks)
{
/* jiffies_64 增加指定ticks */
jiffies_64 += ticks;
/* 更新实际时间 */
update_wall_time();
/* 更新系统的平均负载值 */
calc_global_load();
}void update_process_times(int user_tick)
{
struct task_struct *p = current;
int cpu = smp_processor_id(); /* 更新当前进程占用CPU的时间 */
account_process_tick(p, user_tick);
/* 同时触发软中断，处理所有到期的定时器 */
run_local_timers();
rcu_check_callbacks(cpu, user_tick);
printk_tick();
/* 减少当前进程的时间片数 */
scheduler_tick();
run_posix_cpu_timers(p);
}

struct timer_list {
struct list_head entry;
unsigned long expires; void (*function)(unsigned long);
unsigned long data; struct tvec_base *base;
#ifdef CONFIG_TIMER_STATS
void *start_site;
char start_comm[16];
int start_pid;
#endif
#ifdef CONFIG_LOCKDEP
struct lockdep_map lockdep_map;
#endif
};

struct timer_list my_timer; /* 定义定时器 */
init_timer(&my_timer); /* 初始化定时器 */

my_timer.expires = jiffies + delay; /* 定义超时的节拍数 */
my_timer.data = 0; /* 给定时器函数传入的参数 */
my_timer.function = my_function; /* 定时器超时时，执行的自定义函数 *//* 从定时器结构体中，我们可以看出这个函数的原型应该如下所示： */
void my_function(unsigned long data);

add_timer(&my_timer); /* 激活定时器 */
mod_timer(&my_timer, jiffies + new_delay); /* 修改定时器，设置新的延迟时间 */

/*
* 删除激活的定时器时，此函数返回1
* 删除未激活的定时器时，此函数返回0
*/
del_timer(&my_timer);

/*
* 和del_timer 不同，del_timer_sync 不能在中断上下文中执行
*/
del_timer_sync(&my_timer);

/* 将任务设置为可中断睡眠状态 */
set_current_state(TASK_INTERRUPTIBLE);/* 小睡一会儿，“s“秒后唤醒 */
schedule_timeout(s*HZ);

signed long __sched schedule_timeout(signed long timeout)
{
/* 定义一个定时器 */
struct timer_list timer;
unsigned long expire; switch (timeout)
{
case MAX_SCHEDULE_TIMEOUT:
/*
* These two special cases are useful to be comfortable
* in the caller. Nothing more. We could take
* MAX_SCHEDULE_TIMEOUT from one of the negative value
* but I' d like to return a valid offset (>=0) to allow
* the caller to do everything it want with the retval.
*/
schedule();
goto out;
default:
/*
* Another bit of PARANOID. Note that the retval will be
* 0 since no piece of kernel is supposed to do a check
* for a negative retval of schedule_timeout() (since it
* should never happens anyway). You just have the printk()
* that will tell you if something is gone wrong and where.
*/
if (timeout < 0) {
printk(KERN_ERR "schedule_timeout: wrong timeout "
"value %lx\n", timeout);
dump_stack();
current->state = TASK_RUNNING;
goto out;
}
} /* 设置超时时间 */
expire = timeout + jiffies; /* 初始化定时器，超时处理函数是 process_timeout，后面再补充说明一下这个函数 */
setup_timer_on_stack(&timer, process_timeout, (unsigned long)current);
/* 修改定时器，同时会激活定时器 */
__mod_timer(&timer, expire, false, TIMER_NOT_PINNED);
/* 将本任务睡眠，调度其他任务 */
schedule();
/* 删除定时器，其实就是 del_timer_sync 的宏
del_singleshot_timer_sync(&timer); /* Remove the timer from the object tracker */
destroy_timer_on_stack(&timer); timeout = expire - jiffies; out:
return timeout < 0 ? 0 : timeout;
}
EXPORT_SYMBOL(schedule_timeout);/*
* 超时处理函数 process_timeout 里面只有一步操作，唤醒当前任务。
* process_timeout 的参数其实就是 当前任务的地址
*/
static void process_timeout(unsigned long __data)
{
wake_up_process((struct task_struct *)__data);
}

/* 具体实现参见 include/linux/delay.h
* 以及 arch/x86/include/asm/delay.h
*/
#define mdelay(n) ...
#define udelay(n) ...
#define ndelay(n) ...

[root@vbox ~]# dmesg | grep delay
Calibrating delay loop (skipped), value calculated using timer frequency.. 6387.58 BogoMIPS (lpj=3193792)

#include <linux/sched.h>
#include <linux/timer.h>
#include <linux/jiffies.h>
#include <asm/param.h>
#include <linux/delay.h>
#include "kn_common.h"MODULE_LICENSE("Dual BSD/GPL");static void test_short_delay(void);
static void test_delay(void);
static void test_schedule_timeout(void);
static void my_delay_function(unsigned long);static int testdelay_init(void)
{
printk(KERN_ALERT "HZ in current system: %dHz\n", HZ); /* test short delay */
test_short_delay(); /* test delay */
test_delay(); /* test schedule timeout */
test_schedule_timeout(); return 0;
}static void testdelay_exit(void)
{
printk(KERN_ALERT "*************************\n");
print_current_time(0);
printk(KERN_ALERT "testdelay is exited!\n");
printk(KERN_ALERT "*************************\n");
}static void test_short_delay()
{
printk(KERN_ALERT "jiffies [b e f o r e] short delay: %lu", jiffies);
ndelay(5);
printk(KERN_ALERT "jiffies [a f t e r] short delay: %lu", jiffies);
}static void test_delay()
{
/* 初始化定时器 */
struct timer_list my_timer;
init_timer(&my_timer); /* 填充定时器 */
my_timer.expires = jiffies + 1*HZ; /* 2秒后超时函数执行 */
my_timer.data = jiffies;
my_timer.function = my_delay_function; /* 激活定时器 */
add_timer(&my_timer);
}static void my_delay_function(unsigned long data)
{
printk(KERN_ALERT "This is my delay function start......\n");
printk(KERN_ALERT "The jiffies when init timer: %lu\n", data);
printk(KERN_ALERT "The jiffies when timer is running: %lu\n", jiffies);
printk(KERN_ALERT "This is my delay function end........\n");
}static void test_schedule_timeout()
{
printk(KERN_ALERT "This sample start at : %lu", jiffies); /* 睡眠2秒 */
set_current_state(TASK_INTERRUPTIBLE);
printk(KERN_ALERT "sleep 2s ....\n");
schedule_timeout(2*HZ); printk(KERN_ALERT "This sample end at : %lu", jiffies);
}module_init(testdelay_init);
module_exit(testdelay_exit);

# must complile on customize kernel
obj-m += mydelay.o
mydelay-objs := testdelay.o kn_common.o#generate the path
CURRENT_PATH:=$(shell pwd)
#the current kernel version number
LINUX_KERNEL:=$(shell uname -r)
#the absolute path
LINUX_KERNEL_PATH:=/usr/src/kernels/$(LINUX_KERNEL)
#complie object
all:
make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) modules
rm -rf modules.order Module.symvers .*.cmd *.o *.mod.c .tmp_versions *.unsigned
#clean
clean:
rm -rf modules.order Module.symvers .*.cmd *.o *.mod.c *.ko .tmp_versions *.unsigned

[root@vbox wzh]# make
[root@vbox wzh]# insmod mydelay.ko
[root@vbox wzh]# rmmod mydelay.ko
[root@vbox wzh]# dmesg | tail -14
HZ in current system: 1000Hz
jiffies [b e f o r e] short delay: 4296079617
jiffies [a f t e r] short delay: 4296079617
This sample start at : 4296079619
sleep 2s ....
This is my delay function start......
The jiffies when init timer: 4296079619
The jiffies when timer is running: 4296080621
This is my delay function end........
This sample end at : 4296081622
*************************
2019-9-25 23:7:20
testdelay is exited!
*************************

jiffies [b e f o r e] short delay: 4296079617
jiffies [a f t e r] short delay: 4296079617

The jiffies when init timer: 4296079619
The jiffies when timer is running: 4296080621

This sample start at : 4296079619
This sample end at : 4296081622

[wangyubin@localhost ]$ getconf -a | grep -i 'page'PAGESIZE 4096
PAGE_SIZE 4096
_AVPHYS_PAGES 637406
_PHYS_PAGES 2012863

/*
* 页中包含的成员非常多，还包含了一些联合体
* 其中有些字段我暂时还不清楚含义，以后再补上。。。
*/
struct page {
unsigned long flags; /* 存放页的状态，各种状态参见<linux/page-flags.h> */
atomic_t _count; /* 页的引用计数 */
union {
atomic_t _mapcount; /* 已经映射到mms的pte的个数 */
struct { /* 用于slab层 */
u16 inuse;
u16 objects;
};
};
union {
struct {
unsigned long private; /* 此page作为私有数据时，指向私有数据 */
struct address_space *mapping; /* 此page作为页缓存时，指向关联的address_space */
};
#if USE_SPLIT_PTLOCKS
spinlock_t ptl;
#endif
struct kmem_cache *slab; /* 指向slab层 */
struct page *first_page; /* 尾部复合页中的第一个页 */
};
union {
pgoff_t index; /* Our offset within mapping. */
void *freelist; /* SLUB: freelist req. slab lock */
};
struct list_head lru; /* 将页关联起来的链表项 */
#if defined(WANT_PAGE_VIRTUAL)
void *virtual; /* 页的虚拟地址 */
#endif /* WANT_PAGE_VIRTUAL */
#ifdef CONFIG_WANT_PAGE_DEBUG_FLAGS
unsigned long debug_flags; /* Use atomic bitops on this */
#endif#ifdef CONFIG_KMEMCHECK
/*
* kmemcheck wants to track the status of each byte in a page; this
* is a pointer to such a status block. NULL if not tracked.
*/
void *shadow;
#endif
};

extern void __free_pages(struct page *page, unsigned int order);
extern void free_pages(unsigned long addr, unsigned int order);
extern void free_hot_page(struct page *page);

/**
* @size - 申请分配的字节数
* @flags - 上面讨论的各种 gfp_mask
*/
static __always_inline void *kmalloc(size_t size, gfp_t flags)
#+end_srcvmalloc的定义在 mm/vmalloc.c 中
#+begin_src C
/**
* @size - 申请分配的字节数
*/
void *vmalloc(unsigned long size)

void kfree(const void *)
void vfree(const void *)

struct slab {
struct list_head list; /* 存放缓存对象，这个链表有 满，部分满，空 3种状态 */
unsigned long colouroff; /* slab 着色的偏移量 */
void *s_mem; /* 在 slab 中的第一个对象 */
unsigned int inuse; /* slab 中已分配的对象数 */
kmem_bufctl_t free; /* 第一个空闲对象(如果有的话) */
unsigned short nodeid; /* 应该是在 NUMA 环境下使用 */
};

#include <linux/slab.h>
#include <linux/slab_def.h>
#include "kn_common.h"MODULE_LICENSE("Dual BSD/GPL");#define MYSLAB "testslab"static struct kmem_cache *myslab;/* 申请内存时调用的构造函数 */
static void ctor(void* obj)
{
printk(KERN_ALERT "constructor is running....\n");
}struct student
{
int id;
char* name;
};static void print_student(struct student *);static int testslab_init(void)
{
struct student *stu1, *stu2; /* 建立slab高速缓存，名称就是宏 MYSLAB */
myslab = kmem_cache_create(MYSLAB,
sizeof(struct student),
0,
0,
ctor); /* 高速缓存中分配2个对象 */
printk(KERN_ALERT "alloc one student....\n");
stu1 = (struct student*)kmem_cache_alloc(myslab, GFP_KERNEL);
stu1->id = 1;
stu1->name = "wyb1";
print_student(stu1); printk(KERN_ALERT "alloc one student....\n");
stu2 = (struct student*)kmem_cache_alloc(myslab, GFP_KERNEL);
stu2->id = 2;
stu2->name = "wyb2";
print_student(stu2); /* 释放高速缓存中的对象 */
printk(KERN_ALERT "free one student....\n");
kmem_cache_free(myslab, stu1); printk(KERN_ALERT "free one student....\n");
kmem_cache_free(myslab, stu2); /* 执行完后查看 /proc/slabinfo 文件中是否有名称为 “testslab”的缓存 */
return 0;
}static void testslab_exit(void)
{
/* 删除建立的高速缓存 */
printk(KERN_ALERT "*************************\n");
print_current_time(0);
kmem_cache_destroy(myslab);
printk(KERN_ALERT "testslab is exited!\n");
printk(KERN_ALERT "*************************\n"); /* 执行完后查看 /proc/slabinfo 文件中是否有名称为 “testslab”的缓存 */
}static void print_student(struct student *stu)
{
if (stu != NULL)
{
printk(KERN_ALERT "**********student info***********\n");
printk(KERN_ALERT "student id is: %d\n", stu->id);
printk(KERN_ALERT "student name is: %s\n", stu->name);
printk(KERN_ALERT "*********************************\n");
}
else
printk(KERN_ALERT "the student info is null!!\n");
}module_init(testslab_init);
module_exit(testslab_exit);

# must complile on customize kernel
obj-m += myslab.o
myslab-objs := testslab.o kn_common.o#generate the path
CURRENT_PATH:=$(shell pwd)
#the current kernel version number
LINUX_KERNEL:=$(shell uname -r)
#the absolute path
LINUX_KERNEL_PATH:=/usr/src/kernels/$(LINUX_KERNEL)
#complie object
all:
make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) modules
rm -rf modules.order Module.symvers .*.cmd *.o *.mod.c .tmp_versions *.unsigned
#clean
clean:
rm -rf modules.order Module.symvers .*.cmd *.o *.mod.c *.ko .tmp_versions *.unsigned

[root@vbox wzh]# make
[root@vbox wzh]# insmod myslab.ko
[root@vbox wzh]# dmesg | tail -220
# 可以看到第一次申请内存时，系统一次分配很多内存用于缓存(构造函数执行了多次)
[root@vbox wzh]# cat /proc/slabinfo | grep test #查看我们建立的缓存名在不在系统中
testslab 0 0 16 202 1 : tunables 120 60 0 : slabdata 0 0 0
[root@vbox wzh]# rmmod myslab.ko #卸载内核模块
[root@vbox wzh]# cat /proc/slabinfo | grep test #我们的缓存名已经不在系统中了

/* 将 ZONE_HIGHMEM 区的一个page永久的映射到内核地址空间
* 返回值即为这个page对应的逻辑地址
*/
static inline void *kmap(struct page *page)/* 允许永久映射的数量是有限的，所以不需要高端内存时，应该及时的解除映射 */
static inline void kunmap(struct page *page)

/**
* 将 ZONE_HIGHMEM 区的一个page临时映射到内核地址空间
* 其中的 km_type 表示映射的目的，
* enum kn_type 的定义参见：<asm/kmap_types.h>
*/
static inline void *kmap_atomic(struct page *page, enum km_type idx)/* 相应的解除映射是个宏 */
#define kunmap_atomic(addr, idx) do { pagefault_enable(); } while (0)

[xxxxx@localhost ~]$ ulimit -a | grep 'stack'
stack size (kbytes, -s) 8192

void* p;if (p == NULL)
{
/* 对 P 进行相应的操作，最终 P 不是NULL了 */
}
else
{
/* P 不是NULL，继续对 P 进行相应的操作 */
}

/* 给每个CPU声明一个类型为 type，名称为 name 的变量 */
DECLARE_PER_CPU(type, name)
/* 给每个CPU定义一个类型为 type，名称为 name 的变量 */
DEFINE_PER_CPU(type, name)

DEFINE_PER_CPU(int, name); /* 为每个CPU定义一个 int 类型的name变量 */get_cpu_var(name)++; /* 当前处理器上的name变量 +1 */
put_cpu_var(name); /* 完成对name的操作后，激活当前处理器的内核抢占 */

#define get_cpu_var(var) (*({ \
extern int simple_identifier_##var(void); \
preempt_disable();/* 这句就是禁止当前处理器上的内核抢占 */ \
&__get_cpu_var(var); }))
#define put_cpu_var(var) preempt_enable() /* 这句就是激活当前处理器上的内核抢占 */

/* 给每个处理器分配一个 size 字节大小的对象，对象的偏移量是 align */
extern void *__alloc_percpu(size_t size, size_t align);
/* 释放所有处理器上已分配的变量 __pdata */
extern void free_percpu(void *__pdata);/* 还有一个宏，是按对象类型 type 来给每个CPU分配数据的，
* 其实本质上还是调用了 __alloc_percpu 函数 */
#define alloc_percpu(type) (type *)__alloc_percpu(sizeof(type), \
__alignof__(type))

void *percpu_ptr;
unsigned long *foo;percpu_ptr = alloc_percpu(unsigned long);
if (!percpu_ptr)
/* 内存分配错误 */foo = get_cpu_var(percpu_ptr);
/* 操作foo ... */
put_cpu_var(percpu_ptr);

/*
* 超级块结构中定义的字段非常多，
* 这里只介绍一些重要的属性
*/
struct super_block {
struct list_head s_list; /* 指向所有超级块的链表 */
const struct super_operations *s_op; /* 超级块方法 */
struct dentry *s_root; /* 目录挂载点 */
struct mutex s_lock; /* 超级块信号量 */
int s_count; /* 超级块引用计数 */ struct list_head s_inodes; /* inode链表 */
struct mtd_info *s_mtd; /* 存储磁盘信息 */
fmode_t s_mode; /* 安装权限 */
};/*
* 其中的 s_op 中定义了超级块的操作方法
* 这里只介绍一些相对重要的函数
*/
struct super_operations {
struct inode *(*alloc_inode)(struct super_block *sb); /* 创建和初始化一个索引节点对象 */
void (*destroy_inode)(struct inode *); /* 释放给定的索引节点 */ void (*dirty_inode) (struct inode *); /* VFS在索引节点被修改时会调用这个函数 */
int (*write_inode) (struct inode *, int); /* 将索引节点写入磁盘，wait表示写操作是否需要同步 */
void (*drop_inode) (struct inode *); /* 最后一个指向索引节点的引用被删除后，VFS会调用这个函数 */
void (*delete_inode) (struct inode *); /* 从磁盘上删除指定的索引节点 */
void (*put_super) (struct super_block *); /* 卸载文件系统时由VFS调用，用来释放超级块 */
void (*write_super) (struct super_block *); /* 用给定的超级块更新磁盘上的超级块 */
int (*sync_fs)(struct super_block *sb, int wait); /* 使文件系统中的数据与磁盘上的数据同步 */
int (*statfs) (struct dentry *, struct kstatfs *); /* VFS调用该函数获取文件系统状态 */
int (*remount_fs) (struct super_block *, int *, char *); /* 指定新的安装选项重新安装文件系统时，VFS会调用该函数 */
void (*clear_inode) (struct inode *); /* VFS调用该函数释放索引节点，并清空包含相关数据的所有页面 */
void (*umount_begin) (struct super_block *); /* VFS调用该函数中断安装操作 */
};

/*
* 索引节点结构中定义的字段非常多，
* 这里只介绍一些重要的属性
*/
struct inode {
struct hlist_node i_hash; /* 散列表，用于快速查找inode */
struct list_head i_list; /* 索引节点链表 */
struct list_head i_sb_list; /* 超级块链表超级块 */
struct list_head i_dentry; /* 目录项链表 */
unsigned long i_ino; /* 节点号 */
atomic_t i_count; /* 引用计数 */
unsigned int i_nlink; /* 硬链接数 */
uid_t i_uid; /* 使用者id */
gid_t i_gid; /* 使用组id */
struct timespec i_atime; /* 最后访问时间 */
struct timespec i_mtime; /* 最后修改时间 */
struct timespec i_ctime; /* 最后改变时间 */
const struct inode_operations *i_op; /* 索引节点操作函数 */
const struct file_operations *i_fop; /* 缺省的索引节点操作 */
struct super_block *i_sb; /* 相关的超级块 */
struct address_space *i_mapping; /* 相关的地址映射 */
struct address_space i_data; /* 设备地址映射 */
unsigned int i_flags; /* 文件系统标志 */
void *i_private; /* fs 私有指针 */
};/*
* 其中的 i_op 中定义了索引节点的操作方法
* 这里只介绍一些相对重要的函数
*/
struct inode_operations {
/* 为dentry对象创造一个新的索引节点 */
int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
/* 在特定文件夹中寻找索引节点，该索引节点要对应于dentry中给出的文件名 */
struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);
/* 创建硬链接 */
int (*link) (struct dentry *,struct inode *,struct dentry *);
/* 从一个符号链接查找它指向的索引节点 */
void * (*follow_link) (struct dentry *, struct nameidata *);
/* 在 follow_link调用之后，该函数由VFS调用进行清除工作 */
void (*put_link) (struct dentry *, struct nameidata *, void *);
/* 该函数由VFS调用，用于修改文件的大小 */
void (*truncate) (struct inode *);
};

[wuzhihang@localhost kernel]$ sudo cat /proc/slabinfo | grep dentry
dentry 212545 212625 192 21 1 : tunables 0 0 0 : slabdata 10125 10125 0

/* 目录项对象结构 */
struct dentry {
atomic_t d_count; /* 使用计数 */
unsigned int d_flags; /* 目录项标识 */
spinlock_t d_lock; /* 单目录项锁 */
int d_mounted; /* 是否登录点的目录项 */
struct inode *d_inode; /* 相关联的索引节点 */
struct hlist_node d_hash; /* 散列表 */
struct dentry *d_parent; /* 父目录的目录项对象 */
struct qstr d_name; /* 目录项名称 */
struct list_head d_lru; /* 未使用的链表 */
/*
* d_child and d_rcu can share memory
*/
union {
struct list_head d_child; /* child of parent list */
struct rcu_head d_rcu;
} d_u;
struct list_head d_subdirs; /* 子目录链表 */
struct list_head d_alias; /* 索引节点别名链表 */
unsigned long d_time; /* 重置时间 */
const struct dentry_operations *d_op; /* 目录项操作相关函数 */
struct super_block *d_sb; /* 文件的超级块 */
void *d_fsdata; /* 文件系统特有数据 */ unsigned char d_iname[DNAME_INLINE_LEN_MIN]; /* 短文件名 */
};/* 目录项相关操作函数 */
struct dentry_operations {
/* 该函数判断目录项对象是否有效。VFS准备从dcache中使用一个目录项时会调用这个函数 */
int (*d_revalidate)(struct dentry *, struct nameidata *);
/* 为目录项对象生成hash值 */
int (*d_hash) (struct dentry *, struct qstr *);
/* 比较 qstr 类型的2个文件名 */
int (*d_compare) (struct dentry *, struct qstr *, struct qstr *);
/* 当目录项对象的 d_count 为0时，VFS调用这个函数 */
int (*d_delete)(struct dentry *);
/* 当目录项对象将要被释放时，VFS调用该函数 */
void (*d_release)(struct dentry *);
/* 当目录项对象丢失其索引节点时（也就是磁盘索引节点被删除了），VFS会调用该函数 */
void (*d_iput)(struct dentry *, struct inode *);
char *(*d_dname)(struct dentry *, char *, int);
};

/*
* 文件对象结构中定义的字段非常多，
* 这里只介绍一些重要的属性
*/
struct file {
union {
struct list_head fu_list; /* 文件对象链表 */
struct rcu_head fu_rcuhead; /* 释放之后的RCU链表 */
} f_u;
struct path f_path; /* 包含的目录项 */
const struct file_operations *f_op; /* 文件操作函数 */
atomic_long_t f_count; /* 文件对象引用计数 */
};/*
* 其中的 f_op 中定义了文件对象的操作方法
* 这里只介绍一些相对重要的函数
*/
struct file_operations {
/* 用于更新偏移量指针,由系统调用lleek()调用它 */
loff_t (*llseek) (struct file *, loff_t, int);
/* 由系统调用read()调用它 */
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
/* 由系统调用write()调用它 */
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
/* 由系统调用 aio_read() 调用它 */
ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
/* 由系统调用 aio_write() 调用它 */
ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
/* 将给定文件映射到指定的地址空间上,由系统调用 mmap 调用它 */
int (*mmap) (struct file *, struct vm_area_struct *);
/* 创建一个新的文件对象,并将它和相应的索引节点对象关联起来 */
int (*open) (struct inode *, struct file *);
/* 当已打开文件的引用计数减少时,VFS调用该函数 */
int (*flush) (struct file *, fl_owner_t id);
};

struct file_system_type {
const char *name; /* 文件系统名称 */
int fs_flags; /* 文件系统类型标志 */
/* 从磁盘中读取超级块,并且在文件系统被安装时,在内存中组装超级块对象 */
int (*get_sb) (struct file_system_type *, int,
const char *, void *, struct vfsmount *);
/* 终止访问超级块 */
void (*kill_sb) (struct super_block *);
struct module *owner; /* 文件系统模块 */
struct file_system_type * next; /* 链表中下一个文件系统类型 */
struct list_head fs_supers; /* 超级块对象链表 */ /* 下面都是运行时的锁 */
struct lock_class_key s_lock_key;
struct lock_class_key s_umount_key; struct lock_class_key i_lock_key;
struct lock_class_key i_mutex_key;
struct lock_class_key i_mutex_dir_key;
struct lock_class_key i_alloc_sem_key;
};

struct vfsmount {
struct list_head mnt_hash; /* 散列表 */
struct vfsmount *mnt_parent; /* 父文件系统，也就是要挂载到哪个文件系统 */
struct dentry *mnt_mountpoint; /* 安装点的目录项 */
struct dentry *mnt_root; /* 该文件系统的根目录项 */
struct super_block *mnt_sb; /* 该文件系统的超级块 */
struct list_head mnt_mounts; /* 子文件系统链表 */
struct list_head mnt_child; /* 子文件系统链表 */
int mnt_flags; /* 安装标志 */
/* 4 bytes hole on 64bits arches */
const char *mnt_devname; /* 设备文件名 e.g. /dev/dsk/hda1 */
struct list_head mnt_list; /* 描述符链表 */
struct list_head mnt_expire; /* 到期链表的入口 */
struct list_head mnt_share; /* 共享安装链表的入口 */
struct list_head mnt_slave_list;/* 从安装链表 */
struct list_head mnt_slave; /* 从安装链表的入口 */
struct vfsmount *mnt_master; /* 从安装链表的主人 */
struct mnt_namespace *mnt_ns; /* 相关的命名空间 */
int mnt_id; /* 安装标识符 */
int mnt_group_id; /* 组标识符 */
/*
* We put mnt_count & mnt_expiry_mark at the end of struct vfsmount
* to let these frequently modified fields in a separate cache line
* (so that reads of mnt_flags wont ping-pong on SMP machines)
*/
atomic_t mnt_count; /* 使用计数 */
int mnt_expiry_mark; /* 如果标记为到期，则为 True */
int mnt_pinned; /* "钉住"进程计数 */
int mnt_ghosts; /* "镜像"引用计数 */
#ifdef CONFIG_SMP
int *mnt_writers; /* 写者引用计数 */
#else
int mnt_writers; /* 写者引用计数 */
#endif
};

struct files_struct {
atomic_t count; /* 使用计数 */
struct fdtable *fdt; /* 指向其他fd表的指针 */
struct fdtable fdtab;/* 基 fd 表 */
spinlock_t file_lock ____cacheline_aligned_in_smp; /* 单个文件的锁 */
int next_fd; /* 缓存下一个可用的fd */
struct embedded_fd_set close_on_exec_init; /* exec()时关闭的文件描述符链表 */
struct embedded_fd_set open_fds_init; /* 打开的文件描述符链表 */
struct file * fd_array[NR_OPEN_DEFAULT]; /* 缺省的文件对象数组 */
};

struct fs_struct {
int users; /* 用户数目 */
rwlock_t lock; /* 保护结构体的读写锁 */
int umask; /* 掩码 */
int in_exec; /* 当前正在执行的文件 */
struct path root, pwd; /* 根目录路径和当前工作目录路径 */
};

/* filesystem information */
struct fs_struct *fs;
/* open file information */
struct files_struct *files;
/* namespaces */
struct nsproxy *nsproxy;

[wuzhihang@localhost]$ sudo fdisk -lWARNING: GPT (GUID Partition Table) detected on '/dev/sda'! The util fdisk doesn't support GPT. Use GNU Parted.Disk /dev/sda: 500.1 GB, 500107862016 bytes, 976773168 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes
Disk identifier: 0x00000000

struct buffer_head {
unsigned long b_state; /* 表示缓冲区状态 */
struct buffer_head *b_this_page;/* 当前页中缓冲区 */
struct page *b_page; /* 当前缓冲区所在内存页 */ sector_t b_blocknr; /* 起始块号 */
size_t b_size; /* buffer在内存中的大小 */
char *b_data; /* 块映射在内存页中的数据 */ struct block_device *b_bdev; /* 关联的块设备 */
bh_end_io_t *b_end_io; /* I/O完成方法 */
void *b_private; /* 保留的 I/O 完成方法 */
struct list_head b_assoc_buffers; /* 关联的其他缓冲区 */
struct address_space *b_assoc_map; /* 相关的地址空间 */
atomic_t b_count; /* 引用计数 */
};

enum bh_state_bits {
BH_Uptodate, /* 包含可用数据 */
BH_Dirty, /* 该缓冲区是脏的(说明缓冲的内容比磁盘中的内容新，需要回写磁盘) */
BH_Lock, /* 该缓冲区正在被I/O使用，锁住以防止并发访问 */
BH_Req, /* 该缓冲区有I/O请求操作 */
BH_Uptodate_Lock,/* 由内存页中的第一个缓冲区使用，使得该页中的其他缓冲区 */ BH_Mapped, /* 该缓冲区是映射到磁盘块的可用缓冲区 */
BH_New, /* 缓冲区是通过 get_block() 刚刚映射的，尚且不能访问 */
BH_Async_Read, /* 该缓冲区正通过 end_buffer_async_read() 被异步I/O读操作使用 */
BH_Async_Write, /* 该缓冲区正通过 end_buffer_async_read() 被异步I/O写操作使用 */
BH_Delay, /* 缓冲区还未和磁盘关联 */
BH_Boundary, /* 该缓冲区处于连续块区的边界，下一个块不在连续 */
BH_Write_EIO, /* 该缓冲区在写的时候遇到 I/O 错误 */
BH_Ordered, /* 顺序写 */
BH_Eopnotsupp, /* 该缓冲区发生 “不被支持” 错误 */
BH_Unwritten, /* 该缓冲区在磁盘上的位置已经被申请，但还有实际写入数据 */
BH_Quiet, /* 该缓冲区禁止错误 */ BH_PrivateStart,/* 不是表示状态，分配给其他实体的私有数据区的第一个bit */
};

/*
* I/O 操作的主要单元，针对 I/O块和更低级的层 (ie drivers and
* stacking drivers)
*/
struct bio {
sector_t bi_sector; /* 磁盘上相关扇区 */
struct bio *bi_next; /* 请求列表 */
struct block_device *bi_bdev; /* 相关的块设备 */
unsigned long bi_flags; /* 状态和命令标志 */
unsigned long bi_rw; /* 读还是写 */ unsigned short bi_vcnt; /* bio_vecs的数目 */
unsigned short bi_idx; /* bio_io_vect的当前索引 */ /* Number of segments in this BIO after
* physical address coalescing is performed.
* 结合后的片段数目
*/
unsigned int bi_phys_segments; unsigned int bi_size; /* 剩余 I/O 计数 */ /*
* To keep track of the max segment size, we account for the
* sizes of the first and last mergeable segments in this bio.
* 第一个和最后一个可合并的段的大小
*/
unsigned int bi_seg_front_size;
unsigned int bi_seg_back_size; unsigned int bi_max_vecs; /* bio_vecs数目上限 */
unsigned int bi_comp_cpu; /* 结束CPU */ atomic_t bi_cnt; /* 使用计数 */
struct bio_vec *bi_io_vec; /* bio_vec 链表 */
bio_end_io_t *bi_end_io; /* I/O 完成方法 */
void *bi_private; /* bio结构体创建者的私有方法 */
#if defined(CONFIG_BLK_DEV_INTEGRITY)
struct bio_integrity_payload *bi_integrity; /* data integrity */
#endif
bio_destructor_t *bi_destructor; /* bio撤销方法 */
/*
* We can inline a number of vecs at the end of the bio, to avoid
* double allocations for a small number of bio_vecs. This member
* MUST obviously be kept at the very end of the bio.
* 内嵌在结构体末尾的 bio 向量，主要为了防止出现二次申请少量的 bio_vecs
*/
struct bio_vec bi_inline_vecs[0];
};

struct bio_vec {
struct page *bv_page; /* 对应的物理页 */
unsigned int bv_len; /* 缓冲区大小 */
unsigned int bv_offset; /* 缓冲区开始的位置 */
};

struct mm_struct {
struct vm_area_struct * mmap; /* [内存区域]链表 */
struct rb_root mm_rb; /* [内存区域]红黑树 */
struct vm_area_struct * mmap_cache; /* 最近一次访问的[内存区域] */
unsigned long (*get_unmapped_area) (struct file *filp,
unsigned long addr, unsigned long len,
unsigned long pgoff, unsigned long flags); /* 获取指定区间内一个还未映射的地址，出错时返回错误码 */
void (*unmap_area) (struct mm_struct *mm, unsigned long addr); /* 取消地址 addr 的映射 */
unsigned long mmap_base; /* 地址空间中可以用来映射的首地址 */
unsigned long task_size; /* 进程的虚拟地址空间大小 */
unsigned long cached_hole_size; /* 如果不空的话，就是 free_area_cache 后最大的空洞 */
unsigned long free_area_cache; /* 地址空间的第一个空洞 */
pgd_t * pgd; /* 页全局目录 */
atomic_t mm_users; /* 使用地址空间的用户数 */
atomic_t mm_count; /* 实际使用地址空间的计数， (users count as 1) */
int map_count; /* [内存区域]个数 */
struct rw_semaphore mmap_sem; /* 内存区域信号量 */
spinlock_t page_table_lock; /* 页表锁 */ struct list_head mmlist; /* 所有地址空间形成的链表 */ /* Special counters, in some configurations protected by the
* page_table_lock, in other configurations by being atomic.
*/
mm_counter_t _file_rss;
mm_counter_t _anon_rss; unsigned long hiwater_rss; /* High-watermark of RSS usage */
unsigned long hiwater_vm; /* High-water virtual memory usage */ unsigned long total_vm, locked_vm, shared_vm, exec_vm;
unsigned long stack_vm, reserved_vm, def_flags, nr_ptes;
unsigned long start_code, end_code, start_data, end_data; /* 代码段，数据段的开始和结束地址 */
unsigned long start_brk, brk, start_stack; /* 堆的首地址，尾地址，进程栈首地址 */
unsigned long arg_start, arg_end, env_start, env_end; /* 命令行参数，环境变量首地址，尾地址 */ unsigned long saved_auxv[AT_VECTOR_SIZE]; /* for /proc/PID/auxv */ struct linux_binfmt *binfmt; cpumask_t cpu_vm_mask; /* Architecture-specific MM context */
mm_context_t context; /* Swap token stuff */
/*
* Last value of global fault stamp as seen by this process.
* In other words, this value gives an indication of how long
* it has been since this task got the token.
* Look at mm/thrash.c
*/
unsigned int faultstamp;
unsigned int token_priority;
unsigned int last_interval; unsigned long flags; /* Must use atomic bitops to access the bits */ struct core_state *core_state; /* coredumping support */
#ifdef CONFIG_AIO
spinlock_t ioctx_lock;
struct hlist_head ioctx_list;
#endif
#ifdef CONFIG_MM_OWNER
/*
* "owner" points to a task that is regarded as the canonical
* user/owner of this mm. All of the following must be true in
* order for it to be changed:
*
* current == mm->owner
* current->mm != mm
* new_owner->mm == mm
* new_owner->alloc_lock is held
*/
struct task_struct *owner;
#endif#ifdef CONFIG_PROC_FS
/* store ref to file /proc/<pid>/exe symlink points to */
struct file *exe_file;
unsigned long num_exe_file_vmas;
#endif
#ifdef CONFIG_MMU_NOTIFIER
struct mmu_notifier_mm *mmu_notifier_mm;
#endif
};

#define allocate_mm() (kmem_cache_alloc(mm_cachep, GFP_KERNEL))
#define free_mm(mm) (kmem_cache_free(mm_cachep, (mm)))

# cat /proc/slabinfo | grep mm_struct
mm_struct 35 45 1408 5 2 : tunables 24 12 8 : slabdata 9 9 0

cat /proc/<PID>/maps
或者
pmap PID

struct vm_area_struct {
struct mm_struct * vm_mm; /* 相关的 mm_struct 结构体 */
unsigned long vm_start; /* 内存区域首地址 */
unsigned long vm_end; /* 内存区域尾地址 */ /* linked list of VM areas per task, sorted by address */
struct vm_area_struct *vm_next, *vm_prev; /* VMA链表 */ pgprot_t vm_page_prot; /* 访问控制权限 */
unsigned long vm_flags; /* 标志 */ struct rb_node vm_rb; /* 树上的VMA节点 */ /*
* For areas with an address space and backing store,
* linkage into the address_space->i_mmap prio tree, or
* linkage to the list of like vmas hanging off its node, or
* linkage of vma in the address_space->i_mmap_nonlinear list.
*/
union {
struct {
struct list_head list;
void *parent; /* aligns with prio_tree_node parent */
struct vm_area_struct *head;
} vm_set; struct raw_prio_tree_node prio_tree_node;
} shared; /*
* A file's MAP_PRIVATE vma can be in both i_mmap tree and anon_vma
* list, after a COW of one of the file pages. A MAP_SHARED vma
* can only be in the i_mmap tree. An anonymous MAP_PRIVATE, stack
* or brk vma (with NULL file) can only be in an anon_vma list.
*/
struct list_head anon_vma_node; /* Serialized by anon_vma->lock */
struct anon_vma *anon_vma; /* Serialized by page_table_lock */ /* Function pointers to deal with this struct. */
const struct vm_operations_struct *vm_ops; /* Information about our backing store: */
unsigned long vm_pgoff; /* Offset (within vm_file) in PAGE_SIZE
units, *not* PAGE_CACHE_SIZE */
struct file * vm_file; /* File we map to (can be NULL). */
void * vm_private_data; /* was vm_pte (shared mem) */
unsigned long vm_truncate_count;/* truncate_count or restart_addr */#ifndef CONFIG_MMU
struct vm_region *vm_region; /* NOMMU mapping region */
#endif
#ifdef CONFIG_NUMA
struct mempolicy *vm_policy; /* NUMA policy for the VMA */
#endif
};

/*
* These are the virtual MM functions - opening of an area, closing and
* unmapping it (needed to keep files on disk up-to-date etc), pointer
* to the functions called when a no-page or a wp-page exception occurs.
*/
struct vm_operations_struct {
void (*open)(struct vm_area_struct * area); /* 指定内存区域加入到一个地址空间时，该函数被调用 */
void (*close)(struct vm_area_struct * area); /* 指定内存区域从一个地址空间删除时，该函数被调用 */
int (*fault)(struct vm_area_struct *vma, struct vm_fault *vmf); /* 当没有出现在物理页面中的内存被访问时，该函数被调用 */ /* 当一个之前只读的页面变为可写时，该函数被调用，
* 如果此函数出错，将导致一个 SIGBUS 信号 */
int (*page_mkwrite)(struct vm_area_struct *vma, struct vm_fault *vmf); /* 当 get_user_pages() 调用失败时, 该函数被 access_process_vm() 函数调用 */
int (*access)(struct vm_area_struct *vma, unsigned long addr,
void *buf, int len, int write);
#ifdef CONFIG_NUMA
/*
* set_policy() op must add a reference to any non-NULL @new mempolicy
* to hold the policy upon return. Caller should pass NULL @new to
* remove a policy and fall back to surrounding context--i.e. do not
* install a MPOL_DEFAULT policy, nor the task or system default
* mempolicy.
*/
int (*set_policy)(struct vm_area_struct *vma, struct mempolicy *new); /*
* get_policy() op must add reference [mpol_get()] to any policy at
* (vma,addr) marked as MPOL_SHARED. The shared policy infrastructure
* in mm/mempolicy.c will do this automatically.
* get_policy() must NOT add a ref if the policy at (vma,addr) is not
* marked as MPOL_SHARED. vma policies are protected by the mmap_sem.
* If no [shared/vma] mempolicy exists at the addr, get_policy() op
* must return NULL--i.e., do not "fallback" to task or system default
* policy.
*/
struct mempolicy *(*get_policy)(struct vm_area_struct *vma,
unsigned long addr);
int (*migrate)(struct vm_area_struct *vma, const nodemask_t *from,
const nodemask_t *to, unsigned long flags);
#endif
};

/* Look up the first VMA which satisfies addr < vm_end, NULL if none. */
extern struct vm_area_struct * find_vma(struct mm_struct * mm, unsigned long addr);
extern struct vm_area_struct * find_vma_prev(struct mm_struct * mm, unsigned long addr,
struct vm_area_struct **pprev);/* Look up the first VMA which intersects the interval start_addr..end_addr-1,
NULL if none. Assume start_addr < end_addr. */
static inline struct vm_area_struct * find_vma_intersection(struct mm_struct * mm, unsigned long start_addr, unsigned long end_addr)
{
struct vm_area_struct * vma = find_vma(mm,start_addr); if (vma && end_addr <= vma->vm_start)
vma = NULL;
return vma;
}

static inline unsigned long do_mmap(struct file *file, unsigned long addr,
unsigned long len, unsigned long prot,
unsigned long flag, unsigned long offset)
{
unsigned long ret = -EINVAL;
if ((offset + PAGE_ALIGN(len)) < offset)
goto out;
if (!(offset & ~PAGE_MASK))
ret = do_mmap_pgoff(file, addr, len, prot, flag, offset >> PAGE_SHIFT);
out:
return ret;
}

extern int do_munmap(struct mm_struct *, unsigned long, size_t);

struct address_space {
struct inode *host; /* 拥有此 address_space 的inode对象 */
struct radix_tree_root page_tree; /* 包含全部页面的 radix 树 */
spinlock_t tree_lock; /* 保护 radix 树的自旋锁 */
unsigned int i_mmap_writable;/* VM_SHARED 计数 */
struct prio_tree_root i_mmap; /* 私有映射链表的树 */
struct list_head i_mmap_nonlinear;/* VM_NONLINEAR 链表 */
spinlock_t i_mmap_lock; /* 保护 i_map 的自旋锁 */
unsigned int truncate_count; /* 截断计数 */
unsigned long nrpages; /* 总页数 */
pgoff_t writeback_index;/* 回写的起始偏移 */
const struct address_space_operations *a_ops; /* address_space 的操作表 */
unsigned long flags; /* gfp_mask 掩码与错误标识 */
struct backing_dev_info *backing_dev_info; /* 预读信息 */
spinlock_t private_lock; /* 私有 address_space 自旋锁 */
struct list_head private_list; /* 私有 address_space 链表 */
struct address_space *assoc_mapping; /* 缓冲 */
struct mutex unmap_mutex; /* 保护未映射页的 mutux 锁 */
} __attribute__((aligned(sizeof(long)))); 

/* 源码参照 lib/radix-tree.c */
struct radix_tree_node {
unsigned int height; /* radix树的高度 */
unsigned int count; /* 当前节点的子节点数目 */
struct rcu_head rcu_head; /* RCU 回调函数链表 */
void *slots[RADIX_TREE_MAP_SIZE]; /* 节点中的slot数组 */
unsigned long tags[RADIX_TREE_MAX_TAGS][RADIX_TREE_TAG_LONGS]; /* slot标签 */
};

主要内容：

• 设备类型
• 内核模块
• 内核对象
• sysfs
• 总结

1. 设备类型

linux中主要由3种类型的设备，分别是：

除了以上3种典型的设备之外，其实Linux中还有一些其他的设备类型，其中见的较多的应该算是"伪设备"。

所谓"伪设备"，其实就是一些虚拟的设备，仅提供访问内核功能而已，没有物理设备与之关联。

典型的"伪设备"就是 /dev/random(内核随机数发生器)， /dev/null(空设备)， /dev/zero(零设备)， /dev/full(满设备)

2. 内核模块

Linux内核是模块化组成的，内核中的模块可以按需加载，从而保证内核启动时不用加载所有的模块，即减少了内核的大小，也提高了效率。

通过编写内核模块来给内核增加功能或者接口是个很好的方式（既不用重新编译内核，也方便调试和删除）。

2.1 内核模块示例

内核模块可以带参数也可以不带参数，不带参数的内核模块比较简单。

我之前的几篇随笔中用于测试的例子都是用不带参数的内核模块来实验的。

2.1.1. 无参数的内核模块

。。。。。。

2.1.2. 带参数的内核模块

构造带参数的内核模块其实也不难，内核中已经提供了简单的框架来给我们声明参数。

1. module_param(name, type, perm) : 定义一个模块参数

+ 参数 name :: 既是用户可见的参数名，也是模块中存放模块参数的变量名

+ 参数 type :: 参数的类型(byte, short, int, uint, long, ulong, charp, bool...) byte型存放在char变量中，bool型存放在int变量中

+ 参数 perm :: 指定模块在 sysfs 文件系统中对应的文件权限(关于 sysfs 的内容后面介绍)

2. module_param_named(name, variable, type, perm) : 定义一个模块参数，并且参数对内对外的名称不一样

+ 参数 name :: 用户可见的参数名

+ 参数 variable :: 模块中存放模块参数的变量名

+ 参数 type和perm :: 同 module_param 中的 type 和 perm

3. module_param_string(name, string, len, perm) : 拷贝字符串到指定的字符数组

+ 参数 name :: 用户可见的参数名

+ 参数 string :: 模块中存放模块参数的变量名

+ 参数 len :: string 参数的缓冲区长度

+ 参数 perm :: 同 module_param 中的 perm

4. module_param_array(name, type, nump, perm) : 定义数组类型的模块参数

+ 参数 name :: 同 module_param 中的 name

+ 参数 type :: 同 module_param 中的 type

+ 参数 nump :: 整型指针，存放数组的长度

+ 参数 perm :: 同 module_param 中的 perm

5. module_param_array_named(name, array, type, nump, perm) : 定义数组类型的模块参数,并且数组参数对内对外的名称不一样

+ 参数 name :: 数组参数对外的名称

+ 参数 array :: 数组参数对内的名称

+ 参数 type，nump，perm :: 同 module_param_array 中的 type，nump，perm

6. 参数描述宏

可以通过 MODULE_PARM_DESC() 来给内核模块的参数添加一些描述信息。

这些描述信息在编译完内核模块后，可以通过 modinfo  命令查看。

7. 带参数的内核模块的示例

示例代码：test_paramed_km.c

定义了3个内核模块参数，分别是 int型，char*型，数组型的。

上面的示例对应的 Makefile 如下：

内核模块运行方法：(我的运行环境是 ubuntu  x86_64)

2.2 内核模块的位置

2.2.1.  内核代码外

上面的例子，以及之前博客中内核模块的例子都是把模块代码放在内核之外来运行的。

2.2.2. 内核代码中

内核模块的代码也可以直接放到内核代码树中。

如果你开发了一种驱动，并且希望被加入到内核中，那么，可以在编写驱动的时候就将完成此驱动功能的内核模块加到内核代码树中 driver 的相应位置。

将内核模块加入内核代码树中之后，不需要另外写 Makefile，修改内核代码树中的已有的 Makefile 就行。

比如，写了一个某种字符设备相关的驱动，可以把它加到内核代码的 /drivers/char 下，同时修改 /drivers/char下的Makefie，仿照里面已有的内容，增加新驱动的编译相关内容即可。

之后，在编译内核的时候会将新的驱动以内核模块的方式编译出来。

2.3 内核模块相关操作

2.3.1. 模块安装

2.3.2. 模块依赖性

linux中自动生产模块依赖性的命令：

2.3.3. 模块的载入

内核模块实验时已经用过：

2.3.4. 模块的卸载

内核模块实验时已经用过：

2.3.5. 模块导出符号表

内核模块被载入后，就动态的加载到内核中，为了能让其他内核模块使用其功能，需要将其中函数导出。

内核模块中导出函数的方法：

内核模块导出符号表 示例：

+ 首先编写一个导出函数的模块 module_A: test_module_A.c

test_module_A.c 的 Makefile

+ 再编写一个内核模块 module_B，使用 module_A 导出的函数 : test_module_B.c

test_module_B.c 的 Makefile

+ 测试方法

1. 将 test_export_A.c 和对应的 Makefile 拷贝到 module_A 文件夹中

2. 将 test_export_B.c 和对应的 Makefile 拷贝到 module_B 文件夹中

3. 编译 module_A 中的 test_export_A.c

4. 将编译 module_A 后生成的 Module.symvers 拷贝到 module_B 文件夹中

5. 编译 module_B 中的 test_export_B.c

6. 先安装 模块A，再安装模块B

7. dmesg 查看log

8. 用 rmmod 卸载模块B 和 模块A (注意卸载顺序，先卸载B再卸载A)

注：
1. 必须把编译模块A后生成的 Module.symvers 拷贝到module_B 中再编译模块B，否在模块B找不到模块A导出的函数

2. 先安装模块A，再安装模块B。

3. 先卸载模块B，再卸载模块A。

4. 安装卸载如果不按照上面的顺序，会有错误提示，大家可以试试看。

5. 我实验的系统是 ubuntu x86_64

3. 内核对象

2.6内核中增加了一个引人注目的新特性--统一设备模型(device model)。

统一设备模型的最初动机是为了实现智能的电源管理，linux 内核为了实现智能电源管理，需要建立表示系统中所有设备拓扑关系的树结构，这样在关闭电源时，可以从树的节点开始关闭。

实现了统一设备模型之后，还给内核带来了如下的好处:

1. 代码重复最小化（统一处理的东西多了）

2. 可以列举系统中所有设备，观察它们的状态，并查看它们连接的总线

3. 可以将系统中的全部设备以树的形式完整，有效的展示出来--包括所有总线和内部连接

4. 可以将设备和其对应的驱动联系起来，反之亦然

5. 可以将设备按照类型加以归类，无需理解物理设备的拓扑结构

6. 可以沿设备树的叶子向其根的反向依次遍历，以保证能以正确的顺序关闭设备电源

3.1 kobject 简介

统一设备模型的核心部分就是 kobject，通过下面对kobject结构体的介绍，可以大致了解它是如何使得各个物理设备能够以树结构的形式组织起来的。

3.1.1. kobject

kobject的定义在 <linux/kobject.h> 中

kobject 本身不代表什么实际的内容，一般都是嵌在其他数据结构中来发挥作用。（感觉有点像内核数据结构链表的节点）

比如 <linux/cdev.h> 中的 struct cdev （表示字符设备的struct）

cdev中嵌入了kobject之后，就可以通过 cdev->kboj.parent 建立cdev之间的层次关系，通过 cdev->kobj.entry 获取关联的所有cdev设备等。

总之，嵌入了kobject之后，cdev设备之间就有了树结构关系，cdev设备和其他设备之间也有可层次关系。

3.1.2. ktype

ktype是为了描述一族的kobject所具有的普遍属性，也就是将这一族的kobject的属性统一定义一下，避免每个kobject分别定义。

（感觉有点像面向对象语言中的抽象类或者接口）

ktype的定义很简单，参见<linux/kobject.h>

3.1.3. kset

kset是kobject对象的集合体，可以所有相关的kobject置于一个kset之中，比如所有“块设备”可以放在一个表示块设备的kset中。

kset的定义也不复杂，参见 <linux/kobject.h>

3.1.4. kobject，ktype和kset之间的关系

这3个概念中，kobject是最基本的。kset和ktype是为了将kobject进行分类，以便将共通的处理集中处理，从而减少代码量，也增加维护性。

这里kset和ktype都是为了将kobject进行分类，为什么会有2中分类呢？

从整个内核的代码来看，其实kset的数量是多于ktype的数量的，同一种ktype的kobject可以位于不同的kset中。

做个不是很恰当的比喻，如果把kobject比作一个人的话，kset相当于一个一个国家，ktype则相当于人种(比如黄种人，白种人等等)。

人种的类型只有少数几个，但是国家确有很多，人种的目的是描述一群人的共通属性，而国家的目地则是为了管理一群人。

同样，ktype侧重于描述，kset侧重于管理。

3.1.5. kref

kref记录kobject被引用的次数，当引用计数降到0的时候，则执行release函数释放相关资源。

kref的定义参见：<linux/kref.h>

上面这些函数的具体实现可以参考内核代码  lib/kref.c

3.2 kobject 操作

kobject的相关都在 <linux/kobject.h> 中定义了，主要由以下一些：

上面这些函数的具体实现可以参考内核代码  lib/kobject.c

4. sysfs

sysfs是一个处于内存中的虚拟文件系统，它提供了kobject对象层次结构的视图。

可以用下面这个命令来查看 /sys 的结构

4.1 sysfs中的kobject

既然sysfs是kobject的视图，那么内核中肯定提供了在sysfs中操作kobject的API。

kobject结构体中与sysfs关联的字段就是 「struct sysfs_dirent    *sd; 」这是一个目录项结构，它表示kobject在sysfs中的位置。

4.1.1. sysfs中添加和删除kobject非常简单，就是上面介绍的 kobject操作中提到的

添加了kobject之后，只会增加文件夹，不会增加文件。

因为kobject在sysfs中就是映射成一个文件夹。

添加删除kobject的示例代码如下：

对应的Makefile

测试方法：(我使用的测试系统是：Centos6.5 x86)

4.1.2. sysfs中添加文件

kobject是映射成sysfs中的目录，那sysfs中的文件是什么呢？

其实sysfs中的文件就是kobject的属性，属性的来源有2个：

+ 默认属性 :: kobject所关联的ktype中的 default_attrs 字段

默认属性 default_attrs 的类型是结构体 struct attribute， 定义在 <linux/sysfs.h>

ktype中的 default_attrs 字段(即默认属性)描述了sysfs中的文件，还有一个字段 sysfs_ops 则描述了如何使用默认属性。

struct sysfs_ops 的定义也在 <linux/sysfs.h>

show 方法在读取sysfs中文件时调用，它会拷贝attr提供的属性到buffer指定的缓冲区

store  方法在写sysfs中文件时调用，它会从buffer中读取size字节的数据到attr提供的属性中

增加默认属性的示例代码

对应的Makefile如下：

测试方法：(我使用的测试系统是：ubuntu x86)

注：参考博客 Linux设备模型 (2)

+ 新属性 :: kobject 自己定义的属性

一般来说，使用默认属性就足够了。因为具有共同ktype的kobject在本质上区别都不大，比如都是块设备的kobject，

它们使用默认的属性集合不但可以让事情简单，有助于代码合并，还可以使类似的对象在sysfs中的外观一致。

在一些特殊的情况下，kobject可能会需要自己特有的属性。内核也充分考虑到了这些情况，提供了创建或者删除新属性的方法。

在sysfs中文件的操作方法参见： fs/sysfs/file.c

除了可以在sysfs中增加/删除的文件，还可以在sysfs中增加或者删除一个符号链接。

具体实现参见：fs/sysfs/symlink.c

增加新的属性的示例代码 (这里只演示了增加文件的方法，增加符号链接的方法与之类似)

对应的Makefile如下：

测试方法：(我使用的测试系统是：ubuntu x86)

根据测试代码，增加/删除新属性是根据默认属性 c_attr 的值来决定的。

c_attr 设置为0 时，删除新属性 new_attr

c_attr 设置为1 时，新增新属性 new_attr

4.1.3. sysfs相关约定

为了保持sysfs的干净和直观，在内核开发中涉及到sysfs相关内容时，需要注意以下几点：

+ sysfs属性保证每个文件只导出一个值，该值为文本形式并且可以映射为简单的C类型

+ sysfs中要以一个清晰的层次组织数据

+ sysfs提供内核到用户空间的服务

4.2 基于sysfs的内核事件

内核事件层也是利用kobject和sysfs来实现的，用户空间通过监控sysfs中kobject的属性的变化来异步的捕获内核中kobject发出的信号。

用户空间可以通过一种netlink的机制来获取内核事件。

内核空间向用户空间发送信号使用 kobject_uevent() 函数，具体参见： <linux/kobject.h>

下面用个小例子演示一些内核事件的实现原理：

4.2.1. 内核模块安装或者删除时，会发送 KOBJ_ADD 或者 KOBJ_REMOVE 的消息

内核模块的代码就用上面最简单的那个例子 test_kobject.c 的代码即可

4.2.2. 用户态程序: 通过 netlink机制来接收 kobject 的事件通知

注：代码是拷贝的 《Linux设备节点创建》内核kobject上报uevent过滤规则 中的用户态程序部分

4.2.3. 测试方法：(我使用的测试系统是：ubuntu x86)

5. 总结

kobject加sysfs给内核带来的好处不是三言两语能够说得清楚的，上面的例子也只是通过简单的使用来直观的感受一下kobject，例子本身没有什么实际意义。

最后一个例子中使用了 netlink机制，我在之前的项目中使用过netlink来监控系统进程的I/O信息，对netlink有一些初步的了解。

但是例子中只是用来获取一下 kobject的事件而已，这里主要为了说明kobject，netlink的相关内容以后有机会再补充。

printk(KERN_WARNING "This is a warning!\n");
printk(KERN_DEBUG "This is a debug notice!\n");

if (bad_thing)
BUG();
// 或者
BUG_ON(bad_thing);

if (terrible_thing)
panic("terrible thing is %ld\n", terrible_thing);

if (!debug_check) {
printk(KERN_DEBUG "provide some information...\n");
dump_statck();
}

if (current->uid != 7777) {
/* 原先的代码 */
} else {
/* 新的特性 */
}

static unsigned long prev_jiffy = jiffies; /* 频率限制 */if (time_after(jiffies, prev_jiffy + 2*HZ)) { /* 输出间隔至少 2HZ */
prev_jiffy = jiffies;
printk(KERN_ERR "错误信息....\n");
}

static unsigned long limit = 0;if (limit < 5) { /* 输出5次错误信息后就不再输出 */
limit++;
printk(KERN_ERR "错误信息....\n");
}

git bisect start # 开始二分搜索
git bisect bad <bad_revision> # 指定一个bug出现的内核版本号
git bisect good <good_revision> # 指定一个没有bug的内核版本号, 此时git会检测2个版本直接的隐患# 根据结果再次设置 bad 和 good 的版本号, 缩小Git检索范围, 直至找到可疑之处为止.

typedef __kernel_pid_t pid_t; /* include/linux/types.h */typedef int __kernel_pid_t; /* arch/asm/include/asm/posix_types.h */

typedef signed char s8;
typedef unsigned char u8;typedef signed short s16;
typedef unsigned short u16;typedef signed int s32;
typedef unsigned int u32;typedef signed long s64;
typedef unsigned long u64;

typedef __signed__ char __s8;
typedef unsigned char __u8;typedef __signed__ short __s16;
typedef unsigned short __u16;typedef __signed__ int __s32;
typedef unsigned int __u32;typedef __signed__ long __s64;
typedef unsigned long __u64;

/*
* 某些体系结构中, char类型默认是带符号的, 那么下面 i 的值就为 -1
* 某些体系结构中, char类型默认是不带符号的, 那么下面 i 的值就为 255, 与预期可能有差别!!!
*/
char i = -1;

signed char i = -1; /* 明确 signed, i 的值在哪种体系结构中都是 -1 */
unsigned char i = 255; /* 明确 unsigned, i 的值在哪种体系结构中都是 255 */

/*
* 下面的代码将一个变量从 char 类型转换为 unsigned long 类型,
* char 类型只占 1个字节, 它的地址不一定能被4整除, 转换为 4个字节或者8个字节的 usigned long之后,
* 导致 unsigned long 出现数据不对齐的现象.
*/
char wolf[] = "Like a wolf";
char *p = &wolf[1];
unsigned long p1 = *(unsigned long*) p;

/******************************************************************************
* @file : struct_align.c
* @author : wuzhihang
* @date : 2019-09-27
*
* @brief :
* history : init
******************************************************************************/#include <stdio.h>struct animal_struct
{
char dog; /* 1个字节 */
unsigned long cat; /* 8个字节 */
unsigned short pig; /* 2个字节 */
char fox; /* 1个字节 */
};int main(int argc, char *argv[])
{
/* 在我的64bit 系统中是按8位对齐, 下面的代码输出 24 */
printf ("sizeof(animal_struct)=%d\n", sizeof(struct animal_struct));
return 0;
}

gcc -o test struct_align.c
./test # 输出24

struct animal_struct
{
char dog; /* 1个字节 */
/* 此处填充了7个字节 */
unsigned long cat; /* 8个字节 */
unsigned short pig; /* 2个字节 */
char fox; /* 1个字节 */
/* 此处填充了5个字节 */
};

struct animal_struct
{
unsigned long cat; /* 8个字节 */
unsigned short pig; /* 2个字节 */
char dog; /* 1个字节 */
char fox; /* 1个字节 */
};

struct animal_struct
{
unsigned long cat; /* 8个字节 */
unsigned short pig; /* 2个字节 */
char dog; /* 1个字节 */
char fox; /* 1个字节 */
/* 此处填充了4个字节 */
};

#include <stdio.h>struct animal_struct
{
unsigned long cat; /* 8个字节 */
unsigned short pig; /* 2个字节 */
char dog; /* 1个字节 */
char fox; /* 1个字节 */
};int main(int argc, char *argv[])
{
/* 在我的64bit 系统中是按8位对齐, 下面的代码输出 16 */
printf ("sizeof(animal_struct)=%d\n", sizeof(struct animal_struct));
return 0;
}

gcc -o test struct_align.c
./test # 输出16

00000001 00000002 00000003 00000004

00000001 00000002 00000003 00000004

00000004 00000003 00000002 00000001

int x = 1; /* 二进制 00000000 00000000 00000000 00000001 *//*
* 内存地址方向: 高位 <--------------------> 低位
* little-endian 表示: 00000000 00000000 00000000 00000001
* big-endian 表示: 00000001 00000000 00000000 00000000
*/
if (*(char *) &x == 1) /* 这句话把int型转为char型, 相当于只取了int型的最低8bit */
/* little-endian */
else
/* big-endian */

# 生成patch
diff -urN linux-old/ linux-new/ > my-patch # 比对整个内核代码文件夹
OR
diff -u linux-old/some/file linux-new/some/file > my-patch # 比对某个文件# 应用patch, 应用了patch之后, linux-old 和 linux-new 中的代码就一样了
cd linux-old
patch -p1 < ../my-patch # 这个命令是进入linux内核代码根目录内执行的# PS. 还有个很有用的工具 diffstat
diffstat -p1 my-patch # 列出补丁所引起的变更的统计(加入或移去的代码行)

# 提交修改的或新增的代码
git commit -a # 提交所有修改的代码
OR
git commit linux-src/some/file.c # 提交某个修改的代码
OR
git add linux-src/some/new-file.c # 把新增的文件加入版本库
git commit -a # 提交新增的文件# 生成patch
git format-patch -N # N 是正整数, 这条命令生成最后N次提交产生的补丁
OR
git format-patch -1 # 最后1次提交产生的补丁# 应用patch: 和第一种方法一样