लिनक्स डिवाइस ड्राइवर बफरिंग रणनीति

Question

मान लें कि मेरे पास एक बाहरी डिवाइस है जो लगातार मेरे ड्राइवर में डेटा को एक छोटे बफर में दबा रहा है। मैं एक प्रतीक्षा कतार का उपयोग कर रहा हूं जहां एक इंटरप्ट हैंडलर एक प्रतीक्षा उपयोगकर्ता प्रक्रिया (एलडीडी (तीसरा संस्करण) के समान - एक हैंडलर लागू करना)।

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 कॉलबैक से पढ़ लेंगे।

वास्तव में एक अनुभवहीन है और वास्तव में वास्तव में अक्षम कार्यान्वयन (untested) हो सकता है:

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; 
} 

तुम भी डीएमए या mmap या दोनों का उपयोग करने के लिए और अधिक कुशल कुछ पाने के लिए कर सकते हैं।