内核编程头文件整理

 <linux/types.h>//typedef 了 很多常用的数据类型。

dev_t   等类型

MAJOR(dev_t dev); 
MINOR(dev_t dev);

相反, 如果你有主次编号, 需要将其转换为一个 dev_t, 使用:

MKDEV(int major, int minor);

<linux/fs.h>中

int register_chrdev_region(dev_t first, unsigned int count, char *name);
int alloc_chrdev_region(dev_t *dev, unsigned int firstminor, unsigned int count, char *name);
void unregister_chrdev_region(dev_t first, unsigned int count); 
file_operation 结构
struct file 结构
struct inode 结构
<linux/module.h> 
THIS_MODULE
<linux/cdev.h>

    
    
     
     struct cdev *cdev_alloc(void); 
    
    
    
    

    
    
     
     void cdev_init(struct cdev *dev, struct file_operations *fops); 
    
    
    
    

    
    
     
     int cdev_add(struct cdev *dev, dev_t num, unsigned int count); 
    
    
    
    

    
    
     
     void cdev_del(struct cdev *dev); 
    
    
    
    
     
     #include <linux/kernel.h> 
    
    
    
    
     
     container_of(pointer, type, field); 
    
    
    
    
     
     #include <asm/uaccess.h>
    
    
    
    
     
     unsigned long copy_from_user (void *to, const void *from, unsigned long count); 
    
    
    
    
     
     int put_user(datum,ptr); 
    
    
    
    

    
    
     
     int get_user(local,ptr); 
    
    
    
    

    
    
     
     int __put_user(datum,ptr); 
    
    
    
    

    
    
     
     int __get_user(local,ptr);
    
    
   
   

   
   
    
    int printk(const char * fmt, ...); 

   
   

内核代码的 printf 类似物.

unsigned long copy_to_user (void *to, const void *from, unsigned long count); 
 

   
   
    
    #include <linux/init.h> 
   
   
   
   

   
   
    
    module_init(init_function); 
   
   
   
   

   
   
    
    module_exit(cleanup_function); 
   
   
   
   
    
             __init 
   
   
   
   

   
   
    
    __initdata 
   
   
   
   

   
   
    
    __exit 
   
   
   
   

   
   
    
    __exitdata 
   
   
   
   

   
   
    
    module_param(variable, type, perm); 
   
   
   
   


    
    
宏定义, 创建模块参数, 可以被用户在模块加载时调整( 或者在启动时间, 对于内嵌代码). 

   
   
   
   


    
    
类型可以是 bool, charp, int, invbool, short, ushort, uint, ulong, 或者 intarray.

   
   
   
   
    
    #include <linux/module.h> 
   
   
   
   


    
    
必需的头文件. 它必须在一个模块源码中包含.

   
   
   
   
    
    #include <linux/version.h> 
   
   
   
   


    
    
头文件, 包含在建立的内核版本信息.

   
   
   
   
    
    MODULE_AUTHOR(author); 
   
   
   
   

   
   
    
    MODULE_DESCRIPTION(description); 
   
   
   
   

   
   
    
    MODULE_VERSION(version_string); 
   
   
   
   

   
   
    
    MODULE_DEVICE_TABLE(table_info); 
   
   
   
   

   
   
    
    MODULE_ALIAS(alternate_name); 
   
   
   
   
   
   


   
   
   
   
    
    #include <asm/semaphore.h> 
    
    信号量相关
   
   
   
   


    
    
定义旗标和其上操作的包含文件.

   
   
   
   


    
    
struct semaphore sem;

   
   
   
   
    
    DECLARE_MUTEX(name); 
   
   
   
   

   
   
    
    DECLARE_MUTEX_LOCKED(name); 
   
   
   
   


    
    
2 个宏定义, 用来声明和初始化一个在互斥模式下使用的旗标.

   
   
   
   
    
    void init_MUTEX(struct semaphore *sem); 
   
   
   
   

   
   
    
    void init_MUTEX_LOCKED(struct semaphore *sem); 
   
   
   
   


    
    
这 2 函数用来在运行时初始化一个旗标.

   
   
   
   
    
    void down(struct semaphore *sem); 
   
   
   
   

   
   
    
    int down_interruptible(struct semaphore *sem); 
   
   
   
   

   
   
    
    int down_trylock(struct semaphore *sem); 
   
   
   
   

   
   
    
    void up(struct semaphore *sem); 
   
   
   
   
    
    #include <linux/completion.h> 
   
   
   
   
    
    	struct completion xxx;
   
   
   
   

   
   
    
    DECLARE_COMPLETION(name); 
   
   
   
   

   
   
    
    init_completion(struct completion *c); 
   
   
   
   

   
   
    
    INIT_COMPLETION(struct completion c); 
   
   
   
   
    
    void wait_for_completion(struct completion *c); 
   
   
   
   


    
    
等待一个 completion 事件发出.

   
   
   
   
    
    void complete(struct completion *c); 
   
   
   
   

   
   
    
    void complete_all(struct completion *c); 
   
   
   
   
    
    #include <linux/spinlock.h> 
   
   
   
   
    
    	struct spinlock_t lock;定义名为lock的自旋锁
   
   
   
   

   
   
    
    spinlock_t lock = SPIN_LOCK_UNLOCKED; 
   
   
   
   

   
   
    
    spin_lock_init(spinlock_t *lock); 
   
   
   
   


    
    
定义自旋锁接口的包含文件, 以及初始化锁的 2 个方法.

   
   
   
   
    
    void spin_lock(spinlock_t *lock); 
   
   
   
   

   
   
    
    void spin_lock_irqsave(spinlock_t *lock, unsigned long flags); 
   
   
   
   

   
   
    
    void spin_lock_irq(spinlock_t *lock); 
   
   
   
   

   
   
    
    void spin_lock_bh(spinlock_t *lock); 
   
   
   
   
    
    void spin_unlock(spinlock_t *lock); 
   
   
   
   

   
   
    
    void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags); 
   
   
   
   

   
   
    
    void spin_unlock_irq(spinlock_t *lock); 
   
   
   
   

   
   
    
    void spin_unlock_bh(spinlock_t *lock); 
   
   
   
   
    
    #include <asm/atomic.h> 
   
   
   
   

   
   
    
    atomic_t v = ATOMIC_INIT(value); 
   
   
   
   

   
   
    
    void atomic_set(atomic_t *v, int i); 
   
   
   
   

   
   
    
    int atomic_read(atomic_t *v); 
   
   
   
   

   
   
    
    void atomic_add(int i, atomic_t *v); 
   
   
   
   

   
   
    
    void atomic_sub(int i, atomic_t *v); 
   
   
   
   

   
   
    
    void atomic_inc(atomic_t *v); 
   
   
   
   

   
   
    
    void atomic_dec(atomic_t *v); 
   
   
   
   

   
   
    
    int atomic_inc_and_test(atomic_t *v); 
   
   
   
   

   
   
    
    int atomic_dec_and_test(atomic_t *v); 
   
   
   
   

   
   
    
    int atomic_sub_and_test(int i, atomic_t *v); 
   
   
   
   

   
   
    
    int atomic_add_negative(int i, atomic_t *v); 
   
   
   
   

   
   
    
    int atomic_add_return(int i, atomic_t *v); 
   
   
   
   

   
   
    
    int atomic_sub_return(int i, atomic_t *v); 
   
   
   
   

   
   
    
    int atomic_inc_return(atomic_t *v); 
   
   
   
   

   
   
    
    int atomic_dec_return(atomic_t *v); 
   
   
   
   


    
    
原子地存取整数变量. atomic_t 变量必须只通过这些函数存取.

   
   
   
   
    
    #include <asm/bitops.h> 
   
   
   
   

   
   
    
    void set_bit(nr, void *addr); 
   
   
   
   

   
   
    
    void clear_bit(nr, void *addr); 
   
   
   
   

   
   
    
    void change_bit(nr, void *addr); 
   
   
   
   

   
   
    
    test_bit(nr, void *addr); 
   
   
   
   

   
   
    
    int test_and_set_bit(nr, void *addr); 
   
   
   
   

   
   
    
    int test_and_clear_bit(nr, void *addr); 
   
   
   
   

   
   
    
    int test_and_change_bit(nr, void *addr); 
   
   
   
   
    
    #include <linux/wait.h> 
   
   
   
   

   
   
    
    typedef struct { /* ... */ } wait_queue_head_t; 
   
   
   
   

   
   
    
    void init_waitqueue_head(wait_queue_head_t *queue); 
   
   
   
   

   
   
    
    DECLARE_WAIT_QUEUE_HEAD(queue); 
   
   
   
   


    
    
Linux 等待队列的定义类型. 一个 wait_queue_head_t 必须被明确在运行时使用

   
   
   
   


    
    
 init_waitqueue_head 或者编译时使用 DEVLARE_WAIT_QUEUE_HEAD 进行初始化.

   
   
   
   
    
    void wait_event(wait_queue_head_t q, int condition); 
   
   
   
   

   
   
    
    int wait_event_interruptible(wait_queue_head_t q, int condition); 
   
   
   
   

   
   
    
    int wait_event_timeout(wait_queue_head_t q, int condition, int time); 
   
   
   
   

   
   
    
    int wait_event_interruptible_timeout(wait_queue_head_t q, int condition,int time); 
   
   
   
   


    
    
使进程在给定队列上睡眠, 直到给定条件值为真值.

   
   
   
   
    
    void wake_up(struct wait_queue **q); 
   
   
   
   

   
   
    
    void wake_up_interruptible(struct wait_queue **q); 
   
   
   
   

   
   
    
    void wake_up_nr(struct wait_queue **q, int nr); 
   
   
   
   

   
   
    
    void wake_up_interruptible_nr(struct wait_queue **q, int nr); 
   
   
   
   

   
   
    
    void wake_up_all(struct wait_queue **q); 
   
   
   
   

   
   
    
    void wake_up_interruptible_all(struct wait_queue **q); 
   
   
   
   

   
   
    
    void wake_up_interruptible_sync(struct wait_queue **q); 
   
   
   
   
    
    long wait_event_interruptible_timeout(wait_queue_head_t *q, condition, signed long timeout); 
   
   
   
   
    
    #include <linux/poll.h> 
   
   
   
   

   
   
    
    void poll_wait(struct file *filp, wait_queue_head_t *q, poll_table *p); 
   
   
   
   


    
    
将当前进程放入一个等待队列, 不立刻调度. 它被设计来被设备驱动的 poll 方法使用.

   
   
   
   
    
    int fasync_helper(struct inode *inode, struct file *filp, int mode, struct fasync_struct **fa); 
   
   
   
   


    
    
一个"帮忙者", 来实现 fasync 设备方法. mode 参数是传递给方法的相同的值,

   
   
   
   


    
    
 而 fa 指针指向一个设备特定的 fasync_struct *.

   
   
   
   
    
    void kill_fasync(struct fasync_struct *fa, int sig, int band); 
   
   
   
   


    
    
如果这个驱动支持异步通知, 这个函数可用来发送一个信号到登记在 fa 中的进程.

   
   
   
   
    
    int nonseekable_open(struct inode *inode, struct file *filp); 
   
   
   
   

   
   
    
    loff_t no_llseek(struct file *file, loff_t offset, int whence); 
   
   
   
   


    
    
nonseekable_open 应当在任何不支持移位的设备的 open 方法中被调用. 

   
   
   
   


    
    
这样的设备应当使用 no_llseek 作为它们的 llseek 方法.

   
   
   
   
    
    #include <linux/ioctl.h> 
   
   
   
   


    
    
声明用来定义 ioctl 命令的宏定义. 当前被 <linux/fs.h> 包含.

   
   
   
   
    
    _IOC_NRBITS 
   
   
   
   

   
   
    
    _IOC_TYPEBITS 
   
   
   
   

   
   
    
    _IOC_SIZEBITS 
   
   
   
   

   
   
    
    _IOC_DIRBITS 
   
   
   
   


    
    
ioctl 命令的不同位段所使用的位数. 还有 4 个宏来指定 MASK 和 4 个指定 SHIFT, 

   
   
   
   


    
    
但是它们主要是给内部使用. _IOC_SIZEBIT 是一个要检查的重要的值, 因为它跨体系改变.

   
   
   
   
    
    _IOC_NONE 
   
   
   
   

   
   
    
    _IOC_READ 
   
   
   
   

   
   
    
    _IOC_WRITE 
   
   
   
   


    
    
"方向"位段可能的值. "read" 和 "write" 是不同的位并且可相或来指定 read/write. 这些值是基于 0 的.

   
   
   
   
    
    _IOC(dir,type,nr,size) 
   
   
   
   

   
   
    
    _IO(type,nr) 
   
   
   
   

   
   
    
    _IOR(type,nr,size) 
   
   
   
   

   
   
    
    _IOW(type,nr,size) 
   
   
   
   

   
   
    
    _IOWR(type,nr,size) 
   
   
   
   


    
    
用来创建 ioclt 命令的宏定义.

   
   
   
   
    
    _IOC_DIR(nr) 
   
   
   
   

   
   
    
    _IOC_TYPE(nr) 
   
   
   
   

   
   
    
    _IOC_NR(nr) 
   
   
   
   

   
   
    
    _IOC_SIZE(nr) 
   
   
   
   


    
    
用来解码一个命令的宏定义. 特别地, _IOC_TYPE(nr) 是 _IOC_READ 和 _IOC_WRITE 的 OR 结合

   
   
   
   
    
    #include <linux/param.h> 
   
   
   
   

   
   
    
    HZ 
   
   
   
   
    
    #include <linux/delay.h> 
   
   
   
   

   
   
    
    void ndelay(unsigned long nsecs); 
   
   
   
   

   
   
    
    void udelay(unsigned long usecs); 
   
   
   
   

   
   
    
    void mdelay(unsigned long msecs); 
   
   
   
   


    
    
引入一个整数纳秒, 微秒和毫秒的延迟. 获得的延迟至少是请求的值, 但是可能更多. 

   
   
   
   


    
    
每个函数的参数必须不超过一个平台特定的限制(常常是几千).

   
   
   
   
    
    void msleep(unsigned int millisecs); 
   
   
   
   

   
   
    
    unsigned long msleep_interruptible(unsigned int millisecs); 
   
   
   
   

   
   
    
    void ssleep(unsigned int seconds); 
   
   
   
   


    
    
使进程进入睡眠给定的毫秒数(或者秒, 如果使 ssleep).

   
   
   
   
    
    #include <linux/timer.h> 
   
   
   
   

   
   
    
    void init_timer(struct timer_list * timer); 
   
   
   
   

   
   
    
    struct timer_list TIMER_INITIALIZER(_function, _expires, _data); 
   
   
   
   


    
    
这个函数和静态的定时器结构的声明是初始化一个 timer_list 数据结构的 2 个方法.

   
   
   
   
    
    void add_timer(struct timer_list * timer); 
   
   
   
   


    
    
注册定时器结构来在当前 CPU 上运行.

   
   
   
   
    
    int mod_timer(struct timer_list *timer, unsigned long expires); 
   
   
   
   


    
    
改变一个已经被调度的定时器结构的超时时间. 它也能作为一个 add_timer 的替代.

   
   
   
   
    
    int timer_pending(struct timer_list * timer); 
   
   
   
   


    
    
宏定义, 返回一个布尔值说明是否这个定时器结构已经被注册运行.

   
   
   
   
    
    void del_timer(struct timer_list * timer); 
   
   
   
   

   
   
    
    void del_timer_sync(struct timer_list * timer); 
   
   
   
   


    
    
从激活的定时器链表中去除一个定时器. 后者保证这定时器当前没有在另一个 CPU 上运行.

    
    

     
     
      
      #include <linux/interrupt.h> 
     
     
     
     
     
     

     
     
      
      int request_irq(unsigned int irq, irqreturn_t (*handler)( ), unsigned long flags, const char *dev_name, void *dev_id); 
     
     
     
     

     
     
      
      void free_irq(unsigned int irq, void *dev_id); 
     
     
     
     

     
     
      
      DECLARE_TASKLET(name, func, data); 
     
     
     
     

     
     
      
      DECLARE_TASKLET_DISABLED(name, func, data); 
     
     
     
     

     
     
      
      void tasklet_init(struct tasklet_struct *t, void (*func)(unsigned long), unsigned long data); 
     
     
     
     


      
      
前 2 个宏定义声明一个 tasklet 结构, 而 tasklet_init 函数初始化一个已经通过分配或其他方式获得的 

     
     
     
     


      
      
tasklet 结构. 第 2 个 DECLARE 宏标识这个 tasklet 为禁止的.

     
     
     
     
      
      void tasklet_disable(struct tasklet_struct *t); 
     
     
     
     

     
     
      
      void tasklet_disable_nosync(struct tasklet_struct *t); 
     
     
     
     

     
     
      
      void tasklet_enable(struct tasklet_struct *t); 
     
     
     
     


      
      
禁止和使能一个 tasklet. 每个禁止必须配对一个使能( 你可以禁止这个 tasklet 即便它已经被禁止). 

     
     
     
     


      
      
函数 tasklet_disable 等待 tasklet 终止如果它在另一个 CPU 上运行. 这个非同步版本不采用这个额外的步骤.

     
     
     
     
      
      void tasklet_schedule(struct tasklet_struct *t); 
     
     
     
     

     
     
      
      void tasklet_hi_schedule(struct tasklet_struct *t); 
     
     
     
     


      
      
调度一个 tasklet 运行, 或者作为一个"正常" tasklet 或者一个高优先级的. 

     
     
     
     


      
      
当软中断被执行, 高优先级 tasklets 被首先处理, 而正常 tasklet 最后执行.

     
     
     
     
      
      void tasklet_kill(struct tasklet_struct *t); 
     
     
     
     


      
      
从激活的链表中去掉 tasklet, 如果它被调度执行. 如同 tasklet_disable, 

     
     
     
     


      
      
这个函数可能在 SMP 系统中阻塞等待 tasklet 终止, 如果它当前在另一个 CPU 上运行.

      
      

       
        
        #include <linux/workqueue.h> 
       
       
       

       
        
        struct workqueue_struct; 
       
       
       

       
        
        struct work_struct; 
       
       
       
 
        
这些结构分别表示一个工作队列和一个工作入口.
 
       
       
        
        struct workqueue_struct *create_workqueue(const char *name); 
       
       
       

       
        
        struct workqueue_struct *create_singlethread_workqueue(const char *name); 
       
       
       

       
        
        void destroy_workqueue(struct workqueue_struct *queue); 
       
       
       
 
        
创建和销毁工作队列的函数. 一个对 create_workqueue 的调用创建一个有一个
 
       
       
       
 
        
工作者线程在系统中每个处理器上的队列; 相反, create_singlethread_workqueue 创建一个有一个
 
       
       
       
 
        
单个工作者进程的工作队列.
 
       
       
        
        DECLARE_WORK(name, void (*function)(void *), void *data); 
       
       
       

       
        
        INIT_WORK(struct work_struct *work, void (*function)(void *), void *data); 
       
       
       

       
        
        PREPARE_WORK(struct work_struct *work, void (*function)(void *), void *data); 
       
       
       
 
        
声明和初始化工作队列入口的宏.
 
       
       
        
        int queue_work(struct workqueue_struct *queue, struct work_struct *work); 
       
       
       

       
        
        int queue_delayed_work(struct workqueue_struct *queue, struct work_struct *work, unsigned long delay); 
       
       
       
 
        
从一个工作队列对工作进行排队执行的函数.
 
       
       
        
        int cancel_delayed_work(struct work_struct *work); 
       
       
       

       
        
        void flush_workqueue(struct workqueue_struct *queue); 
       
       
       
 
        
使用 cancel_delayed_work 来从一个工作队列中去除入口; flush_workqueue 确保没有
 
       
       
       
 
        
工作队列入口在系统中任何地方运行.
 
       
       
        
        int schedule_work(struct work_struct *work); 
       
       
       

       
        
        int schedule_delayed_work(struct work_struct *work, unsigned long delay); 
       
       
       

       
        
        void flush_scheduled_work(void); 
       
       
       
 
        
使用共享队列的函数.
 
       
      
      
     
     
    
    

    
    
#include <linux/slab.h> 

    
    

     
     

     
     
      
      void *kmalloc(size_t size, int flags); 
     
     
     
     

     
     
      
      void kfree(void *obj); 
     
     
     
     


      
      
内存分配的最常用接口.

     
     
     
     
      
      #include <linux/mm.h> 
     
     
     
     

     
     
      
      GFP_USER 
     
     
     
     

     
     
      
      GFP_KERNEL 
     
     
     
     

     
     
      
      GFP_NOFS 
     
     
     
     

     
     
      
      GFP_NOIO 
     
     
     
     

     
     
      
      GFP_ATOMIC 
     
     
     
     


      
      
控制内存分配如何进行的标志, 从最少限制的到最多的. GFP_USER 和 GFP_KERNEL 

     
     
     
     


      
      
优先级允许当前进程被置为睡眠来满足请求. GFP_NOFS 和 GFP_NOIO 禁止文件系统操作和所有的 I/O 操作,

     
     
     
     


      
      
 分别地, 而 GFP_ATOMIC 分配根本不能睡眠.

     
     
     
     
      
      __GFP_DMA 
     
     
     
     

     
     
      
      __GFP_HIGHMEM 
     
     
     
     

     
     
      
      __GFP_COLD 
     
     
     
     

     
     
      
      __GFP_NOWARN 
     
     
     
     

     
     
      
      __GFP_HIGH 
     
     
     
     

     
     
      
      __GFP_REPEAT 
     
     
     
     

     
     
      
      __GFP_NOFAIL 
     
     
     
     

     
     
      
      __GFP_NORETRY 
     
     
     
     
      
      #include <linux/malloc.h> 
     
     
     
     

     
     
      
      kmem_cache_t *kmem_cache_create(char *name, size_t size, size_t offset, unsigned long flags, constructor(), destructor( )); 
     
     
     
     

     
     
      
      int kmem_cache_destroy(kmem_cache_t *cache); 
     
     
     
     


      
      
创建和销毁一个 slab 缓存. 这个缓存可被用来分配几个相同大小的对象.

     
     
     
     
      
      SLAB_NO_REAP 
     
     
     
     

     
     
      
      SLAB_HWCACHE_ALIGN 
     
     
     
     

     
     
      
      SLAB_CACHE_DMA 
     
     
     
     


      
      
在创建一个缓存时可指定的标志.

     
     
     
     
      
      SLAB_CTOR_ATOMIC 
     
     
     
     

     
     
      
      SLAB_CTOR_CONSTRUCTOR 
     
     
     
     


      
      
分配器可用传递给构造函数和析构函数的标志.

     
     
     
     
      
      void *kmem_cache_alloc(kmem_cache_t *cache, int flags); 
     
     
     
     

     
     
      
      void kmem_cache_free(kmem_cache_t *cache, const void *obj); 
     
     
     
     


      
      
从缓存中分配和释放一个单个对象. /proc/slabinfo 一个包含对 slab 缓存使用情况统计的虚拟文件.

     
     
     
     
      
      #include <linux/mempool.h> 
     
     
     
     

     
     
      
      mempool_t *mempool_create(int min_nr, mempool_alloc_t *alloc_fn, mempool_free_t *free_fn, void *data); 
     
     
     
     

     
     
      
      void mempool_destroy(mempool_t *pool); 
     
     
     
     


      
      
创建内存池的函数, 它试图避免内存分配设备, 通过保持一个已分配项的"紧急列表".

     
     
     
     
      
      void *mempool_alloc(mempool_t *pool, int gfp_mask); 
     
     
     
     

     
     
      
      void mempool_free(void *element, mempool_t *pool); 
     
     
     
     


      
      
从(并且返回它们给)内存池分配项的函数.

     
     
     
     
      
      unsigned long get_zeroed_page(int flags); 
     
     
     
     

     
     
      
      unsigned long __get_free_page(int flags); 
     
     
     
     

     
     
      
      unsigned long __get_free_pages(int flags, unsigned long order); 
     
     
     
     


      
      
面向页的分配函数. get_zeroed_page 返回一个单个的, 零填充的页. 这个调用的所有的其他版本不初始化返回页的内容.

     
     
     
     
      
      int get_order(unsigned long size); 
     
     
     
     


      
      
返回关联在当前平台的大小的分配级别, 根据 PAGE_SIZE. 这个参数必须是 2 的幂, 并且返回值至少是 0.

     
     
     
     
      
      void free_page(unsigned long addr); 
     
     
     
     

     
     
      
      void free_pages(unsigned long addr, unsigned long order); 
     
     
     
     


      
      
释放面向页分配的函数.

     
     
     
     
      
      struct page *alloc_pages_node(int nid, unsigned int flags, unsigned int order); 
     
     
     
     

     
     
      
      struct page *alloc_pages(unsigned int flags, unsigned int order); 
     
     
     
     

     
     
      
      struct page *alloc_page(unsigned int flags); 
     
     
     
     


      
      
Linux 内核中最底层页分配器的所有变体.

     
     
     
     
      
      void __free_page(struct page *page); 
     
     
     
     

     
     
      
      void __free_pages(struct page *page, unsigned int order); 
     
     
     
     

     
     
      
      void free_hot_page(struct page *page); 
     
     
     
     


      
      
使用一个 alloc_page 形式分配的页的各种释放方法.

     
     
     
     
      
      #include <linux/vmalloc.h> 
     
     
     
     

     
     
      
      void * vmalloc(unsigned long size); 
     
     
     
     

     
     
      
      void vfree(void * addr); 
     
     
     
     

     
     
      
      #include <asm/io.h> 
      
      ？？读io内存和寄存器分别用什函数？？？？？？？？
     
     
     
     

     
     
      
      void * ioremap(unsigned long offset, unsigned long size); 
     
     
     
     

     
     
      
      void iounmap(void *addr);
     
     
    
    

    
    
 

    
    

     
     
      
      void *ioremap(unsigned long phys_addr, unsigned long size); 
     
     
     
     

     
     
      
      void *ioremap_nocache(unsigned long phys_addr, unsigned long size); 
     
     
     
     

     
     
      
      void iounmap(void *virt_addr); 
     
     
     
     
      
      unsigned readb(address); 
     
     
     
     

     
     
      
      unsigned readw(address); 
     
     
     
     

     
     
      
      unsigned readl(address); 
     
     
     
     

     
     
      
      void writeb(unsigned value, address); 
     
     
     
     

     
     
      
      void writew(unsigned value, address); 
     
     
     
     

     
     
      
      void writel(unsigned value, address); 
     
     
     
     
      
      unsigned int ioread8(void *addr); 
     
     
     
     

     
     
      
      unsigned int ioread16(void *addr); 
     
     
     
     

     
     
      
      unsigned int ioread32(void *addr); 
     
     
     
     

     
     
      
      void iowrite8(u8 value, void *addr); 
     
     
     
     

     
     
      
      void iowrite16(u16 value, void *addr); 
     
     
     
     

     
     
      
      void iowrite32(u32 value, void *addr); //推荐用这个
     
     
     
     
      
      void *ioport_map(unsigned long port, unsigned int count); 
     
     
     
     

     
     
      
      void ioport_unmap(void *addr); 
     
     
    
    
   
   
   
   
   
   
    
    #include <asm/signal.h> 
   
   
   
   

   
   
    
    SA_INTERRUPT 
   
   
   
   

   
   
    
    SA_SHIRQ 
   
   
   
   

   
   
    
    SA_SAMPLE_RANDOM 
    
    

   
   
   
   
    
           
   
   
   
   
    
            IRQ_NONE 
   
   
   
   

   
   
    
    IRQ_HANDLED 
   
   
   
   

   
   
    
    IRQ_RETVAL(int x) 
   
   
   
   


    
    
从一个中断处理返回的可能值, 指示是否一个来自设备的真正的中断出现了.

   
   
   
   
    
    void disable_irq(int irq); 
   
   
   
   

   
   
    
    void disable_irq_nosync(int irq); 
   
   
   
   

   
   
    
    void enable_irq(int irq); 
   
   
   
   


    
    
驱动可以使能和禁止中断报告. 如果硬件试图在中断禁止时产生一个中断, 这个中断永远丢失了. 

   
   
   
   


    
    
一个使用一个共享处理者的驱动必须不使用这个函数.

   
   
   
   
    
    void local_irq_save(unsigned long flags); 
   
   
   
   

   
   
    
    void local_irq_restore(unsigned long flags); 
   
   
   
   


    
    
使用 local_irq_save 来禁止本地处理器的中断并且记住它们之前的状态. flags 可以被传递给 

   
   
   
   


    
    
local_irq_restore 来恢复之前的中断状态.

   
   
   
   
    
    void local_irq_disable(void); 
   
   
   
   

   
   
    
    void local_irq_enable(void); 
   
   
   
   


    
    
在当前处理器熵无条件禁止和使能中断的函数.

   
   
#include <linux/sched.h> 
struct task_struct *current; 
   
   
    
    set_current_state(int state); 
   
   
   
   

    
    
设置当前进程的执行状态. TASK_RUNNING 意味着它已经运行, 而睡眠状态是 TASK_INTERRUPTIBLE 和 TASK_UNINTERRUPTIBLE.
   
   
   
   
    
    void schedule(void); 
   
   
   
   
    
    signed long schedule_timeout(signed long timeout); 
   
   
   
   
    
    #include <linux/moduleparam.h>