리눅스 장치 드라이버 버퍼링 전략

Question

내 드라이버의 작은 버퍼에 지속적으로 데이터를 밀어 넣는 외부 장치가 있다고 가정합니다. 인터럽트 처리기가 대기중인 사용자 프로세스를 깨우는 대기열을 사용하고 있습니다 (LDD (3rd edition)과 유사 함 - 처리기 구현).

irq_handler_t irq_handler(int irq, void *dev_id, struct pt_regs *regs) 
{ 

flag = 1; 
wake_up_interruptible(&wq); 

return IRQ_HANDLED; 
} 

ssize_t my_read(struct file *dev, char __user *buf, size_t count, loff_t *f_pos) 

{ 

     wait_event_interruptible(wq, flag != 0); 
     flag = 0; 
     copy_to_user(usr_buf, drv_buf, count); 

} 


/***********************User program***********************/ 

while(1) 
{  
    read(fid, buffer, size); 

    //do stuff with data 

} 

사용자 프로그램은 읽기를 호출하고 인터럽트가 외부 장치에서 새 데이터를 가져올 때까지 대기합니다. 외부 장치는이 코드가 실행할 수있는 것보다 더 빨리 데이터를 푸시 할 수 있으므로 사용자 프로그램이 데이터를 복사하기 전에 데이터를 덮어 쓰지 않도록 어떤 메커니즘을 사용할 수 있습니까? 구조와 같은 링 버퍼가 여기에서 작동합니까? 그것을 구현하는 방법이 명확하지 않습니다.

감사합니다.

Answer 1

예, 링 버퍼가 작동합니다.

버퍼를 인터럽트 처리기에서 채우기 만하면 my_read 콜백에서 읽을 수 있습니다.

정말 순진하고 정말 정말 비효율적 구현 (테스트되지 않은) 수 :

static irqreturn_t irq_handler(int irq, void *dev_id) 
{ 
     struct my_dev *dev = dev_id; 

     buf[buf_wr] = read_device(dev); 
     buf_wr++; 

     if (buf_wr >= BUFSIZE) 
       buf_wr = 0; 

     wake_up(&wq); 
     return IRQ_HANDLED; 
} 

static ssize_t my_read(struct file *file, char __user *ubuf, 
          size_t sz, loff_t *ppos) 
{ 
     int n, ret; 

     ret = wait_event_interruptible(wq, 
           buf_wr != buf_rd); 
     if (ret) 
       return ret; 

     n = buf_wr - buf_rd; 
     if (n < 0) 
       n += BUFSIZE; 

     n = min(count, n); 
     ret = copy_to_user(ubuf, buf, n); 
     buf_rd += n; 

     if (buf_rd >= BUFSIZE) 
       buf_rd -= BUFSIZE; 

     if (ret) 
       return ret; 

     *ppos += n; 
     return 1; 
} 

은 또한보다 효율적으로 무언가를 얻기 위해 DMA 또는 mmap에 또는 둘 모두를 사용할 수 있습니다.