विस्फोट बनाने के लिए नया लिनक्स टीसी क्यूइंग अनुशासन ... ज्ञान से बाहर चला गया

Question

मैं लिनक्स कर्नेल के लिए एक नया टीसी क्यूइंग अनुशासन लिखना चाहता हूं। लक्ष्य कतार उठाना है उदाहरण के लिए। दस पैकेट और फिर उन्हें सब बाहर भेज दें (मुझे पता है, यह वास्तव में नेटवर्किंग के लिए एक अच्छी बात नहीं है, लेकिन मैं इसके साथ कुछ शोध करना चाहता हूं)।

तो, पहले से ही क्या हो चुका है: मेरे पास एक नया शेड्यूल मॉड्यूल (एनक्यू, डेक्यू फ़ंक्शन और इतने पर) का कंकाल है, जो सही ढंग से संकलित और सही तरीके से काम कर रहा है (एक पैकेट कतारबद्ध, एक पैकेट भेजता है- कुछ विशेष नहीं)। मैं इसे चल रहे कर्नेल के समान स्रोतों के साथ उबंटू मावेरिक पर संकलित कर रहा हूं और मेकफ़ाइल और कन्वॉन्ग में अपना मॉड्यूल डालता हूं।

मुझे पता चला कि हर बार एनक्यू फ़ंक्शन कहा जाता है, उसके बाद डेक्यू फ़ंक्शन qdisc_restart (sch_generic.c में) कहा जाता है - और केवल एक पैकेट भेजा जाता है।

मेरी समस्या यह है: मैं अपने मॉड्यूल से नेटवर्क इंटरफेस में एक से अधिक पैकेट कैसे भेज सकता हूं, जैसे कि मैंने उदाहरण के लिए एकत्र किया। 10 पैकेट और अब मैं उन्हें सब बाहर भेजना चाहता हूं?

मैंने qdisc_restart (और लॉकिंग तंत्र) के समान पैरामीटर के साथ sch_direct_xmit फ़ंक्शन (sch_generic.c से) को कॉल करने का प्रयास किया - लेकिन फिर, मेरे मॉड्यूल का संकलन विफल रहता है: अज्ञात प्रतीक sch_direct_xmit (लेकिन greping/proc/kallsyms इसके लिए मुझे एक परिणाम देता है)। कोई विचार, उसमें क्या गलत है? कुछ कोड की आवश्यकता है, बस मुझे सूचित करें

बीआर क्रिस्टोफ (मैं sched_generic.c में के रूप में ही ज शामिल)

Answer 1

मुझे लगता है कि सबसे आसान समाधान एक kthread है कि आप जाग जाएगा उपयोग करने के लिए किया जाएगा जब आपने 10 पैकेट कतारबद्ध की हैं। Kthread पहले से कतारबद्ध पैकेट उपभोग करने के लिए जिम्मेदार होगा।

अपने कोड के कुछ नमूने के बिना यह पता करने के लिए अपने विपंक्ति समारोह बुलाया जा रहा है कि घटनाओं के अनुक्रम हैं क्या मुश्किल है लेकिन आप शायद ऐसा ही कुछ कर सकते हैं:

static struct sk_buff_head foo_skb_queue; 
static DECLARE_WAIT_QUEUE_HEAD(food_wqh); 

int food_sender(void* unused) 
{ 
     struct sk_buff* skb = NULL; 
     unsigned int i = 0; 

     while (!kthread_should_stop()) { 

       while (skb = skb_dequeue(&foo_skb_queue) && i < NUMBER_TO_SEND) { 
         send_packet(skb); 
         ++i; 
       } 

       DECLARE_WAITQUEUE(wq, current); 
       set_current_state(TASK_INTERRUPTIBLE); 
       add_wait_queue(&food_wqh, &wq); 

       /* Avoid wake-up lost race */ 
       if (skb_queue_len(&foo_skb_queue) < NUMBER_TO_SEND) 
         schedule(); 

       remove_wait_queue(&food_wqh, &wq); 
     } 
     return 0; 
} 

int foo_enqueue(struct sk_buff* skb) 
{ 
     skb_queue_tail(&foo_skb, skb);  
     if (skb_queue_len(&foo_skb) >= NUMBER_TO_SEND) 
       wake_up(&food_wqh); 

     return 0; 
} 

कुछ इस तरह यह करना होगा मुझे संदेह है। कोड संकलित नहीं है लेकिन यह आपको यह कैसे करने के बारे में एक विचार देता है।