event.c

在LInux下定义自己的PV操作。。其中有OPEN,WRITE等操作

#include<linux/kernel.h>
#include<linux/module.h>
#include<linux/sched.h>
#include<linux/proc_fs.h>
#include<linux/slab.h>
/*#include<asm/uaccess.h>*/
#include<linux/wait.h>
#include<linux/signal.h>


typedef struct  __myevent{
    int eventNum;
    wait_queue_head_t    *p;
    struct   __myevent  *next;
}myevent_t;

               myevent_t *lpmyevent_head = NULL;
               myevent_t *lpmyevent_end = NULL;            /*global variety*/
asmlinkage int sys_eventopen(int eventNum)
{

     myevent_t *new;
     myevent_t *prev;
     if(eventNum)
          if(!scheventNum(eventNum,&prev))
               return -1;
          else 
               return eventNum;
     else{
     new=(myevent_t *)kmalloc(sizeof(myevent_t),GFP_KERNEL);
     new->p = (wait_queue_head_t *)kmalloc(sizeof(wait_queue_head_t),GFP_KERNEL);
     new->next = NULL;
     new->p->task_list.next = &new->p->task_list;
     new->p->task_list.prev = &new->p->task_list;
     if (!lpmyevent_head){
                 new->eventNum=2;
                 lpmyevent_head = lpmyevent_end = new;
                 return new -> eventNum;
      }
     else
      {
      new->eventNum = lpmyevent_end->eventNum+2;
      lpmyevent_end->next = new;
      lpmyevent_end = new;
     }
          return new->eventNum;

     }
     return 0;
}



asmlinkage int sys_eventwait(int eventNum)
{ 


       myevent_t *tmp;
       myevent_t *prev = NULL;
       wait_queue_t wait;
       unsigned long flags;
       
       if (tmp= scheventNum(eventNum,&prev)) 
       {
        wait.task=current;
        current->state = TASK_UNINTERRUPTIBLE;
        write_lock_irqsave(&tmp->p->lock,flags);
        __add_wait_queue(tmp->p,&wait);
        write_unlock(&tmp->p->lock);
        schedule();
        write_lock_irq(&tmp->p->lock);
        __remove_wait_queue(tmp->p,&wait);
        write_unlock_irqrestore(&tmp->p->lock,flags);
       }
       return 0;

}


asmlinkage int sys_eventsig(int eventNum)
{

        myevent_t *tmp = NULL;
        myevent_t *prev=NULL;
        if(!(tmp = scheventNum(eventNum,&prev)))
             return 0;
        wake_up(tmp->p);
        return 1;
}

asmlinkage int sys_eventclose(int eventNum)
{
     myevent_t *prev;
     myevent_t *releaseItem;
   
     sys_eventsig(eventNum);
     if(releaseItem=scheventNum(eventNum,&prev))
     {
       if(releaseItem==lpmyevent_end)
              lpmyevent_end = prev;
              if (releaseItem == lpmyevent_head)
              {lpmyevent_head = lpmyevent_head->next;
               goto wake;}
       prev->next = releaseItem->next;
       
     }
     wake:
         if(releaseItem)
         {kfree(releaseItem);
          return 1;}
     return 0;
}

 
myevent_t * scheventNum(int eventNum,myevent_t **prev)
{
      myevent_t *tmp = lpmyevent_head;
      *prev=NULL;
      while(tmp){
           if(tmp->eventNum == eventNum)
               return tmp;
           *prev = tmp;
           tmp = tmp->next;    
      }
      return NULL;
}