inter

interrupt/README.md

@@ -1 +1,101 @@
-## 中断处理
+## 中断处理
+
+首先，关于中断和异常的概念，可以参考我的博客，或者等后边的同学进行补充，我们不再这里赘述。我们尽可能的讨论一些进阶的东西。
+
+
+### /proc 接口
+
+如图：我们可以在/proc/interrupts 中看到我们系统中安装的中断。
+
+![d](./image/res.png)
+
+可以看到，我的电脑是有4个CPU ，其实是双核4线程，看来内核是以执行流的来作为CPU的计数标准。
+
+第一列是IRQ中断号，最后一列是中断的名称，中间是每个CPU处理中断的计数。
+
+我们可以发现即使我的个人PC并没有运行太多的服务和程序，但是CPU0明显还是处理的中断更多，这是LINUX内核为了最大化缓存的本地性质。
+
+接着我们来看看/proc/stat 文件。
+
+这个文件中记录的是系统活动的底层统计信息，包括从系统启动到现在系统接受的中断数量。
+
+
+![ss](./image/ddd.png)
+
+可以看到这是一个使用位图的表达方式。
+
+### 中断接口
+
+请求中断线 && 中断描述符：
+
+```
+/**
+ * struct irqaction - per interrupt action descriptor
+ * @handler:	interrupt handler function
+ * @name:	name of the device
+ * @dev_id:	cookie to identify the device
+ * @percpu_dev_id:	cookie to identify the device
+ * @next:	pointer to the next irqaction for shared interrupts
+ * @irq:	interrupt number
+ * @flags:	flags (see IRQF_* above)
+ * @thread_fn:	interrupt handler function for threaded interrupts
+ * @thread:	thread pointer for threaded interrupts
+ * @secondary:	pointer to secondary irqaction (force threading)
+ * @thread_flags:	flags related to @thread
+ * @thread_mask:	bitmask for keeping track of @thread activity
+ * @dir:	pointer to the proc/irq/NN/name entry
+ */
+struct irqaction {
+	irq_handler_t		handler;
+	void			*dev_id;
+	void __percpu		*percpu_dev_id;
+	struct irqaction	*next;
+	irq_handler_t		thread_fn;
+	struct task_struct	*thread;
+	struct irqaction	*secondary;
+	unsigned int		irq;
+	unsigned int		flags;
+	unsigned long		thread_flags;
+	unsigned long		thread_mask;
+	const char		*name;
+	struct proc_dir_entry	*dir;
+} ____cacheline_internodealigned_in_smp;
+
+
+static inline int __must_check
+request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
+	    const char *name, void *dev)
+{
+	return request_threaded_irq(irq, handler, NULL, flags, name, dev);
+}
+
+@irq             要申请的中断号
+@handler_t       安装处理中断的函数指针
+@flags           中断掩码
+@name            中断拥有者
+@dev             中断信号线
+
+```
+
+#### 实现中断程序的几个简单要求
+
+1.处理例程不能向用户空间发送或者接受数据，因为它不能再进程上下文中执行，处理过程也不能休眠。
+
+2.不能调用schdule函数
+
+#### 典型应用
+
+如果中断通知进程所等待的事件已经发生，比如新数据到达，就会唤醒在该设备上休眠的进程。我们最好编写执行时间尽可能短的处理例程。
+如果需要长时间的计算任务最好的使用方法是tasklet 或者 工作队列在更加安全的时间计算。
+
+### 注册中断函数小测试
+
+我们以共享形式在27号中断线设置一个中断处理函数，27号是PCI上的一个周期中断。代码在./code  中。
+
+测试效果：
+
+![s](./image/inter.png)
+
+随着我们系统上27号中断线收到中断请求，我们注册的中断处理信息也被打印。
+
+

interrupt/code/Makefile

@@ -0,0 +1,31 @@
+
+# To build modules outside of the kernel tree, we run "make"
+# in the kernel source tree; the Makefile these then includes this
+# Makefile once again.
+# This conditional selects whether we are being included from the
+# kernel Makefile or not.
+ifeq ($(KERNELRELEASE),)
+
+    # Assume the source tree is where the running kernel was built
+    # You should set KERNELDIR in the environment if it's elsewhere
+    KERNELDIR ?= /lib/modules/$(shell uname -r)/build
+    # The current directory is passed to sub-makes as argument
+    PWD := $(shell pwd)
+
+modules:
+	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
+
+modules_install:
+	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules_install
+
+clean:
+	rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions
+
+.PHONY: modules modules_install clean
+
+else
+    # called from kernel build system: just declare what our modules are
+    obj-m := irq_qu.o
+endif
+
+

interrupt/code/irq_qu.c

@@ -0,0 +1,45 @@
+/*************************************************************************
+	> File Name: irq_qu.c
+	> Author: 
+	> Mail: 
+	> Created Time: 2017年04月25日 星期二 09时18分44秒
+ ************************************************************************/
+#include<linux/init.h>  
+#include<linux/module.h>  
+#include<linux/kernel.h>  
+#include<linux/interrupt.h>  
+   
+MODULE_LICENSE("GPL");  
+
+static int irq = 27;  
+const char *interface = "my_irq";  
+static irqreturn_t myirq_handler(int irq,void *dev);  
+   
+static int __init myirq_init(void)  {  
+ 
+        if(request_irq(irq,myirq_handler,IRQF_SHARED,interface,&irq)){  
+            printk(KERN_ERR "%s interrrupt can't register %d IRQ \n",interface,irq);  
+            return -EIO;  
+        }  
+        printk("%s request %d IRQ\n",interface,irq);  
+        return 0;  
+}  
+
+
+static irqreturn_t myirq_handler(int irq,void *dev){  
+    
+    printk("my_handle %d IRQ is working\n",irq);  
+    
+    return 0;  
+
+}  
+static void  __exit myirq_exit(void){  
+    
+    
+    free_irq(irq,&irq);  
+    printk("%s interrupt free %d IRQ\n",interface,irq);  
+   
+}
+
+module_init(myirq_init);  
+module_exit(myirq_exit);  

kernel_DS/README.md

@@ -4,6 +4,70 @@
 
 我们写了两个小的模块来测试实际数据类型和内存对齐的长度。
 
+内核基本数据类型
+
+
+
+C语言类型（int）
+
+        char、short、int、long long在不同的平台上大小不变。
+
+        long、ptr(指针)平台不同其大小不同，但二者的大小始终相同。
+
+        char的符号问题：
+
+                大多数平台上char默认是signed，但有些平台上默认是 unsigned。
+                char i = -1; 大部分平台上i是-1，有些平台上是255。
+                应该使用：signed char i = -1;   unsigned char i = 255;
+确定大小的类型（u32）
+
+        u8、u16、u32、u64、 s8、s16、s32、s64是Linux内核确定大小的类型。
+        __u8等式linux用户态确定大小的类型。（头文件linux/types.h）
+
+        uint8_t、uint32_t是新编译器支持的C99标准确定大小的类型，可以跨平台。
+特定内核对象的类型（pid_t）
+
+        进程标识符使用pid_t类型，而不使用int，屏蔽了实际的数据类型中任何可能的差异。
+        特定内核对象的类型，打印时，不太好选择printk或printf的输出格式：
+
+        1.  一些平台上排除的警告，在另一平台上可能会出现（size_t在一些平台上是unsigned long，在一些平台上是unsigned int）。
+
+        2. 将其强制转换成可能的最大类型，然后用响应的格式打印输出。
+字节序
+
+大端、小端
+
+        数值0x01020304，内存从低到高依次存储：04 03 02 01 为小端。 存储顺序反过来为大端）
+
+        数值0x00000001，内存从低到高依次存储：01 00 00 00 为小端。
+
+转换函数 
+
+        u32 __cpu_to_be32(u32);    /* 把cpu字节序转为大端字节序 */
+
+        u32 __be32_to_cpu(u32);    /* 把大端字节序转为cpu字节序 */
+        u32 __cpu_to_le32(u32);      /* 把cpu字节序转为小端字节序 */
+        u32 __le32_to_cpu(u32);      /* 把小端字节序转为cpu字节序 */
+        在头文件<linux/byteorder.h>中
+
+
+时间间隔
+
+        使用HZ代表一秒。
+
+        不能假定每秒就1000个jiffies。
+
+        与msec毫秒对应的jiffies数目总是msec*HZ/1000。
+
+页大小
+
+        页大小为PAGE_SIZE个字节，而不是4KB。
+
+        分配16KB的空间临时存储数据，如下：
+
+
+以上，只是基本数据类型中最简单的一部分，绝大多数都是细节问题，要注意。
+
 #### 基本数据类型的长度
 
 ![df](./image/ssd.png)
@@ -14,8 +78,233 @@
 ![fs](./image/dfd.png)
 
 
-####  types.h
+####  types.h 中的重要数据类型
 
+```
+typedef __u32 __kernel_dev_t;
+
+typedef __kernel_fd_set		fd_set;
+typedef __kernel_dev_t		dev_t;
+typedef __kernel_ino_t		ino_t;
+typedef __kernel_mode_t		mode_t;
+typedef unsigned short		umode_t;
+typedef __u32			nlink_t;
+typedef __kernel_off_t		off_t;
+typedef __kernel_pid_t		pid_t;
+typedef __kernel_daddr_t	daddr_t;
+typedef __kernel_key_t		key_t;
+typedef __kernel_suseconds_t	suseconds_t;
+typedef __kernel_timer_t	timer_t;
+typedef __kernel_clockid_t	clockid_t;
+typedef __kernel_mqd_t		mqd_t;
+
+typedef _Bool			bool;
+
+typedef __kernel_uid32_t	uid_t;
+typedef __kernel_gid32_t	gid_t;
+typedef __kernel_uid16_t        uid16_t;
+typedef __kernel_gid16_t        gid16_t;
+
+typedef unsigned long		uintptr_t;
+
+#ifdef CONFIG_HAVE_UID16
+/* This is defined by include/asm-{arch}/posix_types.h */
+typedef __kernel_old_uid_t	old_uid_t;
+typedef __kernel_old_gid_t	old_gid_t;
+#endif /* CONFIG_UID16 */
+
+#if defined(__GNUC__)
+typedef __kernel_loff_t		loff_t;
+#endif
+
+/*
+ * The following typedefs are also protected by individual ifdefs for
+ * historical reasons:
+ */
+#ifndef _SIZE_T
+#define _SIZE_T
+typedef __kernel_size_t		size_t;
+#endif
+
+#ifndef _SSIZE_T
+#define _SSIZE_T
+typedef __kernel_ssize_t	ssize_t;
+#endif
+
+#ifndef _PTRDIFF_T
+#define _PTRDIFF_T
+typedef __kernel_ptrdiff_t	ptrdiff_t;
+#endif
+
+#ifndef _TIME_T
+#define _TIME_T
+typedef __kernel_time_t		time_t;
+#endif
+
+#ifndef _CLOCK_T
+#define _CLOCK_T
+typedef __kernel_clock_t	clock_t;
+#endif
+
+#ifndef _CADDR_T
+#define _CADDR_T
+typedef __kernel_caddr_t	caddr_t;
+#endif
+
+/* bsd */
+typedef unsigned char		u_char;
+typedef unsigned short		u_short;
+typedef unsigned int		u_int;
+typedef unsigned long		u_long;
+
+/* sysv */
+typedef unsigned char		unchar;
+typedef unsigned short		ushort;
+typedef unsigned int		uint;
+typedef unsigned long		ulong;
+
+#ifndef __BIT_TYPES_DEFINED__
+#define __BIT_TYPES_DEFINED__
+
+typedef		__u8		u_int8_t;
+typedef		__s8		int8_t;
+typedef		__u16		u_int16_t;
+typedef		__s16		int16_t;
+typedef		__u32		u_int32_t;
+typedef		__s32		int32_t;
+
+#endif /* !(__BIT_TYPES_DEFINED__) */
+
+typedef		__u8		uint8_t;
+typedef		__u16		uint16_t;
+typedef		__u32		uint32_t;
+
+#if defined(__GNUC__)
+typedef		__u64		uint64_t;
+typedef		__u64		u_int64_t;
+typedef		__s64		int64_t;
+#endif
+
+/* this is a special 64bit data type that is 8-byte aligned */
+#define aligned_u64 __u64 __attribute__((aligned(8)))
+#define aligned_be64 __be64 __attribute__((aligned(8)))
+#define aligned_le64 __le64 __attribute__((aligned(8)))
+
+/**
+ * The type used for indexing onto a disc or disc partition.
+ *
+ * Linux always considers sectors to be 512 bytes long independently
+ * of the devices real block size.
+ *
+ * blkcnt_t is the type of the inode's block count.
+ */
+#ifdef CONFIG_LBDAF
+typedef u64 sector_t;
+typedef u64 blkcnt_t;
+#else
+typedef unsigned long sector_t;
+typedef unsigned long blkcnt_t;
+#endif
+
+/*
+ * The type of an index into the pagecache.
+ */
+#define pgoff_t unsigned long
+
+/*
+ * A dma_addr_t can hold any valid DMA address, i.e., any address returned
+ * by the DMA API.
+ *
+ * If the DMA API only uses 32-bit addresses, dma_addr_t need only be 32
+ * bits wide.  Bus addresses, e.g., PCI BARs, may be wider than 32 bits,
+ * but drivers do memory-mapped I/O to ioremapped kernel virtual addresses,
+ * so they don't care about the size of the actual bus addresses.
+ */
+#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
+typedef u64 dma_addr_t;
+#else
+typedef u32 dma_addr_t;
+#endif
+
+typedef unsigned __bitwise__ gfp_t;
+typedef unsigned __bitwise__ fmode_t;
+typedef unsigned __bitwise__ oom_flags_t;
+
+#ifdef CONFIG_PHYS_ADDR_T_64BIT
+typedef u64 phys_addr_t;
+#else
+typedef u32 phys_addr_t;
+#endif
+
+typedef phys_addr_t resource_size_t;
+
+/*
+ * This type is the placeholder for a hardware interrupt number. It has to be
+ * big enough to enclose whatever representation is used by a given platform.
+ */
+typedef unsigned long irq_hw_number_t;
+
+typedef struct {
+	int counter;
+} atomic_t;
+
+#ifdef CONFIG_64BIT
+typedef struct {
+	long counter;
+} atomic64_t;
+#endif
+
+struct list_head {
+	struct list_head *next, *prev;
+};
+
+struct hlist_head {
+	struct hlist_node *first;
+};
+
+struct hlist_node {
+	struct hlist_node *next, **pprev;
+};
+
+struct ustat {
+	__kernel_daddr_t	f_tfree;
+	__kernel_ino_t		f_tinode;
+	char			f_fname[6];
+	char			f_fpack[6];
+};
+
+/**
+ * struct callback_head - callback structure for use with RCU and task_work
+ * @next: next update requests in a list
+ * @func: actual update function to call after the grace period.
+ *
+ * The struct is aligned to size of pointer. On most architectures it happens
+ * naturally due ABI requirements, but some architectures (like CRIS) have
+ * weird ABI and we need to ask it explicitly.
+ *
+ * The alignment is required to guarantee that bits 0 and 1 of @next will be
+ * clear under normal conditions -- as long as we use call_rcu(),
+ * call_rcu_bh(), call_rcu_sched(), or call_srcu() to queue callback.
+ *
+ * This guarantee is important for few reasons:
+ *  - future call_rcu_lazy() will make use of lower bits in the pointer;
+ *  - the structure shares storage spacer in struct page with @compound_head,
+ *    which encode PageTail() in bit 0. The guarantee is needed to avoid
+ *    false-positive PageTail().
+ */
+struct callback_head {
+	struct callback_head *next;
+	void (*func)(struct callback_head *head);
+} __attribute__((aligned(sizeof(void *))));
+#define rcu_head callback_head
+
+typedef void (*rcu_callback_t)(struct rcu_head *head);
+typedef void (*call_rcu_func_t)(struct rcu_head *head, rcu_callback_t func);
+
+/* clocksource cycle base type */
+typedef u64 cycle_t;
+
+```
 
 
 ####  list.h