内核编程笔记

一，并发控制,concurrency
 同时操作相同的资源(hardware,memory,data)会引起并发.SMP,process preempt,interrupt,Tasklet,bottom half都会引起concurrnecy.
在临界区(critical section)下解决竞争条件(race condition)的用互斥方法,包括:
forbid interrupt,amotic operation,spin lock,semaphore

中断屏蔽:
 可以避免中断和内核抢占进程资源(linux task schdule depend on interrupt),但不能SMP的并发,也不能常时间forbid(影响异步IO和进程调度).
 local_irq_disable()
 ...
 critical section
 ...
 local_irq_enable()
 local_irq_save()     //关中断并保存屏蔽字
 lcoal_irq_restore()
 local_bh_disable()
 local_bh_enable()
原子操作:
 void atomic_set( atomic_t *v, int i )
 atomic_t v = ATOMIC_INIT( 0 )
 atomic_read( atomic_t *v )
 void atomic_add( int i, atomic_t *v )
 void atomic_sub( int i, atomic *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_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 )

 void set_bit( nr, void *addr )   //nr,addr的第nr位
 void clear_bit( nr, void *addr )
 void change_bit( nr, void *addr )
 int 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 )
自旋锁:spin lock
 原子操作test-and-set某个内存变量,并忙等待(就是原地打转),所以不能等待大的critical section,
 另外要防止递归,copy_from_user,kmalloc等block引起的死锁.
 spinlock_t lock;
 spin_lock_init( &lock );
 spin_lock( &lock );
 spin_trylock( &lock );
 尽管自旋锁不受SMP和进程调度影响,但会受irq和bh影响,联合使用.
 spin_lock_irq(); spin_unlock_irq(); spin_lock_irqsave(); spin_unlock_irqrestore();
 spin_lock_bh(); spin_unlock_bh();
读写自旋锁:rwlock
 读锁和写锁分开.
 rwlock_t my_rwlock = RW_LOCK_UNLOCKED;
 rwlock_init( &my_rwlock );
 read_lock( &lock );
 ...
 read_unlock( &lock );
 write_lock_irqsave( &lock, flags );
 ...
 write_unlock_irqrestore( &lock, flags );
顺序锁:seqlock
 写锁互斥,读锁可重复,当读时执行了写操作,重新读取.
 void write_seqlock( seqlock_t *sl );
 int write_tryseqlock( seqlock_t *sl );
 void write_sequnlock( seqlock_t *sl );
 unsigned read_seqbegin( const seqlock_t *sl );
 int read_seqretry( const seqlock_t *sl, unsigned iv );
 do{
  seqnum = read_seqbegin_irqsave( &seqlock_a, flags );
  ...
 }while( read_seqretry_irqrestore( &seqlock_a, seqnum, flags) );
RCU:read-copy update机制
 在2.5.43引入,读不再受限制,写时先备份副本,修改副本,在所有对共享数据的操作完成时,用回调机制改变指针指到副本.
 rcu_read_lock()   相当于preempt_disable()
 rcu_read_unlock()   相当于preempt_enable()
 rcu_read_lock_bh()  相当于local_bh_disable()
 rcu_read_unlock_bh()  相当于local_bh_enable()
 synchronize_rcu();  rcu写单元调用,Block直到读完成.
 synchronzie_kernel();  用来等待所有cpu处于可抢占状态.synchronize_sched()
 void fastcall call_rcu( struct rcu_head *head, void (*func)( struct rcu_head *rcu ) );  挂接回调函数,注册到rcu_data
 void fastcall call_rcu_bh( struct rcu_head *head, void (*func)( struct rcu_head *rcu ) ); 挂接回调函数,注册到rcu_bh_data

 static inline void list_add_rcu( struct list_head *new, struct list_head *head );  rcu保护的链表操作
 static inline void list_add_tail_rcu( struct list_head *new, struct list_head *head );
 static inline void list_del_rcu( struct list_head *entry );
 static inline void list_replace_rcu( struct list_head *old, struct list_head *new );
 list_for_each_rcu( pos, head );          宏,链表操作
 list_for_each_safe_rcu( pos, n, head );
 list_for_each_entry_rcu( pos, head, member );
 static inline void list_del_rcu( struct hlist_node *n );
 
 static inline void hlist_add_head_rcu( struct hlist_node *n, struct hlist_head *h );  哈希链表
 hlist_for_each_rcu( pos, head );
 hlist_for_each_entry_rcu( tpos, pos, head, member );
信号量:semaphore用于同步
 只有获的信号量的进程才能执行临界区代码,当获取不到信号量时,进程进入睡眠.
 struct semaphore sem;
 void sema_init( struct semaphore *sem, int val );
 void init_MUTEX( struct seamphore *sem );  DECLARE_MUTEX( name );  //宏
 void init_MUTEX_LOCKED( struct semaphore *sem );   DECLARE_MUTEX_LOCKED( name );
 void down( struct semaphore *sem );   会睡眠,不能在中断上下文使用.
 int down_interruptible( struct semaphore *sem ); 睡眠可被signal打断.
 int down_trylock( struct semaphore *sem );  试锁定.
 void up( struct semaphore *sem );
 //
 DECLARE_MUTEX( mutex_sem );
 down( &mount_sem );
 ...
 critical section
 ...
 up( &mount_sem );
读写信号量:
 rw_semaphore rw_sem;
 init_rwsem( &rw_sem );
 down_read( &rw_sem );
 ...
 up_read( &rw_sem );
 down_write( &rw_sem );
 ...
 up_write( &rw_sem );
完成量:linux还提供一种比信号量更好的机制completion,用于同步
 struct completion my_completion;
 init_completion( &my_completion );    DECLARE_COMPLETION( my_completion );
 void wait_for_completion( struct completion *c );
 void complete( struct competion *c );   唤醒wait_for_completion等待
 void complete_all( struct completion *c );
互斥体:linux内核中还存在mutex
 struct mutex my_mutex;
 mutex_init( &my_mutex );
 mutex_lock( &my_mutex );
 ...
 mutex_unlock( &my_mutex );
自旋锁和信号量的使用:
 信号量和互斥体属于不同层次的互斥,前者的实现依赖于后者,为保证信号量操作的原子性,SMP中要用自旋锁互斥.
 1,临界区小时用自旋锁.2,信号量可以阻塞.3,中断中只能用自旋锁.

二，阻塞和轮询
等待队列
 当不能获得资源时,进程可以选择阻塞或非阻塞方式,linux驱动程序中,应用等待队列(wait queue)来唤醒阻塞的进程.
 wait_queue_head_t my_queue;       定义等待队列列头
 init_waitqueue_head( &my_queue ) DECLARE_WAIT_QUEUE_HEAD( name )初始化等待队列列头
 DECLARE_WAITQUEUE( name, tsk )       定义等待队列
 void fastcall add_wait_queue( wait_queue_head_t *q, wait_queue_t *wait ) 添加等待队列
 void fastcall remove_wait_queue( wait_queue_head_t *q, wait_queue_t *wait )删除等待队列
 wait_event( queue, condition )       等待事件
 wait_event_interruptible( queue, condition )
 wait_event_timeout( queue, condition, timeout )
 wait_event_interruptible_timeout( queue, condition, timeout )
 void wake_up( wait_queue_head_t, *queue )     唤醒队列
 void wake_up_interruptible( wait_queue_head_t *queue )

 sleep_on( wait_queue_head_t *q )       在等待队列上睡眠
 interruptible_sleep_on( wait_queue_head_t *q )
等待队列实例:
 struct globalfifo_dev
 {
  ...
  wait_queue_head_t r_wait;
  wait_queue_head_t w_wait;
 }
 int globalfifo_init( void )
 {
  ...
  init_waitqueue_head( &globalfifo_devp->r_wait );
  init_waitqueue_head( &globalfifo_devp->w_wait );
 }
 static ssize_t globalfifo_read( struct file *filp, char __user *buf, size_t count, ioff_t *ppos )
 {
  DECLARE_WAITQUEU( wait, current );
  add_wait_queue( &dev->r_wait, &wait );
  在成功读出后唤醒写队列.
  wake_up_interruptible( &dev->w_wait );
   out2:remove_wait_queue( &dev->wait, &wait );
 }
 static ssize_t globalfifo_write( struct file *filp, const char __user *buf, size_t count, loff_t *ppos )
 {
  DECLARE_WAITQUEUE( wait, currnt );
  add_wait_queue( &dev->w_wait, &wait );
  如果写满dev->current_len==GLOBALFIFO_SIZE
  __set_current_state( TASK_INTERRUPTIBLE );
  schedule();
  if ( signal_pending( current ) )
  {
   ret = -ERESTARTSYS;
   goto out2;
  }
  不满则写
  wake_up_interruptible( &dev->r_wait );
 }
轮询操作:非阻塞方式I/O,poll操作本身不被阻塞,但会引起文件描述集中的至少一个文件的可访问和超时.
 在用户态,使用BSD UNIT select.
 int select( int numfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout );
 在内核,使用System V poll.
 unsigned int (*poll)( struct file *filp, struct poll_table *wait );
 void poll_wait( struct file *filp, wait_queue_heat_t *queue, poll_table *wait ); 注册poll_table到等待队列
模板:
 static unsigned int xxx_poll( struct file *filp, poll_table *wait )
 {
  unsigned int mask = 0;
  struct xxx_dev *dev = filp -> private_data; 获得设备结构体指针
  ...
  poll_wait( filp, &dev->r_wait, wait );  加读等待队列头
  poll_wait( filp, &dev->w_wait, wait );  加写等待队列头
  
  if( ... )
  {
   mask |= POLLOUT | POLLWRNORM;  标示数据可获得
  }
  ...
  return mask;
 }

三，异步通知和异步I/O
 异步通知是设备驱动程序模拟一个中断通知应用程序,进行读写.属于异步通知的概念.
 阻塞IO,非阻塞IO和异步通知本身不存在优劣,应该根据不同的场景来选择.
SIGNAL:
 64种,32个已定义,32个自定义.
 除了SIGSTOP和SIGKILL外,进程可以忽略或捕获其它的全部信号.捕获的意思是当信号到达进程时有相应的代码处理它.如果进程忽略这个信号,
 内核将采用默认行为处理.
用户程序处理SIGNAL:
 void ( *signal( int signum, void (*handle)(int)) )( int );
 int sigaction( int signum, const struct sigaction *act, struct sigaction *oldact );
实例:
 main()
 {
  int oflags;
  signal( SIGIO, input_handler );   连接本进程的SIGIO到input_handler.
  fcntl( STDIN_FILENO, F_SETOWN, getpid() ); 通过F_SETOWN命令连接STDIN_FILENO设备文件到本进程.
  oflags = fcntl( STDIN_FILENO, F_GETFL );  
  fcntl( STDIN_FILENO, F_SETFL, oflags|FASYNC); 设置设备文件支持FASYNC

  while(1);
 } 
内核和驱动发送SIGNAL:
 要使驱动程序支持异步通知机制
 1,支持F_SETOWN命令,内核完成filp->f_owner.对应与用户fcntl( fd, F_SETOWN, getpid() ).
 2,支持F_SETFL命令,每当FASYNC标志改变时,驱动中的fasync()将执行.因次驱动要有fasync()函数.对应于fcntl(fd,F_GETFL).
 3,当资源可用时,要有kill_fasync()函数发出signal.对应于signal().
 设备驱动中异步通知编程,主要用到一个数据结构和两个函数.
 struct fasync_struct
 int fasync_helper( int fd, struct file *filp, int mode, struct fasync_struct **fa );
 viod kill_fasync( struct fasync_struct **fa, int sig, int band );
模板:
1,将fasync_struct结构体指针放入设备结构体中
 struct xxx_dev
 {
  struct cdev cdev;
  ...
  struct fasync_struct *async_queue;   异步结构体
 }
2,支持fasync操作
 static int xxx_fasync( int fd, struct file *filp, int mode )
 {
  struct xxx_dev *dev = filp->private_data;
  return fasync_helper( fd, filp, mode, &dev->async_queue );
 }
3,写时发送SIGNAL
 static ssize_t xxx_write( struct file *filp, const char __user *buf, size_t count, loff_t *f_pos )
 {
  struct xxx_dev *dev = filp -> private_data;
  ...
  if ( dev -> async_queue )
   kill_fasync( &dev->async_queue, SIGIO, POLL_IN );
  ...
 }
4,在文件关闭时,将文件从异步通知列表删除
 static int xxx_release( struct inode *inode, struct file *filp )
 {
  struct xxx_dev *dev = filp->private_data;
  xxx_fasync( -1, filp, 0);    将文件从异步通知列表中删除.
  ...
  return 0;
 }

POSIX异步IO,AIO
 在2.6中引进内核,2.4中也有补丁.它不同于同步IO的阻塞等待,而是同时发起多个IO,每个IO有唯一的上下文.aiocb(AIO Control Block),
 它包括buffer,当IO完成时,它用来标识完成的IO操作.
 AIO和SELECT相似,Select对通知事件阻塞,AIO对IO调用阻塞.
AIO的API:被GNU C lib包含,符合POSIX.1b的要求.
 int aio_read( struct aiocb *aiocbp )  对一个文件描述符(文件,socket,pipe..)进行异步读操作
 int aio_write( struct aiocb *aiocbp )
 int aio_error( struct aiocb *aiocbp )  EINPROGRESS,ECANCELLED,-1
 ssize_t aio_return( struct aiocb *aiocbp ) 异步操作不能直接得到返回值,要等到aio_error!=EINPROGRESS.再用aio_return返回值.
 int aio_suspend( const struct aiocb *const cblist[], int n, const struct timespec *timeout );
        阻塞进程,直到异步IO完成返回结果,此时会产生一个信号,或发生其他超时操作.
 int aio_cancel( int fd, struct aiocb *aiocbp );ret:AIO_CANCELLED,AIO_NOTCANCELED,AIO_ALLDONE,然后可以用aio_error来验证.
  struct aiocb *cblist[MAX_LIST];
  bzero( (char*)cblist, sizeof(cblist) );
  cblist[0] = &my_aiocb;
  ret = aio_read( &my_aiocb );
  ret = aio_suspend( cblist, MAX_LIST, NULL );
  ret = aio_error( &my_aiocb );
 int lio_listio( int mode, struct aiocb *list[], int nent, struct sigevent *sig ); 在一个上下文中启动大量异步IO操作.
  struct aiocb aiocb1, aiocb2;
  struct aiocb *list[MAX_LIST];
  ...初始化第一个aiocb
  aiocb1.aio_fildes = fd;
  aiocb1.aio_buf = malloc( BUFSIZE+1 );
  aiocb1.aio_nbytes = BUFSIZE;
  aiocb1.aio_offset = next_offset;
  aiocb1.aio_lio_opcode = LIO_READ;
  ...初试化多个aiocb
  bzero( (char*)list, sizeof(list) );
  list[0] = &aiocb1;
  list[1] = &aiocb2;
  ...
  ret = lio_listio( LIO_WAIT, list, MAX_LIST, NULL );  
使用signal作为通知来返回AIO结果:
  void setup_io(...) 设置异步IO请求
  {
   int fd;
   struct sigaction sig_act;
   struct aiocb my_aiocb;
   ...
   设置信号处理函数
   sigemptyset( &sig_act.sa_mask );
   sig_act.sa_flags = SA_SIGINFO;
   sig_act.sa_sigaction = aio_completion_handle;
   设置AIO请求
   bzero( (char*)&my_aiocb, sizeof( struct aiocb ) );
   my_aiocb.aio_fildes = fd;
   my_aiocb.aio_buf = malloc( BUF_SIZE + 1 );
   my_aiocb.nbytes = BUF_SIZE;
   my_aiocb.aio_offset = next_offset;
   连接AIO请求和信号处理函数
   my_aiocb.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
   my_aiocb.aio_sigevent.sigev_signo = SIGIO;
   my_aiocb.aio_sigevent.sigev_value.sival_ptr = &my_aiocb;
   将信号与信号处理函数绑定
   ret = sigaction( SIGIO, &sig_act, NULL);
   ...
   ret = aio_read( &my_aiocb);      开始异步读
  }

  信号处理函数
  void aio_completion_handler( int signo, siginfo_t *info, void *context )
  {
   struct aiocb *req;
   if ( info->si_signo == SIGIO )
   {
    req = (struct aiocb*)info->si_value.sival_ptr;  获得aiocb
    if ( aio_error(req) == 0 )
    {
     ret = aio_return( req );
    }
   }
   return;
  }

使用回调函数(Callback)作为通知来返回AIO结果:
 /proc/sys/fs/aio-nr 文件,系统范围异步IO请求的数目
 /proc/sys/fs/aio-max-nr 文件,允许并发请求的最大数目 
  void setup_io(...) 设置异步IO请求
  {
   int fd;
   struct aiocb my_aiocb;
   ...
   设置AIO请求
   连接AIO请求和线程回调函数
   my_aiocb.aio_sigevent.sigev_notify = SIGEV_THREAD;
   my_aiocb.aio_sigevent.notify_function = aio_completion_handler;
   my_aiocb.aio_sigevent.notify_attributes = NULL;
   my_aiocb.aio_sigevent.sigev_value.sival_ptr = &my_aiocb;
   ...
   ret = aio_read( &my_aiocb);      开始异步读
  }

AIO与设备驱动:
 aiocb结构体中,ki_filp是file的指针.is_sync_kiocb()可以判断是否同步IO请求.
 块设备和网络设备驱动本身就是异步的,AIO用在字符型设备驱动中,用于改善异步IO的性能.例如磁带机.
 在file_operations中,用到3个AIO函数.
 ssize_t (*aio_read)(struct kiocb *iocb, char *buffer, szie_t count, loff_t offset);
 ssize_t (*aio_write)(struct kiocb *iocb, const char *buffer, size_t count, loff_t offset);
 int (*aio_fsync)(struct kiocb *iocb, int datasync);

 异步读
 static ssize_t xxx_aio_read( struct kiocb *iocb, char *buf, size_t count, loff_t pos )
 {
  return xxx_defer_op( 0, iocb, buf, count, pos );
 }
 异步写
 static ssize_t xxx_aio_write( struct kiocb *iocb, const char *buf, size_t count, loff_t pos )
 {
  return xxx_defer_op( 1, iocb, (char*)buf, count, pos );
 }
 初始化异步IO
 static int xxx_defer_op( int write, struct kiocb *iocb, char *buf, size_t count, loff_t pos )
 {
  struct async_work *async_wk;
  int_result;
  if ( write )
   result = xxx_write( iocb-> ki_filp, buf, count, &pos );
  else
   result = xxx_read( iocb->ki_filp, buf, count, &pos );
  if ( is_sync_kiocb(iocb) )
   return result;
  否则是异步IO:
  async_wk = kmalloc( sizeof(*async_wk), GFP_KERNEL );  async_work(异步工作)结构体将操作延后执行
  if (async_wk == NULL)
   return result;
  调度延迟的工作
  async_wk->iocb = iocb;
  async_wk->result = result;
  INIT_WORK( &async_wk->work, xxx_do_deferred_op, async_wk );
  schedule_delayed_work( &async_wk->work, HZ/100 );  调度async_work执行
  return - EIOCBQUEUED;
 }

 static void xxx_do_deferred_op( void *p )
 {
  struct async_work *async_wk = (struct async_work*)p;
  aio_complete( async_wk->iocb, async_wk->result, 0 );  通知内核驱动程序完成了操作
  kfree( async_wk );
 }

 struct async_work
 {
  struct kiocb *iocb;   
  int result;    执行结果
  struct work_struct work;  工作结构体
 }

四，中断和时钟
中断编程:
 内部中断,外部终端;可屏蔽中断,不屏蔽中断;向量中断,非向量中断(软件根据寄存器分地址).linux将中断分成顶半部,底半部.
 顶半部主要读取寄存器中的中断状态并清除中断标志.再登记中断(将底半部处理程序挂到该设备的底半部执行队列.)
 Vxworks中提供中断上下文和进程上下文相结合的机制.通过netJobAdd()将网络包的接收和上传交给tnetask任务去执行.
 /proc/interrupts 文件中有中断状态的描述.
 int request_irq( unsigned int irq,        硬件中断号
      void (*handler)(int irq, void *dev_id, struct pt_reqs *regs), 中断处理函数
      unsigned long irqflags,       中断处理的属性,SA_INTERRUPT,SA_SHIRQ
      const char *devname,
      void *dev_id );
 void free_irq( unsigned int irq, void *dev_id );
 void enable_irq( int irq );
 void disable_irq_nosync( int irq );       立即返回
 void disable_irq( int irq );        等当前中断处理完后返回
 void local_irq_save( unsigned long flags );      屏蔽本CPU的中断并保存进flags
 void local_irq_restore( unsigned long flags );
 void local_irq_disable( void );
 void local_irq_enable( void );
底半部机制:
 1,tasklet模板:
 DECLARE_TASKLET( xxx_tasklet, xxx_do_tasklet, 0 ); 
 xxx_do_tasklet( unsigned long )
 {...}
 irqreturn_t xxx_interrupt( int irq, void *dev_id, struct pt_reqs *reqs )
 {
  ...
  tasklet_schedule( &xxx_tasklet );
  ...
 }
 int __init xxx_init( void )
 {
  ...
  result = request_irq( xxx_irq, xxx_interrupt, SA_INTERRUPT, "xxx", NULL );
  ...
 }
 void __exit xxx_exit( void )
 {
  ...
  free_irq( xxx_irq, xxx_interrupt );
  ...
 }
 2,工作队列模板:
 struct work_struct xxx_wq;
 void xxx_do_work( insigned long )
 {...}
 irqreturn_t xxx_interrupt( int irq, void *dev_id, struct pt_regs *regs )
 {
  ...
  schedule_work( &xxx_wq );
  ...
 }
 int xxx_int( void )
 {
  ...
  result = request_irq( xxx_irq, xxx_interrupt, SA_INTERRUPT, "xxx", NULL );
  ...
  INIT_WORK( &xxx_wq, (void)(*)(void *)xxx_do_work, NULL );
  ...
 }
 void xxx_exit( void )
 {
  ...
  free( xxx_irq, xxx_interrupt );
  ...
 }
 3,软中断底半部
 硬中断是外部设备对CPU的中断;
 软中断是硬中断处理程序对内核的中断;
 信号是内核对某个进程的中断;
 tasklet基于软中断实现;
 softirq结构体包括软中断处理函数及其参数.
 open_sofirq注册软中断对应的处理函数,raise_softirq触发一个软中断.
共享中断
 linux2.6支持共享中断,单跟硬件中断线上支持多个设备.
 irqreturn_t xxx_interrupt( int irq, void *dev_id, struct pt_regs *regs )
 {
  ...
  int status = read_int_status();
  if ( !is_myint(dev_id_status) )    所有共享的中断处理程序都会执行,要迅速判断执行
  {
   return IRQ_NONE;
  }
  ...
  return IRQ_HANDLED;
 } 
 init  xxx_init( void )
 {
  ...
  result = request_irq( sh_irq, xxx_interrupt, SA_SHIRQ, "xxx", xxx_dev ); 所有中断都要设为SA_SHIRQ,传入xxx_dev.
  ...
 }
内核定时器使用
 1,timer_list 结构
  struct timer_list{
   struct list_head entry;   定时器列表
   unsigned long expires;   定时器到期时间jiffies
   void (*function)(unsigned long);  定时器处理函数
   unsigned long data;    定时器处理函数参数
   struct timer_base_s *base;
  };
 struct timer_list my_list;
 2,void init_timer( struct timer_list *timer );
   TIMER_INITIALIZER( _function, _expires, _data );
   DEFINE_TIMER( _name, _function, _expires, _data );
   static inline void setup_timer( struct timer_list *timer, void(*function)(unsigned long), unsigned long data );
 3,void add_timer( struct timer_list *timer );  注册内核定时器
 4,int del_timer( struct timer_list *timer );
 5,int mod_timer( struct timer_list *timer, unsigned long expires );
模板:
 struct xxx_dev{
  struct cdev cdev;
  ...
  timer_list xxx_timer;     在设备结构体中添加定时器
 }
 xxx_fcntl(...)
 {
  struct xxx_dev *dev = filp->private_data;
  ...
  init_timer( &dev->xxx_timer );
  dev->xxx_timer.function = &xxx_do_timer;
  dev->xxx_timer.data = (unsigned long)dev;
  dev->xxx_timer.expires = jiffies + delay;   初始化定时器结构体
  ...
  add_timer( &dev->xxx_timer );
  ...
 }
 xxx_func2(...)
 {
  ...
  del_timer( &dev->xxx_timer);
  ...
 }
 static void xxx_do_timer( unsigned long arg )
 {
  struct xxx_device *dev = (struct xxx_device *)(arg); 
  ...
  dev->xxx_timer.expire = jiffies + delay;   重设时间
  add_timer( &dev->xxx_timer );    再次注册
  ...
 }
内核延时
 短延时
 void ndelay( unsigned long nsecs );    CPU等待
 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 second );
 长延时
 unsigned long delay = jiffies + 100;    jiffies+2*HZ
 while ( time_before( jiffies, delay ) );   time_after(a,b),用来比较时间
 睡着延时
 void msleep( unsigned int msecs )
 {
  unsigned long timeout = msecs_to_jiffies( msecs ) + 1;
  while( timeout )
   timeout = schedule_timeout_uninterruptible( timeout ); 调度到睡眠状态
 }
 unsigned long msleep_interruptible( unsigned int msecs )
 {
  unsigned long timeout = msecs_to_jiffies(msecs) + 1;
  while ( timeout && !signal_pending(current) )
   timeout = schedule_timeout_interruptible( timeout );
  return jiffies_to_msecs( timeout );
 }
 或将当前进程添加到等待队列:
 sleep_on_timeout( wait_queue_head_t *q, unsigned long timeout );
 interruptible_sleep_on_timeout( wait_queue_head_t *q, unsigned long timeout );

五，内存管理和I/O
硬件基础
 内存空间和I/O空间
 X86中有I/O空间,ARM，MIPS上没有,只有内存空间,I/O空间可选.  IN 累加器,{端口号|DX}; OUT {端口号|DX},累加器
 typedef void (*lpunction)();
 lpFunction lpReset = (lpFunction)0xF000FFF0;
 lpReset();   相当于软启动
 MMU
 内存管理单元,用来实现虚拟和物理地址间的转换,内存访问权限保护,Cache缓存控制.它包括：
 TLB:Translation Lookaside Buffer,其中C位用于控制对应地址高速缓存,B位写缓存,访问权限和域位控制读写允许,不允许则发送一个存储器异常信号.
 TTW:Translation Table walk，如TLB中没有找到虚拟地址入口,则通过TTW遍历获取 地址转换信息和权限,放入到TLB中的空位或替换一个入口.
     当访问权限允许时,对物理地址的访问发生在Cache或内存.
 ARM7TDMI中的S3C4B0X,Dragonball,ColdFire,Hitachi H8/300不带MMU,使用uclinux.
 S3C2410,2440带MMU.vivi中会建立一个一级页表.
 void mem_map_init(void)
 {
    #ifdef CONFIG_S3C2410_ANND_BOOT
  mem_map_nand_boot();  最终会调用mem_mapping_linear,建立一级页表.
    #else
  mem_map_nor();
    #endif
  cache_clean_invalidate(); 清空cache,使cache无效
  tlb_invalidate();  使快表tlb无效
 }
 static inline void mem_mapping_linear(void)
 {
  unsigned long pageoffset, sectionNumber;
  putstr( "MMU table base address = 0x%", (unsigned long)mmu_tlb_base );
  //使用ARM920T内存映射的Section模式,分成4096*1MB,mmu_table转换表大小16KB.
  //内存映射模式包括:fault(无映射),Coarse Page(粗页表),Section(段),Fine Page(细页表).
  for( sectionNumber = 0; sectionNumber < 4096; sectionNumber++ )
  {
   pageoffset = ( sectionNumber << 20 );
   *( mmu_table_base + ( pageoffset>>20 ) ) = pageoffset | MMU_SECDESC;
  }
  //使SDRAM区域可缓存,0x30000000-0x33ffffff. DRAM_BASE = 0x30000000, DRAM_SIZE=64M.
  for ( pageoffset = DRAM_BASE; pageoffset < (DRAM_BASE+DRAM_SIZE); pageoffset += SZ_1M )
  {
   *(mmu_table_base + ( pageoffset >> 20 )) = pageoffset | MMU_SECDESC | MMU_CACHEABLE;
  }
 }

linux内存管理
 用户空间0到3GB 0xC0000000,内核空间3GB到4GB.都有相应的页表.内核1GB空间分为
 3G 物理内存映射区; MAX 896MB
  隔离带;
  虚拟内存分配区; VMALLOC_START~VMALLOC_END,vmalloc()
  隔离带;
  高端页面映射区; PKMAP_BASE
  专用页面映射区; FIXADDR_START~FIXADDR_TOP
 4G 保留区;
 对大于4GB的物理内存,使用CPU的扩展分页(PAE)模式,64位页目录项.这需要CPU支持(Intel pentium Pro).
用户空间申请和释放内存
 char *p = malloc(...);
 free( p );
内核空间申请和释放内存
 void *kmalloc( size_t size, int flags );会阻塞,所以不能用于 中断上下文,自旋锁,中断处理函数,tasklet和内核定时器.这些用GFP_ATOMIC
     GFP_KERNEL: 在内核空间的进程中申请内存.底层依靠__get_free_pages()实现.
     GFP_USER: 为用户空间页分配内存.
     GFP_HIGHUSER: 为用户空间页分配内存,但是从高端内存分配.
     GFP_NOIO: 不允许任何I/O初始化.
     GFP_NOFS: 不允许任何文件系统调用.
     __GFP_DMA: 要求分配在能够DMA的内存区.
     __GFP_HIGHMEM:分配的内存可以位于高端内存.
     __GFP_COLD: 请求一个较长时间不访问的页.
     __GFP_NOWARN: 当一个分配无法满足时,阻止内核发出警告.
     __GFP_HIGH: 高优先级请求,要求分配保留页.
     __GFP_REPEAT: 分配失败则重复尝试.
     __GFP_NOFAIL: 标示只能成功.
     __GFP_NORETRY:申请不到,则立即放弃.

 __get_free_pages( unsigned int flags, unsigned int order ); order为0到11,1页到2048页.2的oreder次方.
 __get_free_page( int unsigned flag );
 get_zeroed_page( unsigned int flags );
 struct page *alloc_pages( int gfp_mask, unsigned long order ); 返回 分配的页描述符而非首地址.
 void free_page( unsigned long addr );
 void free_pages( unsigned long addr, insigned long order );
 
 void *vmalloc( unsigned long size );     会新建页表,开销大.用于软件中较大的顺序缓冲区.小的页分配用kmalloc.
 void vfree( void *addr );       内部调用kmalloc,GFP_KERNEL. 例如create_module()会用到.
 
    slab机制操作内存:
 struct kmem_cache *kmem_cache_create( const char *name, size_t size,
      size_t align, unsigned long flags,
      void (*ctor)(void*, struct kmem_cache *, unsigned long),
      void (*dtor)(void*, struct kmem_cache *, unsigned long) );
  创建一个slab缓存,可以驻留任意数目大小一样的后备缓存.size是分配的数据结构的大小,flags是如何分配的位掩码.
  SLAB_NO_REAP  :内存紧缺也不自动收缩这块缓存.
  SLAB_HWCACHE_ALIGN :数据对象对齐到一个缓存行.
  SLAB_CACHE_DMA :数据对象在DMA内存区分配.
 void *kmem_cache_alloc( struct kmem_cache *cachep, gfp_t flags );  
       在kmem_cache_create()创建的slab后备缓冲中分配一块并返回首地址指针.
 void kmem_cache_free( struct kmem_cache *cachep, gfp_t flags );
 int kmem_cache_destory( struct kmem_cache *cachep );
  static lmem_cache_t *xxx_cachep;
  xxx_cahep = kmem_cache_create( "xxx", sizeof(struct xxx), 0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
  struct xxx *ctx;
  ctx = kmem_cache_alloc( xxx_cachep, GTP_KERNEL );
  ...
  kmem_cache_free( xxx_cachep, ctx );
  kmem_cache_destory( xxx_cachep );
    内存池机制操作内存:
 创建内存池;
 mempool_t *mempool_create( int min_nr,    需要预分配对象的数目.
     mempool_alloc_t *alloc_fn,   指向内存池机制提供的标准对象的分配函数指针.
     mempool_alloc_t *free_fn,  指向内存池机制提供的标准对象的回收函数指针.
     void *pool_data    分配和回收函数用到的指针.
         );
  alloc_fn的原型是: typedef void *(mempool_alloc_t)( int gfp_mask, void *pool_data );
  free_fn的原型是: typedef void (mempool_alloc_t)( void *element, void *pool_data );
 void *mempool_alloc( mempool_t *pool, int gfp_mask ); 分配对象
 void mempool_free( void *element, mempool_t *pool );  回收对象
 void mempool_destory( mempool_t *pool );   回收内存池
虚拟地址与物理地址的转换
 #define __pa(x) ( (unsigned long)(x) - PAGE_OFFSET )  
 extern inline unsigned long virt_to_phys( volatile void *address )
 {
  return __pa( address );
 }
 #define __va(x) ( (void *)(unsigned long)(x) + PAGE_OFFSET )  PAGE_OFFSET=3GB
 extern inline void *phys_to_virt( unsigned long address )
 {
  return __va( address );
 }
 上述方法只适用与常规内存,高端内存的虚拟地址和物理地址不适用这样简单的换算关系.
 
设备I/O端口和I/O内存的访问
 设备通常有一组寄存器,包括设备读,写和状态.既控制寄存器,数据寄存器和状态寄存器.
 当这些寄存器位于I/O空间,就叫IO端口.当这些寄存器位于内存空间,就叫IO内存.